Class to manage ROOT output readers. More...

#include <GGSTRootReader.h>

Inheritance diagram for GGSTRootReader:

Public Member Functions
	GGSTRootReader ()
	Constructor.

	~GGSTRootReader ()
	Destructor.

GGSTFilesHandler *	Open (const std::string &fileName, GGSTFilesHandler *filesHandler=nullptr, bool force=false)
	Open ROOT files. More...

GGSTFilesHandler *	Open (const char fileName, GGSTFilesHandler filesHandler=nullptr, bool force=false)
	Open ROOT files. More...

bool	OpenFile (const char *fileName)
	Opens a ROOT file. More...

template<class T >
T *	GetReader (GGSTFilesHandler *filesHandler=nullptr, const TString &treeName="")
	Get a chain reader. More...

void	GetEntry (Long64_t entry)
	Reads an event. More...

Long64_t	GetEntries ()
	The total number of events. More...

Long64_t	GetReadEntry ()
	Returns the current entry (event). More...

const GGSTSimInfo *	GetSimInfo (const GGSTFilesHandler *filesHandler=nullptr)
	Returns the simulation informations. More...

const GGSTGeoParams *	GetGeoParams (const GGSTFilesHandler *filesHandler=nullptr)
	Returns the geometry parameters. More...

const GGSTParameters *	GetGenParams (const GGSTFilesHandler *filesHandler=nullptr)
	Returns the generator parameters. More...

const TGeoManager *	GetROOTGeometry (GGSTFilesHandler *filesHandler=nullptr)
	Returns the simulation geometry in TGeo format. More...

bool	HasROOTGeometry (GGSTFilesHandler *filesHandler=nullptr)
	Checks if the data files contains the detector geometry in TGeo format. More...

Detailed Description

Class to manage ROOT output readers.

GGS actions which write output on a ROOT file generally write each one on its own tree. So for each of these trees there should be a reader class to read back the data. GGSTRootReader simplifies the handling of multiple tree reader classes, by providing facilities for opening ROOT files and reading entries for all the trees. The main method of this class is the GetReader method. See its documentation for further details.

Definition at line 38 of file GGSTRootReader.h.

Member Function Documentation

Long64_t GGSTRootReader::GetEntries ( )

The total number of events.

This method returns the number of events in the event chain. Since all the chains are enforced to contain the same number of event when they are created, there is no ambiguity on the returned value even in presence of multiple chains. If no reader has already been retrieved by GetReader when this method is called then there is still no chain. This is because chains are created when calling GetReader to connect each reader to its chain and branches. In this case a "blind" number of entries is returned: the files belonging to the files handler created by the first call to Open are scanned and when the first TTree object is found a chain is created and the number of its entries is used as the return value. This value might be incorrect in some corner cases, e.g. if two handlers containing a different number of events are opened and the second one is the one which will be effectively used for the analysis.

Returns: The number of entries.

Definition at line 295 of file GGSTRootReader.cpp.

                                     {
   static const std::string routineName("GGSTRootReader::GetEntries");
 
   if (_readers.size() > 0)
     return _readers[0]->chain->GetEntries();
   else {
     GGSCOUT(WARNING) << "GetEntries may return a wrong number of entries when called before GetReader." << GGSENDL;
     return _GetEntriesBlind();
   }
 }

void GGSTRootReader::GetEntry ( Long64_t entry )

Reads an event.

This method reads the event specified by entry. It calls GetEntry for every chain associated with the already instantiated readers (

See Also: GetReader), so that every reader makes reference to the current event.

Parameters

entry The event to be read.

Definition at line 287 of file GGSTRootReader.cpp.

                                             {
 
   for (unsigned int i = 0; i < _readers.size(); i++) {
     _readers[i]->reader->GetEntry(entry);
   }
   _currentEv = entry;
 }

const GGSTParameters * GGSTRootReader::GetGenParams ( const GGSTFilesHandler * filesHandler = nullptr )

Returns the generator parameters.

Parameters

filesHandler The handler to the file(s) containing the desired info object. If nullptr then the handler returned by the first invocation of Open will be automatically used.

