#include <DataGetterHelper.h>

Inheritance diagram for gallery::DataGetterHelper:

Public Member Functions
	DataGetterHelper (EventNavigator const *eventNavigator, std::shared_ptr< EventHistoryGetter > historyGetter)

	DataGetterHelper (DataGetterHelper const &)=delete

	DataGetterHelper (DataGetterHelper &&)=delete

DataGetterHelper &	operator= (DataGetterHelper const &)=delete

DataGetterHelper &	operator= (DataGetterHelper &&)=delete

ProductWithID	getByLabel (std::type_info const &typeInfoOfWrapper, art::InputTag const &inputTag) const

std::vector< art::InputTag >	getInputTags (std::type_info const &typeInfoOfWrapper) const

std::vector< ProductWithID >	getManyByType (std::type_info const &typeInfoOfWrapper) const

art::BranchDescription const &	getProductDescription (art::ProductID) const

void	updateFile (TFile iFile, TTree iTree, bool initializeTheCache)

void	initializeTTreeCache ()

void	updateEvent ()

Public Member Functions inherited from art::PrincipalBase
virtual	~PrincipalBase ()=0

	PrincipalBase ()

EDProductGetter const *	getEDProductGetter (ProductID const &pid) const

Private Member Functions
void	initializeForProcessHistory () const

void	addProcess (std::string const &processName) const

void	addBranchData (std::string branchName, unsigned int processIndex, InfoForTypeLabelInstance const &info, bool initializeTheCache=false) const

TClass *	getTClass (InfoForTypeLabelInstance const &info, std::string const &processName) const

InfoForTypeLabelInstance &	getInfoForTypeLabelInstance (art::TypeID const &type, std::string const &label, std::string const &instance) const

void	addTypeLabelInstance (art::TypeID const &type, std::string const &label, std::string const &instance) const

void	insertIntoInfoMap (art::TypeID const &type, std::string const &label, std::string const &instance, unsigned int infoIndex) const

art::EDProduct const *	readProduct (art::ProductID const productID, art::TypeID const &type) const

art::ProductID	getMaybeValidProductID (std::vector< IndexProductIDPair > const &processIndexToProductID, unsigned int processIndex) const

void	updateBranchDataIndexOrderedByHistory (InfoForTypeLabelInstance const &info) const

std::vector< art::BranchDescription const * >	getProductDescriptions (art::TypeID const &typeIDOfWrapper) const

BranchData const *	getBranchData (InfoForTypeLabelInstance const &info, unsigned int processIndex) const

BranchData const *	getBranchData (art::BranchDescription const &) const

art::EDProductGetter const *	getEDProductGetter_ (art::ProductID const &) const override

Private Attributes
EventNavigator const *	eventNavigator_

TTree *	tree_ {nullptr}

std::shared_ptr< EventHistoryGetter >	historyGetter_

bool	initializedForProcessHistory_ {false}

art::ProcessHistoryID	previousProcessHistoryID_ {}

std::vector< std::string >	previousProcessHistoryNames_ {}

std::vector< std::string >	processNames_ {}

std::map< std::string, unsigned int >	processNameToProcessIndex_ {}

std::vector< unsigned int >	orderedProcessIndexes_ {}

std::vector< InfoForTypeLabelInstance >	infoVector_ {}

std::map< TypeLabelInstanceKey, unsigned int >	infoMap_ {}

std::map< art::ProductID, std::unique_ptr< BranchData > >	branchDataMap_ {}

BranchData	invalidBranchData_ {}

std::set< art::ProductID >	branchDataMissingSet_ {}

BranchMapReader	branchMapReader_ {}

art::root::DictionaryChecker	dictChecker_ {}

Detailed Description

Definition at line 72 of file DataGetterHelper.h.

Constructor & Destructor Documentation

gallery::DataGetterHelper::DataGetterHelper	(	EventNavigator const *	eventNavigator,
		std::shared_ptr< EventHistoryGetter >	historyGetter
	)

explicit

Definition at line 69 of file DataGetterHelper.cc.

     : eventNavigator_{eventNavigator}, historyGetter_{historyGetter}
   {
     initializeStreamers();
   }

gallery::DataGetterHelper::DataGetterHelper ( DataGetterHelper const & )

delete

gallery::DataGetterHelper::DataGetterHelper ( DataGetterHelper && )

delete

Member Function Documentation

