QwRootFile Class Reference

A wrapper class for a ROOT file or memory mapped file. More...

#include <QwRootFile.h>

Collaboration diagram for QwRootFile:

Public Member Functions
	QwRootFile (const TString &run_label)
	Constructor with run label.
virtual	~QwRootFile ()
	Destructor.
void	ProcessOptions (QwOptions &options)
	Process the configuration options.
Bool_t	IsRootFile () const
	Is the ROOT file active?
Bool_t	IsMapFile () const
	Is the map file active?
void	ConstructIndices (const std::string &from, const std::string &to, bool reverse=true)
	Construct indices from one tree to another tree.
template<class T>
void	ConstructTreeBranches (const std::string &name, const std::string &desc, T &object, const std::string &prefix="")
	Construct the tree branches of a generic object.
template<class T>
void	FillTreeBranches (const std::string &name, const T &object)
	Fill the tree branches of a generic object by tree name.
template<class T>
void	FillTreeBranches (const T &object)
	Fill the tree branches of a generic object by type only.
template<class T>
Int_t	WriteParamFileList (const TString &name, T &object)
template<class T>
void	ConstructObjects (const std::string &name, T &object)
	Construct the histograms of a generic object.
template<class T>
void	ConstructHistograms (const std::string &name, T &object)
	Construct the histograms of a generic object.
template<class T>
void	FillHistograms (T &object)
	Fill histograms of the subsystem array.
void	NewTree (const std::string &name, const std::string &desc)
	Create a new tree with name and description.
TTree *	GetTree (const std::string &name)
	Get the tree with name.
Int_t	FillTree (const std::string &name)
	Fill the tree with name.
Int_t	FillTrees ()
	Fill all registered trees.
void	PrintTrees () const
	Print registered trees.
void	PrintDirs () const
	Print registered histogram directories.
template<class T>
Int_t	WriteObject (const T *obj, const char *name, Option_t *option="", Int_t bufsize=0)
	Write any object to the ROOT file (only valid for TFile)
void	Update ()
void	Print ()
void	ls ()
void	Map ()
void	Close ()
Bool_t	cd (const char *path=0)
TDirectory *	mkdir (const char *name, const char *title="")
Int_t	Write (const char *name=0, Int_t option=0, Int_t bufsize=0)

Static Public Member Functions
static void	DefineOptions (QwOptions &options)
	Define the configuration options.
static void	SetDefaultRootFileDir (const std::string &dir)
	Set default ROOT files dir.
static void	SetDefaultRootFileStem (const std::string &stem)
	Set default ROOT file stem.

Private Member Functions
void	ClearInMemoryObjects (TDirectory *dir)
	QwRootFile ()
	Private default constructor.
Bool_t	HasAnyFilled (void)
	Search for non-empty trees or histograms in the file.
Bool_t	HasAnyFilled (TDirectory *d)
void	DisableTree (const TString &regexp)
	Add regexp to list of disabled trees names.
bool	IsTreeDisabled (const std::string &name)
	Does this tree name match a disabled tree name?
void	DisableHisto (const TString &regexp)
	Add regexp to list of disabled histogram directories.
bool	IsHistoDisabled (const std::string &name)
	Does this histogram directory match a disabled histogram directory?
bool	HasTreeByName (const std::string &name)
	Is a tree registered for this name.
template<class T>
bool	HasTreeByType (const T &object)
	Is a tree registered for this type.
template<class T>
bool	HasTreeByAddr (const T &object)
	Is a tree registered for this object.
bool	HasDirByName (const std::string &name)
	Is a tree registered for this name.
template<class T>
bool	HasDirByType (const T &object)
	Is a directory registered for this type.

Private Attributes
TFile *	fRootFile
	ROOT file.
TString	fRootFileDir
	ROOT files dir.
TString	fRootFileStem
	ROOT file stem.
TString	fPermanentName
Bool_t	fMakePermanent
Bool_t	fUseTemporaryFile
TMapFile *	fMapFile
	Map file.
Bool_t	fEnableMapFile
TString	fMapFileDir
Int_t	fUpdateInterval
Int_t	fCompressionAlgorithm
Int_t	fCompressionLevel
Int_t	fRNTupleCompressionAlgorithm
Int_t	fRNTupleCompressionLevel
Int_t	fBasketSize
Int_t	fAutoFlush
Int_t	fAutoSave
std::vector< TPRegexp >	fDisabledTrees
	List of excluded trees.
std::vector< TPRegexp >	fDisabledHistos
std::map< const std::string, std::vector< QwRootTree * > >	fTreeByName
	Tree names, addresses, and types.
std::map< const void *, std::vector< QwRootTree * > >	fTreeByAddr
std::map< const std::type_index, std::vector< QwRootTree * > >	fTreeByType
std::map< const std::string, TDirectory * >	fDirsByName
	Directories.
std::map< const std::string, std::vector< std::string > >	fDirsByType
UInt_t	fNumMpsEventsToSkip
	Prescaling of events written to tree.
UInt_t	fNumMpsEventsToSave
UInt_t	fNumHelEventsToSkip
UInt_t	fNumHelEventsToSave
UInt_t	fCircularBufferSize
UInt_t	fCurrentEvent
UInt_t	fHistoFillPrescale = 1
UInt_t	fHistoFillCount = 0

Static Private Attributes
static std::string	fDefaultRootFileDir = "."
	Default ROOT files dir.
static std::string	fDefaultRootFileStem = "Qweak_"
	Default ROOT file stem.
static const Long64_t	kMaxTreeSize = 100000000000LL
	Maximum tree size.
static const Int_t	kMaxMapFileSize = 0x3fffffff

Detailed Description

A wrapper class for a ROOT file or memory mapped file.

This class functions as a wrapper around a ROOT TFile or a TMapFile. The common inheritance of both is only TObject, so there is a lot that we have to wrap (rather than inherit). Theoretically you could have both a TFile and a TMapFile represented by an object of this class at the same time, but that is untested.

The functionality of writing to the file is done by templated functions. The objects that are passed to these functions have to provide the following functions:

• ConstructHistograms, FillHistograms
• ConstructBranchAndVector, FillTreeVector

The class keeps track of the registered tree names, and the types of objects that have branches constructed in those trees (via QwRootTree). In most cases it should be possible to just call FillTreeBranches with only the object, although in rare cases this could be ambiguous.

The proper way to register a tree is by either calling ConstructTreeBranches of NewTree first. Then FillTreeBranches will fill the vector, and FillTree will actually fill the tree. FillTree should be called only once.

Definition at line 859 of file QwRootFile.h.

Constructor & Destructor Documentation

QwRootFile() [1/2]

QwRootFile::QwRootFile

(

const TString &

run_label

)

Constructor with run label.

Constructor with relative filename

Definition at line 28 of file QwRootFile.cc.

  : fRootFile(0), fMakePermanent(0),
    fMapFile(0), fEnableMapFile(kFALSE),
    fUpdateInterval(-1)
#ifdef HAS_RNTUPLE_SUPPORT
    , fEnableRNTuples(kFALSE)