Returns: pointer to the geometry parameters object.; nullptr if an invalid filesHandler is used as argument, if no file(s) has still been opened or if the geometry parameters are not available.

Definition at line 330 of file GGSTRootReader.cpp.

                                                                                        {
 
   if (filesHandler == nullptr) {
     if (_filesHandlers.size() > 0)
       filesHandler = _filesHandlers[0];
     else
       return nullptr;
   }
 
   return &(filesHandler->_genParams);
 }

const GGSTGeoParams * GGSTRootReader::GetGeoParams ( const GGSTFilesHandler * filesHandler = nullptr )

Returns the geometry parameters.

Parameters

filesHandler The handler to the file(s) containing the desired info object. If nullptr then the handler returned by the first invocation of Open will be automatically used.

Returns: pointer to the geometry parameters object.; nullptr if an invalid filesHandler is used as argument, if no file(s) has still been opened or if the geometry parameters are not available.

Definition at line 318 of file GGSTRootReader.cpp.

                                                                                       {
 
   if (filesHandler == nullptr) {
     if (_filesHandlers.size() > 0)
       filesHandler = _filesHandlers[0];
     else
       return nullptr;
   }
 
   return &(filesHandler->_geoParams);
 }

Long64_t GGSTRootReader::GetReadEntry ( )

inline

Returns the current entry (event).

Returns: The current entry.

Definition at line 161 of file GGSTRootReader.h.

161 { return _currentEv; }

template<class T >

T * GGSTRootReader::GetReader	(	GGSTFilesHandler *	filesHandler = `nullptr`,
		const TString &	treeName = `""`
	)

Get a chain reader.

The template argument T is the class name of a reader class, which must inherit from GGSTChainReader. The method will return a pointer to a reader of class T for the specified tree, eventually chaining all the files handled by the GGSTFilesHandler passed as first argument. The reader will be automatically set to current entry.

If a nullptr value is passed for GGSTFilesHandler then the first handler (i.e. the file(s) opened with the first call to Open) will be used. If an empty std::string is passed for treeName, then the default tree name will be used.

Parameters

filesHandler	Handler to the Root files to be read by the reader.
treeName	The name of the tree to be read by the reader T.

Returns: Pointer to the reader (or nullptr if tree could not be found in files handled by the handler).

Definition at line 245 of file GGSTRootReader.h.

                                                                                                        {
 
   static const char *routineName = "GGSTRootReader::GetReader";
 
   // Set filesHandler to first handler if no handler is provided
   if (filesHandler == nullptr) {
     if (_filesHandlers.size() > 0)
       filesHandler = _filesHandlers[0];
   }
 
   // Set default tree name if no name is provided
   TString tName(treeName);
   if (tName == "") {
     tName = "GGSEventsTree";
   }
 
   // Search the tree in stored trees (i.e., already requested by a reader)
   for (unsigned int iReader = 0; iReader < _readers.size(); iReader++) {
     if (_readers[iReader]->filesHandler == filesHandler && _readers[iReader]->chain->GetName() == tName) {
       // Check if found reader is of the desired type
       T *retVal = dynamic_cast<T *>(_readers[iReader]->reader);
       if (retVal) {
         return retVal;
       }
     }
   }
 
   // Search for chain
   TChain *chain = _FindChain(tName, filesHandler);
   if (chain) {
     T *reader = new T;
     // Read first entry if no entry has been read yet.
     // This is necessary in order to make branches available so that readers can check for branch match in their
     // SetChain methods.
     if (chain->GetReadEntry() < 0)
       chain->GetEntry(0);
     if (reader->SetChain(chain)) {
       // Reset the read entry to -1, to avoid missing to read the first event with some readers.
       chain->GetEntry(-1);
       for (unsigned int iReader = 0; iReader < _readers.size(); iReader++) {
         if (chain->GetEntries() != _readers[iReader]->chain->GetEntries()) {
           GGSCOUT(WARNING) << routineName << "Event number for the requested reader (" << chain->GetEntries()
                            << ") and for reader no. " << iReader << " (" << _readers[iReader]->chain->GetEntries()
                            << ") do not match. The reader has not been created." << std::endl;
           delete reader;
           return nullptr;
         }
       }
       if (_currentEv != -1)
         reader->GetEntry(_currentEv);
       _readers.push_back(new ReadersInfo());
       _readers.back()->reader = reader;
       _readers.back()->chain = chain;
       _readers.back()->filesHandler = filesHandler;
       return reader;
     } else {
       GGSCOUT(WARNING) << "Tree " << tName
                        << " cannot be read by the requested reader. The reader has not been created." << std::endl;
       chain->GetEntry(-1);
       delete reader;
       return nullptr;
     }
   } else {
     GGSCOUT(WARNING) << "Can't find tree " << tName << ". The reader has not been created." << GGSENDL;
     return nullptr;
   }
 }

