GGSRootFileService Class Reference

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

#include <GGSRootFileService.h>

Public Types
enum	OutputMode { SINGLEFILE, MULTIFILE }
	Aliases for the different output modes. More...

Public Member Functions
TFile *	GetFileForThisRun (const std::filesystem::path &baseName, const G4Run *run)
	Opens a file for a given run and returns a pointer to it. More...
void	CloseFileForThisRun (const std::filesystem::path &baseName, const G4Run *run)
	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 std::filesystem::path &newFileBase)
	Sets the default file name. More...
int	StoreVolume (TFile *tFilePtr, 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...
OutputMode	GetOutputMode ()
	Gets the ouptut mode. More...

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

Friends
class	GGSMultiUserAction
struct	std::hash< VolumeKey >

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 Enumeration Documentation

enum GGSRootFileService::OutputMode

strong

Aliases for the different output modes.

In MT mode, the output can be either on a single Root file or in one Root file per thread. These two possibilities are encoded in this enum class.

Definition at line 154 of file GGSRootFileService.h.

{ SINGLEFILE, MULTIFILE };

Member Function Documentation

void GGSRootFileService::CloseFileForThisRun	(	const std::filesystem::path &	baseName,
		const G4Run *	run
	)

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.
run	The current run.

Definition at line 167 of file GGSRootFileService.cpp.

                                                                                                {

  G4AutoLock lock(mutexForCloseFile);

  std::filesystem::path absPath;

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

  // Strip extension and append suffix and extension
  absPath = _AppendSuffixAndExt(absPath, run);

  // Helper lambda that writes the general simulation information on the output file
  auto WriteGeneralSimInfo = [this](TFile *outFile) {
    // Write simulation informations
    outFile->WriteObjectAny(&_simInfo, "GGSTSimInfo", _simInfo.GetName());

    // 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());
    outFile->WriteObject(&geoParams, "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
        outFile->WriteObject(&generatorParams, "GGSGenParams");
      } catch (...) {
      }
    }
  };

  int iThread = G4Threading::G4GetThreadId();
  for (auto fileInfoIter = _filesInfo.begin(); fileInfoIter != _filesInfo.end(); ++fileInfoIter) {
    if (fileInfoIter->absPath == absPath) {
      for (auto tFileInfoIter = fileInfoIter->tFilesInfo.begin(); tFileInfoIter != fileInfoIter->tFilesInfo.end();
           ++tFileInfoIter) {
        if (tFileInfoIter->threadNo == iThread) {
          --(tFileInfoIter->nRequests);
          if (tFileInfoIter->nRequests == 0) {
            if (tFileInfoIter->defaultEventsTree) {
              tFileInfoIter->defaultEventsTree->Write(); // The tree is already associated to the right TFile
            }
            // Write the detectors array and the general simulation information in the file, but if there is a buffer
            // merger then do it later just on the merged file
            if (!(fileInfoIter->bufferMerger)) {
              if (fileInfoIter->detectorsArray) {
                tFileInfoIter->tFile->WriteObject(fileInfoIter->detectorsArray, "GGSHitDetInfo", "SingleKey");
              }
              WriteGeneralSimInfo(tFileInfoIter->tFile.get());
            }
            // Mute due to this:
            // https://root-forum.cern.ch/t/warning-message-when-merging-files-with-tbuffermerger/42349
            // WARNING: this will suppress any output message from other threads occurring at the same time.
            GGSSmartLog::MuteOutput();
            tFileInfoIter->tFile->Write();
            GGSSmartLog::UnmuteOutput();
            tFileInfoIter = --(fileInfoIter->tFilesInfo.erase(tFileInfoIter));
          } else {
            return;
          }
        }
      }
      if (fileInfoIter->tFilesInfo.size() == 0) {
        if (fileInfoIter->bufferMerger) {
          // Delete the buffer merger
          fileInfoIter->bufferMerger.reset();
          // Open the file for writing global objects
          auto outFile = std::unique_ptr<TFile>(TFile::Open(fileInfoIter->absPath.string().c_str(), "UPDATE"));
          if (fileInfoIter->detectorsArray) {
            outFile->WriteObject(fileInfoIter->detectorsArray, "GGSHitDetInfo", "SingleKey");
          }
          WriteGeneralSimInfo(outFile.get());
          outFile->Close();
        }
        fileInfoIter = --(_filesInfo.erase(fileInfoIter));
      }
    }
  }
}

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 266 of file GGSRootFileService.cpp.

                                                     {
  // Don't allow other threads to ask for a file in the meantime since this might invalidate the references in the
  // loops
  G4AutoLock lock(mutexForGetFile);

  for (auto &fileInfo : _filesInfo) {
    for (auto &tFileInfo : fileInfo.tFilesInfo) {
      if (file == tFileInfo.tFile.get()) {
        if (tFileInfo.defaultEventsTree == nullptr) {
          tFileInfo.defaultEventsTree = new TTree("GGSEventsTree", "GGS events tree. Info: ", 99, file);
        }
        return tFileInfo.defaultEventsTree;
      }
    }
  }
  return nullptr;
}

