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
   auto _path = AbsoluteUnixPath(path);
   if (_path)
      SetTitle(_path.value());
   else
      throw std::runtime_error(Form("<KVSimDir::KVSimDir> : invalid path %s given to constructor", 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));
      // we become the owner of these files
      fAuxDir->fSimData.Clear("nodelete");
      fAuxDir->fFiltData.Clear("nodelete");
   }
}
 
 
 
 
 
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> phi((TNamed*)file->Get("RandomPhi"));
                  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();
                  Bool_t random_phi = true;
                  if (phi) random_phi = (TString(phi->GetTitle()) == "yes");
                  TString origin;
                  if (orig) {
                     origin = orig->GetTitle();
                     // possibly need to correct name of original file
                     // due to a bug in KVEventFiltering, when filtering files with names like
                     //    HIPSE_197Au_197Au_40.0AMeV_ASYM.root.36
                     // the 'original file name' stored in this TNamed object became
                     //    HIPSE_197Au_197Au_40.0AMeV_ASYM.36.root
                     // which is almost the same, but not quite...
                     KVString o(origin);
                     o.Begin(".");
                     std::vector<KVString> bits;
                     while (!o.End()) {
                        bits.push_back(o.Next());
                     }
                     if (bits.size() > 2) {
                        // if the last two bits are an integer and "root", swap them round
                        auto last_bit = bits.size() - 1;
                        auto last_but_one_bit = last_bit - 1;
                        if (bits[last_bit] == "root" && bits[last_but_one_bit].IsDec()) {
                           origin.Remove(origin.Index(Form(".%d.root", bits[last_but_one_bit].Atoi())),
                                         origin.Length() - origin.Index(Form(".%d.root", bits[last_but_one_bit].Atoi())));
                           origin += Form(".root.%d", bits[last_but_one_bit].Atoi());
                        }
                     }
                  }
                  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);
                  fff->SetRandomPhi(random_phi);
                  unique_ptr<TNamed> gem((TNamed*)file->Get("Gemini++"));
                  if (gem) {
                     if (!strcmp(gem->GetTitle(), "yes")) fff->SetGemini();
                     unique_ptr<TNamed> gemdec((TNamed*)file->Get("GemDecayPerEvent"));
                     if (gemdec) {
                        TString gemdecperev = gemdec->GetTitle();
                        fff->SetGemDecayPerEvent(gemdecperev.Atoi());
                     }
                     unique_ptr<TNamed> gemrot((TNamed*)file->Get("GemAddRotEner"));
                     if (gemrot) {
                        fff->SetGemAddRotEner(TString(gemrot->GetTitle()) == "yes");
                     }
                  }
                  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();
}