#endif // HAS_RNTUPLE_SUPPORT
{
  // Process the configuration options
  ProcessOptions(gQwOptions);
 
#ifdef QW_ENABLE_MAPFILE
  // Check for the memory-mapped file flag
  if (fEnableMapFile) {
 
    // Verify the target directory exists and is writable before asking ROOT
    // to mmap a file there.  On platforms without /dev/shm (e.g. macOS) the
    // default location is absent; give an actionable message instead of a
    // cryptic TMapFile failure.
    if (gSystem->AccessPathName(fMapFileDir, kWritePermission)) {
      QwError << "Memory-mapped file directory '" << fMapFileDir
              << "' does not exist or is not writable." << QwLog::endl;
      QwError << "Set --mapfile-dir to a writable directory (ideally a RAM "
                 "disk).  /dev/shm does not exist on macOS; a normal directory "
                 "or a hdiutil-mounted RAM disk works there." << QwLog::endl;
      return;
    }
 
    TString mapfilename = fMapFileDir + "/QwMemMapFile.map";
 
    fMapFile = TMapFile::Create(mapfilename,"UPDATE", kMaxMapFileSize, "RealTime Producer File");
 
    if (not fMapFile) {
      QwError << "Memory-mapped file " << mapfilename
              << " could not be opened!" << QwLog::endl;
      return;
    }
 
    QwMessage << "================== RealTime Producer Memory Map File =================" << QwLog::endl;
    QwMessage << "Memory-mapped file: " << mapfilename << QwLog::endl;
    fMapFile->Print();
    QwMessage << "======================================================================" << QwLog::endl;
  } else
#endif
  {
 
    TString rootfilename = fRootFileDir;
    TString hostname = gSystem -> HostName();
 
    // Use a probably-unique temporary file name.
    pid_t pid = getpid();
 
    fPermanentName = rootfilename
      + Form("/%s%s.root", fRootFileStem.Data(), run_label.Data());
    if (fUseTemporaryFile){
      rootfilename += Form("/%s%s.%s.%d.root",
                           fRootFileStem.Data(), run_label.Data(),
                           hostname.Data(), pid);
      // Delete permanent file if it exists to prevent accumulation across segments
      if (gSystem->AccessPathName(fPermanentName.Data()) == 0) {
        QwVerbose << "Removing existing permanent file: " << fPermanentName << QwLog::endl;
        gSystem->Unlink(fPermanentName.Data());
      }
      // CRITICAL: Also delete the temporary file if it exists!
      // RECREATE mode doesn't properly clear files that contain RNTuples,
      // so we must manually delete before opening
      if (gSystem->AccessPathName(rootfilename.Data()) == 0) {
        QwVerbose << "Removing existing temporary file before RECREATE: " << rootfilename << QwLog::endl;
        gSystem->Unlink(rootfilename.Data());
      }
    } else {
      rootfilename = fPermanentName;
      // Delete permanent file if it exists to ensure RECREATE truly starts fresh
      // This is especially important for RNTuple files where RECREATE doesn't properly clear
      if (gSystem->AccessPathName(rootfilename.Data()) == 0) {
        QwMessage << "File exists before RECREATE, deleting: " << rootfilename << QwLog::endl;
        int unlink_result = gSystem->Unlink(rootfilename.Data());
        if (unlink_result == 0) {
          QwMessage << "Successfully deleted file" << QwLog::endl;
        } else {
          QwError << "Failed to delete file! Error code: " << unlink_result << QwLog::endl;
        }
      } else {
        QwMessage << "File does not exist before RECREATE: " << rootfilename << QwLog::endl;
      }
    }
    QwMessage << "Opening file with RECREATE mode: " << rootfilename << QwLog::endl;
    QwMessage << "QwRootFile constructor called for: " << rootfilename << QwLog::endl;
    // Use TFile::Open instead of `new TFile(...)` so the ROOT plug-in manager
    // can dispatch remote URLs (e.g. root://host/path) to TNetXNGFile etc.
    // The TFile(name, opt, title) constructor refuses remote paths and returns
    // a half-built object, which then segfaults at first use.
    fRootFile = TFile::Open(rootfilename.Data(), "RECREATE", "myfile1");
    if (!fRootFile || fRootFile->IsZombie()) {
      QwError << "ROOT file " << rootfilename
              << " could not be opened!" << QwLog::endl;
      delete fRootFile;
      fRootFile = nullptr;
      return;
    } else {
      QwMessage << "Opened "<< (fUseTemporaryFile?"temporary ":"")
                <<"rootfile " << rootfilename << QwLog::endl;
    }
 
    TString run_condition_name = Form("condition_%s", run_label.Data());
    TList *run_cond_list = (TList*) fRootFile -> FindObjectAny(run_condition_name);
    if (not run_cond_list) {
      QwRunCondition run_condition(
          gQwOptions.GetArgc(),
          gQwOptions.GetArgv(),
          run_condition_name
      );
 
      fRootFile -> WriteObject(
          run_condition.Get(),
          run_condition.GetName()
      );
    }
 
    fRootFile->SetCompressionAlgorithm(fCompressionAlgorithm);
    fRootFile->SetCompressionLevel(fCompressionLevel);
  }
}

References QwLog::endl(), fCompressionAlgorithm, fCompressionLevel, fEnableMapFile, fMakePermanent, fMapFile, fMapFileDir, fPermanentName, fRootFile, fRootFileDir, fRootFileStem, fUpdateInterval, fUseTemporaryFile, QwRunCondition::Get(), QwRunCondition::GetName(), gQwOptions, kMaxMapFileSize, ProcessOptions(), QwError, QwMessage, QwVerbose, and WriteObject().

Here is the call graph for this function:

~QwRootFile()

QwRootFile::~QwRootFile ( )

virtual

Destructor.

Destructor

Definition at line 156 of file QwRootFile.cc.

{
  // Keep the file on disk if any trees or histograms have been filled.
  // Also respect any other requests to keep the file around.
  if (!fMakePermanent) fMakePermanent = HasAnyFilled();
 
  // Close the map file
  if (fMapFile) {
    fMapFile->Close();
    // TMapFiles may not be deleted
    fMapFile = 0;
  }
 
  // Close the ROOT file.
  // Rename if permanence is requested, remove otherwise
  if (fRootFile) {
    TString rootfilename = fRootFile->GetName();
 
    fRootFile->Close();
    delete fRootFile;
    fRootFile = 0;
 
    int err;
    const char* action;
    if (fUseTemporaryFile){
      if (fMakePermanent) {
        // Delete existing permanent file first to avoid accumulation
        if (gSystem->AccessPathName(fPermanentName.Data()) == 0) {
          remove(fPermanentName.Data());
        }
        action = " rename ";
        err = rename( rootfilename.Data(), fPermanentName.Data() );
      } else {
        action = " remove ";
        err = remove( rootfilename.Data() );
      }
      // It'd be proper to "extern int errno" and strerror() here,
      // but that doesn't seem very C++-ish.
      if (err) {
        QwWarning << "Couldn't" << action << rootfilename << QwLog::endl;
      } else {
        QwMessage << "Was able to" << action << rootfilename << QwLog::endl;
        QwMessage << "Root file is " << fPermanentName << QwLog::endl;
      }
    }
  }
 
  // Delete Qweak ROOT trees
  std::map< const std::string, std::vector<QwRootTree*> >::iterator map_iter;
  std::vector<QwRootTree*>::iterator vec_iter;
  for (map_iter = fTreeByName.begin(); map_iter != fTreeByName.end(); map_iter++) {
    for (vec_iter = map_iter->second.begin(); vec_iter != map_iter->second.end(); vec_iter++) {
      delete *vec_iter;
    }
  }
}

References QwLog::endl(), fMakePermanent, fMapFile, fPermanentName, fRootFile, fTreeByName, fUseTemporaryFile, HasAnyFilled(), QwMessage, and QwWarning.

Here is the call graph for this function:

QwRootFile() [2/2]

QwRootFile::QwRootFile ( )

private

Private default constructor.

Member Function Documentation

cd()

Bool_t QwRootFile::cd ( const char * path = 0 )

inline

Definition at line 1176 of file QwRootFile.h.

                                    {
      Bool_t status = kTRUE;
      if (fMapFile)  status &= fMapFile->cd(path);
      if (fRootFile) status &= fRootFile->cd(path);
      return status;
    }

References fMapFile, and fRootFile.

Referenced by ConstructTreeBranches(), and NewTree().

Here is the caller graph for this function:

ClearInMemoryObjects()

void QwRootFile::ClearInMemoryObjects ( TDirectory * dir )

inlineprivate

Recursively clear in-memory objects from a directory tree. This removes objects from the TDirectory's in-memory list without deleting their on-disk representation (keys). Used to prevent RNTupleWriter::Close() from creating duplicate histogram cycles when it internally calls TFile::Write().

Definition at line 1093 of file QwRootFile.h.

                                               {
      if (!dir) return;
      
      // First, collect subdirectory names
      std::vector<TString> subdirs;
      TIter next(dir->GetListOfKeys());
      TKey* key;
      while ((key = (TKey*)next())) {
        if (TString(key->GetClassName()) == "TDirectoryFile") {
          subdirs.push_back(key->GetName());
        }
      }
      
      // Recursively clear subdirectories
      for (const auto& name : subdirs) {
        TDirectory* sub = dynamic_cast<TDirectory*>(dir->Get(name));
        if (sub) ClearInMemoryObjects(sub);
      }
      
      // Clear this directory's in-memory object list
      // "nodelete" option: remove from list but don't delete the TKey entries
      TList* list = dir->GetList();
      if (list) {
        list->Clear("nodelete");
      }
    }

References ClearInMemoryObjects().

Referenced by ClearInMemoryObjects(), and Close().

Here is the call graph for this function:

Here is the caller graph for this function:

Close()

void QwRootFile::Close ( )

inline

