Belle2::RootIOUtilities Namespace Reference

Some constants and helpers common to the RootInput and RootOutput modules. More...

Classes
class	RootFileInfo
	Helper class to factorize some necessary tasks when working with Belle2 output files. More...

Functions
std::set< std::string >	filterBranches (const std::set< std::string > &branchesToFilter, const std::vector< std::string > &branches, const std::vector< std::string > &excludeBranches, int durability, bool quiet=false)
	Given a list of input branches and lists of branches to include/exclude, returns a list of branches that are accepted.
size_t	setBranchStatus (TBranch *branch, bool process)
	Set Branch to be read or not.
std::vector< std::string >	expandWordExpansions (const std::vector< std::string > &filenames)
	Performs wildcard expansion using wordexp(), returns matches.
long	getEntryNumberWithEvtRunExp (TTree *tree, long event, long run, long experiment)
	return entry number with given (event, run, experiment) from tree.
void	buildIndex (TTree *tree)
	Build TTreeIndex on tree (assumes either EventMetaData branch exists or is a ntuple tree).
bool	hasStreamer (const TClass *cl)
	Returns true if and only if 'cl' or one of its bases has I/O streamers.
bool	hasCustomStreamer (const TClass *cl)
	Returns true if and only if 'cl' has a user-defined streamer.
void	setCreationData (FileMetaData &metadata)
	Fill the creation info of a file meta data: site, user, data.
std::string	getCommitID ()
	Return git SHA1 hashes taking into account local & central release.
bool	isReservedTreeName (const std::string &name)
	Check whether a tree name is a reserved basf2 tree name as defined in RootIOUtilities::c_treeNames.

Variables
const std::string	c_treeNames [] = { "tree", "persistent" }
	Names of trees.
const std::string	c_SteerBranchNames [] = { "branchNames", "branchNamesPersistent" }
	Steering parameter names for m_branchNames.
const std::string	c_SteerExcludeBranchNames [] = { "excludeBranchNames", "excludeBranchNamesPersistent" }
	Steering parameter names for m_excludeBranchNames.
const std::string	c_SteerAdditionalBranchNames [] = { "additionalBranchNames", "additionalBranchNamesPersistent" }
	Steering parameter names for m_additionalBranchNames.

Detailed Description

Some constants and helpers common to the RootInput and RootOutput modules.

Function Documentation

buildIndex()

void buildIndex

(

TTree *

tree

)

Build TTreeIndex on tree (assumes either EventMetaData branch exists or is a ntuple tree).

Definition at line 154 of file RootIOUtilities.cc.

{
  std::string treeName = tree->GetName();
  TBranch* const EventMetaDataBranch = tree->GetBranch("EventMetaData");
  if ((strcmp(treeName.c_str(), "tree") == 0) && EventMetaDataBranch) {
    tree->BuildIndex("1000000*EventMetaData.m_experiment+EventMetaData.m_run", "EventMetaData.m_event");
  }
  // for ntuple trees that do not have EventMetaData branch we use the tree level branches
  else {
    std::string key = "1000000*" + treeName + ".__experiment__+" + treeName + ".__run__";
    std::string event = treeName + ".__event__";
    tree->BuildIndex(key.c_str(), event.c_str());
  }
}

expandWordExpansions()

std::vector< std::string > expandWordExpansions

(

const std::vector< std::string > &

filenames

)

Performs wildcard expansion using wordexp(), returns matches.

Definition at line 116 of file RootIOUtilities.cc.

{
  std::vector<std::string> out;
  wordexp_t expansions;
  wordexp("", &expansions, 0);
  for (const std::string& pattern : filenames) {
    if (wordexp(pattern.c_str(), &expansions, WRDE_APPEND | WRDE_NOCMD | WRDE_UNDEF) != 0) {
      B2ERROR("Failed to expand pattern '" << pattern << "'!");
    }
  }
  out.resize(expansions.we_wordc);
  for (unsigned int i = 0; i < expansions.we_wordc; i++) {
    out[i] = expansions.we_wordv[i];
  }
  wordfree(&expansions);
  return out;
}

filterBranches()

std::set< std::string > filterBranches	(	const std::set< std::string > &	branchesToFilter,
		const std::vector< std::string > &	branches,
		const std::vector< std::string > &	excludeBranches,
		int	durability,
		bool	quiet = false )

Given a list of input branches and lists of branches to include/exclude, returns a list of branches that are accepted.

