KVSimDir.cpp

//Created by KVClassFactory on Tue Jul 17 08:46:41 2012
//Author: John Frankland,,,
 
#include "KVSimDir.h"
#include "KVSimFile.h"
#include "KVSystemDirectory.h"
#include "TSystem.h"
#include "KVString.h"
#include "TTree.h"
#include "TKey.h"
#include "TFile.h"
#include "TBranchElement.h"
#include <KVSystemFile.h>
#include <iostream>
using namespace std;
 
ClassImp(KVSimDir)
 
 
 
 
 
KVSimDir::KVSimDir()
{
   // Default constructor
   init();
}
 
 
 
 
KVSimDir::KVSimDir(const Char_t* name, const Char_t* path)
   : KVBase(name, path)
{
   // Ctor with name and directory to analyse
   init();
   // make sure we have absolute path
   KVString _path(path);
   gSystem->ExpandPathName(_path);
   if (!gSystem->IsAbsoluteFileName(_path)) {
      if (_path.CountChar('.') == 1) {
         _path.ReplaceAll(".", "$(PWD)");
         gSystem->ExpandPathName(_path);
      }
   }
   SetTitle(_path);
}
 
 
 
 
void KVSimDir::init()
{
   // Default initialisations
   fSimData.SetName("Simulated Data");
   fFiltData.SetName("Filtered Simulated Data");
}
 
 
 
 
 
KVSimDir::KVSimDir(const KVSimDir& obj)  : KVBase()
{
   // Copy constructor
   // This ctor is used to make a copy of an existing object (for example
   // when a method returns an object), and it is always a good idea to
   // implement it.
   // If your class allocates memory in its constructor(s) then it is ESSENTIAL :-)
 
   obj.Copy(*this);
}
 
 
 
 
 
void KVSimDir::Copy(TObject& obj) const
{
   // This method copies the current state of 'this' object into 'obj'
   // You should add here any member variables, for example:
   //    (supposing a member variable KVSimDir::fToto)
   //    CastedObj.fToto = fToto;
   // or
   //    CastedObj.SetToto( GetToto() );
 
   KVBase::Copy(obj);
   //KVSimDir& CastedObj = (KVSimDir&)obj;
}
 
 
 
 
void KVSimDir::SetAuxDirectory(const TString& fullpath)
{
   // Add an auxiliary directory to this simulated dataset.
   //
   // When AnalyseDirectory() is called, the auxiliary directory will also be scanned
   // and any files found will be added to use
 
   fAuxDir = std::make_unique<KVSimDir>("aux",fullpath);
}
 
 
 
 
TString KVSimDir::GetAuxDirectory() const
{
   if(fAuxDir)
      return fAuxDir->GetDirectory();
   return "";
}
 
 
 
 
Bool_t KVSimDir::HasAuxDirectory() const
{
   return (Bool_t)fAuxDir;
}
 
 
 
 
Bool_t KVSimDir::IsFromAuxDirectory(KVSimFile*sf) const
{
   // returns true if given file is in the auxiliary directory
   if(sf->GetSimDir() == this)
      return false;
   if(fAuxDir && sf->GetSimDir() == fAuxDir.get()) return true;
   Error("IsFromAuxDirectory", "The file %s is neither associated to the main nor the auxiliary directory of dataset %s",
         sf->GetName(), GetName());
   return false;
}
 
 
 
 
 
void KVSimDir::AnalyseDirectory()
{
   // Read contents of directory given to ctor.
   // Each ROOT file will be analysed by AnalyseFile().
 
   Info("AnalyseDirectory", "Analysing %s...", GetDirectory());
   fSimData.Clear();
   fFiltData.Clear();
   //loop over files in current directory
   KVSystemDirectory thisDir(".", GetDirectory());
   auto fileList = thisDir.GetListOfFiles();
   TIter nextFile(fileList);
   KVSystemFile* aFile = 0;
   while ((aFile = (KVSystemFile*)nextFile())) {
 
      KVString fileName = aFile->GetName();
      if (!fileName.EndsWith(".root") && !fileName.Contains(".root."))  continue; /* skip non-ROOT files */
 
      AnalyseFile(fileName);
   }
 
   // analyse auxiliary directory, if set
   if(fAuxDir){
      fAuxDir->AnalyseDirectory();
      // copy all files to our lists
      fSimData.AddAll(&(fAuxDir->fSimData));
      fFiltData.AddAll(&(fAuxDir->fFiltData));
   }
}
 
 
 
 
 