Definition at line 1121 of file QwRootFile.h.

                  {
 
      if (fRootFile) {
        // Step 1: Write all trees explicitly
        for (auto iter = fTreeByName.begin(); iter != fTreeByName.end(); iter++) {
          if (!iter->second.empty() && iter->second.front()) {
            TTree* tree = iter->second.front()->GetTree();
            if (tree && tree->GetEntries() > 0) {
              tree->Write();
            }
          }
        }
 
        // Step 2: Write all in-memory objects (histograms, etc.) to disk
        // Use kOverwrite to avoid creating duplicate cycles
        fRootFile->Write(0, TObject::kOverwrite);
 
        // Check if we should make the file permanent AFTER writing
        // This ensures histograms are on disk and detectable by HasAnyFilled()
        if (!fMakePermanent) fMakePermanent = HasAnyFilled();
 
        // Step 3: CRITICAL FIX for RNTuple histogram duplication
        // Clear all in-memory objects from the TFile's directory structure.
        // This prevents RNTupleWriter::Close() from re-writing histograms,
        // which would create duplicate cycles. The histograms are already
        // safely written to disk in Step 2.
#ifdef HAS_RNTUPLE_SUPPORT
        if (!fNTupleByName.empty()) {
          ClearInMemoryObjects(fRootFile);
        }
#endif // HAS_RNTUPLE_SUPPORT
      }
 
#ifdef HAS_RNTUPLE_SUPPORT
      // Step 4: Close all RNTuples
      // Now that in-memory histograms are cleared, the RNTupleWriter destructor
      // won't create duplicate histogram cycles when it internally writes to TFile
      for (auto& pair : fNTupleByName) {
        for (auto& ntuple : pair.second) {
          if (ntuple) ntuple->Close();
        }
      }
#endif // HAS_RNTUPLE_SUPPORT
 
      // Step 5: Close the file
      if (fRootFile) {
        fRootFile->Close();
      }
 
      // TMapFile::Close() is NOT idempotent: re-closing in ~QwRootFile()
      // crashes on the already-detached mmap descriptor.
      if (fMapFile) { fMapFile->Close(); fMapFile = 0; }
    }

References ClearInMemoryObjects(), fMakePermanent, fMapFile, fRootFile, fTreeByName, and HasAnyFilled().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructHistograms()

template<class T>

void QwRootFile::ConstructHistograms	(	const std::string &	name,
		T &	object )

Construct the histograms of a generic object.

Construct the histogram of a generic object

Parameters

name	Name for histogram directory
object	Subsystem array

Definition at line 1657 of file QwRootFile.h.

{
  // Return if we do not want this histogram information
  if (IsHistoDisabled(name)) return;
 
  // Create the histograms in a directory
  if (fRootFile) {
    std::string type = typeid(object).name();
    fDirsByName[name] =
        fRootFile->GetDirectory(("/" + name).c_str()) ?
            fRootFile->GetDirectory(("/" + name).c_str()) :
            fRootFile->GetDirectory("/")->mkdir(name.c_str());
    fDirsByType[type].push_back(name);
 
    object.ConstructHistograms(fDirsByName[name]);
  }
 
  // No support for directories in a map file
  if (fMapFile) {
    QwMessage << "QwRootFile::ConstructHistograms::detectors address "
          << &object
          << " and its name " << name
          << QwLog::endl;
 
    // TMapFile does not support subdirectories: histograms created inside a
    // mkdir'd directory are NOT retrievable via TMapFile::Get (readers such as
    // panguin get NULL).  We must cd() into the map's top-level directory so
    // that histograms created by object.ConstructHistograms() attach there and
    // are streamed into shared memory by TMapFile::Update(); otherwise only
    // empty name stubs (class=NULL, size=0) reach the map.
    std::string type = typeid(object).name();
    fMapFile->cd();
    fDirsByName[name] = fMapFile->GetDirectory();
    fDirsByType[type].push_back(name);
    // TMapFile has no subdirectories, so every group's histograms share the
    // map's single top-level directory.  Without a namespace, identically
    // named histograms from different groups (evt_histo/mul_histo/burst_histo)
    // collide: TDirectoryFile::Append replaces (and orphans) the earlier one,
    // producing "Replacing existing TH1 (Potential memory leak)" warnings and
    // dropping histograms from the live display.  Prefix each group's
    // histograms with its directory name so they all coexist in the flat map.
    TString prefix = TString(name.c_str()) + "_";
    object.ConstructHistograms((TDirectory*)NULL, prefix);
  }
}

References QwLog::endl(), fDirsByName, fDirsByType, fMapFile, fRootFile, IsHistoDisabled(), and QwMessage.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructIndices()

void QwRootFile::ConstructIndices ( const std::string & from, const std::string & to, bool reverse = true )

inline

Construct indices from one tree to another tree.

Construct the indices from one tree to another tree, and optionally in reverse as well.

Parameters

from	Name of tree where index will be created
to	Name of tree to which index will point
reverse	Flag to create indices in both direction

Definition at line 1378 of file QwRootFile.h.

{
  // Return if we do not want this tree information
  if (IsTreeDisabled(from)) return;
  if (IsTreeDisabled(to)) return;
 
  // If the trees are defined
  if (fTreeByName.count(from) > 0 && fTreeByName.count(to) > 0) {
 
    // Construct index from the first tree to the second tree
    fTreeByName[from].front()->ConstructIndexTo(fTreeByName[to].front());
 
    // Construct index from the second tree back to the first tree
    if (reverse)
      fTreeByName[to].front()->ConstructIndexTo(fTreeByName[from].front());
  }
}

References fTreeByName, and IsTreeDisabled().

Here is the call graph for this function:

ConstructObjects()

template<class T>

void QwRootFile::ConstructObjects	(	const std::string &	name,
		T &	object )

Construct the histograms of a generic object.

Construct the objects directory of a generic object

Parameters

name	Name for objects directory
object	Subsystem array

Definition at line 1616 of file QwRootFile.h.

{
  // Create the objects in a directory
  if (fRootFile) {
    std::string type = typeid(object).name();
    fDirsByName[name] =
        fRootFile->GetDirectory(("/" + name).c_str()) ?
            fRootFile->GetDirectory(("/" + name).c_str()) :
            fRootFile->GetDirectory("/")->mkdir(name.c_str());
    fDirsByType[type].push_back(name);
    object.ConstructObjects(fDirsByName[name]);
  }
 
  // No support for directories in a map file
  if (fMapFile) {
    QwMessage << "QwRootFile::ConstructObjects::detectors address "
          << &object
          << " and its name " << name
          << QwLog::endl;
 
    // TMapFile does not support subdirectories: objects created inside a
    // mkdir'd directory are NOT retrievable via TMapFile::Get (readers get
    // NULL).  We must cd() into the map's top-level directory so that objects
    // created by object.ConstructObjects() attach there and are streamed into
    // shared memory by TMapFile::Update(); otherwise only empty name stubs
    // reach the map.
    std::string type = typeid(object).name();
    fMapFile->cd();
    fDirsByName[name] = fMapFile->GetDirectory();
    fDirsByType[type].push_back(name);
    object.ConstructObjects();
  }
}

References QwLog::endl(), fDirsByName, fDirsByType, fMapFile, fRootFile, and QwMessage.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructTreeBranches()

template<class T>

void QwRootFile::ConstructTreeBranches	(	const std::string &	name,
		const std::string &	desc,
		T &	object,
		const std::string &	prefix = "" )

Construct the tree branches of a generic object.

Construct the tree branches of a generic object

Parameters

name	Name for tree
desc	Description for tree
object	Subsystem array
prefix	Prefix for the tree

Definition at line 1404 of file QwRootFile.h.

{
  // Return if we do not want this tree information
  if (IsTreeDisabled(name)) return;
 
  // Pointer to new tree
  QwRootTree* tree = 0;
 
  // If the tree does not exist yet, create it
  if (fTreeByName.count(name) == 0) {
 
    // Go to top level directory
 
    this->cd();
 
    // New tree with name, description, object, prefix
    tree = new QwRootTree(name, desc, object, prefix);
 
    // Settings only relevant for new trees
    if (name == "evt")
      tree->SetPrescaling(fNumMpsEventsToSave, fNumMpsEventsToSkip);
    else if (name == "mul")
      tree->SetPrescaling(fNumHelEventsToSave, fNumHelEventsToSkip);
 
    #if ROOT_VERSION_CODE >= ROOT_VERSION(5,26,00)
    tree->SetAutoFlush(fAutoFlush);
    #endif
    tree->SetAutoSave(fAutoSave);
    tree->SetBasketSize(fBasketSize);
    tree->SetMaxTreeSize(kMaxTreeSize);
 
    if (fCircularBufferSize > 0)
      tree->SetCircular(fCircularBufferSize);
 
  } else {
 
    // New tree based on existing tree
    tree = new QwRootTree(fTreeByName[name].front(), object, prefix);
  }
 
   // Add the branches to the list of trees by name, object, type
  const void* addr = static_cast<const void*>(&object);
  const std::type_index type = typeid(object);
  fTreeByName[name].push_back(tree);
  fTreeByAddr[addr].push_back(tree);
  fTreeByType[type].push_back(tree);
}

