KVSimReader.cpp

//Created by KVClassFactory on Wed Jun 30 17:45:01 2010
//Author: bonnet
 
#include "KVSimReader.h"
#include "TDirectory.h"
#include "TStopwatch.h"
 
ClassImp(KVSimReader)
 
 
 
KVSimReader::KVSimReader()
   : evt{new KVSimEvent}
{
   linked_info.SetName("Simulation info");
   linked_objects.SetName("List of objects");
}
 
 
 
 
void KVSimReader::ConvertEventsInFile(KVString filename)
{
   if (!OpenFileToRead(filename)) return;
   if(!ReadFileHeader())
   {
      KVError::Error(this,"ReadFileHeader","Error reading the file header");
      return;
   }
   Run();
   CloseFile();
}
 
 
 
 
bool KVSimReader::NeedToIterateReadEvent()
{
   // The usual loop for reading, converting and saving events is
   //
   //~~~{.cpp}
   // ReadEventHeader();
   // ReadEvent();
   // FillTree();
   //~~~
   //
   // If several separate events share the same header and need to be read
   // sequentially, this can be achieved if this method is overriden to return true
   // as many times as needed, by adding this effective loop:
   //
   //~~~{.cpp}
   // ReadEventHeader();
   // do {
   //    ReadEvent();
   //    FillTree();
   // } while( NeedToIterateEvents() );
   //~~~
   return false;
}
 
 
 
 
void KVSimReader::InitializeOutputFileAndTree()
{
   // Create a new TFile containing a TTree with a branch for storing KVSimEvent objects
   //
   // The file will be written in the directory given to SetOutputDirectory() (local working directory if not).
   //
   //   ROOT files and TTrees will be generated with names/titles according to the values which can be set with:
   //
   //     + SetTreeName()
   //     + SetTreeTitle()
   //     + SetROOTFileName()
   //     + SetBranchName()
 
 
   auto filename = GetCurrentRootFileName();
   if (!fOutputDirectory.EndsWith("/")) fOutputDirectory += "/";
   filename.Prepend(fOutputDirectory);
   file = new TFile(filename, "recreate");
   KVError::Info(this, "InitializeOutputFileAndTree", "Opened output file: %s", filename.Data());
 
   tree = new TTree(tree_name, tree_title);
   KVEvent::MakeEventBranch(tree, branch_name, evt);
}
 
 
 
 
void KVSimReader::ReadEventsInFile()
{
   // Method driving the main loop to read and convert all events in file
 
   total_nevents=total_nevents_current_output_file=0;
   while (IsOK()) {
      if (ReadEventHeader(evt))
      {
         bool ok = true;
         do {
            if((ok = ReadEvent(evt)))
            {
               ++total_nevents;
               if(NeedNewOutputFile())
               {
                  NotifyChangeOfOutputFile();
                  InitializeOutputFileAndTree();
                  total_nevents_current_output_file=0;
               }
               ++total_nevents_current_output_file;
               FillTree();
               if(OutputFileIsFull())
               {
                  SaveTree();
               }
               evt->Clear();
            }
            else
               break;
         } while(ok && NeedToIterateReadEvent());
      }
      else
         break;
   }
}
 
 
 
 
Bool_t KVSimReader::ReadFileHeader()
{
   // Implement as needed to read informations at the beginning of the input file, if present.
   //
   // Such informations may be used in ReadFileHeader() to set the names of output files/TTrees,
   // using the methods
   //
   //   + SetTreeName()
   //   + SetTreeTitle()
   //   + SetROOTFileName()
   //   + SetBranchName()
   //
   // \returns true unless there is a problem reading the header (inconsistent file structure, end of file, etc.)
   return true;
}
 
 
 
 
Bool_t KVSimReader::ReadEventHeader(KVSimEvent*)
{
   // Implement as needed to read informations present at the beginning of each new event, if present.
   //
   // There is no need to call KVSimEvent::Clear(): the event object will be ready to be filled with new informations.
   //
   // \returns true unless there is a problem reading the header (inconsistent file structure, end of file, etc.)
   return true;
}
 
 
 
 
Bool_t KVSimReader::ReadNucleus(KVSimNucleus*)
{
   // If required, this method can be implemented in child classes, to be used in ReadEvent().
   // As the implementation of ReadEvent() is the user's responsibility, the meaning of the returned
   // bool value is also up to the user.
   return true;
}
 
 
 
 
void KVSimReader::NotifyChangeOfOutputFile()
{
   // This method will be called just before initialising a new output file during
   // conversion of events (note that the previous file will already have been written to
   // disk and closed at this point).
   //
   // It can be overridden in child classes if necessary, e.g. to reset histograms or other statistics.
}
 
 
 
 
TString KVSimReader::GetCurrentRootFileName()
{
   TString filename;
   filename = root_file_name;
   if (fMultiFiles) filename += Form(".%d", fFileIndex);
   if(max_number_events_per_output_file)
      filename += Form(".%d", current_output_file_index++);
   filename += ".root";
   return filename;
}
 
 
 
 
void KVSimReader::ConvertAndSaveEventsInFile(KVString filename)
{
   // Read events, convert and save in ROOT file(s)
   ConvertEventsInFile(filename);
   if(!NeedNewOutputFile())
      SaveTree();
}
 
 
 
 
KVSimReader* KVSimReader::MakeSimReader(const char* model_uri)
{
   // Returns an instance of a child class specific to given model.
 
   TPluginHandler* ph = LoadPlugin("KVSimReader", model_uri);
   if (!ph) {
      ::Error("KVSimReader::MakeSimReader", "No plugin defined with name %s", model_uri);
      return nullptr;
   }
   return (KVSimReader*)ph->ExecPlugin(0);
}
 
 
 
 
void KVSimReader::Run()
{
 
   AddInfo({"ascii file read", GetFileName()});
 
   TStopwatch chrono;
   chrono.Start();
 
   InitializeOutputFileAndTree();
 
   ReadEventsInFile();
 
   chrono.Stop();
 
   AddInfo({"date", GetDate()});
   AddInfo({"user", gSystem->GetUserInfo()->fUser});
 
}
 
 
 
 
void KVSimReader::SaveTree()
{
   WriteObjects();
   WriteInfo();
   GetTree()->Write();
   KVError::Info(this, "SaveTree", "Writing %d events in file : %s", total_nevents_current_output_file, file->GetName());
   file->Close();
   file = nullptr;
}
 
 
 
 
KVSeqCollection* KVSimReader::GetSimuInfo()
{
   return &linked_info;
}
 
 
 
 
void KVSimReader::AddInfo(const KVNamedParameter& info)
{
   // Add information on simulation using KVNamedParameter, can be int, double, bool or string:
   //~~~{.cpp}
   // AddInfo({"model", "AMD"});
   // AddInfo({"sigma_NN_screen_factor", 0.85});
   // AddInfo({"N_part_test", 150});
   //~~~
   // This information will be written to disk with the TTree and can be retrieved
   // using TTree::GetUserInfo().
   linked_info.Add(new KVNamedParameter(info));
}
 
 
 
 
void KVSimReader::WriteInfo()
{
   TList* list = GetTree()->GetUserInfo();
   Int_t nentries = linked_info.GetEntries();
   for (Int_t ii = 0; ii < nentries; ii += 1) {
      // copy informations to TTree user info list
      list->Add(new KVNamedParameter(*static_cast<KVNamedParameter*>(linked_info.At(ii))));
   }
}
 
 
 
 
KVSeqCollection* KVSimReader::GetLinkedObjects()
{
   return &linked_objects;
}
 
 
 
 
void KVSimReader::AddObject(TObject* obj)
{
   // Adds an object to a list which will be written to disk with the TTree.
   //
   // These objects can be retrieved from the list returned by TTree::GetUserInfo().
   GetLinkedObjects()->Add(obj);
}
 
 
 
 
void KVSimReader::WriteObjects()
{
 
   TList* list = GetTree()->GetUserInfo();
   Int_t nentries = linked_objects.GetEntries();
   for (Int_t ii = 0; ii < nentries; ii += 1)
   {
      list->Add(linked_objects.At(ii));
   }
 
}