Common Analysis Framework » QFRAMEWORK » TQSampleFolder

class TQSampleFolder: public TQFolder


 TQSampleFolder:

 The TQSampleFolder class is a representation of a certain group/category of event samples
 and by inheriting from the TQFolder class allows to build up a tree-like structure. Analysis
 results (e.g. histograms or cutflow counters) corresponding to the group of samples
 represented by an instance of the TQSampleFolder class may be stored in specific sub-folders
 (instances of TQFolder) of that instance (e.g. ".histograms" or ".cutflow"). Analysis results
 are retrieved from instances of TQSampeFolder using the TQSampleDataReader class, with
 wrappers implemented in the TQSampleFolder class:

 - TQSampleFolder::getHistogram("<path>", "<name>", ...)

 - TQSampleFolder::getCounter("<path>", "<name>", ...)

 A new and independent instance of TQSampleFolder is created using the static method
 TQSampleFolder::newSampleFolder(...):

 TQSampleFolder * sf = TQSampleFolder::newSampleFolder("sf");

 whereas a new instance inside an existing sample folder tree can be created using
 TQSampleFolder::getSampleFolder(...):

 TQSampleFolder * sf = sf->getSampleFolder("newSf+");

 similar to TQFolder::getFolder(...).

 Histograms and counter can be deleted recursively using

 - TQSampleFolder::deleteHistogram(...)
 - TQSampleFolder::deleteSingleCounter(...)
 - TQSampleFolder::deleteHistograms(...)
 - TQSampleFolder::deleteCounter(...)

 and renamed recursively using

 - TQSampleFolder::renameHistogram(...)
 - TQSampleFolder::renameCounter(...)

 Histograms and counter can be copied (optionally performing additional operations on these
 objects) using:

 - TQSampleFolder::copyHistogram(...)
 - TQSampleFolder::copyHistograms(...)

 The TQSampleFolder class provides powerful features to validate cutflow counter between
 two different instances of TQSampleFolder:

 - TQSampleFolder::validateAllCounter(...)
 - TQSampleFolder::validateCounter(...)

 Generalization of histograms and counter:

 Storing histograms or other analysis result objects in a sample folder tree can become very
 memory extensive if for each sample an individual instance is stored. To reduce the
 granularity of object storage and thereby the memory usage the concept of "generalization"
 has been introduced. Generalizing e.g. a histogram at some node in the sample folder tree
 will sum up and remove individual contributions within the corresponding sub-tree and store
 the final sum in the respective sample folder the generalization has taken place at:

 - TQSampleFolder::generalizeHistograms(...)
 - TQSampleFolder::generalizeCounter(...)



Function Members (Methods)

