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
Int_t	fUpdateInterval
Int_t	fCompressionAlgorithm
Int_t	fCompressionLevel
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

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 833 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 25 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) {
 
    TString mapfilename = "/dev/shm/";
 
    mapfilename += "/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;
    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;
    fRootFile = new TFile(rootfilename.Data(), "RECREATE", "myfile1");
    if (! fRootFile) {
      QwError << "ROOT file " << rootfilename
              << " could not be opened!" << QwLog::endl;
      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, 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 135 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 1136 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 1055 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 1083 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();
      }
 
      if (fMapFile) fMapFile->Close();
    }

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 1595 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;
 
    std::string type = typeid(object).name();
    fDirsByName[name] = fMapFile->GetDirectory()->mkdir(name.c_str());
    fDirsByType[type].push_back(name);
    //object.ConstructHistograms(fDirsByName[name]);
    object.ConstructHistograms();
  }
}

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 1327 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 1561 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;
 
    std::string type = typeid(object).name();
    fDirsByName[name] = fMapFile->GetDirectory()->mkdir(name.c_str());
    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 1353 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 196 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()
    ("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");
 
#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");
 
  // 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)");
}

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 1217 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 1207 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 901 of file QwRootFile.h.

                                   {
      // Update regularly
      static Int_t update_count = 0;
      update_count++;
      if ((fUpdateInterval > 0) && ( update_count % fUpdateInterval == 0)) Update();
 
      // Debug directory registration
      std::string type = typeid(object).name();
      bool hasDir = HasDirByType(object);
 
      if (! hasDir) return;
      // Fill histograms
      object.FillHistograms();
    }

References 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 955 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 1412 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 1438 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 961 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 949 of file QwRootFile.h.

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

References fTreeByName, and HasTreeByName().

Referenced by QwCorrelator::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 370 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 367 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 1293 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 1299 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 1260 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 1247 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 1253 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 1221 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 860 of file QwRootFile.h.

{ return (fMapFile); };

References fMapFile.

IsRootFile()

Bool_t QwRootFile::IsRootFile ( ) const

inline

Is the ROOT file active?

Definition at line 858 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 1211 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 1047 of file QwRootFile.h.

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

References fMapFile, and fRootFile.

Map()

void QwRootFile::Map ( )

inline

Definition at line 1048 of file QwRootFile.h.

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

References fRootFile.

mkdir()

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

inline

Definition at line 1144 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 918 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 QwCorrelator::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 1046 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 1007 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 992 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 294 of file QwRootFile.cc.