void gallery::DataGetterHelper::addBranchData	(	std::string	branchName,
		unsigned int	processIndex,
		InfoForTypeLabelInstance const &	info,
		bool	initializeTheCache = `false`
	)		const

private

Definition at line 340 of file DataGetterHelper.cc.

   {
     auto branch = tree_->GetBranch(branchName.c_str());
     if (branch == nullptr) {
       return;
     }
     auto pd =
       branchMapReader_.productDescription(info, processNames_[processIndex]);
     assert(pd);
     auto const productID = pd->productID();
     if (info.isAssns()) {
       auto const& processName = processNames_[processIndex];
       auto tClass = getTClass(info, processName);
 
       art::TypeID const typeIDInDescription{tClass->GetTypeInfo()};
       branchDataMap_[productID] =
         std::make_unique<AssnsBranchData>(typeIDInDescription,
                                           tClass,
                                           branch,
                                           eventNavigator_,
                                           this,
                                           move(branchName),
                                           info.type(),
                                           info.partnerType());
     } else {
       branchDataMap_[productID] =
         std::make_unique<BranchData>(info.type(),
                                      info.tClass(),
                                      branch,
                                      eventNavigator_,
                                      this,
                                      move(branchName));
     }
     info.processIndexToProductID().emplace_back(processIndex, productID);
     if (initializeTheCache && branch) {
       tree_->AddBranchToCache(branch, kTRUE);
     }
   }

void gallery::DataGetterHelper::addProcess ( std::string const & processName ) const

private

Definition at line 324 of file DataGetterHelper.cc.

   {
     unsigned int const processIndex = processNames_.size();
     processNames_.push_back(processName);
     processNameToProcessIndex_[processName] = processIndex;
     for (auto& info : infoVector_) {
       auto pd = branchMapReader_.productDescription(info, processName);
       if (pd == nullptr) {
         continue;
       }
       assert(branchMapReader_.branchInRegistryOfAnyOpenedFile(pd->productID()));
       addBranchData(pd->branchName(), processIndex, info);
     }
   }

void gallery::DataGetterHelper::addTypeLabelInstance	(	art::TypeID const &	type,
		std::string const &	label,
		std::string const &	instance
	)		const

private

Definition at line 426 of file DataGetterHelper.cc.

   {
     dictChecker_.checkDictionaries(art::uniform_type_name(type.typeInfo()),
                                    true);
     dictChecker_.reportMissingDictionaries();
     unsigned int infoIndex = infoVector_.size();
     infoVector_.emplace_back(type, label, instance);
     insertIntoInfoMap(type, label, instance, infoIndex);
     InfoForTypeLabelInstance const& info = infoVector_[infoIndex];
     if (info.isAssns()) {
       insertIntoInfoMap(info.partnerType(), label, instance, infoIndex);
     }
     unsigned int processIndex{};
     for (auto const& processName : processNames_) {
       std::string branchName{buildBranchName(info, processName)};
       art::ProductID const productID{branchName};
       if (branchMapReader_.branchInRegistryOfAnyOpenedFile(productID)) {
         addBranchData(move(branchName), processIndex, info);
       }
       ++processIndex;
     }
     updateBranchDataIndexOrderedByHistory(info);
   }

BranchData const * gallery::DataGetterHelper::getBranchData	(	InfoForTypeLabelInstance const &	info,
		unsigned int	processIndex
	)		const

private

Definition at line 488 of file DataGetterHelper.cc.

   {
     auto const pid =
       getMaybeValidProductID(info.processIndexToProductID(), processIndex);
     return pid.isValid() ? branchDataMap_.at(pid).get() : nullptr;
   }

BranchData const * gallery::DataGetterHelper::getBranchData ( art::BranchDescription const & desc ) const

private

Definition at line 519 of file DataGetterHelper.cc.

   {
     if (!initializedForProcessHistory_) {
       initializeForProcessHistory();
     }
     TClass* tClass = TClass::GetClass(desc.wrappedName().c_str());
     if (tClass == nullptr) {
       throw art::Exception(art::errors::DictionaryNotFound,
                            "DataGetterHelper::getBranchData: ")
         << "Missing dictionary for wrapped class.\n"
         << desc.wrappedName() << "\n";
     }
 
     auto const& typeInfoOfWrapper = *tClass->GetTypeInfo();
     art::TypeID const type{typeInfoOfWrapper};
     auto const& info = getInfoForTypeLabelInstance(
       type, desc.moduleLabel(), desc.productInstanceName());
     auto itProcess = processNameToProcessIndex_.find(desc.processName());
     if (itProcess != cend(processNameToProcessIndex_)) {
       unsigned int const processIndex = itProcess->second;
       auto branchData = getBranchData(info, processIndex);
       if (branchData && branchData->branch() != nullptr) {
         return branchData;
       }
     }
     return nullptr;
   }