More precisely, an item b from 'branchesToFilter' will be in the returned set if b not in excludeBranches and (b in branches or empty(branches) or b in relationsBetweenAcceptedBranches) and b not in relationsInvolvingExcludedBranches

Parameters

branchesToFilter	input
branches	if not empty, the list of branches to be accepted
excludeBranches	branches that should never end up in output (takes precedence over everything else)
durability	Durability being filtered (used for messages only)
quiet	If true don't warn about branches which are missing/extra/duplicate in the lists

Definition at line 32 of file RootIOUtilities.cc.

{
  std::set<std::string> branchSet, excludeBranchSet;
  for (const std::string& b : branches) {
    if (branchesToFilter.count(b) == 0 and not quiet)
      B2WARNING("The branch " << b << " given in " << c_SteerBranchNames[durability] << " does not exist.");
    if (!branchSet.insert(b).second and not quiet)
      B2WARNING(c_SteerBranchNames[durability] << " has duplicate entry " << b);
  }
  for (const std::string& b : excludeBranches) {
    // FIXME: ProcessStatistics is excluded by default but not always present. We should switch that to not write it out
    // in the first place but the info message is meaningless for almost everyone
    if (branchesToFilter.count(b) == 0 and not quiet and b != "ProcessStatistics")
      B2INFO("The branch " << b << " given in " << c_SteerExcludeBranchNames[durability] << " does not exist.");
    if (!excludeBranchSet.insert(b).second and not quiet)
      B2WARNING(c_SteerExcludeBranchNames[durability] << " has duplicate entry " << b);
  }
 
  std::set<std::string> out;
  for (const std::string& branch : branchesToFilter) {
    if (excludeBranchSet.count(branch))
      continue;
    if (branchSet.empty() or branchSet.count(branch))
      out.insert(branch);
  }
  std::set<std::string> excluderelations;
  if (!excludeBranchSet.empty()) {
    //remove relations for excluded things
    for (const std::string& from : branchesToFilter) {
      for (const std::string& to : branchesToFilter) {
        std::string branch = DataStore::relationName(from, to);
        if (out.count(branch) == 0)
          continue; //not selected
        if (excludeBranchSet.count(from) == 0 and excludeBranchSet.count(to) == 0)
          continue; //at least one side should be excluded
        if (branchSet.count(branch) != 0)
          continue; //specifically included
        excluderelations.insert(branch);
      }
    }
    for (const std::string& rel : excluderelations) {
      out.erase(rel);
    }
  }
  //add relations between accepted branches
  std::set<std::string> relations;
  for (const std::string& from : out) {
    for (const std::string& to : out) {
      std::string branch = DataStore::relationName(from, to);
      if (branchesToFilter.count(branch) == 0)
        continue; //not in input
      if (excludeBranchSet.count(branch))
        continue;
      relations.insert(branch);
    }
  }
  out.insert(relations.begin(), relations.end());
  return out;
}

getCommitID()

std::string getCommitID

(

)

Return git SHA1 hashes taking into account local & central release.

ID is a combined hash $CENTRAL_SHA1[+$LOCAL_SHA1][-modified], or just SHA1[-modified] if only one release or they are on the same revision. Empty string denotes at least one untracked release directory.

Definition at line 219 of file RootIOUtilities.cc.

{
  return GIT_COMMITID;
}

getEntryNumberWithEvtRunExp()

long getEntryNumberWithEvtRunExp	(	TTree *	tree,
		long	event,
		long	run,
		long	experiment )

return entry number with given (event, run, experiment) from tree.

Returns -1 if not found.

Definition at line 135 of file RootIOUtilities.cc.

{
  const long major = 1000000 * experiment + run;
  const long minor = event;
 
  if (!tree->GetTreeIndex()) {
    B2DEBUG(100, "No TTreeIndex found, rebuild it...");
    buildIndex(tree);
  }
  long entry = tree->GetEntryNumberWithIndex(major, minor);
 
  if (entry == -1) {
    //should be handled by caller
    B2DEBUG(100, "Couldn't find entry (" << event << ", " << run << ", " << experiment << ") in file! (major index: " << major <<
            ", minor index: " << minor << ")");
  }
  return entry;
}

hasCustomStreamer()

bool hasCustomStreamer

(

const TClass *

cl

)

Returns true if and only if 'cl' has a user-defined streamer.

In that case, TClonesArrays of this type should be written with BypassStreamer(false) and split-level -1 (no splitting).

Definition at line 190 of file RootIOUtilities.cc.

{
  // Does this class have a custom streamer?
  return cl->HasCustomStreamerMember();
}