{
  // Option 'rootfiles' to specify ROOT files dir
  fRootFileDir = TString(options.GetValue<std::string>("rootfiles"));
 
  // 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
  fUseTemporaryFile = options.GetValue<bool>("write-temporary-rootfiles");
 
#ifdef HAS_RNTUPLE_SUPPORT
  // Option 'enable-rntuples' to enable RNTuple output
  fEnableRNTuples = options.GetValue<bool>("enable-rntuples");
#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(".*");
 
  // 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$");
 
  // 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");
 
  // Update interval for the map file
  fCircularBufferSize = options.GetValue<int>("circular-buffer");
  fUpdateInterval = options.GetValue<int>("mapfile-update-interval");
  fCompressionAlgorithm = options.GetValue<int>("compression-algorithm");
  fCompressionLevel = options.GetValue<int>("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, fNumHelEventsToSave, fNumHelEventsToSkip, fNumMpsEventsToSave, fNumMpsEventsToSkip, fRootFileDir, fRootFileStem, fUpdateInterval, fUseTemporaryFile, QwOptions::GetValue(), QwOptions::GetValueVector(), 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 848 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 852 of file QwRootFile.h.

                                                              {
      fDefaultRootFileStem = stem;
    }

References fDefaultRootFileStem.

Update()

void QwRootFile::Update ( )

inline

Definition at line 1028 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 1151 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 1019 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 1629 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 1195 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fAutoSave

Int_t QwRootFile::fAutoSave

private

Definition at line 1196 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fBasketSize

Int_t QwRootFile::fBasketSize

private

Definition at line 1194 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fCircularBufferSize

UInt_t QwRootFile::fCircularBufferSize

private

Definition at line 1313 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fCompressionAlgorithm

Int_t QwRootFile::fCompressionAlgorithm

private

Definition at line 1192 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fCompressionLevel

Int_t QwRootFile::fCompressionLevel

private

Definition at line 1193 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fCurrentEvent

UInt_t QwRootFile::fCurrentEvent

private

Definition at line 1314 of file QwRootFile.h.

fDefaultRootFileDir

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

staticprivate

Default ROOT files dir.

Definition at line 1171 of file QwRootFile.h.

Referenced by DefineOptions(), and SetDefaultRootFileDir().

fDefaultRootFileStem

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

staticprivate

Default ROOT file stem.

Definition at line 1176 of file QwRootFile.h.

Referenced by DefineOptions(), and SetDefaultRootFileStem().

fDirsByName

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

private

Directories.

Definition at line 1289 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 1290 of file QwRootFile.h.

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

fDisabledHistos

std::vector< TPRegexp > QwRootFile::fDisabledHistos

private

Definition at line 1204 of file QwRootFile.h.

Referenced by DisableHisto(), and IsHistoDisabled().

fDisabledTrees

std::vector< TPRegexp > QwRootFile::fDisabledTrees

private

List of excluded trees.

Definition at line 1203 of file QwRootFile.h.

Referenced by DisableTree(), and IsTreeDisabled().

fEnableMapFile

Bool_t QwRootFile::fEnableMapFile

private

Definition at line 1190 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fMakePermanent

Bool_t QwRootFile::fMakePermanent

private

Definition at line 1181 of file QwRootFile.h.

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

fMapFile

TMapFile* QwRootFile::fMapFile

private

Map file.

Definition at line 1189 of file QwRootFile.h.

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

fNumHelEventsToSave

UInt_t QwRootFile::fNumHelEventsToSave

private

Definition at line 1312 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fNumHelEventsToSkip

UInt_t QwRootFile::fNumHelEventsToSkip

private

Definition at line 1311 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fNumMpsEventsToSave

UInt_t QwRootFile::fNumMpsEventsToSave

private

Definition at line 1310 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and ProcessOptions().

fNumMpsEventsToSkip

UInt_t QwRootFile::fNumMpsEventsToSkip

private

Prescaling of events written to tree.

Definition at line 1309 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 1180 of file QwRootFile.h.

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

fRootFile

TFile* QwRootFile::fRootFile

private

ROOT file.

Definition at line 1166 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 1169 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fRootFileStem

TString QwRootFile::fRootFileStem

private

ROOT file stem.

Definition at line 1174 of file QwRootFile.h.

Referenced by ProcessOptions(), and QwRootFile().

fTreeByAddr

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

private

Definition at line 1232 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 1231 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 1233 of file QwRootFile.h.

Referenced by ConstructTreeBranches(), and HasTreeByType().

fUpdateInterval

Int_t QwRootFile::fUpdateInterval

private

Definition at line 1191 of file QwRootFile.h.

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

fUseTemporaryFile

Bool_t QwRootFile::fUseTemporaryFile

private

Definition at line 1182 of file QwRootFile.h.

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

kMaxMapFileSize

const Int_t QwRootFile::kMaxMapFileSize = 0x3fffffff

staticprivate

Definition at line 1318 of file QwRootFile.h.

Referenced by QwRootFile().

kMaxTreeSize

const Long64_t QwRootFile::kMaxTreeSize = 100000000000LL

staticprivate

Maximum tree size.

Definition at line 1317 of file QwRootFile.h.

Referenced by ConstructTreeBranches().

---

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

• QwRootFile.h
• QwRootFile.cc