References cd(), fAutoFlush, fAutoSave, fBasketSize, fCircularBufferSize, fNumHelEventsToSave, fNumHelEventsToSkip, fNumMpsEventsToSave, fNumMpsEventsToSkip, fTreeByAddr, fTreeByName, fTreeByType, IsTreeDisabled(), kMaxTreeSize, QwRootTree::SetAutoFlush(), QwRootTree::SetAutoSave(), QwRootTree::SetBasketSize(), QwRootTree::SetCircular(), QwRootTree::SetMaxTreeSize(), and QwRootTree::SetPrescaling().

Referenced by QwExtractor::ConstructTreeBranches(), VQwDataHandler::ConstructTreeBranches(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

DefineOptions()

void QwRootFile::DefineOptions ( QwOptions & options )

static

Define the configuration options.

Defines configuration options using QwOptions functionality.

Parameters

options

Options object

Definition at line 217 of file QwRootFile.cc.

{
  // Define the ROOT files directory
  options.AddOptions("Default options")
    ("rootfiles", po::value<std::string>()->default_value(fDefaultRootFileDir),
     "directory of the output ROOT files");
 
  // Define the ROOT filename stem
  options.AddOptions("Default options")
    ("rootfile-stem", po::value<std::string>()->default_value(fDefaultRootFileStem),
     "stem of the output ROOT filename");
 
  // Define the memory map option
  options.AddOptions()
    ("enable-mapfile", po::value<bool>()->default_bool_value(false),
     "enable output to memory-mapped file\n(likely requires circular-buffer too)");
  options.AddOptions()
    ("mapfile-dir", po::value<std::string>()->default_value("/dev/shm"),
     "directory that holds the memory-mapped file (QwMemMapFile.map).  Defaults "
     "to /dev/shm (Linux tmpfs).  Set this on platforms without /dev/shm "
     "(e.g. macOS) to a writable directory, ideally a RAM disk.");
  options.AddOptions()
    ("write-temporary-rootfiles", po::value<bool>()->default_bool_value(true),
     "When writing ROOT files, use the PID to create a temporary filename");
 
  // Define the histogram and tree options
  options.AddOptions("ROOT output options")
    ("disable-tree", po::value<std::vector<std::string>>()->composing(),
     "disable output to tree regex");
  options.AddOptions("ROOT output options")
    ("disable-trees", po::value<bool>()->default_bool_value(false),
     "disable output to all trees");
  options.AddOptions("ROOT output options")
    ("disable-histos", po::value<bool>()->default_bool_value(false),
     "disable output to all histograms");
 
  // Define the helicity window versus helicity pattern options
  options.AddOptions("ROOT output options")
    ("disable-mps-tree", po::value<bool>()->default_bool_value(false),
     "disable helicity window output");
  options.AddOptions("ROOT output options")
    ("disable-pair-tree", po::value<bool>()->default_bool_value(false),
     "disable helicity pairs output");
  options.AddOptions("ROOT output options")
    ("disable-hel-tree", po::value<bool>()->default_bool_value(false),
     "disable helicity pattern output");
  options.AddOptions("ROOT output options")
    ("disable-burst-tree", po::value<bool>()->default_bool_value(false),
     "disable burst tree");
  options.AddOptions("ROOT output options")
    ("disable-slow-tree", po::value<bool>()->default_bool_value(false),
     "disable slow control tree");
  options.AddOptions("ROOT output options")
    ("disable-redundant-trees", po::value<bool>()->default_bool_value(false),
     "disable the per-entry trees whose content is already captured by a "
     "matching histogram directory (evt/mul/burst).  Histograms, the "
     "running-sum trees (evts/muls/bursts), the pair tree (pr) and the slow "
     "control tree (slow) are kept.");
 
#ifdef HAS_RNTUPLE_SUPPORT
  // Define the RNTuple options
  options.AddOptions("ROOT output options")
    ("enable-rntuples", po::value<bool>()->default_bool_value(false),
     "enable RNTuple output");
#endif // HAS_RNTUPLE_SUPPORT
 
  // Define the tree output prescaling options
  options.AddOptions("ROOT output options")
    ("num-mps-accepted-events", po::value<int>()->default_value(0),
     "number of accepted consecutive MPS events");
  options.AddOptions("ROOT output options")
    ("num-mps-discarded-events", po::value<int>()->default_value(0),
     "number of discarded consecutive MPS events");
  options.AddOptions("ROOT output options")
    ("num-hel-accepted-events", po::value<int>()->default_value(0),
     "number of accepted consecutive pattern events");
  options.AddOptions("ROOT output options")
    ("num-hel-discarded-events", po::value<int>()->default_value(0),
     "number of discarded consecutive pattern events");
  options.AddOptions("ROOT output options")
    ("mapfile-update-interval", po::value<int>()->default_value(-1),
     "Events between a map file update");
  options.AddOptions("ROOT output options")
    ("fill-prescale", po::value<int>()->default_value(1),
     "Fill trees and histograms only on every Nth processed event (physics is "
     "still computed every event).  Roughly multiplies live (mapfile) throughput "
     "by N at the cost of fewer accumulated monitoring entries.  Default 1 = "
     "fill every event.");
 
  // Define the autoflush and autosave option (default values by ROOT)
  options.AddOptions("ROOT performance options")
    ("autoflush", po::value<int>()->default_value(0),
     "TTree autoflush");
  options.AddOptions("ROOT performance options")
    ("autosave", po::value<int>()->default_value(300000000),
     "TTree autosave");
  options.AddOptions("ROOT performance options")
    ("basket-size", po::value<int>()->default_value(16000),
     "TTree basket size");
  options.AddOptions("ROOT performance options")
    ("circular-buffer", po::value<int>()->default_value(0),
     "TTree circular buffer");
  options.AddOptions("ROOT performance options")
    ("compression-algorithm", po::value<int>()->default_value(1),
     "TFile compression algorithm (1=ZLIB, 2=LZMA, 4=LZ4, 5=ZSTD, default=1 ZLIB)");
  options.AddOptions("ROOT performance options")
    ("compression-level", po::value<int>()->default_value(1),
     "TFile compression level (default = 1, no compression = 0)");
  options.AddOptions("ROOT performance options")
    ("rntuple-compression-algorithm", po::value<int>()->default_value(4),
     "RNTuple compression algorithm (1=ZLIB, 2=LZMA, 4=LZ4, 5=ZSTD, default=4 LZ4)");
  options.AddOptions("ROOT performance options")
    ("rntuple-compression-level", po::value<int>()->default_value(0),
     "RNTuple compression level (0-12, default=0 for maximum performance)");
}

References QwOptions::AddOptions(), fDefaultRootFileDir, and fDefaultRootFileStem.

Referenced by QwOptions::DefineOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

DisableHisto()

void QwRootFile::DisableHisto ( const TString & regexp )

inlineprivate

Add regexp to list of disabled histogram directories.

Definition at line 1262 of file QwRootFile.h.

                                             {
      fDisabledHistos.push_back(regexp);
    }

References fDisabledHistos.

Referenced by ProcessOptions().

Here is the caller graph for this function:

DisableTree()

void QwRootFile::DisableTree ( const TString & regexp )

inlineprivate

Add regexp to list of disabled trees names.

Definition at line 1252 of file QwRootFile.h.

                                            {
      fDisabledTrees.push_back(regexp);
    }

References fDisabledTrees.

Referenced by ProcessOptions().

Here is the caller graph for this function:

FillHistograms()

template<class T>

void QwRootFile::FillHistograms ( T & object )

inline

Fill histograms of the subsystem array.

Definition at line 927 of file QwRootFile.h.

                                   {
      // Update regularly
      static Int_t update_count = 0;
      update_count++;
      if ((fUpdateInterval > 0) && ( update_count % fUpdateInterval == 0)) Update();
 
      // Histogram fill prescaling.  Physics is processed every event, but the
      // (relatively expensive) histogram fill is performed only on every Nth
      // event.  This thins the live monitoring output to gain throughput; the
      // visual refresh rate is unaffected because the displayed histograms
      // simply accumulate slightly fewer entries.
      if (fHistoFillPrescale > 1) {
        if (++fHistoFillCount % fHistoFillPrescale != 0) return;
      }
 
      // Debug directory registration
      std::string type = typeid(object).name();
      bool hasDir = HasDirByType(object);
 
      if (! hasDir) return;
      // Fill histograms
      object.FillHistograms();
    }

References fHistoFillCount, fHistoFillPrescale, fUpdateInterval, HasDirByType(), and Update().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

FillTree()

Int_t QwRootFile::FillTree ( const std::string & name )

inline

Fill the tree with name.

Definition at line 993 of file QwRootFile.h.

                                          {
      if (! HasTreeByName(name)) return 0;
      else return fTreeByName[name].front()->Fill();
    }

References fTreeByName, and HasTreeByName().

Referenced by QwExtractor::FillTreeBranches(), VQwDataHandler::FillTreeBranches(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

FillTreeBranches() [1/2]

template<class T>

void QwRootFile::FillTreeBranches	(	const std::string &	name,
		const T &	object )

Fill the tree branches of a generic object by tree name.

Fill the tree branches of a generic object by name

Parameters

name	Name for tree
object	Subsystem array

Definition at line 1463 of file QwRootFile.h.

{
  // If this name has no registered trees
  if (! HasTreeByName(name)) return;
  // If this type has no registered trees
  if (! HasTreeByType(object)) return;
 
  // Get the address of the object
  const void* addr = static_cast<const void*>(&object);
 
  // Fill the trees with the correct address
  for (size_t tree = 0; tree < fTreeByAddr[addr].size(); tree++) {
    if (fTreeByAddr[addr].at(tree)->GetName() == name) {
      fTreeByAddr[addr].at(tree)->FillTreeBranches(object);
    }
  }
}

References fTreeByAddr, HasTreeByName(), and HasTreeByType().

Referenced by QwExtractor::FillTreeBranches(), VQwDataHandler::FillTreeBranches(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

FillTreeBranches() [2/2]

template<class T>

void QwRootFile::FillTreeBranches

(

const T &

object

)

Fill the tree branches of a generic object by type only.

Fill the tree branches of a generic object by type only

Parameters

object

Subsystem array

Definition at line 1489 of file QwRootFile.h.

{
  // If this address has no registered trees
  if (! HasTreeByAddr(object)) return;
 
  // Get the address of the object
  const void* addr = static_cast<const void*>(&object);
 
  // Fill the trees with the correct address
  for (size_t tree = 0; tree < fTreeByAddr[addr].size(); tree++) {
    fTreeByAddr[addr].at(tree)->FillTreeBranches(object);
  }
}

References fTreeByAddr, and HasTreeByAddr().

Here is the call graph for this function:

FillTrees()

Int_t QwRootFile::FillTrees ( )

inline

Fill all registered trees.

Definition at line 999 of file QwRootFile.h.

                      {
      // Loop over all registered tree names
      Int_t retval = 0;
      std::map< const std::string, std::vector<QwRootTree*> >::iterator iter;
      for (iter = fTreeByName.begin(); iter != fTreeByName.end(); iter++) {
        retval += iter->second.front()->Fill();
      }
      return retval;
    }

References fTreeByName.

GetTree()

TTree * QwRootFile::GetTree ( const std::string & name )

inline

Get the tree with name.

Definition at line 987 of file QwRootFile.h.

                                          {
      if (! HasTreeByName(name)) return 0;
      else return fTreeByName[name].front()->GetTree();
    }

References fTreeByName, and HasTreeByName().

Referenced by GrandCorrelator::ConstructTreeBranches(), QwCorrelator::ConstructTreeBranches(), and QwCorrelatorNew::ConstructTreeBranches().

Here is the call graph for this function:

Here is the caller graph for this function:

HasAnyFilled() [1/2]

Bool_t QwRootFile::HasAnyFilled ( TDirectory * d )

private

Definition at line 522 of file QwRootFile.cc.

                                             {
  if (!d) {
 
    return false;
  }
 
  // First check if any in-memory trees have been filled
  for (auto& pair : fTreeByName) {
    for (auto& tree : pair.second) {
      if (tree && tree->GetTree()) {
        Long64_t entries = tree->GetTree()->GetEntries();
        if (entries > 0) {
 
          return true;
        }
      }
    }
  }
 
#ifdef HAS_RNTUPLE_SUPPORT
  // Then check if any RNTuples have been filled
  for (auto& pair : fNTupleByName) {
    for (auto& ntuple : pair.second) {
      if (ntuple && ntuple->fCurrentEvent > 0) {
 
        return true;
      }
    }
  }
#endif // HAS_RNTUPLE_SUPPORT
 
  TList* l = d->GetListOfKeys();
 
 
  for( int i=0; i < l->GetEntries(); ++i) {
    const char* name = l->At(i)->GetName();
    TObject* obj = d->FindObjectAny(name);
 
 
 
    // Objects which can't be found don't count.
    if (!obj) {
 
      continue;
    }
 
    // Lists of parameter files, map files, and job conditions don't count.
    if ( TString(name).Contains("parameter_file") ) {
 
      continue;
    }
    if ( TString(name).Contains("mapfile") ) {
      continue;
    }
    if ( TString(name).Contains("_condition") ) {
      continue;
    }
    //  The EPICS tree doesn't count
    if ( TString(name).Contains("slow") ) {
      continue;
    }
 
    // Recursively check subdirectories.
    if (obj->IsA()->InheritsFrom( "TDirectory" )) {
      if (this->HasAnyFilled( (TDirectory*)obj )) return true;
    }
 
    if (obj->IsA()->InheritsFrom( "TTree" )) {
      Long64_t entries = ((TTree*) obj)->GetEntries();
      if ( entries ) return true;
    }
 
    if (obj->IsA()->InheritsFrom( "TH1" )) {
      Double_t entries = ((TH1*) obj)->GetEntries();
      if ( entries ) return true;
    }
  }
  return false;
}

References fTreeByName, and HasAnyFilled().

Here is the call graph for this function:

HasAnyFilled() [2/2]

Bool_t QwRootFile::HasAnyFilled ( void )

private

Search for non-empty trees or histograms in the file.

Determine whether the rootfile object has any non-empty trees or histograms.

Definition at line 519 of file QwRootFile.cc.

                                    {
  return this->HasAnyFilled(fRootFile);
}

References fRootFile, and HasAnyFilled().

Referenced by Close(), HasAnyFilled(), HasAnyFilled(), and ~QwRootFile().

Here is the call graph for this function:

Here is the caller graph for this function:

HasDirByName()

bool QwRootFile::HasDirByName ( const std::string & name )

inlineprivate

Is a tree registered for this name.

Definition at line 1338 of file QwRootFile.h.

                                             {
      if (fDirsByName.count(name) == 0) return false;
      else return true;
    }

References fDirsByName.

HasDirByType()

template<class T>

bool QwRootFile::HasDirByType ( const T & object )

inlineprivate

Is a directory registered for this type.

Definition at line 1344 of file QwRootFile.h.

                                       {
      std::string type = typeid(object).name();
      if (fDirsByType.count(type) == 0) return false;
      else return true;
    }

References fDirsByType.

Referenced by FillHistograms().

Here is the caller graph for this function:

HasTreeByAddr()

template<class T>

bool QwRootFile::HasTreeByAddr ( const T & object )

inlineprivate

Is a tree registered for this object.

Definition at line 1305 of file QwRootFile.h.

                                        {
      const void* addr = static_cast<const void*>(&object);
      if (fTreeByAddr.count(addr) == 0) return false;
      else return true;
    }

References fTreeByAddr.

Referenced by FillTreeBranches().

Here is the caller graph for this function:

HasTreeByName()

bool QwRootFile::HasTreeByName ( const std::string & name )

inlineprivate

Is a tree registered for this name.

Definition at line 1292 of file QwRootFile.h.

                                              {
      if (fTreeByName.count(name) == 0) return false;
      else return true;
    }

References fTreeByName.

Referenced by FillTree(), FillTreeBranches(), GetTree(), and NewTree().

Here is the caller graph for this function:

HasTreeByType()

template<class T>

bool QwRootFile::HasTreeByType ( const T & object )

inlineprivate

Is a tree registered for this type.

Definition at line 1298 of file QwRootFile.h.

                                        {
      const std::type_index type = typeid(object);
      if (fTreeByType.count(type) == 0) return false;
      else return true;
    }

References fTreeByType.

Referenced by FillTreeBranches().

Here is the caller graph for this function:

IsHistoDisabled()

bool QwRootFile::IsHistoDisabled ( const std::string & name )

inlineprivate

Does this histogram directory match a disabled histogram directory?

Definition at line 1266 of file QwRootFile.h.

                                                {
      for (size_t i = 0; i < fDisabledHistos.size(); i++)
        if (fDisabledHistos.at(i).Match(name)) return true;
      return false;
    }

References fDisabledHistos.

Referenced by ConstructHistograms().

Here is the caller graph for this function:

IsMapFile()

Bool_t QwRootFile::IsMapFile ( ) const

inline

Is the map file active?

Definition at line 886 of file QwRootFile.h.

{ return (fMapFile); };

References fMapFile.

IsRootFile()

Bool_t QwRootFile::IsRootFile ( ) const

inline

Is the ROOT file active?

Definition at line 884 of file QwRootFile.h.

{ return (fRootFile); };

References fRootFile.

IsTreeDisabled()

bool QwRootFile::IsTreeDisabled ( const std::string & name )

inlineprivate

Does this tree name match a disabled tree name?

Definition at line 1256 of file QwRootFile.h.

                                               {
      for (size_t i = 0; i < fDisabledTrees.size(); i++)
        if (fDisabledTrees.at(i).Match(name)) return true;
      return false;
    }

References fDisabledTrees.

Referenced by ConstructIndices(), ConstructTreeBranches(), and NewTree().

Here is the caller graph for this function:

ls()

void QwRootFile::ls ( )

inline

Definition at line 1085 of file QwRootFile.h.

{ if (fMapFile) fMapFile->ls();     if (fRootFile) fRootFile->ls(); }

References fMapFile, and fRootFile.

Map()

void QwRootFile::Map ( )

inline

Definition at line 1086 of file QwRootFile.h.

{ if (fRootFile) fRootFile->Map(); }

References fRootFile.

mkdir()

TDirectory * QwRootFile::mkdir ( const char * name, const char * title = "" )

inline

Definition at line 1184 of file QwRootFile.h.

                                                                {
      // TMapFile has no support for mkdir
      if (fRootFile) return fRootFile->mkdir(name, title);
      else return 0;
    }

References fRootFile.

NewTree()

void QwRootFile::NewTree ( const std::string & name, const std::string & desc )

inline

Create a new tree with name and description.

Definition at line 953 of file QwRootFile.h.

                                                               {
      if (IsTreeDisabled(name)) return;
      this->cd();
      QwRootTree *tree = 0;
      if (! HasTreeByName(name)) {
        tree = new QwRootTree(name,desc);
      } else {
        tree = new QwRootTree(fTreeByName[name].front());
      }
      fTreeByName[name].push_back(tree);
    }

References cd(), fTreeByName, HasTreeByName(), and IsTreeDisabled().

Referenced by GrandCorrelator::ConstructTreeBranches(), QwCorrelator::ConstructTreeBranches(), and QwCorrelatorNew::ConstructTreeBranches().

Here is the call graph for this function:

Here is the caller graph for this function:

Print()

void QwRootFile::Print ( )

inline

Definition at line 1084 of file QwRootFile.h.

{ if (fMapFile) fMapFile->Print();  if (fRootFile) fRootFile->Print(); }

References fMapFile, and fRootFile.

PrintDirs()

void QwRootFile::PrintDirs ( ) const

inline

Print registered histogram directories.

Definition at line 1045 of file QwRootFile.h.

                           {
      QwMessage << "Dirs: " << QwLog::endl;
      // Loop ove rall registered directories
      std::map< const std::string, TDirectory* >::const_iterator iter;
      for (iter = fDirsByName.begin(); iter != fDirsByName.end(); iter++) {
        QwMessage << iter->first << QwLog::endl;
      }
    }

References QwLog::endl(), fDirsByName, and QwMessage.

Here is the call graph for this function:

PrintTrees()

void QwRootFile::PrintTrees ( ) const

inline

Print registered trees.

Definition at line 1030 of file QwRootFile.h.

                            {
      QwMessage << "Trees: " << QwLog::endl;
      // Loop over all registered tree names
      std::map< const std::string, std::vector<QwRootTree*> >::const_iterator iter;
      for (iter = fTreeByName.begin(); iter != fTreeByName.end(); iter++) {
        QwMessage << iter->first << ": " << iter->second.size()
                  << " objects registered" << QwLog::endl;
        // Loop over all registered objects for this tree
        std::vector<QwRootTree*>::const_iterator tree;
        for (tree = iter->second.begin(); tree != iter->second.end(); tree++) {
          (*tree)->Print();
        }
      }
    }

References QwLog::endl(), fTreeByName, and QwMessage.

Here is the call graph for this function:

ProcessOptions()

void QwRootFile::ProcessOptions

(

QwOptions &

options

)

Process the configuration options.

Parse the configuration options and store in class fields

Parameters

options

Options object

Definition at line 338 of file QwRootFile.cc.

{
  // Option 'rootfiles' to specify ROOT files dir
  fRootFileDir = TString(options.GetValue<std::string>("rootfiles"));
  fs::path tmppath(fRootFileDir.Data());
  if( ! fs::exists(tmppath) || ! fs::is_directory(tmppath)) {
    QwError << "ERROR:  The rootfile directory path, " << fRootFileDir
            << ", does not exist.  Exiting."
            << QwLog::endl;
    exit(2);
  }
 
  // Option 'root-stem' to specify ROOT file stem
  fRootFileStem = TString(options.GetValue<std::string>("rootfile-stem"));
 
  // Option 'mapfile' to enable memory-mapped ROOT file
  fEnableMapFile = options.GetValue<bool>("enable-mapfile");
#ifndef QW_ENABLE_MAPFILE
  if( fEnableMapFile ) {
    QwMessage << QwLog::endl;
    QwWarning << "QwRootFile::ProcessOptions:  "
              << "The 'enable-mapfile' flag is not supported by the ROOT "
                 "version with which this app is built. Disabling it."
              << QwLog::endl;
    fEnableMapFile = false;
  }
#endif
  fMapFileDir = TString(options.GetValue<std::string>("mapfile-dir"));
  while (fMapFileDir.Length() > 1 && fMapFileDir.EndsWith("/"))
    fMapFileDir.Remove(fMapFileDir.Length() - 1);
  fUseTemporaryFile = options.GetValue<bool>("write-temporary-rootfiles");
 
#ifdef HAS_RNTUPLE_SUPPORT
  // Option 'enable-rntuples' to enable RNTuple output
  fEnableRNTuples = options.GetValue<bool>("enable-rntuples");
  // RNTuples require a TFile (RNTupleWriter::Append takes a TDirectory&);
  // they cannot be hosted by a TMapFile.  If both flags are requested,
  // disable RNTuples and warn loudly so the run does not crash later in
  // QwRootNTuple::InitializeWriter with a null TFile*.
  if (fEnableMapFile && fEnableRNTuples) {
    QwMessage << QwLog::endl;
    QwWarning << "QwRootFile::ProcessOptions:  "
              << "RNTuple output is not supported alongside --enable-mapfile "
                 "(TMapFile is not a TDirectory). Disabling RNTuples."
              << QwLog::endl;
    fEnableRNTuples = false;
  }
#endif // HAS_RNTUPLE_SUPPORT
 
  // Options 'disable-trees' and 'disable-histos' for disabling
  // tree and histogram output
  auto v = options.GetValueVector<std::string>("disable-tree");
  std::for_each(v.begin(), v.end(), [&](const std::string& s){ this->DisableTree(s); });
  if (options.GetValue<bool>("disable-trees"))  DisableTree(".*");
  if (options.GetValue<bool>("disable-histos")) DisableHisto(".*");
 
  // Read --circular-buffer up front so the mapfile-mode logic below can use
  // it (the original ProcessOptions read it further down, but we now need
  // it during the mapfile-tree decision).
  fCircularBufferSize = options.GetValue<int>("circular-buffer");
 
  // TMapFile-mode tree publishing.
  //
  // TTrees can be published into the mapfile: TDirectoryFile::Append
  // auto-calls TMapFile::Add() when the directory's mother is a TMapFile,
  // so a TTree created while gDirectory == fMapFile->GetDirectory()
  // becomes a TMapRec on its own.  TMapFile::Update() then re-streams the
  // tree (header + baskets) into the 1 GiB mmap on every interval.
  //
  // The hazard is that an unbounded TTree's serialized size grows
  // monotonically and CustomReAlloc2 aborts as soon as it overruns the
  // mmap.  TTree::SetCircular(N) caps the in-memory entry count, which
  // caps the serialized size.  Require a non-zero circular buffer in
  // mapfile mode; if the user did not pass one, force a safe default
  // and warn loudly rather than silently dropping all trees.
  if (fEnableMapFile && fCircularBufferSize == 0) {
    const UInt_t kMapFileCircularDefault = 100;
    QwMessage << QwLog::endl;
    QwWarning << "QwRootFile::ProcessOptions:  "
              << "--enable-mapfile requires a bounded TTree to avoid "
                 "overrunning the " << (kMaxMapFileSize >> 20)
              << " MiB mmap region.  "
                 "Forcing --circular-buffer=" << kMapFileCircularDefault
              << " (pass --circular-buffer=N to override; pass "
                 "--disable-trees to suppress tree output entirely)."
              << QwLog::endl;
    fCircularBufferSize = kMapFileCircularDefault;
  }
 
#ifdef HAS_RNTUPLE_SUPPORT
  // TTree and RNTuple writers share per-channel state (fTreeArrayIndex,
  // fTreeArrayNumEntries, fDataToSave, b* flags). When both are active,
  // the second Construct*AndVector() call clobbers the first writer's
  // layout, and subsequent Fill*Vector() then walks a vector whose entry
  // types no longer match what was pushed (e.g. SetValue throws
  // "entry type 'D' cannot store unsigned int value 'block2'").
  // Until per-writer layout state is added, make the two writers
  // mutually exclusive: keep RNTuples and silence TTrees.
  if (fEnableRNTuples) {
    QwMessage << QwLog::endl;
    QwMessage << "QwRootFile::ProcessOptions:  "
              << "--enable-rntuples is set; disabling tree output "
                 "(channels share layout state between TTree and RNTuple "
                 "writers, so the two cannot be produced in the same run)."
              << QwLog::endl;
    DisableTree(".*");
  }
#endif // HAS_RNTUPLE_SUPPORT
 
  // Options 'disable-mps' and 'disable-hel' for disabling
  // helicity window and helicity pattern output
  if (options.GetValue<bool>("disable-mps-tree"))  DisableTree("^evt$");
  if (options.GetValue<bool>("disable-pair-tree"))  DisableTree("^pr$");
  if (options.GetValue<bool>("disable-hel-tree"))  DisableTree("^mul$");
  if (options.GetValue<bool>("disable-burst-tree"))  DisableTree("^burst$");
  if (options.GetValue<bool>("disable-slow-tree")) DisableTree("^slow$");
 
  // Option 'disable-redundant-trees' disables the per-entry trees that are
  // fully captured by their matching histogram directories
  // (evt->evt_histo, mul->mul_histo, burst->burst_histo).  The running-sum
  // trees (evts/muls/bursts) hold the unbinned moments, and the pair (pr)
  // and slow (EPICS) trees have no histogram equivalent, so they are left
  // untouched.
  if (options.GetValue<bool>("disable-redundant-trees")) {
    DisableTree("^evt$");
    DisableTree("^mul$");
    DisableTree("^burst$");
  }
 
  // Options 'num-accepted-events' and 'num-discarded-events' for
  // prescaling of the tree output
  fNumMpsEventsToSave = options.GetValue<int>("num-mps-accepted-events");
  fNumMpsEventsToSkip = options.GetValue<int>("num-mps-discarded-events");
  fNumHelEventsToSave = options.GetValue<int>("num-mps-accepted-events");
  fNumHelEventsToSkip = options.GetValue<int>("num-mps-discarded-events");
 
  // Live-output fill prescale.  Filling trees and histograms is a sizeable
  // fraction of the per-event cost, so thinning it to 1-in-N raises throughput
  // (e.g. for live mapfile monitoring) while physics is still processed every
  // event.  The histogram side is gated in FillHistograms() via
  // fHistoFillPrescale; the tree side reuses the existing per-tree prescale.
  // If the user explicitly set a tree prescale we leave it untouched.
  int fillPrescale = options.GetValue<int>("fill-prescale");
  if (fillPrescale < 1) fillPrescale = 1;
  fHistoFillPrescale = fillPrescale;
  if (fillPrescale > 1) {
    if (fNumMpsEventsToSave == 0 && fNumMpsEventsToSkip == 0) {
      fNumMpsEventsToSave = 1;
      fNumMpsEventsToSkip = fillPrescale - 1;
    }
    if (fNumHelEventsToSave == 0 && fNumHelEventsToSkip == 0) {
      fNumHelEventsToSave = 1;
      fNumHelEventsToSkip = fillPrescale - 1;
    }
  }
 
  // Update interval for the map file
  fUpdateInterval = options.GetValue<int>("mapfile-update-interval");
  fCompressionAlgorithm = options.GetValue<int>("compression-algorithm");
  fCompressionLevel = options.GetValue<int>("compression-level");
  fRNTupleCompressionAlgorithm = options.GetValue<int>("rntuple-compression-algorithm");
  fRNTupleCompressionLevel = options.GetValue<int>("rntuple-compression-level");
  fBasketSize = options.GetValue<int>("basket-size");
 
  // Autoflush and autosave
  fAutoFlush = options.GetValue<int>("autoflush");
  if ((ROOT_VERSION_CODE < ROOT_VERSION(5,26,00)) && fAutoFlush != -30000000){
    QwMessage << QwLog::endl;
    QwWarning << "QwRootFile::ProcessOptions:  "
              << "The 'autoflush' flag is not supported by ROOT version "
              << ROOT_RELEASE
              << QwLog::endl;
  }
  fAutoSave  = options.GetValue<int>("autosave");
  return;
}

References DisableHisto(), DisableTree(), QwLog::endl(), fAutoFlush, fAutoSave, fBasketSize, fCircularBufferSize, fCompressionAlgorithm, fCompressionLevel, fEnableMapFile, fHistoFillPrescale, fMapFileDir, fNumHelEventsToSave, fNumHelEventsToSkip, fNumMpsEventsToSave, fNumMpsEventsToSkip, fRNTupleCompressionAlgorithm, fRNTupleCompressionLevel, fRootFileDir, fRootFileStem, fUpdateInterval, fUseTemporaryFile, QwOptions::GetValue(), QwOptions::GetValueVector(), kMaxMapFileSize, QwError, QwMessage, and QwWarning.

Referenced by QwRootFile().

Here is the call graph for this function:

Here is the caller graph for this function:

SetDefaultRootFileDir()

static void QwRootFile::SetDefaultRootFileDir ( const std::string & dir )

inlinestatic

Set default ROOT files dir.

Definition at line 874 of file QwRootFile.h.

                                                            {
      fDefaultRootFileDir = dir;
    }

References fDefaultRootFileDir.

SetDefaultRootFileStem()

static void QwRootFile::SetDefaultRootFileStem ( const std::string & stem )

inlinestatic

Set default ROOT file stem.

Definition at line 878 of file QwRootFile.h.

                                                              {
      fDefaultRootFileStem = stem;
    }

References fDefaultRootFileStem.

Update()

void QwRootFile::Update ( )

inline

Definition at line 1066 of file QwRootFile.h.

                  {
      if (fMapFile) {
        QwMessage << "TMapFile memory resident size: "
                  << ((int*)fMapFile->GetBreakval() - (int*)fMapFile->GetBaseAddr()) *
                     4 / sizeof(int32_t) / 1024 / 1024 << " MiB"
                  << QwLog::endl;
        fMapFile->Update();
      }else{
    // this option will allow for reading the tree during write
    Long64_t nBytes(0);
    for (auto iter = fTreeByName.begin(); iter != fTreeByName.end(); iter++)
      nBytes += iter->second.front()->AutoSave("SaveSelf");
 
    QwMessage << "TFile saved: "
                  << nBytes/1000000 << "MB (inaccurate number)" //FIXME this calculation is inaccurate
                  << QwLog::endl;
      }
    }

References QwLog::endl(), fMapFile, fTreeByName, and QwMessage.

Referenced by FillHistograms().

Here is the call graph for this function:

Here is the caller graph for this function:

Write()

Int_t QwRootFile::Write ( const char * name = 0, Int_t option = 0, Int_t bufsize = 0 )

inline

Definition at line 1191 of file QwRootFile.h.

                                                                           {
      Int_t retval = 0;
      // TMapFile has no support for Write
      if (fRootFile) retval = fRootFile->Write(name, option, bufsize);
      return retval;
    }

References fRootFile.

Referenced by main().

Here is the caller graph for this function:

WriteObject()

template<class T>

Int_t QwRootFile::WriteObject ( const T * obj, const char * name, Option_t * option = "", Int_t bufsize = 0 )

inline

Write any object to the ROOT file (only valid for TFile)

Definition at line 1057 of file QwRootFile.h.

                                                                                                {
      Int_t retval = 0;
      // TMapFile has no support for WriteObject
      if (fRootFile) retval = fRootFile->WriteObject(obj,name,option,bufsize);
      return retval;
    }

References fRootFile.

Referenced by QwRootFile().

Here is the caller graph for this function:

WriteParamFileList()

template<class T>

Int_t QwRootFile::WriteParamFileList	(	const TString &	name,
		T &	object )

Definition at line 1705 of file QwRootFile.h.

{
  Int_t retval = 0;
  if (fRootFile) {
    TList *param_list = (TList*) fRootFile->FindObjectAny(name);
    if (not param_list) {
      retval = fRootFile->WriteObject(object.GetParamFileNameList(name), name);
    }
  }
  return retval;
}

References fRootFile.

Referenced by main().

Here is the caller graph for this function:

Field Documentation

fAutoFlush

Int_t QwRootFile::fAutoFlush

private

Definition at line 1240 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fAutoSave

Int_t QwRootFile::fAutoSave

private

Definition at line 1241 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fBasketSize

Int_t QwRootFile::fBasketSize

private

Definition at line 1239 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fCircularBufferSize

UInt_t QwRootFile::fCircularBufferSize

private

Definition at line 1358 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fCompressionAlgorithm

Int_t QwRootFile::fCompressionAlgorithm

private

Definition at line 1235 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fCompressionLevel

Int_t QwRootFile::fCompressionLevel

private

Definition at line 1236 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fCurrentEvent

UInt_t QwRootFile::fCurrentEvent

private

Definition at line 1359 of file QwRootFile.h.

fDefaultRootFileDir

std::string QwRootFile::fDefaultRootFileDir = "."

staticprivate

Default ROOT files dir.

Definition at line 1211 of file QwRootFile.h.

Referenced by DefineOptions(), and SetDefaultRootFileDir().

fDefaultRootFileStem

std::string QwRootFile::fDefaultRootFileStem = "Qweak_"

staticprivate

Default ROOT file stem.

Definition at line 1216 of file QwRootFile.h.

Referenced by DefineOptions(), and SetDefaultRootFileStem().

fDirsByName

std::map< const std::string, TDirectory* > QwRootFile::fDirsByName

private

Directories.

Definition at line 1334 of file QwRootFile.h.

Referenced by ConstructHistograms(), ConstructObjects(), HasDirByName(), and PrintDirs().

fDirsByType

std::map< const std::string, std::vector<std::string> > QwRootFile::fDirsByType

private

Definition at line 1335 of file QwRootFile.h.

Referenced by ConstructHistograms(), ConstructObjects(), and HasDirByType().

fDisabledHistos

std::vector< TPRegexp > QwRootFile::fDisabledHistos

private

Definition at line 1249 of file QwRootFile.h.

Referenced by DisableHisto(), and IsHistoDisabled().

fDisabledTrees

std::vector< TPRegexp > QwRootFile::fDisabledTrees

private

List of excluded trees.

Definition at line 1248 of file QwRootFile.h.

Referenced by DisableTree(), and IsTreeDisabled().

fEnableMapFile

Bool_t QwRootFile::fEnableMapFile

private

Definition at line 1230 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fHistoFillCount

UInt_t QwRootFile::fHistoFillCount = 0

private

Definition at line 1365 of file QwRootFile.h.

Referenced by FillHistograms().

fHistoFillPrescale

UInt_t QwRootFile::fHistoFillPrescale = 1

private

Live-output fill prescale: fill histograms (and, via the per-tree prescale, the trees) only on every Nth processed event. Default 1 fills on every event. Used to raise throughput in live mapfile mode.

Definition at line 1364 of file QwRootFile.h.

Referenced by FillHistograms(), and ProcessOptions().

fMakePermanent

Bool_t QwRootFile::fMakePermanent

private

Definition at line 1221 of file QwRootFile.h.

Referenced by Close(), QwRootFile(), and ~QwRootFile().

fMapFile

TMapFile* QwRootFile::fMapFile

private

Map file.

Definition at line 1229 of file QwRootFile.h.

Referenced by cd(), Close(), ConstructHistograms(), ConstructObjects(), IsMapFile(), ls(), Print(), QwRootFile(), Update(), and ~QwRootFile().

fMapFileDir

TString QwRootFile::fMapFileDir

private

Directory that holds the memory-mapped file (default "/dev/shm" on Linux; override with –mapfile-dir on platforms without /dev/shm, e.g. macOS).

Definition at line 1233 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fNumHelEventsToSave

UInt_t QwRootFile::fNumHelEventsToSave

private

Definition at line 1357 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fNumHelEventsToSkip

UInt_t QwRootFile::fNumHelEventsToSkip

private

Definition at line 1356 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fNumMpsEventsToSave

UInt_t QwRootFile::fNumMpsEventsToSave

private

Definition at line 1355 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fNumMpsEventsToSkip

UInt_t QwRootFile::fNumMpsEventsToSkip

private

Prescaling of events written to tree.

Definition at line 1354 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fPermanentName

TString QwRootFile::fPermanentName

private

While the file is open, give it a temporary filename. Perhaps change to a permanent name when closing the file.

Definition at line 1220 of file QwRootFile.h.

Referenced by QwRootFile(), and ~QwRootFile().

fRNTupleCompressionAlgorithm

Int_t QwRootFile::fRNTupleCompressionAlgorithm

private

Definition at line 1237 of file QwRootFile.h.

Referenced by ProcessOptions().

fRNTupleCompressionLevel

Int_t QwRootFile::fRNTupleCompressionLevel

private

Definition at line 1238 of file QwRootFile.h.

Referenced by ProcessOptions().

fRootFile

TFile* QwRootFile::fRootFile

private

ROOT file.

Definition at line 1206 of file QwRootFile.h.

Referenced by cd(), Close(), ConstructHistograms(), ConstructObjects(), HasAnyFilled(), IsRootFile(), ls(), Map(), mkdir(), Print(), QwRootFile(), Write(), WriteObject(), WriteParamFileList(), and ~QwRootFile().

fRootFileDir

TString QwRootFile::fRootFileDir

private

ROOT files dir.

Definition at line 1209 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fRootFileStem

TString QwRootFile::fRootFileStem

private

ROOT file stem.

Definition at line 1214 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fTreeByAddr

std::map< const void* , std::vector<QwRootTree*> > QwRootFile::fTreeByAddr

private

Definition at line 1277 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), FillTreeBranches(), FillTreeBranches(), and HasTreeByAddr().

fTreeByName

std::map< const std::string, std::vector<QwRootTree*> > QwRootFile::fTreeByName

private

Tree names, addresses, and types.

Definition at line 1276 of file QwRootFile.h.

Referenced by Close(), ConstructIndices(), ConstructTreeBranches(), FillTree(), FillTrees(), GetTree(), HasAnyFilled(), HasTreeByName(), NewTree(), PrintTrees(), Update(), and ~QwRootFile().

fTreeByType

std::map< const std::type_index , std::vector<QwRootTree*> > QwRootFile::fTreeByType

private

Definition at line 1278 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and HasTreeByType().

fUpdateInterval

Int_t QwRootFile::fUpdateInterval

private

Definition at line 1234 of file QwRootFile.h.

Referenced by FillHistograms(), ProcessOptions(), and QwRootFile().

fUseTemporaryFile

Bool_t QwRootFile::fUseTemporaryFile

private

Definition at line 1222 of file QwRootFile.h.

Referenced by ProcessOptions(), QwRootFile(), and ~QwRootFile().

kMaxMapFileSize

const Int_t QwRootFile::kMaxMapFileSize = 0x3fffffff

staticprivate

Definition at line 1369 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

kMaxTreeSize

const Long64_t QwRootFile::kMaxTreeSize = 100000000000LL

staticprivate

Maximum tree size.

Definition at line 1368 of file QwRootFile.h.

Referenced by ConstructTreeBranches().

---

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

• QwRootFile.h
• QwRootFile.cc