public:
virtual~TQSampleFolder()
voidTObject::AbstractMethod(const char* method) const
virtual voidTFolder::Add(TObject* obj)
virtual TQFolder*TQFolder::addCopyOfObject(TObject* object, TString destination = "", TClass* folderClass = TQFolder::Class())
TQFolder*TQFolder::addFolder(TQFolder* folder_, TString path_ = "", TClass* tclass = 0)
TFolder*TFolder::AddFolder(const char* name, const char* title, TCollection* collection = 0)
virtual TQFolder*TQFolder::addObject(TObject* object, TString destination = "", TClass* folderClass = TQFolder::Class())
TQSampleFolder*addSampleFolder(TQSampleFolder* sampleFolder_, TString path_ = "", TClass* tclass = 0)
boolTQTaggable::allTagsOfTypeBool()
boolTQTaggable::allTagsOfTypeDouble()
boolTQTaggable::allTagsOfTypeInteger()
boolTQTaggable::allTagsOfTypeString()
boolTQTaggable::allTagsValidBools()
boolTQTaggable::allTagsValidDoubles()
boolTQTaggable::allTagsValidIntegers()
virtual voidTObject::AppendPad(Option_t* option = "")
intTQFolder::areRelated(const TQFolder* other) const
voidTQFolder::autoSetExportName()
voidTQFolder::autoSetExportNames()
voidbefriend(TQSampleFolder* other)
virtual voidTFolder::Browse(TBrowser* b)
boolTQTaggable::canSetThisTag(const TString& key, bool& treatAsList)
boolTQFolder::checkConsistency(bool verbose = false)
ULong_tTObject::CheckedHash()
intTQTaggable::claimTags(const TString& definition, bool printErrMsg = false)
intTQTaggable::claimTags(const TString& definition, TString& message)
intTQTaggable::claimTags(const TString& definition, TString& missing, TString& invalid, TString& unexpected)
static TClass*Class()
virtual const char*TObject::ClassName() const
voidTQTaggable::clear()
virtual voidTFolder::Clear(Option_t* option = "")
voidclearFriends()
intTQTaggable::clearTags()
virtual TObject*TNamed::Clone(const char* newname = "") const
boolTQFolder::collapse()
virtual intTQFolder::Compare(const TObject* obj) const
static TStringTQFolder::concatPaths(TString path1, TString path2)
static TStringTQFolder::concatPaths(const TString& path1, const TString& path2, const TString& path3)
static TStringTQFolder::concatPaths(const TString& path1, const TString& path2, const TString& path3, const TString& path4)
static TStringTQFolder::concatPaths(const TString& path1, const TString& path2, const TString& path3, const TString& path4, const TString& path5)
voidconvertLegacyNFs()
virtual TQFolder*TQFolder::copy(const TString& newName = "")
virtual voidTFolder::Copy(TObject&) const
static TQFolder*TQFolder::copyDirectoryStructure(const TString& basepath, int maxdepth = 999)
static TQFolder*TQFolder::copyDirectoryStructureEOS(const TString& basepath, int maxdepth = 999)
static TQFolder*TQFolder::copyDirectoryStructureLocal(const TString& basepath, int maxdepth = 999)
virtual TQFolder*TQFolder::copyFolder(const TString& source, const TString& dest)
intcopyHistogram(TString source, TString destination, TString options = "")
intcopyHistograms(TString sourceFilter, TString appendix, TString options = "")
intcopyHistogramToCounter(TString source, TString destination = "")
virtual TQFolder*TQFolder::copyTo(TQFolder* dest)
virtual TQFolder*TQFolder::copyTo(const TString& dest)
intcountFriends()
intTQTaggable::countMatchingTags(const TString& name) const
static intTQFolder::countPathLevels(TString path, bool checkPathTokens = true)
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual intTQFolder::deleteAll()
intdeleteCounter(TString filter)
intdeleteHistogram(TString name)
intdeleteHistograms(TString filter)
booldeleteLocalCounter(TString name)
booldeleteLocalHistogram(TString name)
booldeleteLocalObject(TString category, TString name)
virtual intTQFolder::deleteObject(TString name, bool removeOnly = false, TClass* tclass = 0)
intdeleteSingleCounter(TString name)
TQFolder*TQFolder::detachFromBase()
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt,...) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
boolTQFolder::executeCopyCommand(TString object, TString& errMsg, bool moveOnly, const TString& destPrefix = "")
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
boolTQTaggable::exportConfigFile(bool writeUnreadKeys = true)
boolTQTaggable::exportConfigFile(const TString& filename, bool writeUnreadKeys = true)
boolTQTaggable::exportConfigFile(const TString& filename, const TString& prefix, bool writeUnreadKeys = true)
intTQTaggable::exportTags(TQTaggable* dest, const TString& subDest = "", const TString& filter = "", bool recursive = false)
TStringTQTaggable::exportTagsAsConfigString(const TString& prefix, const TString& filter = "")
stringTQTaggable::exportTagsAsStandardConfigString(const TString& prefix, const TString& filter = "")
stringTQTaggable::exportTagsAsStandardString(const TString& filter = "", bool xmlStyle = false)
TStringTQTaggable::exportTagsAsString(const TString& filter = "", bool xmlStyle = false)
virtual TList*TQFolder::exportTagsToText(const TString& filter)
virtual boolTQFolder::exportTagsToTextFile(const TString& filename, const TString& filter)
boolTQFolder::exportToHTMLFile(const TString& filename, int expandDepth = 1, bool includeUntextables = true)
virtual TList*TQFolder::exportToText(bool includeUntextables = false, int indent = 0)
virtual boolTQFolder::exportToTextFile(const TString& filename, bool includeUntextables = false)
virtual voidTObject::Fatal(const char* method, const char* msgfmt,...) const
virtual voidTNamed::FillBuffer(char*& buffer)
TQFolder*TQFolder::findCommonBaseFolder(TCollection* fList, bool allowWildcards = true)
voidfindFriends(bool forceUpdate = false)
voidfindFriends(const TString& pathpattern, bool forceUpdate = false)
voidfindFriends(TQSampleFolder* otherSF, bool forceUpdate = false)
virtual const char*TFolder::FindFullPathName(const char* name) const
virtual const char*TFolder::FindFullPathName(const TObject* obj) const
virtual TObject*TFolder::FindObject(const char* name) const
virtual TObject*TFolder::FindObject(const TObject* obj) const
virtual TObject*TFolder::FindObjectAny(const char* name) const
intgeneralizeCounters(const TString& paths = "", const TString& options = "")
intgeneralizeCounters(TList* names, const TString& paths, const TString& options)
intgeneralizeHistograms(const TString& paths = "", const TString& options = "")
intgeneralizeHistograms(TList* names, const TString& paths, const TString& options)
intgeneralizeObjects(const TString& prefix, const TString& options = "")
intgeneralizeObjects(TList* names, TClass* objClass, const TString& options, const TString& paths, const TString& subpath)
TQFolder*TQFolder::getBase(int depth = 1) const
TQSampleFolder*getBaseSampleFolder()
virtual TQTaggable*TQFolder::getBaseTaggable() const
TObject*TQFolder::getCopyOfObject(const TString& name_, const TString& path_ = "")
TQCounter*getCounter(TString path, TString name, TString options = "", TList* sfList = 0)
intTQFolder::getDepth()
virtual TList*TQFolder::getDescendantTaggables()
TDirectory*TQFolder::getDirectory()
intTQFolder::getDistToRoot() const
virtual Option_t*TObject::GetDrawOption() const
static Longptr_tTObject::GetDtorOnly()
const TString&TQFolder::getExportName()
virtual TStringTQTaggable::getFlags()
intTQTaggable::getFlagsSize()
TQFolder*TQFolder::getFolder(const TString& path)
TQFolder*TQFolder::getFolder(const char* path)
TQFolder*TQFolder::getFolder(const TString& path_, TClass* tclass)
vector<TString>TQFolder::getFolderPaths(const TString& path_ = "?", TClass* tClass = TQFolder::Class(), bool toplevelOnly = false)
vector<TString>TQFolder::getFolderPathsWildcarded(const TString& path_ = "?", TClass* tClass = TQFolder::Class(), bool toplevelOnly = false)
vector<TQFolder*>TQFolder::getFoldersWithTagEquivalentTo(const TQValue* tag)
vector<TQFolder*>TQFolder::getFoldersWithTagEquivalentTo(const TQValue& tag)
vector<TQFolder*>TQFolder::getFoldersWithTagsEquivalentTo(const vector<const TQValue*>& tags)
shared_ptr<set<TQSampleFolder*> >getFriends()
boolTQTaggable::getGlobalIgnoreCase() const
boolTQTaggable::getGlobalOverwrite() const
static shared_ptr<TQTaggable>TQTaggable::getGlobalTaggable(const char* name)
static shared_ptr<TQTaggable>TQTaggable::getGlobalTaggable(const TString& name)
TH1*getHistogram(TString path, TString name, TQTaggable* options = nullptr, TList* sfList = 0)
TH1*getHistogram(TString path, TString name, TString options, TList* sfList = 0)
virtual const char*TObject::GetIconName() const
TList*getListOfCounterNames(const TString& path = ".", TList* sfList = 0)
TCollection*TFolder::GetListOfFolders() const
TList*TQFolder::getListOfFolders(const TString& path_ = "?", TClass* tclass = TQFolder::Class(), bool toplevelOnly = false, bool firstMatchOnly = false)
TList*getListOfHistogramNames(const TString& path = ".", TList* sfList = 0)
TList*TQTaggable::getListOfKeys(const TString& filter = "")
TList*TQFolder::getListOfObjectNames(TClass* class_ = 0, bool recursive = false, TString path_ = "")
TList*TQFolder::getListOfObjectPaths(TString path_ = "?", TClass* tclass = TObject::Class())
TList*TQFolder::getListOfObjects(TString path_ = "?", TClass* tclass = TObject::Class())
TList*getListOfSampleFolders(const TString& path_ = "?", TClass* tclass = TQSampleFolder::Class(), bool toplevelOnly = false)
TList*getListOfSamples(const TString& path = "*")
virtual TList*TQFolder::getListOfTaggables(const TString& taggables)
TList*TQTaggable::getListOfTagNames()
virtual TList*TQTaggable::getListOfUnreadKeys(const TString& filter = "")
TStringTQFolder::getName() const
virtual const char*TNamed::GetName() const
const TString&TQFolder::getNameConst() const
virtual intTQFolder::getNElements(bool recursive = false, TClass* class_ = 0)
virtual intTQFolder::getNObjects(const TString& nameFilter = "") const
virtual intTQFolder::getNObjects(const TString& nameFilter, bool recursive)
intgetNSampleFolders(bool recursive = false)
intgetNSamples(bool recursive = false)
intTQTaggable::getNTags() const
TObject*TQFolder::getObject(const TString& name_, const TString& path_ = "")
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
TStringTQFolder::getObjectPath(TString name_)
TList*TQFolder::getObjectPaths(TString namepattern, TString pathpattern = "./", TClass* objClass = TObject::Class())
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual intTQFolder::getOwnSize() const
TStringTQFolder::getPath()
TStringgetPathFriendsWildcarded(bool requireWildcardTag = true)
static TStringTQFolder::getPathHead(TString& path)
static TStringTQFolder::getPathTail(TString& path)
TStringTQFolder::getPathWildcarded()
static TStringTQFolder::getPathWithoutHead(TString path)
static TStringTQFolder::getPathWithoutTail(TString path)
TQFolder*TQFolder::getRoot()
TQSampleFolder*getRootSampleFolder()
TQSample*getSample(const TString& path)
TQSampleFolder*getSampleFolder(TString path_, TClass* tclass = 0)
vector<TString>getSampleFolderPaths(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
vector<TString>getSampleFolderPathsWildcarded(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
vector<TQSampleFolder*>getSampleFoldersWithTagEquivalentTo(const TQValue* tag)
vector<TQSampleFolder*>getSampleFoldersWithTagEquivalentTo(const TQValue& tag)
vector<TQSampleFolder*>getSampleFoldersWithTagsEquivalentTo(const vector<const TQValue*>& tags)
vector<TString>getSamplePaths(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
vector<TString>getSamplePathsWildcarded(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
doublegetScaleFactor(const TString& name, bool recursive = false)
boolgetScaleFactor(const TString& path, double& scale, double& uncertainty, bool recursive = false)
TQCounter*getScaleFactorCounter(const TString& name)
TQCounter*getScaleFactorCounterInternal(TString name)
TQCounter*getScaleFactorCounterInternal(const TString& path, const TString& scaleScheme)
TQCounter*getScaleFactorCounterRecursive(const TString& name)
virtual intTQFolder::getSize(bool memoryOnly = true)
virtual TStringTQFolder::getSizeAsString(bool memoryOnly = true)
boolTQTaggable::getTag(const TString& key, double& value)
boolTQTaggable::getTag(const TString& key, int& value)
boolTQTaggable::getTag(const TString& key, bool& value)
boolTQTaggable::getTag(const TString& key, TString& value)
intTQTaggable::getTag(const TString& key, vector<TString>& vec)
intTQTaggable::getTag(const TString& key, vector<int>& vec)
intTQTaggable::getTag(const TString& key, vector<double>& vec)
intTQTaggable::getTag(const TString& key, vector<bool>& vec)
intTQTaggable::getTag(const TString& key, TList* l)
boolTQTaggable::getTag(const TString& key, double& value, bool recursive)
boolTQTaggable::getTag(const TString& key, int& value, bool recursive)
boolTQTaggable::getTag(const TString& key, bool& value, bool recursive)
boolTQTaggable::getTag(const TString& key, TString& value, bool recursive)
boolTQTaggable::getTagAsString(const TString& key, TString& tag)
boolTQTaggable::getTagBool(const TString& key, bool& value)
boolTQTaggable::getTagBool(const TString& key, bool& value, bool recursive)
boolTQTaggable::getTagBoolDefault(const TString& key, bool defaultVal = false)
doubleTQTaggable::getTagDefault(const TString& key, double defaultVal)
intTQTaggable::getTagDefault(const TString& key, int defaultVal)
boolTQTaggable::getTagDefault(const TString& key, bool defaultVal)
TStringTQTaggable::getTagDefault(const TString& key, const TString& defaultVal)
TStringTQTaggable::getTagDefault(const TString& key, const char* defaultVal)
boolTQTaggable::getTagDouble(const TString& key, double& value)
boolTQTaggable::getTagDouble(const TString& key, double& value, bool recursive)
doubleTQTaggable::getTagDoubleDefault(const TString& key, double defaultVal = 0.)
virtual TList*TQFolder::getTaggablesByName(const TString& taggables)
boolTQTaggable::getTagInteger(const TString& key, int& value)
boolTQTaggable::getTagInteger(const TString& key, int& value, bool recursive)
intTQTaggable::getTagIntegerDefault(const TString& key, int defaultVal = 0)
TList*TQTaggable::getTagList(const TString& key)
intTQTaggable::getTagListLength(const TString& key)
intTQTaggable::getTagsSize()
stringTQTaggable::getTagStandardStringDefault(const TString& key, const TString& defaultVal = "")
boolTQTaggable::getTagString(const TString& key, TString& value)
boolTQTaggable::getTagString(const TString& key, TString& value, bool recursive)
TStringTQTaggable::getTagStringDefault(const TString& key, const TString& defaultVal = "")
vector<bool>TQTaggable::getTagVBool(const TString& key)
vector<double>TQTaggable::getTagVDouble(const TString& key)
vector<int>TQTaggable::getTagVInt(const TString& key)
vector<int>TQTaggable::getTagVInteger(const TString& key)
vector<string>TQTaggable::getTagVStandardString(const TString& key)
vector<TString>TQTaggable::getTagVString(const TString& key)
virtual const char*TNamed::GetTitle() const
TList*TQFolder::getTraceToRoot(bool startAtRoot = false)
boolTQTaggable::getTypeOfTagAsString(const TString& key, TString& type)
virtual UInt_tTObject::GetUniqueID() const
static const TString&TQTaggable::getValidKeyCharacters()
static const TString&TQFolder::getValidNameCharacters()
boolTQTaggable::getValueOfTagAsString(const TString& key, TString& value)
TStringTQTaggable::getValuesOfTags(const TString& keys, const TString& sep = ", ")
virtual Bool_tTObject::HandleTimer(TTimer* timer)
boolhasCounter(TString path, TString name, TString options = "")
boolTQTaggable::hasEquivalentTag(const TQValue* reference, bool recurseUp = true)
boolTQTaggable::hasEquivalentTag(const TQValue& reference, bool recurseUp = true)
boolTQTaggable::hasEquivalentTag(const TString& key, const TString& value)
boolTQTaggable::hasEquivalentTag(const TString& key, const double value)
boolTQTaggable::hasEquivalentTag(const TString& key, const int value)
boolTQTaggable::hasEquivalentTag(const TString& key, const bool value)
boolhasFriends()
static boolTQTaggable::hasGlobalTaggable(const char* name)
static boolTQTaggable::hasGlobalTaggable(const TString& name)
virtual ULong_tTNamed::Hash() const
boolhasHistogram(TString path, TString name, TString options = "")
Bool_tTObject::HasInconsistentHash() const
boolTQTaggable::hasMatchingTag(const TString& name) const
virtual boolTQFolder::hasObject(TString name)
boolTQTaggable::hasTag(const TString& key)
boolTQTaggable::hasTagBool(const TString& key)
boolTQTaggable::hasTagDouble(const TString& key)
boolTQTaggable::hasTagInteger(const TString& key)
boolTQTaggable::hasTagString(const TString& key)
boolTQTaggable::hasTagWithIndex(const TString& key)
boolTQTaggable::hasTagWithoutIndex(const TString& key)
virtual boolTQTaggable::hasUnreadKeys(const TString& filter = "")
virtual boolTQFolder::importFromText(const TString& input)
virtual boolTQFolder::importFromText(const TString& input, TString& errorMessage)
virtual boolTQFolder::importFromTextFile(const TString& filename)
virtual boolTQFolder::importFromTextFile(const TString& filename, TString& errorMessage)
virtual boolTQFolder::importFromTextFiles(const TString& filePattern)
virtual boolTQFolder::importFromTextFiles(const TString& filePattern, TString& errorMessage)
virtual TObject*TQFolder::importObject(TString importPath, bool recurse = true)
intTQTaggable::importTag(TString tag, bool overwrite = true, bool keepStringQuotes = false)
intTQTaggable::importTags(TString tags, bool overwrite = true, bool keepStringQuotes = false)
intTQTaggable::importTags(const TQTaggable* tags, bool overwrite = true, bool recursive = false)
intTQTaggable::importTags(shared_ptr<TQTaggable> tags, bool overwrite = true, bool recursive = false)
intTQTaggable::importTags(const TQTaggable& tags, bool overwrite = true, bool recursive = false)
intTQTaggable::importTagsWithoutPrefix(const TQTaggable* tags, const TString& prefix, bool overwrite = true, bool recursive = false)
intTQTaggable::importTagsWithoutPrefix(const TQTaggable& tags, const TString& prefix, bool overwrite = true, bool recursive = false)
intTQTaggable::importTagsWithPrefix(TString tags, const TString& prefix, bool overwrite = true, bool keepStringQuotes = false, TString fallbackKey = "")
intTQTaggable::importTagsWithPrefix(const TQTaggable* tags, const TString& prefix, bool overwrite = true, bool recursive = false, TString fallbackKey = "")
intTQTaggable::importTagsWithPrefix(const TQTaggable& tags, const TString& prefix, bool overwrite = true, bool recursive = false, TString fallbackKey = "")
intTQTaggable::importTagWithPrefix(const TString& tag, const TString& prefix, bool overwrite = true, TString fallbackKey = "", bool keepStringQuotes = false)
virtual voidTObject::Info(const char* method, const char* msgfmt,...) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
boolTQFolder::isBaseOf(TQFolder* folder)
Bool_tTObject::IsDestructed() const
boolTQFolder::isEmpty() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual boolTQFolder::isEquivalentTo(TQFolder* f, const TString& options = "")
virtual boolTQFolder::isEquivalentTo(TQFolder* f, TQTaggable& options)
virtual Bool_tTFolder::IsFolder() const
boolisFriend(TQSampleFolder* other)
boolTQFolder::isLazy()
boolTQFolder::isOnDisk()
boolTQFolder::isOnDisk(TDirectory* dir)
Bool_tTObject::IsOnHeap() const
Bool_tTFolder::IsOwner() const
boolTQFolder::isRoot()
virtual boolTQFolder::IsSortable() const
boolTQTaggable::isTagOverwrittenByDescendants(TString key)
static boolTQTaggable::isValidKey(const TString& key)
static boolTQFolder::isValidName(const TString& name)
static boolTQFolder::isValidPath(TString path, bool allowRelativePaths = true, bool allowWildcards = true, bool allowArithmeticStringExpressions = false)
boolisVariant(bool recursive = true)
Bool_tTObject::IsZombie() const
static TQFolder*TQFolder::loadFolder(TString path, bool lazy = false)
static TQFolder*TQFolder::loadFromTextFile(TString filename, bool showErrorMessage = false)
static TQFolder*TQFolder::loadFromTextFile(TString filename, TString& errorMessage)
static TQFolder*TQFolder::loadLazyFolder(TString path)
static TQSampleFolder*loadLazySampleFolder(const TString& path)
static TQSampleFolder*loadSampleFolder(TString path, bool lazy = false)
virtual voidTFolder::ls(Option_t* option = "") constMENU
static TStringTQFolder::makeExportName(TString exportName)
static TList*TQTaggable::makeListOfTags(TList* unTags)
static TStringTQFolder::makeValidIdentifier(TString identifier, TString replacement = "")
static TStringTQFolder::makeValidPath(TString path, TString replacement = "", bool allowRelativePaths = true, bool allowWildcards = true)
voidTObject::MayNotUse(const char* method) const
boolmerge(TQSampleFolder* f, bool sumElements = false, bool verbose = false)
boolmerge(TQSampleFolder* f, const TString& traceID, bool sumElements = false, bool verbose = false)
boolTQFolder::mergeTags(TQFolder* other)
virtual boolTQFolder::moveFolder(const TString& source, const TString& dest)
virtual boolTQFolder::moveTo(const TString& dest)
virtual boolTQFolder::moveTo(TQFolder* dest, const TString& newName = "")
static TQFolder*TQFolder::newFolder(TString name)
virtual TQFolder*newInstance(const TString& name)
static TQSampleFolder*newSampleFolder(TString name)
static TQSampleFolder*newSampleList(const TString& name, const TString& treeLocation, double normalization = 1.)
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
virtual Int_tTFolder::Occurence(const TObject* obj) const
virtual voidTQTaggable::onAccess(TQValue* tag)
virtual voidTQTaggable::onRead(TQValue* tag)
virtual voidTQTaggable::onWrite(TQValue* tag)
static TFile*TQFolder::openFile(TString& importPath, const TString& opt = "READ")
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TQFolder&TQFolder::operator=(const TQFolder&)
virtual voidTObject::Paint(Option_t* option = "")
static boolTQFolder::parseDestination(TString dest, TString& path, TString& newName)
static TQTaggable*TQTaggable::parseFlags(const TString& flags)
boolTQTaggable::parseKey(TString key, TString& bareKey, int& opUp, int& opDown)
static boolTQFolder::parseLocation(TString importpath, TString& filename, TString& objname)
static TQTaggable*TQTaggable::parseParameterList(const TString& parameter, const TString& sep = ",", bool trim = true, const TString& blocks = "", const TString& quotes = "")
virtual voidTObject::Pop()
voidTQFolder::print(const TString& options = "")
virtual voidTNamed::Print(Option_t* option = "") const
intTQTaggable::printClaim(const TString& definition)
voidTQFolder::printContents(const TString& options = "")
voidprintCounter(const TString& path, const TString& name, const TString& options = "", TList* sfList = 0)
boolTQFolder::printDiff(TQFolder* f, const TString& options = "")
boolTQFolder::printDiff(const TString& path1, const TString& path2, const TString& options = "")
boolTQTaggable::printDiffOfTags(TQTaggable* tags, const TString& options = "")
boolTQTaggable::printDiffOfTags(TQTaggable* tags, TQTaggable& options)
voidprintFriends()
voidprintListOfCounters(const TString& options = "")
voidprintListOfHistograms(const TString& options = "")
intprintListOfSamples(const TString& path = "*")
voidprintScaleFactors(TString filter = "")
voidTQTaggable::printTags(TString options = "r")
voidpurgeWithoutTag(const TString& tag)
virtual Int_tTObject::Read(const char* name)
virtual voidTFolder::RecursiveRemove(TObject* obj)
virtual voidTFolder::Remove(TObject* obj)
static boolTQTaggable::removeGlobalTaggable(const char* name)
static boolTQTaggable::removeGlobalTaggable(const TString& name)
virtual boolTQFolder::removeObject(const TString& name)
intTQTaggable::removeTag(const TString& key)
intTQTaggable::removeTags(const TString& key)
intrenameCounter(TString oldName, TString newName)
intrenameHistogram(TString oldName, TString newName)
boolrenameLocalCounter(TString oldName, TString newName)
boolrenameLocalHistogram(TString oldName, TString newName)
boolrenameLocalObject(TString category, TClass* classType, TString oldName, TString newName)
boolTQTaggable::renameTag(const TString& oldKey, const TString& newKey)
intTQTaggable::renameTags(const TString& oldPrefix, const TString& newPrefix)
intTQFolder::replaceInFolderTags(TQTaggable& params, const TString& path, const TString& tagFilter = "*", TClass* typeFilter = TQFolder::Class())
stringTQTaggable::replaceInStandardString(const TString& in, bool keepQuotes = false)
stringTQTaggable::replaceInStandardString(const TString& in, const char* prefix, bool keepQuotes = false)
stringTQTaggable::replaceInStandardString(const TString& in, const TString& prefix, bool keepQuotes = false)
stringTQTaggable::replaceInStandardStringRecursive(TString in, const TString& prefix = "", bool keepQuotes = false)
intTQTaggable::replaceInTags(TQTaggable& params, const TString& tagFilter = "*")
TStringTQTaggable::replaceInText(const TString& in, bool keepQuotes = false)
TStringTQTaggable::replaceInText(const TString& in, const char* prefix, bool keepQuotes = false)
TStringTQTaggable::replaceInText(const TString& in, const TString& prefix, bool keepQuotes = false)
TStringTQTaggable::replaceInText(const TString& in, int& nReplaced, int& nFailed, bool keepQuotes = false)
TStringTQTaggable::replaceInText(TString in, int& nReplaced, int& nFailed, const TString& prefix, bool keepQuotes = false)
TStringTQTaggable::replaceInTextRecursive(TString in, const TString& prefix = "", bool keepQuotes = false)
voidTObject::ResetBit(UInt_t f)
virtual voidTQTaggable::resetReadFlags()
TObject*TQFolder::resolveImportLink(const TString& linkName, bool recurse = true)
TObject*TQFolder::resolveImportLink(const TString& linkName, TDirectory* dir, bool recurse = true)
intTQFolder::resolveImportLinks(bool recurse = true)
intTQFolder::resolveImportLinks(TDirectory* dir, bool recurse = true)
virtual voidTFolder::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
intTQFolder::setDirectory(TDirectory* dir = (ROOT::Internal::TDirectoryAtomicAdapter(TDirectory::CurrentDirectory())), bool own = false)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidTQFolder::setExportName(const TString& name)
voidTQTaggable::setGlobalIgnoreCase(bool globalIgnoreCase = true)
voidTQTaggable::setGlobalOverwrite(bool globalOverwrite = true)
voidTQFolder::setInfoTags()
voidsetIsVariant(bool isVariant = true)
voidTQFolder::setName(const TString& newName)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTFolder::SetOwner(Bool_t owner = kTRUE)
intsetScaleFactor(const TString& name, double scaleFactor, double uncertainty = 0)
intsetScaleFactor(const char* name, double scaleFactor, double uncertainty = 0)
intsetScaleFactor(const TString& name, double scaleFactor, const TString& sampleFolders)
intsetScaleFactor(const TString& name, double scaleFactor, const char* sampleFolders)
intsetScaleFactor(const TString& name, double scaleFactor, double uncertainty, const TString& sampleFolders)
intsetScaleFactor(TString name, const TString& title, double scaleFactor, double uncertainty = 0)
intTQTaggable::setTag(const TString& key, double value, const TString& destination = "")
intTQTaggable::setTag(const TString& key, int value, const TString& destination = "")
intTQTaggable::setTag(const TString& key, bool value, const TString& destination = "")
intTQTaggable::setTag(const TString& key, const TString& value, const TString& destination = "")
intTQTaggable::setTag(const TString& key, const char* value, const TString& destination = "")
intTQTaggable::setTag(const char* key, double value, const TString& destination = "")
intTQTaggable::setTag(const char* key, int value, const TString& destination = "")
intTQTaggable::setTag(const char* key, bool value, const TString& destination = "")
intTQTaggable::setTag(const char* key, const TString& value, const TString& destination = "")
intTQTaggable::setTag(const char* key, const char* value, const TString& destination = "")
intTQTaggable::setTagAuto(const TString& key, TString value, const TString& destination = "")
intTQTaggable::setTagBool(TString key, bool value, const TString& destination = "")
intTQTaggable::setTagDouble(TString key, double value, const TString& destination = "")
intTQTaggable::setTagInteger(TString key, int value, const TString& destination = "")
intTQTaggable::setTagList(const TString& key, TString value, const TString& destination = "")
intTQTaggable::setTagString(TString key, const TString& value, const TString& destination = "")
virtual voidTNamed::SetTitle(const char* title = "")MENU
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp) const
virtual Int_tTNamed::Sizeof() const
virtual intTQFolder::sortByName()
virtual voidTQFolder::sortByNameRecursive()
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt,...) const
boolTQTaggable::tagIsOfTypeBool(const TString& key)
boolTQTaggable::tagIsOfTypeDouble(const TString& key)
boolTQTaggable::tagIsOfTypeInteger(const TString& key)
boolTQTaggable::tagIsOfTypeString(const TString& key)
boolTQTaggable::tagsAreEquivalentTo(TQTaggable* tags, const TString& filter = "")
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
TQSampleFolder()
TQSampleFolder(TString name_)
voidunfriend(TQSampleFolder* other)
virtual voidTObject::UseCurrentStyle()
boolvalidateAllCounter(TQSampleFolder* sampleFolder, TString options = "")
boolvalidateAllCounter(TString path1, TString path2, TString options = "")
boolvalidateCounter(TString path1, TString path2, TString counterName, TString options = "")
boolvalidateCounter(TQSampleFolder* sampleFolder, TString counterName, TString options = "", int indent = 0)
intvisitMe(TQSampleVisitor* visitor, bool requireSelectionTag = false)
intvisitSampleFolders(TQSampleVisitor* visitor, const TString& category = "?")
intvisitSampleFolders(TQSampleVisitor* visitor, const vector<TQSampleFolder*>& selectedFolders)
intvisitSampleFolders(TQSampleVisitor* visitor, const set<TQSampleFolder*>& selectedFolders)
virtual voidTObject::Warning(const char* method, const char* msgfmt,...) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
virtual boolTQFolder::writeDirectory(TDirectory* baseDir)
virtual boolTQFolder::writeFolder(TDirectory* dir, int depth = -1, bool keepInMemory = true)
virtual boolTQFolder::writeFolder(TDirectory* dir, TString name, int depth = -1, bool keepInMemory = true)
virtual boolTQFolder::writeFolderMaxSize(TDirectory* dir, int maxSizeInMB = 10, bool keepInMemory = true)
virtual boolTQFolder::writeFolderMaxSize(TDirectory* dir, TString name, int maxSizeInMB = 10, bool keepInMemory = true)
virtual intTQFolder::writeToFile(const TString& filename, bool overwrite = 0, int depth = -1, bool keepInMemory = true)
virtual boolTQFolder::writeUpdate(int depth = -1, bool keepInMemory = true)
protected:
voidTQFolder::clearDirectoryInternal()
intTQTaggable::countTagDown(const TString& key)
intTQTaggable::countTagUp(const TString& key)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidfindFriends(TQSampleFolder* otherSF, bool forceUpdate, shared_ptr<TList> otherSFContents)
virtual voidfindFriendsInternal(TQSampleFolder* otherSF, bool forceUpdateSubFolders = false, shared_ptr<TList> otherSFContents = nullptr)
TQValue*TQTaggable::findTag(TString name)
intgeneralizeObjectsPrivate(TList* names, TClass* objClass, TQTaggable* options, const TString& subpath)
intgeneralizeObjectsPrivate(TList* names, TClass* objClass, TQTaggable* options, const TString& paths, const TString& subpath)
voidTQFolder::getFoldersWithTagEquivalentToInternal(const TQValue* tag, vector<TQFolder*>& matches)
TList*TQTaggable::getListOfTags()
boolTQTaggable::getOp(const TString& op, int& opCode)
boolTQTaggable::getTag(const TString& key, TQValue*& tag)
virtual boolTQFolder::importFromTextFilePrivate(const TString& filename_, int& nNewlines, TString& errFile, TString& errMsg)
virtual boolTQFolder::importFromTextPrivate(TString input, int& nNewlines, TString& errFile, TString& errMsg)
virtual TObject*TQFolder::importObjectFromDirectory(TDirectory* dir, TString importPath, bool recurse = true, TClass* expectedClass = __null)
voidinit()
voidTObject::MakeZombie()
boolTQFolder::mergeAsFolder(TQFolder* other, TQFolder::MergeMode mode)
boolmergeAsSampleFolder(TQSampleFolder* f, const TString& traceID, TQFolder::MergeMode mode, bool verbose)
voidTQFolder::mergeObjects(TQFolder* other, TQFolder::MergeMode mode)
boolTQFolder::printDiff(TQFolder* f, TQTaggable& options, int indent)
voidTQFolder::printInternal(TString options, int indent, bool resolve = true)
voidTQFolder::setBase(TQFolder* base_)
voidTQFolder::setDirectoryInternal(TDirectory* dir)
intTQTaggable::setTag(TQValue* tag, const TString& destination = "")
intTQTaggable::setTag(TQValue* tag, const TString& destination, bool overwrite)
virtual boolTQFolder::split(TDirectory* dir, int depth)
boolTQFolder::writeContentsToHTML(ostream& out, int expandDepth, bool includeUntextables)
virtual boolTQFolder::writeFolderHook(TDirectory* dir, const TString& exportName, int depth, bool keepInMemory)
boolTQFolder::writeFolderInternal(TDirectory* dir, const TString& exportName, int depth, bool keepInMemory)
private:
virtual Bool_tCheckTObjectHashConsistency() const

Data Members

public:
static TObject::(anonymous)TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TObject::EStatusBitsTObject::kHasUUID
static TObject::(anonymous)TObject::kInconsistent
static TObject::EStatusBitsTObject::kInvalidObject
static TObject::(anonymous)TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TObject::EStatusBitsTObject::kMustCleanup
static TObject::EStatusBitsTObject::kNoContextMenu
static TObject::(anonymous)TObject::kNotDeleted
static TObject::EDeprecatedStatusBitsTObject::kObjInCanvas
static TObject::(anonymous)TObject::kOverwrite
static TObject::(anonymous)TObject::kSingleKey
static TObject::(anonymous)TObject::kWriteDelete
static TObject::(anonymous)TObject::kZombie
static const TStringrestrictSelectionTagName
protected:
static TQFolder::MergeModeTQFolder::PreferOther
static TQFolder::MergeModeTQFolder::PreferThis
static TQFolder::MergeModeTQFolder::SumElements
TQFolder*TQFolder::fBase
TStringTQFolder::fExportName!
TCollection*TFolder::fFolderspointer to the list of folders
shared_ptr<set<TQSampleFolder*> >fFriends!
boolTQTaggable::fGlobalIgnoreCase!
boolTQTaggable::fGlobalOverwrite!
boolTQFolder::fIsEquivalentToSnapshot!
boolfIsFindingFriends! temporary flag to prevent infinite recursions in friend finding
Bool_tTFolder::fIsOwnertrue if folder own its contained objects
boolfIsVariant!
TDirectory*TQFolder::fMyDir!
TStringTNamed::fNameobject identifier
boolTQFolder::fOwnMyDir!
TList*TQTaggable::fReadFlags!
TList*TQTaggable::fTags
TStringTNamed::fTitleobject title
boolTQFolder::isFullyResolved!
static TObject::(anonymous)TObject::kOnlyPrepStep
static TQTaggable::(anonymous)TQTaggable::kOpADD
static TQTaggable::(anonymous)TQTaggable::kOpAND
static TQTaggable::(anonymous)TQTaggable::kOpCNT
static TQTaggable::(anonymous)TQTaggable::kOpMULT
static TQTaggable::(anonymous)TQTaggable::kOpNone
static TQTaggable::(anonymous)TQTaggable::kOpOR
static TQTaggable::(anonymous)TQTaggable::kOpRec
static map<TString,shared_ptr<TQTaggable> >TQTaggable::sGlobalTaggables

Class Charts

Inheritance Chart:
TObject
TNamed
TFolder
TQTaggable
TQFolder
TQSampleFolder
TQSample

Function documentation

TQSampleFolder()
 Default constructor of TQSampleFolder class: a new and empty instance of
 TQSampleFolder is created and initialized. Its name will be set to "unkown".
 Please note: users should not use this constructor but the static factory method
 TQSampleFolder::newSampleFolder(...). This default constructor has to be present
 to allow ROOT's CINT to stream instances of TQSampleFolder.
TQSampleFolder(TString name_)
 Default constructor of TQSampleFolder class: a new and empty instance of
 TQSampleFolder is created and initialized. Its name will be set to the value of
 the parameter <name> if it is a valid name.
 Please note: users should not use this constructor but the static factory method
 TQSampleFolder::newSampleFolder(...).
TQSampleFolder * newSampleFolder(TString name)
 Returns a new and empty instance of the TQSampleFolder class with name <name>
 if <name> is a valid name and a null pointer otherwise. Please refer to the
 documentation of the static method TQSampleFolder::isValidName(...) for details
 on valid folder names.
TQFolder * newInstance(const TString& name)
 Returns a new and empty instance of the TQSampleFolder class with name <name>
 if <name> is a valid name and a null pointer otherwise. Please note: this method
 does exactly the same as TQSampleFolder::newSampleFolder(...) but may be over-
 written by sub-classes of TQSampleFolder.
TQSampleFolder * loadLazySampleFolder(const TString& path)
 this function works exactly as TQSampleFolder::loadSampleFolder, with the
 exception that all folder branches that have been externalized/splitted
 when writing the file will remain in collapsed state until they are
 accessed. for large files with an excessive use of
 externalization/splitting, this will significantly speed up accessing the
 data, since the branches are only expanded on-demand.

 please note, however, that you will only experience a total speed gain if
 you only access small fractions of your data. if you plan to read most of
 the file's data at some point, requiring the expansion of all branches,
 this 'lazy' feature will only postpone the work of loading the data into
 RAM to the point where it is accessed bringing no total speed gain.
TQSampleFolder * loadSampleFolder(TString path, bool lazy = false)
 Loads an instance of TQSampleFolder from an external ROOT file and returns a
 pointer to it and a NULL pointer in case of failure. The ROOT file and the key
 within the key within the ROOT file to be read is identified by <path> which
 has to have the form "filename:keyname", e.g. "file.root:folder".
 If the sample folder to load is stored within a structre of TDirectory in the
 file it can be accessed by prepending the corresponding path to the sample
 folder name, e.g. "file.root:dir1/dir2/folder". To load only a subfolder of an
 instance of TQSampleFolder from the ROOT file one can append the corresponding
 path to the folder name, e.g. "file.root:folder/subfolder". In this case a
 pointer to "subfolder" is returned which is made the root folder before.

 the 'lazy' flag will trigger lazy loading, please refer to TQFolder::loadLazySampleFolder
 for documentation of this feature.
TQSampleFolder * newSampleList(const TString& name, const TString& treeLocation, double normalization = 1.)
 Scans the file system for files matching the string pattern of file part in
 <treeLocation> and returns an instance of TQSampleFolder with name <name> and
 instances of TQSample referring to each matching file. The tree name is set
 to the tree part in <treeLocation> and the sample normalization is set to
 <normalization>.

 Examples:

 - TQSampleFolder * samples =
 TQSampleFolder::newSampleList("data", "data_*.root:Tree", 1.) will create
 a sample folder of samples for each "data_*.root" ntuple using the TTree
 "Tree".
 make sure the user requested a valid name
void init()
 Nothing happens here
TQSampleFolder * addSampleFolder(TQSampleFolder* sampleFolder_, TString path_ = "", TClass* tclass = 0)
int visitMe(TQSampleVisitor* visitor, bool requireSelectionTag = false)
 recursively visit this sample (folder) with the given visitor
int visitSampleFolders(TQSampleVisitor* visitor, const TString& category = "?")
 Lets the sample visitor (instance of TQSampleVisitor) <visitor> visit those
 sample folders that match the path pattern <category> and returns the number
 visits. <category> may consists of multiple comma-separated paths and wildcards
 "?" and "*" may be used. If an exclamation mark "!" is appended to a path pattern
 the corresponding sample folders are visited non-recursively. This "!" feature doesn't actually work-> TODO: fix or remove comment
int visitSampleFolders(TQSampleVisitor * visitor, const std::vector<TQSampleFolder*>& selectedFolders)
 wrapper function for std::set<TQSampleFolder*> variant
int visitSampleFolders(TQSampleVisitor * visitor, const std::set<TQSampleFolder*>& selectedFolders)
 visit an already selected set of folders
TList * getListOfSampleFolders(const TString& path_ = "?", TClass* tclass = TQSampleFolder::Class(), bool toplevelOnly = false)
get a list of sample folders
std::vector<TString> getSampleFolderPaths(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
std::vector<TString> getSampleFolderPathsWildcarded(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
std::vector<TString> getSamplePaths(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
std::vector<TString> getSamplePathsWildcarded(const TString& path_ = "?", TClass* tClass = __null, bool toplevelOnly = false)
TQSample * getSample(const TString& path)
 Returns the sample (instance of TQSample) that matches the path pattern <path>
 and a NULL pointer in case no match can be found. If more than one sample matches
 <path> (because wildcards are used) the first match is returned.
TQSampleFolder * getBaseSampleFolder()
 Returns a pointer to the base sample folder and a NULL pointer if either there
 is no base folder or the base folder is not an instance of TQSampleFolder.
TQSampleFolder * getRootSampleFolder()
 Returns the a pointer to the instance of TQSampleFolder which is the root of
 this samplefolder hierarchy (not necessarily the root of the folder hierarchy).
std::vector<TQSampleFolder*> getSampleFoldersWithTagsEquivalentTo(const vector<const TQValue*>& tags)
 wrapper for TQFolder variant (returned set is reduced by TQFolders returned by
 the TQFolder variant of this method (getFoldersWithTagsEquivalentTo) which are
 not also TQSampleFolders.
std::vector<TQSampleFolder*> getSampleFoldersWithTagEquivalentTo(const TQValue* tag)
 wrapper for TQFolder variant (returned set is reduced by TQFolders returned by
 the TQFolder variant of this method (getFoldersWithTagEquivalentTo) which are
 not also TQSampleFolders.
std::vector<TQSampleFolder*> getSampleFoldersWithTagEquivalentTo(const TQValue& tag)
TList * getListOfSamples(const TString& path = "*")
 Returns a list (instance of TList) of samples (instances of TQSample) withing
 this sample folder matching the path pattern <path>. If no matching sample
 can be found a NULL pointer is returned.
int printListOfSamples(const TString& path = "*")
 prints a list of samples (instances of TQSample) withing
 this sample folder matching the path pattern <path>.
 the number of matched samples is returned
TQSampleFolder * getSampleFolder(TString path_, TClass* tclass = 0)
 Returns the sample folder (instance of TQSampleFolder) that matches the path
 pattern <path_> and a NULL pointer in case no match can be found. If more than
 one sample folder matches <path_> (because wildcards are used) the first match
 is returned. Additionally, a new instance of TQSampleFolder is created as
 requested if it does not already exist and a "+" has been appended to <path_>.
 The path <path_> may be built up from any number of path levels in either case
 and an arbitrary number of nested sample folders may be created by appending
 one "+" to the full path.

 Examples:

 - getSampleFolder("subfolder") returns a pointer to the instance of TQSampleFolder
 named "subfolder" within this instance of TQSampleFolder if it does exist.
 - getSampleFolder("subfolder+") returns a pointer to the instance of TQSampleFolder
 named "subfolder" within this instance of TQSampleFolder and does create it if
 it does not exist
 - getSampleFolder("subfolder/fol2+") returns a pointer to the instance of
 TQSampleFolder named "fol2" within "subfolder" (in turn within this instance of
 TQSampleFolder) and does create it if it does not exist
int getNSampleFolders(bool recursive = false)
 Returns the number of sample folders (instances of TQSampleFolder) within this
 instance of TQSampleFolder. If <recursive> == true not only sample folders
 within this instance but also recursively within sub sample folder will be
 counted.
int getNSamples(bool recursive = false)
 Returns the number of samples (instances of TQSample) within this instance of
 TQSampleFolder. If <recursive> == true not only samples within this instance
 but also recursively within sub sample folder will be counted.
bool hasHistogram(TString path, TString name, TString options = "")
 Returns true if a histogram <name> in <path> can be retrieved with options
 <options> using TQSampleFolder::getHistogram(...).
 [Please note: this is a wrapper to TQSampleDataReader::hasHistogram(...).]
bool hasCounter(TString path, TString name, TString options = "")
 Returns true if a counter <name> in <path> can be retrieved with options
 <options> using TQSampleFolder::getCounter(...).
 [Please note: this is a wrapper to TQSampleDataReader::hasCounter(...).]
bool renameLocalObject(TString category, TClass* classType, TString oldName, TString newName)
 Renames a local object within subfolder <category> and name <oldName> into
 <newName> also allowing to move the object to a different subfolder and returns
 true in case of success and false otherwise. This method is used by
 TQSampleFolder::renameLocalHistogram(...) and TQSampleFolder::
 renameLocalCounter(...) to rename local histograms and counters.
 get the local object
bool renameLocalHistogram(TString oldName, TString newName)
 Renames the local histogram (instance of TH1 wihtin ".histograms" subfolder)
 with name <oldName> to <newName> also allowing to move the histogram to a new
 subfolder and returns true in case of success and false otherwise. In case a
 histogram is moved to a new subfolder it is created unless it already exist.
 This method does not affect histograms within sub sample folders.

 Examples:

 - renameLocalHistogram("CutMETRel/MT", "CutMETRel/MT_2") renames the histogram
 "MT" in "CutMETRel" to "MT_2".
 - renameLocalHistogram("CutMETRel/MT", "CutMETRel_2/MT") moves the histogram
 "MT" in "CutMETRel" to "CutMETRel_2".
bool renameLocalCounter(TString oldName, TString newName)
 Renames the local counter (instance of TQCounter wihtin ".cutflow" subfolder)
 with name <oldName> to <newName> also allowing to move the counter to a new
 subfolder and returns true in case of success and false otherwise. In case a
 counter is moved to a new subfolder it is created unless it already exist.
 This method does not affect counters within sub sample folders.

 Examples:

 - renameLocalCounter("CutMETRel", "CutMETRel_2") renames the counter
 "CutMETRel" to "CutMETRel_2".
 - renameLocalCounter("CutMETRel", "test/CutMETRel") moves the counter
 "CutMETRel" to "test".
int renameHistogram(TString oldName, TString newName)
 Renames the histogram with name <oldName> into <newName> and returns the number
 of contributing histograms that have been renamed. This method also allows
 to move histograms to new subfolders without the need to take additional
 action. Examples:

 - renameHistogram("Cut_0jet/MT", "Cut_0jet/MT_2") renames the histogram
 "Cut_0jet/MT" into "Cut_0jet/MT_2"
 - renameHistogram("Cut_0jet/MT", "Cut_0jet_test/MT") moves the histogram "MT"
 from "Cut_0jet" to "Cut_0jet_test" (with the latter being created if it does
 not exists prior to the operation
 - renameHistogram("Cut_0jet/MT", "1/2/3/MT") moves the histogram "MT"
 from "Cut_0jet" to "1/2/3" (with the latter being created if it does
 not exists prior to the operation
int renameCounter(TString oldName, TString newName)
 Renames the counter with name <oldName> into <newName> and returns the number
 of contributing counter that have been renamed. This method also allows
 to move counter to new subfolders without the need to take additional
 action. Examples:

 - renameCounter("Cut_0jet", "Cut_0jet_2") renames the counter "Cut_0jet" into
 "Cut_0jet_2"
 - renameCounter("Cut_0jet", "1/2/3/Cut_0jet") moves the counter "Cut_0jet"
 to "1/2/3" (with the latter being created if it does not exists prior to the
 operation
bool deleteLocalObject(TString category, TString name)
bool deleteLocalHistogram(TString name)
bool deleteLocalCounter(TString name)
int deleteHistogram(TString name)
 Deletes all contributing histograms to histogram <name> within this instance of
 TQSampleFolder and all sub sample folders and returns the number of contributing
 histograms that have been deleted.
int deleteSingleCounter(TString name)
 Deletes all contributing counter to counter <name> within this instance of
 TQSampleFolder and all sub sample folders and returns the number of contributing
 counter that have been deleted.
int deleteHistograms(TString filter)
 Deletes all contributing histograms to histograms matching the string pattern
 <filter> within this instance of TQSampleFolder and all sub sample folders and
 returns the number of histograms that have been deleted. The string pattern
 is matched using TQStringUtils::matchesFilter(...) and allows the use of wildcards
 "*" and "?", a negation by prepending "!", and an OR of multiple comma-separated
 string patterns.
int deleteCounter(TString filter)
 Deletes all contributing counter to counter matching the string pattern <filter>
 within this instance of TQSampleFolder and all sub sample folders and returns
 the number of counter that have been deleted. The string pattern is matched
 using TQStringUtils::matchesFilter(...) and allows the use of wildcards "*" and
 "?", a negation by prepending "!", and an OR of multiple comma-separated string
 patterns.
int copyHistograms(TString sourceFilter, TString appendix, TString options = "")
int copyHistogram(TString source, TString destination, TString options = "")
 Retrieves the histogram <source> applying options <options>, stores the resulting
 histgram as <destination>, and returns the number of contributions to the new
 histogram.

 Examples:
 - copyHistogram("Cut_0jet/MT + Cut_1jet/MT", "Cut_Sum01jet/MT") creates a new
 histogram "Cut_Sum01jet/MT" from the sum of "Cut_0jet/MT" and "Cut_1jet/MT"
 - copyHistogram("Cut/MT_vs_Mll", "Cut/MT", "projX = true") creates a new
 histogram "Cut/MT" from the projection of "Cut/MT_vs_Mll" onto its X axis
int copyHistogramToCounter(TString source, TString destination = "")
TH1 * getHistogram(TString path, TString name, TQTaggable* options = nullptr, TList* sfList = 0)
 Returns a histogram (pointer to an instance of TH1) obtained from summing
 contributions matching <name> from sample folders matching <path>. Additional
 options may be passed via <options> and a list of contribution sample folders
 is returned if <sfList> is valid pointer to an instance of TList.

 [Please note: this is a wrapper to TQSampleDataReader::getHistogram(...).
 Please check the corresponding documentation for details.]
 the reader to retrieve histograms
TH1 * getHistogram(TString path, TString name, TString options, TList* sfList = 0)
 Returns a histogram (pointer to an instance of TH1) obtained from summing
 contributions matching <name> from sample folders matching <path>. Additional
 options may be passed via <options> and a list of contributing sample folders
 is returned if <sfList> is a valid pointer to an instance of TList.

 [Please note: this is a wrapper to TQSampleDataReader::getHistogram(...).
 Please check the corresponding documentation for details.]
 the reader to retrieve histograms
TQCounter * getCounter(TString path, TString name, TString options = "", TList* sfList = 0)
 Returns a counter (pointer to an instance of TQCounter) obtained from summing
 contributions matching <name> from sample folders matching <path>. Additional
 options may be passed via <options> and a list of contributing sample folders
 is returned if <sfList> is a valid pointer to an instance of TList.

 [Please note: this is a wrapper to TQSampleDataReader::getCounter(...).
 Please check the corresponding documentation for details.]
 the reader to retrieve counter
void printCounter(const TString& path, const TString& name, const TString& options = "", TList* sfList = 0)
 Convenience wrapper for getCounter which prints the cunter after checking for
 potential nullptrs and cleans up the retrieved counter afterwards
TList * getListOfHistogramNames(const TString& path = ".", TList* sfList = 0)
 Returns a list (pointer to instance of TList) of histogram names (as instances
 of TObjString) present within the sample folder referred to by <path> and a
 NULL pointer if no histogram could be found. Additionally, a list of contributing
 sample folders is returned if <sfList> is a valid pointer to an instance of TList.
void printListOfHistograms(const TString& options = "")
 Prints a list of histogram names present within the sample folder
TList * getListOfCounterNames(const TString& path = ".", TList* sfList = 0)
 Returns a list (pointer to instance of TList) of counter names (as instances
 of TObjString) present within the sample folder referred to by <path> and a
 NULL pointer if no counter could be found. Additionally, a list of contributing
 sample folders is returned if <sfList> is a valid pointer to an instance of TList.
void printListOfCounters(const TString& options = "")
 Prints a list of counters present within the sample folder
bool validateAllCounter(TString path1, TString path2, TString options = "")
 Validates all available counter in sample folders referred to by <path1> and
 <path2> by comparing instances with matching names in these two sample folders,
 prints out the result, and returns true if all counter agree or false otherwise.
 The default output is a list of all counter names (present in any of the two
 sample folders) with the second column indicating the result of the comparison
 of the corresponding counter retrieved from the two input sample folders:

 (1) = (2) [green] counter agree within chosen accuracy (weighted number,
 uncertainty, and raw number)
 (1) ~ (2) [yellow] counter agree only in raw number
 (1) > (2) [red] counter retrieved from sample folder 1 has a larger
 weighted number than the one retrieved from sample folder 2
 (1) < (2) [red] similarly
 (1) - [red] counter does not exist in sample folder 2
 - (2) [red] similarly

 Additional options may be passed via <options>. The following options are
 available:

 - "d" additionally trace mismatch of counter that do not agree.
 - "m" only list counter that do not match
 - "e" only list counter that exists in both sample folders
 - "c" print counter states in additional columns
 - "r" show ratio of weighted numbers of the two counter
 - "a[<accuracy>]" set relative accuracy used for comparing counter
 to <accuracy> (default is 1E-7)
 - "f[<filter>]" only list counter whose name match <filter> (allows use
 of wildcards "*" and "?" in the usual "ls-like" way)
bool validateAllCounter(TQSampleFolder* sampleFolder, TString options = "")
bool validateCounter(TString path1, TString path2, TString counterName, TString options = "")
get the samples folders to compare
bool validateCounter(TQSampleFolder* sampleFolder, TString counterName, TString options = "", int indent = 0)
column widths
int setScaleFactor(const char* name, double scaleFactor, double uncertainty = 0)
 Set a scale factor (better: normalization factor) and its uncertainty.
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
int setScaleFactor(const TString& name, double scaleFactor, double uncertainty = 0)
 Set a scale factor (better: normalization factor) and its uncertainty.
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
int setScaleFactor(TString name, const TString& title, double scaleFactor, double uncertainty = 0)
 Set a scale factor (better: normalization factor) and its uncertainty.
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
int setScaleFactor(const TString& name, double scaleFactor, double uncertainty, const TString& sampleFolders)
 Set a scale factor (better: normalization factor) and its uncertainty.
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
 The default scheme is '.default'.
int setScaleFactor(const TString& name, double scaleFactor, const TString& sampleFolders)
 Set a scale factor (better: normalization factor).
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
 The default scheme is '.default'.
int setScaleFactor(const TString& name, double scaleFactor, const char* sampleFolders)
 Set a scale factor (better: normalization factor).
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
 The default scheme is '.default'.
void printScaleFactors(TString filter = "")
 Prints a summary of scale factors (better: normalization factors) associated
 to this instance of TQSampleFolder. If no normalization factors are associated
 to it a corresponding message is printed.
bool getScaleFactor(const TString& path, double& scale, double& uncertainty, bool recursive = false)
 Returns a scale factor (better: normalization factor)
 The 'path' is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
 The default scheme is '.default'.

 The value of the scale factor will be deployed in the 'scale' argument,
 The uncertainty value will be deployed in the 'uncertainty' argument.

 The recursive flag can be used to collect and multiply corresponding scale factors
 from parent directories in an upward-recursive fashion (default: false).
void convertLegacyNFs()
 convert legacy NFs into the most recent format
TQCounter* getScaleFactorCounter(const TString& name)
 Returns a scale factor (better: normalization factor) as the underlying TQCounter object
 the path is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
 The default scheme is '.default'.
TQCounter* getScaleFactorCounterInternal(TString name)
 Returns a scale factor (better: normalization factor) as the underlying TQCounter
 object the path is the name of the corresponding scale factor (typically name
 of the cut) and may be prefixed with "schemeName:" to use a the scale factor
 scheme 'schemeName'. The default scheme is '.default'.
TQCounter* getScaleFactorCounterInternal(const TString& path, const TString& scaleScheme)
 Returns a scale factor (better: normalization factor) as the underlying TQCounter
 object the path is the name of the corresponding scale factor (typically name
 of the cut).
TQCounter* getScaleFactorCounterRecursive(const TString& name)
 Returns a scale factor (better: normalization factor) as the underlying TQCounter object
 the path is the name of the corresponding scale factor (typically name of the cut).
double getScaleFactor(const TString& name, bool recursive = false)
 Returns a scale factor (better: normalization factor)
 the path is the name of the corresponding scale factor (typically name of the cut)
 and may be prefixed with "schemeName:" to use a the scale factor scheme 'schemeName'.
 The default scheme is '.default'.

 The value of the scale factor will be returned.

 The recursive flag can be used to collect and multiply corresponding scale factors
 from parent directories in an upward-recursive fashion (default: false).
int generalizeObjectsPrivate(TList* names, TClass* objClass, TQTaggable* options, const TString& paths, const TString& subpath)
 Generalizes (merges) contributions to histograms
int generalizeObjects(const TString& prefix, const TString& options = "")
 Generalizes (merges) contributions to histograms
int generalizeObjectsPrivate(TList* names, TClass* objClass, TQTaggable* options, const TString& subpath)
 Generalizes (merges) contributions to histograms
int generalizeHistograms(const TString& paths = "", const TString& options = "")
 Generalizes (merges) contributions to histogram
int generalizeCounters(const TString& paths = "", const TString& options = "")
 Generalizes (merges) contributions to counter
int generalizeHistograms(TList* names, const TString& paths, const TString& options)
 Generalizes (merges) contributions to histogram
int generalizeCounters(TList* names, const TString& paths, const TString& options)
 Generalizes (merges) contributions to counter
~TQSampleFolder()
TString getPathFriendsWildcarded(bool requireWildcardTag = true)
 Returns the full path of this instance of TQFolder in the hierarchy. For the
 root folder "/" is returned.
 this version of getPath replaces the names of folders that have the tag
 wildcarded=true
 set with a wildcard ('?')
bool merge(TQSampleFolder* f, bool sumElements = false, bool verbose = false)
 merge two sample folders
bool merge(TQSampleFolder* f, const TString& traceID, bool sumElements = false, bool verbose = false)
 merge two sample folders
bool mergeAsSampleFolder(TQSampleFolder* f, const TString& traceID, TQFolder::MergeMode mode, bool verbose)
 merge two sample folders
void findFriends(const TString& pathpattern, bool forceUpdate = false)
 find the friends of this sample folder in a branch of the current folder tree
void findFriends(bool forceUpdate = false)
 find the friends of this sample folder in the current folder tree
void findFriends(TQSampleFolder* otherSF, bool forceUpdate = false)
 public version wrapping protected version which uses additional, performance saving parameters
void findFriends(TQSampleFolder* otherSF, bool forceUpdate, shared_ptr<TList> otherSFContents)
protected version with additional arguments (pre-compiled contents of otherSF) for performance reasons
void findFriendsInternal(TQSampleFolder* otherSF, bool forceUpdateSubFolders = false, shared_ptr<TList> otherSFContents = nullptr)
 find the friends of this sample folder in some other sample folder
 the otherSFContents shared_ptr can optionally be provided and has to be equivalent
 to obtainig it (as a bare ptr) as other->getListOfSampeFolders("*") . This should only be used
 in recursive calls to save us from recreating this list over and over again
void unfriend(TQSampleFolder* other)
 remove a friend
void befriend(TQSampleFolder* other)
 add another sample as a friend
void clearFriends()
 clear the list of friends
std::shared_ptr<std::set<TQSampleFolder*>> getFriends()
 retrieve the set of friends
int countFriends()
 retrieve the list of friends
bool hasFriends()
 retrieve the list of friends
bool isFriend(TQSampleFolder* other)
 check if another folder is a friend
void printFriends()
 print the list of friends
bool isVariant(bool recursive = true)
void purgeWithoutTag(const TString& tag)
int generalizeObjects(const TString& prefix, const TString& options = "")
void setIsVariant(bool isVariant = true)