GGSRootFileService Class Reference

Singleton for a centralized ROOT files management. More...

#include <GGSRootFileService.h>

Public Member Functions
	~GGSRootFileService ()
	Destructor.
TFile *	GetFileForThisRun (const path &baseName, const G4Run *run)
	Opens a file for a given run and returns a pointer to it. More...
void	CloseFileForThisRun (const path &baseName)
	Closes the ROOT output file. More...
TTree *	GetDefaultTree (TFile *file)
	Gets the default tree for this file. More...
void	SetSuffix (const std::string &suffix)
	Sets the suffix for file names. More...
void	SetDefaultFileBase (const path &newFileBase)
	Sets the default file name. More...
int	StoreVolume (TFile *filePtr, const std::string &detector, const G4VPhysicalVolume *volume, const G4ThreeVector &position, int id)
	Set persistence for the specified volume. More...
void	SetSimInfo (const GGSTSimInfo &simInfo)
	Set the simulation info object to be saved on output files. More...

Static Public Member Functions
static GGSRootFileService &	GetInstance ()
	Get reference to GGSRootFileService unique instance. More...

Friends
class	GGSUserActionsManager
std::size_t	hash_value (const VolumeKey &key)

Detailed Description

Singleton for a centralized ROOT files management.

The aim of this class is to provide a centralized management for ROOT output files. For each run, the singleton will provide pointers to output file to the action which may require them with the GetFileForThisRun method. The purpose of this is to allow multiple actions to write on the same ROOT file, avoiding the proliferation of output files when many actions are in use. Typically, the singleton will create a file the first time that file is requested; if subsequently other actions require the same file, the singleton will not open it again, but it will simply return a pointer to the already opened file. Consistently, file closure requests issued by calling CloseFileForThisRun will be ignored until no more actions require that file. Users wishing to use this service in their actions are demanded to call GetFileForThisRun in BeginOfRunAction to get the file and to close it with CloseFileForThisRun in EndOfRunAction. The service also provides a standard TTree called GGSEventsTree to let actions save their event data in different branches of the same tree rather than in different trees. This helps I/O performance. See GetDefaultTree.

Definition at line 46 of file GGSRootFileService.h.

Member Function Documentation

void GGSRootFileService::CloseFileForThisRun

(

const path &

baseName

)

Closes the ROOT output file.

The closure request is handled this way: if a file has been requested N times, it will be closed when this method is called for the N-th time. This will avoid to close the file when other actions may still need it.

WARNING: when a ROOT file is closed, all the TTree objects associated to it will be automatically deleted. User must NOT delete its trees before calling this method. Eg.:

outRootFile->cd(); outTree->Write(); GGSRootFileService::GetInstance().CloseFileForThisRun(outBase); //delete outTree; // Uncommenting this will generate a segfault

Parameters

baseName

The file base name.

Definition at line 120 of file GGSRootFileService.cpp.

                                                                 {

  path absBaseName;

  // Set default if no base name has been provided
  if (baseName.string() == "") {
    absBaseName = _defaultOutBase;
  } else
    absBaseName = baseName;
  absBaseName = _GetAbsolutePath(absBaseName);

  for (FileInfoContainer::iterator iter = _files.begin(); iter != _files.end(); iter++)
    if (iter->absBaseName == absBaseName) {
      if (iter->nRequests > 1) {
        iter->nRequests--;
        return;
      } else {
        iter->filePtr->cd();
        if (iter->defaultEventsTree)
          iter->defaultEventsTree->Write();
        if (iter->detectorsArray)
          iter->detectorsArray->Write(
              "GGSHitDetInfo",
              TObject::kSingleKey); //  Automatically set iter->detectorsArray ownership to iter->filePtr
        iter->filePtr->Close();
        delete iter->filePtr;
        delete iter->detectorsMap;
        iter = _files.erase(iter);
      }
    }
}

TTree * GGSRootFileService::GetDefaultTree

(

TFile *

file

)

Gets the default tree for this file.