const TGeoManager * GGSTRootReader::GetROOTGeometry ( GGSTFilesHandler * filesHandler = nullptr )

Returns the simulation geometry in TGeo format.

Parameters

filesHandler The handler to the file(s) containing the desired info object. If nullptr then the handler returned by the first invocation of Open will be automatically used.

Returns: pointer to the geometry manager.; nullptr if an invalid filesHandler is used as argument, if no file(s) has still been opened or if the geometry manager is not available.

Definition at line 342 of file GGSTRootReader.cpp.

                                                                                  {
   if (filesHandler == nullptr) {
     if (_filesHandlers.size() > 0)
       filesHandler = _filesHandlers[0];
     else
       return nullptr;
   }
   if (!(filesHandler->_geoManager)) {
     if (filesHandler->_chains.size() != 0) {
       auto readEntry = filesHandler->_chains[0]->GetReadEntry();
       filesHandler->_chains[0]->GetEntry(0);
       if (GGSSmartLog::verboseLevel < GGSSmartLog::DEBUG) {
         GGSSmartLog::MuteOutput();
       }
       filesHandler->_geoManager = (TGeoManager *)(filesHandler->_chains[0]->GetCurrentFile()->Get("GGSGeometry"));
       GGSSmartLog::UnmuteOutput();
       filesHandler->_chains[0]->GetEntry(readEntry);
     } else if (filesHandler->_files.size() != 0) {
       TFile *tGeoFile = TFile::Open(filesHandler->_files[0].c_str());
       filesHandler->_geoManager = (TGeoManager *)(tGeoFile->Get("GGSGeometry"));
       tGeoFile->Close();
       delete tGeoFile;
     }
   }
 
   return filesHandler->_geoManager;
 }

const GGSTSimInfo * GGSTRootReader::GetSimInfo ( const GGSTFilesHandler * filesHandler = nullptr )

Returns the simulation informations.

Since this class can manage many handlers, the user can specify from which of them the simulation informations must be read. If no handler is specified, then the one obtained with the first call to Open will be used. All the files belonging to the same handler are forced to have the same GGSTSimInfo object, except for the initial seeds.

Parameters

filesHandler The handler to the file(s) containing the desired info object. If nullptr then the handler returned by the first invocation of Open will be automatically used.

Returns: Pointer to simulation informations object.; nullptr if an invalid filesHandler is used as argument or if no file(s) has still been opened.

Definition at line 306 of file GGSTRootReader.cpp.

                                                                                   {
 
   if (filesHandler == nullptr) {
     if (_filesHandlers.size() > 0)
       filesHandler = _filesHandlers[0];
     else
       return nullptr;
   }
 
   return &(filesHandler->_simInfo);
 }

bool GGSTRootReader::HasROOTGeometry ( GGSTFilesHandler * filesHandler = nullptr )

Checks if the data files contains the detector geometry in TGeo format.

This method checks if the TGeo geometry is available in the Root file without actually reading it. This is more efficient than checking the return value of GetROOTGeometry (which will read out the geometry from the file) when one just wants to know if the geometry is available without having to actually use it.

Parameters

filesHandler The handler to the file(s) containing the desired info object. If nullptr then the handler returned by the first invocation of Open will be automatically used.

Returns: true if the file contains the TGeo geometry.