ProductWithID gallery::DataGetterHelper::getByLabel	(	std::type_info const &	typeInfoOfWrapper,
		art::InputTag const &	inputTag
	)		const

Definition at line 78 of file DataGetterHelper.cc.

   {
     if (!initializedForProcessHistory_) {
       initializeForProcessHistory();
     }
     art::TypeID const type{typeInfoOfWrapper};
     auto const& info =
       getInfoForTypeLabelInstance(type, inputTag.label(), inputTag.instance());
 
     if (inputTag.process().empty()) {
       // search in reverse order of the ProcessHistory
       for (auto reverseIter = crbegin(info.productIDsOrderedByHistory()),
                 iEnd = crend(info.productIDsOrderedByHistory());
            reverseIter != iEnd;
            ++reverseIter) {
         if (auto edProduct = readProduct(*reverseIter, type)) {
           // If the product was present in the input file and we
           // successfully read it then we are done
           return std::make_pair(edProduct, *reverseIter);
         }
       }
     } else { // process is not empty
       auto itProcess = processNameToProcessIndex_.find(inputTag.process());
       if (itProcess != cend(processNameToProcessIndex_)) {
         unsigned int const processIndex = itProcess->second;
         auto branchData = getBranchData(info, processIndex);
         if (branchData) {
           auto pd = branchMapReader_.productDescription(info, itProcess->first);
           assert(pd);
           auto product = branchData->uniqueProduct_(type);
           return std::make_pair(product, pd->productID());
         }
       }
     }
     return std::make_pair(nullptr, art::ProductID::invalid());
   }

art::EDProductGetter const * gallery::DataGetterHelper::getEDProductGetter_ ( art::ProductID const & productID ) const

overrideprivatevirtual

Implements art::PrincipalBase.

Definition at line 561 of file DataGetterHelper.cc.

   {
     auto itFind = branchDataMap_.find(productID);
     if (itFind != cend(branchDataMap_)) {
       return itFind->second.get();
     }
 
     if (branchDataMissingSet_.find(productID) != cend(branchDataMissingSet_)) {
       return &invalidBranchData_;
     }
 
     auto const pd = branchMapReader_.productDescription(productID);
     if (pd == nullptr) {
       return &invalidBranchData_;
     }
 
     auto branchData = getBranchData(*pd);
     if (branchData == nullptr) {
       branchDataMissingSet_.insert(productID);
       return &invalidBranchData_;
     }
     return branchData;
   }

InfoForTypeLabelInstance & gallery::DataGetterHelper::getInfoForTypeLabelInstance	(	art::TypeID const &	type,
		std::string const &	label,
		std::string const &	instance
	)		const

private

Definition at line 407 of file DataGetterHelper.cc.

   {
     if (label.empty()) {
       throw art::Exception(art::errors::LogicError)
         << "getValidHandle was passed an empty module label. Not allowed.\n";
     }
     TypeLabelInstanceKey const key{type, label, instance};
     auto itFind = infoMap_.find(key);
     if (itFind == cend(infoMap_)) {
       addTypeLabelInstance(type, label, instance);
       itFind = infoMap_.find(key);
     }
     return infoVector_[itFind->second];
   }

std::vector< art::InputTag > gallery::DataGetterHelper::getInputTags ( std::type_info const & typeInfoOfWrapper ) const

Definition at line 137 of file DataGetterHelper.cc.

   {
     std::vector<art::InputTag> result;
     art::TypeID const type{typeInfoOfWrapper};
     for (auto const* pd : getProductDescriptions(type)) {
       result.push_back(pd->inputTag());
     }
     return result;
   }

std::vector< ProductWithID > gallery::DataGetterHelper::getManyByType ( std::type_info const & typeInfoOfWrapper ) const

Definition at line 148 of file DataGetterHelper.cc.

   {
     std::vector<ProductWithID> result;
     art::TypeID const type{typeInfoOfWrapper};
     for (auto const* pd : getProductDescriptions(type)) {
       auto itProcess = processNameToProcessIndex_.find(pd->processName());
       if (itProcess == cend(processNameToProcessIndex_)) {
         continue;
       }
 
       auto const& info = getInfoForTypeLabelInstance(
         type, pd->moduleLabel(), pd->productInstanceName());
 
       unsigned int const processIndex = itProcess->second;
       auto branchData = getBranchData(info, processIndex);
       if (!branchData) {
         continue;
       }
 
       if (auto product = branchData->uniqueProduct_(type)) {
         result.emplace_back(product, pd->productID());
       }
     }
     return result;
   }