hasStreamer()

bool hasStreamer

(

const TClass *

cl

)

Returns true if and only if 'cl' or one of its bases has I/O streamers.

TObject is not considered to have any.

Definition at line 169 of file RootIOUtilities.cc.

{
  if (cl == TObject::Class())
    return false;
 
  if (cl->GetClassVersion() <= 0) {
    // version number == 0 means no streamers for this class, check base classes
    TList* baseClasses = const_cast<TClass*>(cl)->GetListOfBases(); //method might update an internal cache, but is const otherwise
    TIter it(baseClasses);
    while (auto* base = static_cast<TBaseClass*>(it())) {
      if (hasStreamer(base->GetClassPointer()))
        return true;
    }
    //nothing found
    return false;
  } else {
    return true;
  }
}

isReservedTreeName()

bool isReservedTreeName

(

const std::string &

name

)

Check whether a tree name is a reserved basf2 tree name as defined in RootIOUtilities::c_treeNames.

Definition at line 224 of file RootIOUtilities.cc.

{
  return std::any_of(std::begin(RootIOUtilities::c_treeNames),
                     std::end(RootIOUtilities::c_treeNames),
  [&name](const std::string & s) { return s == name; });
}

setBranchStatus()

size_t setBranchStatus	(	TBranch *	branch,
		bool	process )

Set Branch to be read or not.

TTree::SetBranchAddress doesn't do what we want it to do because our branch names seem to not be conform to their expectations. But we don't need to use name matching, we know our structure and it's simple enough so we just recursively go through the branch and all children and set processing on or off.

Parameters

branch	The branch to change the status for
process	Whether or not to read/process this branch

Returns

the number of branches enabled/disabled

Definition at line 94 of file RootIOUtilities.cc.

{
  size_t found{0};
  std::queue<TBranch*> branches;
  branches.emplace(branch);
  while (!branches.empty()) {
    ++found;
    auto* current = branches.front();
    branches.pop();
    // set the flag we need
    if (process) current->ResetBit(kDoNotProcess);
    else current->SetBit(kDoNotProcess);
    // add all children to the queue
    auto* children = current->GetListOfBranches();
    const auto nchildren = children->GetEntriesFast();
    for (int i = 0; i < nchildren; ++i) {
      branches.emplace(dynamic_cast<TBranch*>(children->UncheckedAt(i)));
    }
  }
  return found;
}

setCreationData()

void setCreationData

(

FileMetaData &

metadata

)

Fill the creation info of a file meta data: site, user, data.

Definition at line 196 of file RootIOUtilities.cc.

{
  std::string site;
  char date[100];
  auto now = time(nullptr);
  strftime(date, 100, "%Y-%m-%d %H:%M:%S", gmtime(&now));
  const char* belle2_site = getenv("BELLE2_SITE");
  if (belle2_site) {
    site = belle2_site;
  } else {
    char hostname[1024];
    gethostname(hostname, 1023); //will not work well for ipv6
    hostname[1023] = '\0'; //if result is truncated, terminating null byte may be missing
    site = hostname;
  }
  const char* user = getenv("BELLE2_USER");
  if (!user) user = getenv("USER");
  if (!user) user = getlogin();
  if (!user) user = "unknown";
  auto commitid = RootIOUtilities::getCommitID();
  metadata.setCreationData(date, site, user, commitid);
}

Variable Documentation

c_SteerAdditionalBranchNames

const std::string c_SteerAdditionalBranchNames = { "additionalBranchNames", "additionalBranchNamesPersistent" }

extern

Steering parameter names for m_additionalBranchNames.

Definition at line 30 of file RootIOUtilities.cc.

{ "additionalBranchNames", "additionalBranchNamesPersistent" };

c_SteerBranchNames

const std::string c_SteerBranchNames = { "branchNames", "branchNamesPersistent" }

extern

Steering parameter names for m_branchNames.

Definition at line 28 of file RootIOUtilities.cc.

{ "branchNames", "branchNamesPersistent" };

c_SteerExcludeBranchNames

const std::string c_SteerExcludeBranchNames = { "excludeBranchNames", "excludeBranchNamesPersistent" }

extern

Steering parameter names for m_excludeBranchNames.

Definition at line 29 of file RootIOUtilities.cc.

{ "excludeBranchNames", "excludeBranchNamesPersistent" };

c_treeNames

const std::string c_treeNames = { "tree", "persistent" }

extern

Names of trees.

Definition at line 27 of file RootIOUtilities.cc.

{ "tree", "persistent" };