/// <summary>
/// Return all trees that are in a given directory. Make sure that if we have multiple
/// cycles in the directory we only process the first one we encounter.
/// </summary>
/// <param name="dir"></param>
/// <returns></returns>
public IEnumerable <ROOTClassShell> ParseTDirectory(ROOTNET.Interface.NTDirectory dir)
{
var converter = new ParseTTree();
converter.ProxyGenerationLocation = ProxyGenerationLocation;
HashSet <string> seenTreeNames = new HashSet <string>();
foreach (var key in dir.ListOfKeys.Cast <ROOTNET.Interface.NTKey>())
{
var c = ROOTNET.NTClass.GetClass(key.GetClassName());
if (c != null)
{
if (c.InheritsFrom("TTree"))
{
if (!seenTreeNames.Contains(key.Name))
{
seenTreeNames.Add(key.Name);
var t = key.ReadObj() as ROOTNET.Interface.NTTree;
if (t != null)
{
foreach (var cshell in converter.GenerateClasses(t))
{
yield return(cshell);
}
}
}
}
}
}
}
/// <summary>
/// Create a new future directory container that will write its objects to the given root directory
/// </summary>
/// <remarks>
/// In ROOT, when you create a new directory the gDirectory variable isn't changed; so the global directory
/// will be unchanged by this operation.
/// </remarks>
/// <param name="dir"></param>
public FutureTDirectory(ROOTNET.Interface.NTDirectory dir)
{
if (dir == null)
{
throw new ArgumentNullException("Can't create a new FutureTDirectory pointing to a null directory");
}
Directory = dir;
}
/// <summary>
/// Search an input directory for a histogram or any ROOT object.
/// </summary>
/// <param name="?"></param>
/// <param name="path"></param>
/// <returns></returns>
public static object Get(ROOTNET.Interface.NTDirectory d, string path)
{
var h = d.Get(path);
if (h == null)
{
throw new ArgumentException(string.Format("Unable to locate histogram '{0}' in directory '{1}'", path, d.Name));
}
return(h);
}
/// <summary>
/// Attempt to find all the objects that are of type T or inherrit from T in the input file,
/// and return them. Note that the file or owner of the directory needs to stay open as long as the sequence
/// is being parsed!! This is an iterator, and processes on an as-need basis!!!
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="rootDir"></param>
/// <returns></returns>
public static IEnumerable <T> FindAllOfType <T>(ROOTNET.Interface.NTDirectory rootDir)
where T : ROOTNET.Interface.NTObject
{
var objectKeys = rootDir.GetListOfKeys();
string basename = typeof(T).Name.Substring(1);
foreach (var item in objectKeys.Cast <ROOTNET.Interface.NTKey>())
{
var c = ROOTNET.NTClass.GetClass(item.GetClassName());
if (c.InheritsFrom(basename))
{
yield return((T)item.ReadObj());
}
}
}
/// <summary>
/// Search an input directory for a histogram or any ROOT object whose name matches the regular expression name.
/// Only does the matching in the current directory.
/// </summary>
/// <param name="d">Directory to search for</param>
/// <param name="regularExpression"></param>
/// <returns>List of objects that match the regular expression, including a zero length list.</returns>
public static object[] GetAll(ROOTNET.Interface.NTDirectory d, string regularExpression)
{
var re = new Regex(regularExpression);
var found = new List <object>();
foreach (var key in d.ListOfKeys.Cast <ROOTNET.Interface.NTKey>())
{
if (!key.IsFolder() && re.Match(key.Name).Success)
{
found.Add(d.Get(key.Name));
}
}
return(found.ToArray());
}
/// <summary>
/// Do an immediate write to a root directory
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="dir"></param>
public static void WriteToROOTDirectory <T>(this T obj, ROOTNET.Interface.NTDirectory dir)
where T : ROOTNET.Interface.NTObject
{
obj.InternalWriteObject(dir);
}
/// <summary>
/// Save a plot to a TDirectory. Return the plot so it can also be used in other
/// places.
///
/// Temp Fix: We need to set the object owner so that this object won't be cleaned up during
/// GC, however, ROOT.NET doesn't support it yet. So instead we will just set it to null and
/// return null for now. To be fixed when we update ROOT.NET.
/// </summary>
/// <param name="hist"></param>
/// <param name="dir"></param>
/// <returns></returns>
public static ROOTNET.Interface.NTH1 SaveToROOTDirectory(this ROOTNET.Interface.NTH1 hist, ROOTNET.Interface.NTDirectory dir)
{
hist.InternalWriteObject(dir);
return(null);
}
/// <summary>
/// Add a histogram to a ROOT directory.
/// </summary>
/// <param name="dir"></param>
/// <param name="h"></param>
public static void Add(this ROOTNET.Interface.NTDirectory dir, ROOTNET.Interface.NTH1 h)
{
h.SetDirectory(dir);
}
public void Save(ROOTNET.Interface.NTDirectory dir)
{
AsTObject.InternalWriteObject(dir);
}
/// <summary>
/// Make pT and Eta histograms
/// </summary>
/// <param name="alljets"></param>
/// <param name="p"></param>
private static void MakeGenericHistos(IQueryable <ROOTNET.Interface.NBTagJet> alljets, string namePrefix, ROOTNET.Interface.NTDirectory dir)
{
var heta = alljets.ApplyToObject(new ROOTNET.NTH1F(namePrefix + "_eta", "\\Eta for " + namePrefix, 50, -5.0, 5.0), (h, x) => h.Fill(x.Eta()));
heta.SetDirectory(dir);
var hpt = alljets.ApplyToObject(new ROOTNET.NTH1F(namePrefix + "_pt", "p_{T} for " + namePrefix, 50, 0.0, 150.0), (h, x) => h.Fill(x.Pt() / 1000.0));
hpt.SetDirectory(dir);
}
/// <summary>
/// Write out an object. Eventually, with ROOTNET improvements this will work better and perahps
/// won't be needed!
/// </summary>
/// <param name="obj">The object to be written. Assumed not null.</param>
/// <param name="dir"></param>
internal static void InternalWriteObject(this ROOTNET.Interface.NTObject obj, ROOTNET.Interface.NTDirectory dir)
{
if (obj == null)
{
Console.WriteLine("WARNING: Unable to write out null object to a TDirectory!");
return;
}
using (ROOTLock.Lock())
{
if (obj is ROOTNET.Interface.NTH1 h)
{
var copy = h.Clone();
dir.WriteTObject(copy); // Ugly from a memory pov, but...
copy.SetNull();
}
else
{
dir.WriteTObject(obj);
obj.SetNull();
}
}
}