TFile * GGSRootFileService::GetFileForThisRun	(	const std::filesystem::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 an empty name is provided, the default one ("GGSRootOutput") will be used (the default name can be set with SetDefaultFileBase).
run	The current run.

Returns

Pointer to the output ROOT file.

Definition at line 85 of file GGSRootFileService.cpp.

                                                                                                {

  G4AutoLock lock(mutexForGetFile);

  std::filesystem::path absPath;

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

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

  // Strip extension and append suffix and extension
  absPath = _AppendSuffixAndExt(absPath, run);

  // Lambda that creates a new TFile for current thread and for the given file info
  auto CreateNewTFile = [this, &absPath](FileInfoContainer::iterator fileInfoIter) -> TFile * {
    std::shared_ptr<TFile> newTFile = nullptr;
    if (G4Threading::IsMultithreadedApplication() && _singleFileForMT) {
      // Create the TFile with TBufferMerger in MT single-file mode
      if (!fileInfoIter->bufferMerger) {
        fileInfoIter->bufferMerger = std::make_unique<ROOT::TBufferMerger>(absPath.string().c_str());
      }
      newTFile = fileInfoIter->bufferMerger->GetFile();
    } else {
      // Create the TFile normally in ST mode or in MT multi-file mode
      if (fileInfoIter->tFilesInfo.size() != 0) {
        G4Exception("GGSRootFileService::GetFileForThisRun", "TFile clash", G4ExceptionSeverity::FatalException,
                    ("A TFile is already existing for file " + absPath.string() + " in ST mode; can't create it again")
                        .c_str());
      }
      newTFile = std::make_shared<TFile>(absPath.string().c_str(), "RECREATE");
    }
    fileInfoIter->tFilesInfo.emplace_back();
    auto &tFileInfo = fileInfoIter->tFilesInfo.back();
    tFileInfo.tFile = newTFile;
    tFileInfo.defaultEventsTree = nullptr;
    tFileInfo.threadNo = G4Threading::G4GetThreadId();
    tFileInfo.nRequests = 1;

    return newTFile.get();
  };

  // Check if the file info is already present
  int iThread = G4Threading::G4GetThreadId();
  auto fileInfoIter = _filesInfo.begin();
  for (; fileInfoIter != _filesInfo.end(); ++fileInfoIter) {
    if (absPath == fileInfoIter->absPath) {
      // File info found. Check for the TFile
      for (auto &tFileInfo : fileInfoIter->tFilesInfo) {
        if (tFileInfo.threadNo == iThread) {
          ++(tFileInfo.nRequests);
          return tFileInfo.tFile.get();
        }
      }
      // TFile not found. Create and return it
      return CreateNewTFile(fileInfoIter);
    }
  }

  // File info has not been found, so create it
  _filesInfo.emplace_back();
  fileInfoIter = --(_filesInfo.end());
  fileInfoIter->absPath = absPath;

  // Create the TFile
  TFile *newTFile = CreateNewTFile(fileInfoIter);

  // Set storage of detector to nullptr values to force proper initialization in StoreVolume
  _currVolStorageTFile = nullptr;
  _currDetVolName = "";

  return newTFile;
}

GGSRootFileService & GGSRootFileService::GetInstance ( )

static

Get reference to GGSRootFileService unique instance.

Returns

reference to the root file service.

Definition at line 71 of file GGSRootFileService.cpp.

                                                    {
  static GGSRootFileService instance;
  return instance;
}

OutputMode GGSRootFileService::GetOutputMode ( )

inline

Gets the ouptut mode.

In MT mode, this method will return OutputMode::SINGLEFILE if the simulation output of the different threads will be merged into a single output file, or OutputMode::MULTIFILE if there will be one output file per thread. In ST mode it always returns OutputMode::SINGLEFILE.

Returns

The output mode (single-file or multi-file).

Definition at line 164 of file GGSRootFileService.h.

{ return (_singleFileForMT ? OutputMode::SINGLEFILE : OutputMode::MULTIFILE); }

void GGSRootFileService::SetDefaultFileBase ( const std::filesystem::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 boost::filesystem::path).

Definition at line 122 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 147 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 114 of file GGSRootFileService.h.

{ _suffix = suffix; }

int GGSRootFileService::StoreVolume	(	TFile *	tFilePtr,
		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

tFilePtr	The TFile 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 345 of file GGSRootFileService.cpp.

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

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

  // 1. Retrieve file info structure
  bool fileChanged = false, found = false;
  if (tFilePtr != _currVolStorageTFile) {
    fileChanged = true;
    _currVolStorageTFile = tFilePtr;

    for (_currVolStorageFileInfo = _filesInfo.begin(); _currVolStorageFileInfo != _filesInfo.end();
         ++_currVolStorageFileInfo) {
      for (auto &tFileInfo : _currVolStorageFileInfo->tFilesInfo) {
        if (tFileInfo.tFile.get() == tFilePtr) {
          found = true;
          break;
        }
      }
      if (found) {
        break;
      }
    }
    if (!found) {
      G4Exception("GGSRootFileService::StoreVolume", "TFile not found", G4ExceptionSeverity::FatalException,
                  (std::string("TFile for ") + tFilePtr->GetName() + " is not managed by GGSRootFileService").c_str());
    }
  }

  // 2. Find the detector in the index
  if (fileChanged || _currDetVolName != detVolName) {
    _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::make_pair<std::string, HitVolMap>(std::string(_currDetVolName), HitVolMap()));
      _currDetector = _currVolStorageFileInfo->detectorsMap.end(); // Past-the-end iterator
      --_currDetector;                                             // Set the iterator to the last element
      if (_currVolStorageFileInfo->detectorsArray == nullptr) {
        _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
  std::string volAndId = volume->GetName() + std::to_string(id);

  auto insertResult =
      _currDetector->second.emplace(VolumeKey(volAndId, volume, position), _currPersDetector->volumes.GetEntries());
  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