This method returns the default events tree for the specified file. This is intended to allow user actions to write their output as branches of the same tree instead of using a tree for each action. In this way the best performance of the I/O system of ROOT can be exploited (see https://twiki.cern.ch/twiki/bin/view/LHCb/PersistencyMigration#POOL). The Fill() and Write() operations for the default tree are managed by GGSRootFileService. The only operation that can be done with the tree is the creation of a branch. Explicitly calling Fill() or Write() for the default tree in user actions will result in a wrong number of events and in multiple keys for the tree in the output file. Fill() will be automatically called at the end of each event after calling EndOfEventAction() for every user action.

Different default trees can be requested for different files.

Parameters

file	The file on which the default tree will be saved. This file pointer must have been previously retrieved by calling GetFileForThisRun; DON'T use a file created in any other way.

Returns

a pointer to the default tree, NULL if file has not been created by GetFileForThisRun.

Definition at line 153 of file GGSRootFileService.cpp.

                                                     {

  for (FileInfoContainer::iterator iter = _files.begin(); iter != _files.end(); iter++) {
    if (file == iter->filePtr) {
      if (iter->defaultEventsTree == NULL) {
        iter->filePtr->cd();
        iter->defaultEventsTree = new TTree("GGSEventsTree", "GGS events tree. Info: ");
      }
      return iter->defaultEventsTree;
    }
  }
  return NULL;
}

TFile * GGSRootFileService::GetFileForThisRun	(	const path &	baseName,
		const G4Run *	run
	)

Opens a file for a given run and returns a pointer to it.

This method will open a file for a given run and return a pointer to it; if the file is already opened, it will simply return the pointer without attempting to open it again. The created file will be named baseName.root for run 0 (eventually baseName_suffix.root if a suffix is specified calling SetSuffix); for subsequent runs, it will be named baseName_RunID.root (or baseName_RunID_suffix.root).

Parameters

baseName	The file base name (.root extension, run ID and suffix will be (eventually) automatically appended). If no name is provided, the default one ("GGSRootOutput") will be used (it can also be set with SetDefaultFileBase).
run	The current run.

Returns

Pointer to the (eventually opened) output ROOT file.

Definition at line 52 of file GGSRootFileService.cpp.

                                                                                   {

  path absBaseName;

  // Set default if no base name has been provided
  if (baseName.string() == "") {
    absBaseName = _defaultOutBase;
  } else
    absBaseName = baseName;

  // Retrieve absolute path
  absBaseName = _GetAbsolutePath(absBaseName);

  // check if the file is already opened
  for (FileInfoContainer::iterator iter = _files.begin(); iter != _files.end(); iter++)
    if (absBaseName == iter->absBaseName) {
      iter->nRequests++;
      return iter->filePtr;
    }

  // Create new file info struct
  FileInfo fInfo;
  fInfo.nRequests = 1;
  fInfo.absBaseName = absBaseName;

  // Strip extension and append suffix and extension
  TString absFileName = _AppendSuffixAndExt(absBaseName, run);

  // Open file and store it
  fInfo.filePtr = new TFile(absFileName, "RECREATE");
  _files.push_back(fInfo);

  // Write simulation informations
  _simInfo.Write();

  // Write geometry informations
  GGSVGeometryConstruction *geoCons = GGSGeoPluginManager::GetInstance().GetGeoConstruction();
  GGSTGeoParams geoParams;
  geoParams.SetIntGeoParams(geoCons->GetIntParameters());
  geoParams.SetBoolGeoParams(geoCons->GetBoolParameters());
  geoParams.SetRealGeoParams(geoCons->GetRealParameters());
  geoParams.SetStringGeoParams(geoCons->GetStringParameters());
  geoParams.SetVectIntGeoParams(geoCons->GetVectIntParameters());
  geoParams.SetVectBoolGeoParams(geoCons->GetVectBoolParameters());
  geoParams.SetVectRealGeoParams(geoCons->GetVectRealParameters());
  geoParams.SetVectStringGeoParams(geoCons->GetVectStringParameters());
  geoParams.Write("GGSGeoParams");

  // Write generator informations
  // These are written only for GGS generators that export a parameter object containing the "generator" name setting.
  auto *genAction =
      dynamic_cast<const GGSGeneratorAction *>(GGSRunManager::GetRunManager()->GetUserPrimaryGeneratorAction());
  if (genAction) {
    GGSTParameters generatorParams(genAction->GetParameters());
    try {
      generatorParams.GetParam<std::string>("generator"); // Throws if "generator" parameter is not present
      generatorParams.Write("GGSGenParams");
    } catch (...) {
    }
  }
  // Set storage of detector to null values to force proper initialization in StoreVolume
  _currVolStorageFile = NULL;
  _currDetVolName = "";

  return fInfo.filePtr;
}

GGSRootFileService & GGSRootFileService::GetInstance ( )

static

Get reference to GGSRootFileService unique instance.

Returns

reference to the root file service.

Definition at line 30 of file GGSRootFileService.cpp.

                                                    {
  static GGSRootFileService instance;
  return instance;
}

void GGSRootFileService::SetDefaultFileBase ( const path &  newFileBase )

inline

Sets the default file name.

The default file name is used when a file is requested by calling GetFileForThisRun but no file name is provided.

Parameters

newFileBase

The new default file base name (optionally with path).

Definition at line 123 of file GGSRootFileService.h.

{ _defaultOutBase = newFileBase; }

void GGSRootFileService::SetSimInfo ( const GGSTSimInfo &  simInfo )

inline

Set the simulation info object to be saved on output files.

Parameters

simInfo

The object containing informations about the simulation.

Definition at line 148 of file GGSRootFileService.h.

{ _simInfo = simInfo; }

void GGSRootFileService::SetSuffix ( const std::string &  suffix )

inline

Sets the suffix for file names.

The suffix will be appended after just before the .root extension.

Parameters

suffix

The suffix.

Definition at line 115 of file GGSRootFileService.h.

{ _suffix = suffix; }

int GGSRootFileService::StoreVolume	(	TFile *	filePtr,
		const std::string &	detector,
		const G4VPhysicalVolume *	volume,
		const G4ThreeVector &	position,
		int	id
	)

Set persistence for the specified volume.

The specified volume (volume name, position and id) will be saved as a GGSTHitVolInfo object inside the GGSTHitDetInfo object corresponding to the specified detector. The GGSTHitDetInfo is saved as an element of a TClonesArray called GGSHitDetArray inside the specified file.

The (volume name, id) pair must be unique for each volume to be stored.

Parameters

filePtr	The file where to save the informations about detectors and volumes.
detector	The name of the detector.
volume	The pointer to the physical volume.
position	The position of the volume (in internal G4 units; will be saved in [cm]).
id	The ID of the volume (see GGSTHitVolInfo).

Returns

The position of the volume in the store.

See Also

GGSTHitVolInfo

Definition at line 213 of file GGSRootFileService.cpp.

                                                                           {
  static const std::string routineName("GGSRootFileService::StoreVolume");

  std::string detVolName = detector.substr(0, detector.find_first_of('.'));

  // 1. Retrieve file info structure
  bool fileChanged = false;
  if (filePtr != _currVolStorageFile) {
    fileChanged = true;
    _currVolStorageFile = filePtr;
    for (_currVolStorageFileInfo = _files.begin(); _currVolStorageFileInfo != _files.end(); _currVolStorageFileInfo++) {
      if (_currVolStorageFileInfo->filePtr == filePtr)
        break;
    }
    if (_currVolStorageFileInfo == _files.end()) {
      COUT(WARNING) << "The requested file is not managed by GGSRootFileService. Volume informations will not be saved."
                    << ENDL;
      return -1;
    }
  }

  // 2. Find the detector in the index
  static HitDetMap::iterator currDetector;
  static GGSTHitDetInfo *currPersDetector = NULL;
  if (fileChanged || _currDetVolName != detVolName) {
    if (_currVolStorageFileInfo->detectorsMap == NULL)
      _currVolStorageFileInfo->detectorsMap = new HitDetMap;
    _currDetVolName = detVolName;
    int currPersDetectorIndex = 0;
    for (currDetector = _currVolStorageFileInfo->detectorsMap->begin();
         currDetector != _currVolStorageFileInfo->detectorsMap->end(); currDetector++, currPersDetectorIndex++) {
      if (currDetector->first == _currDetVolName)
        break;
    }
    if (currDetector == _currVolStorageFileInfo->detectorsMap->end()) {
      // 2.1 Detector not found. Create it both in index and persistence array
      _currVolStorageFileInfo->detectorsMap->push_back(std::pair<std::string, HitVolMap>(_currDetVolName, HitVolMap()));
      currDetector = _currVolStorageFileInfo->detectorsMap->end(); // Past-the-end iterator
      currDetector--;                                              // Set the iterator to the last element
      if (_currVolStorageFileInfo->detectorsArray == NULL) {
        _currVolStorageFileInfo->detectorsArray = new TClonesArray("GGSTHitDetInfo");
      }
      currPersDetectorIndex = _currVolStorageFileInfo->detectorsArray->GetEntries(); // Redundant
      currPersDetector = new ((*(_currVolStorageFileInfo->detectorsArray))[currPersDetectorIndex]) GGSTHitDetInfo;
      currPersDetector->detectorName = _currDetVolName.data();
    } else {
      // 2.2 Detector found. Set the current persistent detector
      currPersDetector = (GGSTHitDetInfo *)(_currVolStorageFileInfo->detectorsArray->At(currPersDetectorIndex));
    }
  }

  // 3. Insert the volume in the index and in the persistency structure

  // Append volume ID to volume name to avoid placing all the replicated volumes at the same place in the index
  static std::stringstream ss;
  ss.str("");
  ss << id;
  std::string volAndId = volume->GetName() + ss.str();

  std::pair<VolumeKey, G4int> insertValue(VolumeKey(volAndId, volume, position),
                                          currPersDetector->volumes.GetEntries());
  std::pair<HitVolMap::iterator, bool> insertResult;
  insertResult = currDetector->second.insert(insertValue); // TODO: using emplace instead of insert would improve speed?
  if (insertResult.second) {
    // 3.1 No hash collision: this is a new volume. Add it also to the volumes array in detector object...
    GGSTHitVolInfo *volInfo = new ((currPersDetector->volumes)[currPersDetector->volumes.GetEntries()]) GGSTHitVolInfo;
    volInfo->volumeName = volume->GetName().data();
    for (int i = 0; i < 3; i++) {
      volInfo->volumePos[i] = position[i] / cm;
    }
    volInfo->id = id;
    // ... then return its position in the array
    return currPersDetector->volumes.GetEntries() - 1;
  } else {
    // 3.2 A hash collision has happened: the volume is already present. So take its position from the index
    return insertResult.first->second;
  }
}

---

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

• GGSRootFileService.h
• GGSRootFileService.cpp