Definition at line 370 of file GGSTRootReader.cpp.

                                                                    {
   if (filesHandler == nullptr) {
     if (_filesHandlers.size() > 0)
       filesHandler = _filesHandlers[0];
     else
       return false;
   }
   if (filesHandler->_geoManager) {
     return true;
   }
 
   TKey *geoKey = nullptr;
   if (filesHandler->_chains.size() != 0) {
     auto readEntry = filesHandler->_chains[0]->GetReadEntry();
     filesHandler->_chains[0]->GetEntry(0);
     if (GGSSmartLog::verboseLevel < GGSSmartLog::DEBUG) {
       GGSSmartLog::MuteOutput();
     }
     geoKey = (filesHandler->_chains[0]->GetCurrentFile()->GetKey("GGSGeometry"));
     GGSSmartLog::UnmuteOutput();
     filesHandler->_chains[0]->GetEntry(readEntry);
   } else if (filesHandler->_files.size() != 0) {
     TFile *tGeoFile = TFile::Open(filesHandler->_files[0].c_str());
     geoKey = tGeoFile->GetKey("GGSGeometry");
     tGeoFile->Close();
     delete tGeoFile;
   }
 
   return geoKey;
 }

GGSTFilesHandler * GGSTRootReader::Open	(	const std::string &	fileName,
		GGSTFilesHandler *	filesHandler = `nullptr`,
		bool	force = `false`
	)

Open ROOT files.

The argument of this method can either be the name of a single file or multiple files, in turn specified using wildcards (*, ? and []) or the name of a txt file containing the full paths to the desired files (one per row). The reader will handle the files and return a pointer to a GGSTFilesHandler object handling all the files that have been opened.

When opening with wildcards the files will be sorted in alphabetical order, while when using the txt file the order will not be modified.

If the file(s) do not exist or in case of an error, a nullptr value will be returned. When opening multiple files a consistency check is done in order to assure that all the files have been produced in the same way. The check is based on the content of the GGSTSimInfo stored in each file, and currently it only checks that the content of each member of the GGSTSimInfo objects exactly match those of the GGSTSimInfo object contained in the first file. This means that two file produced with two datacards with different names will be considered as inconsistent, even if the content of the datacards was actually the same. Files which are inconsistent with respecto to the first one will be ignored. The consistency check can be turned off using the #force argument.

The pointer to the handler can eventually be passed to GetReader to specify which files the desired reader should use (see GetReader).

After a handler has been created by calling Open, more files can be added to it by passing it as the second argument to subsequent calls of Open. In this case the returned address will be equal to that of the argument. If an error occurs the method will return nullptr and the handler will not be modified (i.e. no files will be appended).

The reader retains the ownership of the handler objects it creates and will adopt eventual handlers instantiated explicitly by the user and passed to Open as the second argument (e.g. the user must not delete the handler in these cases)

Parameters

fileName	Path to Root file (eventually with wildcards) or to a txt file containing the list of desired Root files.
filesHandler	The files handler to which the newly opened file will be appended. If nullptr a new handler will be created.
force	if true, no consistency check between different files will be done.

Returns: A pointer to a GGSTFilesHandler object handling the opened files (nullptr if the files do not exist or if an error has occurred).