art::ProductID gallery::DataGetterHelper::getMaybeValidProductID	(	std::vector< IndexProductIDPair > const &	processIndexToProductID,
		unsigned int	processIndex
	)		const

private

Definition at line 471 of file DataGetterHelper.cc.

   {
     auto itBranchDataIndex = lower_bound(
       processIndexToProductID.cbegin(),
       processIndexToProductID.cend(),
       std::make_pair(processIndex, art::ProductID::invalid()),
       [](auto const& l, auto const& r) { return l.first < r.first; });
     if (itBranchDataIndex != processIndexToProductID.cend() &&
         itBranchDataIndex->first == processIndex) {
       return itBranchDataIndex->second;
     }
     return art::ProductID::invalid();
   }

art::BranchDescription const & gallery::DataGetterHelper::getProductDescription ( art::ProductID productID ) const

Definition at line 548 of file DataGetterHelper.cc.

   {
     auto pd = branchMapReader_.productDescription(productID);
     if (pd == nullptr) {
       throw art::Exception{art::errors::ProductNotFound,
                            "DataGetterHelper::getProductDescription: "}
         << "No product description could be found for ProductID " << productID
         << ".\n";
     }
     return *pd;
   }

std::vector< art::BranchDescription const * > gallery::DataGetterHelper::getProductDescriptions ( art::TypeID const & typeIDOfWrapper ) const

private

Definition at line 117 of file DataGetterHelper.cc.

   {
     std::vector<art::BranchDescription const*> result;
     if (!initializedForProcessHistory_) {
       initializeForProcessHistory();
     }
     auto const fcn = typeIDOfWrapper.friendlyClassName();
     for (auto const& pr : branchMapReader_.productDescriptions()) {
       auto const& pd = pr.second;
       if (pd.friendlyClassName() != fcn) {
         continue;
       }
 
       result.push_back(&pd);
     }
     return result;
   }

TClass * gallery::DataGetterHelper::getTClass	(	InfoForTypeLabelInstance const &	info,
		std::string const &	processName
	)		const

private

Definition at line 383 of file DataGetterHelper.cc.

   {
     auto bd = branchMapReader_.productDescription(info, processName);
     if (bd == nullptr) {
       throw art::Exception{art::errors::LogicError,
                            "DataGetterHelper::getTClass: "}
         << "TBranch exists but no BranchDescription in ProductRegistry.\n"
         << "This shouldn't be possible. For type " << info.type().className()
         << "\n";
     }
 
     art::detail::AssnsStreamer::init_streamer(bd->producedClassName());
     auto tClass = TClass::GetClass(bd->wrappedName().c_str());
     if (tClass == nullptr) {
       throw art::Exception{art::errors::DictionaryNotFound,
                            "DataGetterHelper::getTClass: "}
         << "Missing dictionary for wrapped Assns class.\n"
         << bd->wrappedName() << "\n";
     }
     return tClass;
   }

void gallery::DataGetterHelper::initializeForProcessHistory ( ) const

private

Definition at line 279 of file DataGetterHelper.cc.

   {
     initializedForProcessHistory_ = true;
     // Do nothing if the process names in the process history are the same
     auto const processHistoryID = historyGetter_->processHistoryID();
     if (processHistoryID == previousProcessHistoryID_) {
       return;
     }
     previousProcessHistoryID_ = processHistoryID;
     art::ProcessHistory const& processHistory =
       historyGetter_->processHistory();
     if (previousProcessHistoryNames_.size() == processHistory.size()) {
       bool same = true;
       auto iPrevious = previousProcessHistoryNames_.begin();
       for (auto i = processHistory.begin(), iEnd = processHistory.end();
            i != iEnd;
            ++i, ++iPrevious) {
         if (i->processName() != *iPrevious) {
           same = false;
           break;
         }
       }
       if (same) {
         return;
       }
     }
     previousProcessHistoryNames_.clear();
     // update for the new process history
     orderedProcessIndexes_.clear();
     for (auto const& processConfig : processHistory) {
       std::string const& processName = processConfig.processName();
       previousProcessHistoryNames_.push_back(processName);
       auto itFind = processNameToProcessIndex_.find(processName);
       if (itFind == processNameToProcessIndex_.end()) {
         addProcess(processName);
         itFind = processNameToProcessIndex_.find(processName);
       }
       orderedProcessIndexes_.push_back(itFind->second);
     }
     for (auto const& info : infoVector_) {
       updateBranchDataIndexOrderedByHistory(info);
     }
   }