void KVSimDir::AnalyseFile(const Char_t* filename)
{
   // Analyse ROOT file given as argument.
   // If there is a TTree in the file, then we look at all of its branches until we find one
   // containing objects which derive from KVEvent:
   //
   //   -- if they inherit from KVSimEvent, we add the file to the list of simulated data:
   //            * a KVSimFile is created. The title of the TTree where data were found will
   //               be used as 'Information' on the nature of the simulation.
   //   -- if they inherit from KVReconstructedEvent, we add the file to the list of filtered data.
   //            * a KVSimFile is created. Informations on the filtered data are extracted from
   //              TNamed objects in the file with names 'Dataset', 'System', 'Run', 'Origin'
   //              (i.e. the name of the simulation
   //              file which was filtered), 'Filter' (type of filter: Geo, GeoThresh or Full).
   //              These objects are automatically created when data is filtered using KVEventFiltering.
   //
   // Analysis of the file stops after the first TTree with a branch satisfying one of the
   // two criteria is found (it is assumed that in each file there is only one TTree containing
   // either simulated or filtered data).
 
   //Info("AnalyseFile", "Analysing file %s...", filename);
   TString fullpath;
   AssignAndDelete(fullpath, gSystem->ConcatFileName(GetDirectory(), filename));
   unique_ptr<TFile> file(TFile::Open(fullpath));
   if (!file.get() || file->IsZombie()) return;
   // look for TTrees in file
   TIter next(file->GetListOfKeys());
   TKey* key;
   while ((key = (TKey*)next())) {
      TString cn = key->GetClassName();
      if (cn == "TTree") {
         // look for branch with KVEvent objects
         TTree* tree = (TTree*)file->Get(key->GetName());
         TSeqCollection* branches = tree->GetListOfBranches();
         TIter nextB(branches);
         TBranchElement* branch;
         while ((branch = (TBranchElement*)nextB())) {
            TString branch_classname = branch->GetClassName();
            TClass* branch_class = TClass::GetClass(branch_classname, kFALSE, kTRUE);
            if (branch_class && branch_class->InheritsFrom("KVEvent")) {
               if (branch_class->InheritsFrom("KVReconstructedEvent")) {
                  // filtered data. there must be TNamed called 'Dataset', and possibly 'System' and/or 'Run' in the file.
                  unique_ptr<TNamed> ds((TNamed*)file->Get("Dataset"));
                  unique_ptr<TNamed> orig((TNamed*)file->Get("Origin"));
                  unique_ptr<TNamed> sys((TNamed*)file->Get("System"));
                  unique_ptr<TNamed> r((TNamed*)file->Get("Run"));
                  unique_ptr<TNamed> f((TNamed*)file->Get("Filter"));
                  unique_ptr<TNamed> dqa((TNamed*)file->Get("DataQualityAudit"));
                  TString dataset;
                  if (ds) dataset = ds->GetTitle();
                  TString system;
                  if (sys) system = sys->GetTitle();
                  TString run;
                  if (r) run = r->GetTitle();
                  TString origin;
                  if (orig) origin = orig->GetTitle();
                  TString filter;
                  if (f) filter = f->GetTitle();
                  Int_t run_number = -1;
                  if (run.IsDec()) run_number = run.Atoi();
                  TString _dqa;
                  if(dqa) _dqa = dqa->GetTitle();
                  KVSimFile* fff = new KVSimFile(this, filename, tree->GetTitle(), tree->GetEntries(), tree->GetName(), branch->GetName(),
                                                 dataset, system, run_number, origin, filter, _dqa);
                  fFiltData.Add(fff);
                  unique_ptr<TNamed> gem((TNamed*)file->Get("Gemini++"));
                  if (gem.get()) {
                     if (!strcmp(gem->GetTitle(), "yes")) fff->SetGemini();
                     unique_ptr<TNamed> gemdec((TNamed*)file->Get("GemDecayPerEvent"));
                     if (gemdec.get()) {
                        TString gemdecperev = gemdec->GetTitle();
                        fff->SetGemDecayPerEvent(gemdecperev.Atoi());
                     }
                  }
                  return;
               }
               else {
                  fSimData.Add(new KVSimFile(this, filename, tree->GetTitle(), tree->GetEntries(), tree->GetName(), branch->GetName()));
                  return;
               }
            }
         }
      }
   }
}
 
 
 
 
void KVSimDir::AddSimData(KVSimFile* f, bool set_parent_aux_dir)
{
   // adds a simulated data file to dataset
   //
   // if set_parent_aux_dir=true: set the auxiliary simdir as parent
   fSimData.Add(f);
   if(set_parent_aux_dir) f->SetSimDir(fAuxDir.get());
   else f->SetSimDir(this);
}
 
 
 
 
void KVSimDir::AddFiltData(KVSimFile* f, bool set_parent_aux_dir)
{
   // adds a filtered data file to dataset
   //
   // if set_parent_aux_dir=true: set the auxiliary simdir as parent
   fFiltData.Add(f);
   if(set_parent_aux_dir) f->SetSimDir(fAuxDir.get());
   else f->SetSimDir(this);
}
 
 
 
 
 
void KVSimDir::ls(Option_t*) const
{
   TROOT::IndentLevel();
   cout << "SIMULATION SET: " << GetName() << endl;
   cout << "DIRECTORY: " << GetDirectory() << endl;
   cout << "CONTENTS:" << endl;
   cout << "--simulated data:" << endl;
   fSimData.ls();
   cout << "--filtered data:" << endl;
   fFiltData.ls();
}