Definition at line 34 of file GGSTRootReader.cpp.

                                                                                                             {
   static const std::string routineName("GGSTRootReader::Open");
 
   GGSTFilesHandler *handler = nullptr;
   if (filesHandler == nullptr)
     handler = new GGSTFilesHandler;
   else {
     handler = filesHandler;
   }
 
   if (fileName.find('?') != std::string::npos || fileName.find('*') != std::string::npos) {
     // ******* Name with wildcards *******
 
     // ++++ Convert fileName into a regular expression ++++
     std::string regExpFiles(fileName);
     // 1. escape all .
     std::string::size_type pos = 0;
     while ((pos = regExpFiles.find('.', pos)) != std::string::npos) {
       regExpFiles.replace(pos, 1, "\\.");
       pos += 2;
     }
     // 2. convert all * to .*
     pos = 0;
     while ((pos = regExpFiles.find('*', pos)) != std::string::npos) {
       regExpFiles.replace(pos, 1, ".*");
       pos += 2;
     }
     // 3. convert all ? to .
     std::replace(regExpFiles.begin(), regExpFiles.end(), '?', '.');
 
     // ++++ Search files ++++
     std::string basePathName(fileName);
     // Extract path
     size_t posOfLastSlash = basePathName.find_last_of('/');
     if (posOfLastSlash != std::string::npos)
       basePathName.erase(posOfLastSlash);
     else
       basePathName = std::filesystem::current_path().string();
 
     std::filesystem::path basePath(std::filesystem::absolute(basePathName));
 
     std::filesystem::directory_iterator endItr; // Default constructor yields past-the-end
     std::filesystem::directory_iterator dirIter(basePath);
     if (dirIter == endItr) {
       if (filesHandler == nullptr) {
         delete handler;
       }
       return nullptr;
     }
 
     for (; dirIter != endItr; ++dirIter) {
       // Skip if not a file
       if (!std::filesystem::is_regular_file(dirIter->status()))
         continue;
       std::smatch what;
       // Skip if no match
       auto pathStr = dirIter->path().string();
       if (!std::regex_match(pathStr, what, std::regex(regExpFiles)))
         continue;
       // Skip if not a Root file
       if (pathStr.substr(pathStr.size() - 5) != ".root")
         continue;
       // File matches, store it
       handler->_AddFile(pathStr, force);
     }
     if (handler->GetNFiles() == 0) {
       GGSCOUT(WARNING) << fileName << ": no file found." << GGSENDL;
       delete handler;
       return nullptr;
     }
     handler->_SortFiles();
 
   } else if (fileName.substr(fileName.size() - 4) == ".txt") {
     // *******  Text file with file names *******
     if (std::filesystem::exists(fileName)) {
       std::ifstream file(fileName.data(), std::ios::in);
       std::string currFile;
       while (file.good()) {
         getline(file, currFile);
         if (std::filesystem::exists(currFile) && currFile.substr(currFile.size() - 5) == ".root")
           handler->_AddFile(currFile, force);
       }
     } else {
       if (filesHandler == nullptr) {
         delete handler;
       }
       return nullptr;
     }
   } else if (fileName.substr(fileName.size() - 5) == ".root") {
     // *******  Single root file *******
     if (!handler->_AddFile(fileName, force)) {
       if (filesHandler == nullptr) {
         delete handler;
       }
       return nullptr;
     }
   } else {
     if (filesHandler == nullptr) {
       delete handler;
     }
     return nullptr;
   }
 
   if (find(_filesHandlers.begin(), _filesHandlers.end(), handler) == _filesHandlers.end())
     _filesHandlers.push_back(handler);
   return handler;
 }

GGSTFilesHandler* GGSTRootReader::Open	(	const char *	fileName,
		GGSTFilesHandler *	filesHandler = `nullptr`,
		bool	force = `false`
	)

inline

Open ROOT files.

Overload with const char *.

Parameters

fileName	Path to Root file (eventually with wildcards) or to a txt file containing the list of desired Root files.
filesHandler	The files handler to which the newly opened file will be appended. If nullptr a new handler will be created.
force	if true, no consistency check between different files will be done.

Returns: A pointer to a GGSTFilesHandler object handling the opened files (nullptr if file(s) do(es) not exist or if an error has occurred).

Definition at line 101 of file GGSTRootReader.h.

                                                                                                              {
     return Open(std::string(fileName), filesHandler, force);
   }

bool GGSTRootReader::OpenFile ( const char * fileName )

inline

Opens a ROOT file.

This method is kept for backward compatibility. It opens a single Root file. The usage of this method is discouraged and it will be deprecated in some future release. The suggested method is Open.

Parameters

fileName Path to file.

Returns: true if file opening was successful, false otherwise.

Definition at line 113 of file GGSTRootReader.h.

113 { return Open(fileName); }

GGSTRootReader::Open

GGSTFilesHandler * Open(const std::string &fileName, GGSTFilesHandler *filesHandler=nullptr, bool force=false)

Open ROOT files.

Definition: GGSTRootReader.cpp:34

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Member Function Documentation