GGSTRootReader.h

Go to the documentation of this file.

/*
 * GGSTRootReader.h
 *
 *  Created on: 22 Aug 2011
 *      Author: Nicola Mori
 */

#ifndef GGSTROOTREADER_H_
#define GGSTROOTREADER_H_

// Standard headers
#include <iostream>
#include <vector>

// ROOT headers
#include "TChain.h"
#include "TFile.h"
#include "TGeoManager.h"

// GGS headers
#include "montecarlo/readers/GGSTChainReader.h"
#include "montecarlo/readers/GGSTFilesHandler.h"
#include "utils/GGSSmartLog.h"

class GGSTRootReader {

public:
  GGSTRootReader();

  ~GGSTRootReader();

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

  GGSTFilesHandler *Open(const char *fileName, GGSTFilesHandler *filesHandler = nullptr, bool force = false) {
    return Open(std::string(fileName), filesHandler, force);
  }

  bool OpenFile(const char *fileName) { return Open(fileName); }

  template <class T> T *GetReader(GGSTFilesHandler *filesHandler = nullptr, const TString &treeName = "");

  void GetEntry(Long64_t entry);

  Long64_t GetEntries();

  Long64_t GetReadEntry() { return _currentEv; }

  const GGSTSimInfo *GetSimInfo(const GGSTFilesHandler *filesHandler = nullptr);

  const GGSTGeoParams *GetGeoParams(const GGSTFilesHandler *filesHandler = nullptr);

  const GGSTParameters *GetGenParams(const GGSTFilesHandler *filesHandler = nullptr);

  const TGeoManager *GetROOTGeometry(const GGSTFilesHandler *filesHandler = nullptr);

private:
  TChain *_FindChain(const TString &treeName, GGSTFilesHandler *filesHandler);
  TChain *_CreateChain(const TString &treeName, GGSTFilesHandler *filesHandler);
  bool _CheckBranches(TTree *tree1, TTree *tree2);

  Long64_t _GetEntriesBlind();

  std::vector<GGSTFilesHandler *> _filesHandlers;

  struct ReadersInfo {
    GGSTChainReader *reader;
    TChain *chain;
    GGSTFilesHandler *filesHandler;

    ~ReadersInfo() { delete reader; }
  };
  typedef std::vector<ReadersInfo *> ReadersStore;

  ReadersStore _readers;
  Long_t _currentEv;
  GGSTSimInfo _simInfo;
};

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....

template <class T> T *GGSTRootReader::GetReader(GGSTFilesHandler *filesHandler, const TString &treeName) {

  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()) {
          COUT(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 {
      COUT(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 {
    COUT(WARNING) << "Can't find tree " << tName << ". The reader has not been created." << ENDL;
    return nullptr;
  }
}
#endif /* GGSTROOTREADER_H_ */