void gallery::DataGetterHelper::initializeTTreeCache ( )

Definition at line 256 of file DataGetterHelper.cc.

   {
     tree_->SetCacheSize();
     tree_->AddBranchToCache(eventNavigator_->eventAuxiliaryBranch(), kTRUE);
     for (auto const& info : infoVector_) {
       for (auto const& i : info.processIndexToProductID()) {
         auto const productID = i.second;
         auto& branchData = *branchDataMap_.at(productID);
         if (auto branch = branchData.branch()) {
           tree_->AddBranchToCache(branch, kTRUE);
         }
       }
     }
     tree_->StopCacheLearningPhase();
   }

void gallery::DataGetterHelper::insertIntoInfoMap	(	art::TypeID const &	type,
		std::string const &	label,
		std::string const &	instance,
		unsigned int	infoIndex
	)		const

private

Definition at line 453 of file DataGetterHelper.cc.

   {
     TypeLabelInstanceKey const newKey{type, label, instance};
     infoMap_[newKey] = infoIndex;
   }

DataGetterHelper& gallery::DataGetterHelper::operator= ( DataGetterHelper const & )

delete

DataGetterHelper& gallery::DataGetterHelper::operator= ( DataGetterHelper && )

delete

art::EDProduct const * gallery::DataGetterHelper::readProduct	(	art::ProductID const	productID,
		art::TypeID const &	type
	)		const

private

Definition at line 463 of file DataGetterHelper.cc.

   {
     auto const& branchData = branchDataMap_.at(productID);
     return branchData->uniqueProduct_(type);
   }

void gallery::DataGetterHelper::updateBranchDataIndexOrderedByHistory ( InfoForTypeLabelInstance const & info ) const

private

Definition at line 497 of file DataGetterHelper.cc.

   {
     info.productIDsOrderedByHistory().clear();
     if (info.productIDsOrderedByHistory().capacity() <
         orderedProcessIndexes_.size()) {
       info.productIDsOrderedByHistory().reserve(orderedProcessIndexes_.size());
     }
     for (auto processIndex : orderedProcessIndexes_) {
       auto const& orderedProcessName = processNames_[processIndex];
       auto pd = branchMapReader_.productDescription(info, orderedProcessName);
       if (pd == nullptr) {
         continue;
       }
       auto branchData = getBranchData(info, processIndex);
       if (branchData && branchData->branch() != nullptr) {
         info.productIDsOrderedByHistory().emplace_back(pd->productID());
       }
     }
   }

void gallery::DataGetterHelper::updateEvent ( )

Definition at line 273 of file DataGetterHelper.cc.

   {
     initializedForProcessHistory_ = false;
   }

void gallery::DataGetterHelper::updateFile	(	TFile *	iFile,
		TTree *	iTree,
		bool	initializeTheCache
	)

Definition at line 175 of file DataGetterHelper.cc.

   {
     tree_ = iTree;
     art::configureProductIDStreamer(); // Null out the ProductID streamer
     branchMapReader_.updateFile(iFile);
     art::configureProductIDStreamer(branchMapReader_.branchIDLists());
     if (initializeTheCache) {
       tree_->SetCacheSize();
       tree_->AddBranchToCache(eventNavigator_->eventAuxiliaryBranch(), kTRUE);
     }
     for (auto& info : infoVector_) {
       std::vector<IndexProductIDPair> old;
       old.swap(info.processIndexToProductID());
       info.processIndexToProductID().reserve(processNames_.size());
       for (unsigned int processIndex{}; processIndex < processNames_.size();
            ++processIndex) {
         auto const& processName = processNames_[processIndex];
         auto bd = branchMapReader_.productDescription(info, processName);
         if (bd == nullptr) {
           // Product not available.
           continue;
         }
 
         auto const productID = getMaybeValidProductID(old, processIndex);
         if (productID.isValid()) {
           auto& branchData = *branchDataMap_.at(productID);
           auto branch = tree_->GetBranch(branchData.branchName().c_str());
           // This will update the pointer to the TBranch in
           // BranchData.  This loop is sufficient to update all
           // BranchData objects in the vector.
           branchData.updateFile(branch);
 
           // A little paranoia here. What if in one input file
           // Assns<A,B,C> is written into the file and Assns<B,A,C> is
           // written into another? The following deals properly with
           // that case by constructing a new AssnsBranchData object,
           // although I imagine it might never happen in practice.
           if (info.isAssns() && branch != nullptr) {
             TClass* tClass = getTClass(info, processName);
 
             art::TypeID const typeIDInDescription{tClass->GetTypeInfo()};
             art::TypeID const typeIDInBranchData{
               branchData.tClass()->GetTypeInfo()};
             if (typeIDInDescription != typeIDInBranchData) {
               std::string branchName = branchData.branchName();
               branchDataMap_[productID] =
                 std::make_unique<AssnsBranchData>(typeIDInDescription,
                                                   tClass,
                                                   branch,
                                                   eventNavigator_,
                                                   this,
                                                   move(branchName),
                                                   info.type(),
                                                   info.partnerType());
             }
           }
           info.processIndexToProductID().emplace_back(processIndex,
                                                       bd->productID());
           if (initializeTheCache && branch) {
             tree_->AddBranchToCache(branch, kTRUE);
           }
         } else if (branchMapReader_.branchInRegistryOfAnyOpenedFile(
                      productID)) {
           addBranchData(
             bd->branchName(), processIndex, info, initializeTheCache);
         }
       }
       updateBranchDataIndexOrderedByHistory(info);
     }
     if (initializeTheCache) {
       tree_->StopCacheLearningPhase();
     }
     // This must be cleared because the BranchIDLists may be different
     // in different input files.
     branchDataMissingSet_.clear();
     updateEvent();
   }

Member Data Documentation

std::map<art::ProductID, std::unique_ptr<BranchData> > gallery::DataGetterHelper::branchDataMap_ {}

mutableprivate

Definition at line 200 of file DataGetterHelper.h.

std::set<art::ProductID> gallery::DataGetterHelper::branchDataMissingSet_ {}

mutableprivate

Definition at line 207 of file DataGetterHelper.h.

BranchMapReader gallery::DataGetterHelper::branchMapReader_ {}

private

Definition at line 210 of file DataGetterHelper.h.

art::root::DictionaryChecker gallery::DataGetterHelper::dictChecker_ {}

mutableprivate

Definition at line 212 of file DataGetterHelper.h.

EventNavigator const* gallery::DataGetterHelper::eventNavigator_

private

Definition at line 149 of file DataGetterHelper.h.

std::shared_ptr<EventHistoryGetter> gallery::DataGetterHelper::historyGetter_

private

Definition at line 153 of file DataGetterHelper.h.

std::map<TypeLabelInstanceKey, unsigned int> gallery::DataGetterHelper::infoMap_ {}

mutableprivate

Definition at line 182 of file DataGetterHelper.h.

std::vector<InfoForTypeLabelInstance> gallery::DataGetterHelper::infoVector_ {}

mutableprivate

Definition at line 178 of file DataGetterHelper.h.

bool gallery::DataGetterHelper::initializedForProcessHistory_ {false}

mutableprivate

Definition at line 155 of file DataGetterHelper.h.

BranchData gallery::DataGetterHelper::invalidBranchData_ {}

private

Definition at line 202 of file DataGetterHelper.h.

std::vector<unsigned int> gallery::DataGetterHelper::orderedProcessIndexes_ {}

mutableprivate

Definition at line 171 of file DataGetterHelper.h.

art::ProcessHistoryID gallery::DataGetterHelper::previousProcessHistoryID_ {}

mutableprivate

Definition at line 157 of file DataGetterHelper.h.

std::vector<std::string> gallery::DataGetterHelper::previousProcessHistoryNames_ {}

mutableprivate

Definition at line 159 of file DataGetterHelper.h.

std::vector<std::string> gallery::DataGetterHelper::processNames_ {}

mutableprivate

Definition at line 164 of file DataGetterHelper.h.

std::map<std::string, unsigned int> gallery::DataGetterHelper::processNameToProcessIndex_ {}

mutableprivate

Definition at line 168 of file DataGetterHelper.h.

TTree* gallery::DataGetterHelper::tree_ {nullptr}

private

Definition at line 151 of file DataGetterHelper.h.

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

gallery/gallery/DataGetterHelper.h
gallery/gallery/DataGetterHelper.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation