#include <Principal.h>

Inheritance diagram for art::Principal:

Public Types
enum	allowed_processes { allowed_processes::current_process, allowed_processes::input_source, allowed_processes::all }

using	GroupCollection = std::map< ProductID, std::unique_ptr< Group >>

using	const_iterator = GroupCollection::const_iterator

Public Member Functions
virtual	~Principal () noexcept

	Principal (BranchType, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, ProcessHistoryID const &, std::unique_ptr< DelayedReader > &&)

	Principal (RunAuxiliary const &, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< DelayedReader > &&reader=std::make_unique< NoDelayedReader >())

	Principal (SubRunAuxiliary const &, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< DelayedReader > &&reader=std::make_unique< NoDelayedReader >())

	Principal (EventAuxiliary const &, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< History > &&history=std::make_unique< History >(), std::unique_ptr< DelayedReader > &&reader=std::make_unique< NoDelayedReader >(), bool lastInSubRun=false)

	Principal (ResultsAuxiliary const &, ProcessConfiguration const &, cet::exempt_ptr< ProductTable const > presentProducts, std::unique_ptr< DelayedReader > &&reader=std::make_unique< NoDelayedReader >())

	Principal (Principal const &)=delete

Principal &	operator= (Principal const &)=delete

GroupQueryResult	getByProductID (ProductID const pid) const

GroupQueryResult	getBySelector (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

GroupQueryResult	getByLabel (ModuleContext const &mc, WrappedTypeID const &wrapped, std::string const &label, std::string const &productInstanceName, ProcessTag const &processTag) const

std::vector< GroupQueryResult >	getMany (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

std::vector< InputTag >	getInputTags (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

std::vector< cet::exempt_ptr< Group > >	getMatchingSequence (ModuleContext const &, SelectorBase const &, ProcessTag const &) const

EDProductGetter const *	productGetter (ProductID const &pid) const

ProcessHistory const &	processHistory () const

void	removeCachedProduct (ProductID) const

OutputHandle	getForOutput (ProductID const &, bool resolveProd) const

cet::exempt_ptr< BranchDescription const >	getProductDescription (ProductID const pid, bool const alwaysEnableLookupOfProducedProducts=false) const

void	createGroupsForProducedProducts (ProductTables const &producedProducts)

void	enableLookupOfProducedProducts (ProductTables const &producedProducts)

void	markProcessHistoryAsModified ()

void	readImmediate () const

ProcessConfiguration const &	processConfiguration () const

cet::exempt_ptr< ProductProvenance const >	branchToProductProvenance (ProductID const &) const

size_t	size () const

const_iterator	begin () const

const_iterator	cbegin () const

const_iterator	end () const

const_iterator	cend () const

void	addToProcessHistory ()

BranchType	branchType () const

RangeSet	seenRanges () const

void	put (BranchDescription const &, std::unique_ptr< ProductProvenance const > &&, std::unique_ptr< EDProduct > &&, std::unique_ptr< RangeSet > &&)

RunAuxiliary const &	runAux () const

SubRunAuxiliary const &	subRunAux () const

EventAuxiliary const &	eventAux () const

ResultsAuxiliary const &	resultsAux () const

RunID const &	runID () const

SubRunID	subRunID () const

EventID const &	eventID () const

RunNumber_t	run () const

SubRunNumber_t	subRun () const

EventNumber_t	event () const

Timestamp const &	beginTime () const

Timestamp const &	endTime () const

void	endTime (Timestamp const &time)

Timestamp const &	time () const

void	updateSeenRanges (RangeSet const &rs)

RunPrincipal const &	runPrincipal () const

SubRunPrincipal const &	subRunPrincipal () const

cet::exempt_ptr< RunPrincipal const >	runPrincipalExemptPtr () const

SubRunPrincipal const *	subRunPrincipalPtr () const

void	setRunPrincipal (cet::exempt_ptr< RunPrincipal const > rp)

void	setSubRunPrincipal (cet::exempt_ptr< SubRunPrincipal const > srp)

EventAuxiliary::ExperimentType	ExperimentType () const

bool	isReal () const

EventSelectionIDVector const &	eventSelectionIDs () const

History const &	history () const

bool	isLastInSubRun () const

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

	PrincipalBase ()

EDProductGetter const *	getEDProductGetter (ProductID const &pid) const

Protected Member Functions
void	fillGroup (BranchDescription const &)

void	setProcessHistoryIDcombined (ProcessHistoryID const &)

Private Member Functions
void	ctor_create_groups (cet::exempt_ptr< ProductTable const >)

void	ctor_read_provenance ()

void	ctor_fetch_process_history (ProcessHistoryID const &)

cet::exempt_ptr< Group >	getGroupLocal (ProductID const) const

std::vector< cet::exempt_ptr< Group > >	matchingSequenceFromInputFile (ModuleContext const &, SelectorBase const &) const

size_t	findGroupsFromInputFile (ModuleContext const &, WrappedTypeID const &wrapped, SelectorBase const &, std::vector< cet::exempt_ptr< Group >> &results) const

size_t	findGroups (ProcessLookup const &, ModuleContext const &, SelectorBase const &, std::vector< cet::exempt_ptr< Group >> &groups) const

size_t	findGroupsForProcess (std::vector< ProductID > const &vpid, ModuleContext const &mc, SelectorBase const &selector, std::vector< cet::exempt_ptr< Group >> &groups) const

bool	producedInProcess (ProductID) const

bool	presentFromSource (ProductID) const

auto	tryNextSecondaryFile () const

std::vector< cet::exempt_ptr< Group > >	findGroupsForProduct (ModuleContext const &mc, WrappedTypeID const &wrapped, SelectorBase const &, ProcessTag const &) const

EDProductGetter const *	getEDProductGetter_ (ProductID const &) const override

cet::exempt_ptr< Group const >	getGroupTryAllFiles (ProductID const) const

Private Attributes
BranchType	branchType_ {}

ProcessHistory	processHistory_ {}

std::atomic< bool >	processHistoryModified_

ProcessConfiguration const &	processConfiguration_

std::atomic< ProductTable const * >	presentProducts_

std::atomic< ProductTable const * >	producedProducts_

std::atomic< bool >	enableLookupOfProducedProducts_

std::recursive_mutex	groupMutex_ {}

GroupCollection	groups_ {}

std::unique_ptr< DelayedReader >	delayedReader_ {nullptr}

std::vector< std::unique_ptr< Principal > >	secondaryPrincipals_ {}

int	nextSecondaryFileIdx_ {}

RangeSet	rangeSet_ {RangeSet::invalid()}

RunAuxiliary	runAux_ {}

SubRunAuxiliary	subRunAux_ {}

std::atomic< EventAuxiliary * >	eventAux_

ResultsAuxiliary	resultsAux_ {}

cet::exempt_ptr< RunPrincipal const >	runPrincipal_ {nullptr}

std::atomic< SubRunPrincipal const * >	subRunPrincipal_

std::unique_ptr< History >	history_ {nullptr}

bool	lastInSubRun_ {false}

Detailed Description

Definition at line 54 of file Principal.h.

Member Typedef Documentation

using art::Principal::const_iterator = GroupCollection::const_iterator

Definition at line 57 of file Principal.h.

using art::Principal::GroupCollection = std::map<ProductID, std::unique_ptr<Group>>

Definition at line 56 of file Principal.h.

Member Enumeration Documentation

enum art::Principal::allowed_processes

strong

Enumerator
current_process
input_source
all

Definition at line 58 of file Principal.h.

58 { current_process, input_source, all };

all

static QInternalList< QTextCodec > * all

Definition: qtextcodec.cpp:63

Constructor & Destructor Documentation

virtual art::Principal::~Principal ( )

inlinevirtualnoexcept

Definition at line 64 of file Principal.h.

     {
       presentProducts_ = nullptr;
       producedProducts_ = nullptr;
       delete eventAux_.load();
     }

art::Principal::Principal	(	BranchType	branchType,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		ProcessHistoryID const &	hist,
		std::unique_ptr< DelayedReader > &&	reader
	)

Definition at line 124 of file Principal.cc.

     : branchType_{branchType}
     , processConfiguration_{pc}
     , delayedReader_{std::move(reader)}
   {
     processHistoryModified_ = false;
     presentProducts_ = presentProducts.get();
     producedProducts_ = nullptr;
     enableLookupOfProducedProducts_ = false;
     delayedReader_->setPrincipal(this);
     eventAux_ = nullptr;
     subRunPrincipal_ = nullptr;
     ctor_create_groups(presentProducts);
     ctor_read_provenance();
     ctor_fetch_process_history(hist);
   }

art::Principal::Principal	(	RunAuxiliary const &	aux,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< DelayedReader > &&	reader = `std::make_unique<NoDelayedReader>()`
	)

Definition at line 146 of file Principal.cc.

     : branchType_{InRun}
     , processConfiguration_{pc}
     , delayedReader_{std::move(reader)}
     , runAux_{aux}
   {
     processHistoryModified_ = false;
     presentProducts_ = presentProducts.get();
     producedProducts_ = nullptr;
     enableLookupOfProducedProducts_ = false;
     delayedReader_->setPrincipal(this);
     eventAux_ = nullptr;
     subRunPrincipal_ = nullptr;
     ctor_create_groups(presentProducts);
     ctor_read_provenance();
     ctor_fetch_process_history(runAux_.processHistoryID());
   }

art::Principal::Principal	(	SubRunAuxiliary const &	aux,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< DelayedReader > &&	reader = `std::make_unique<NoDelayedReader>()`
	)

Definition at line 169 of file Principal.cc.

     : branchType_{InSubRun}
     , processConfiguration_{pc}
     , delayedReader_{std::move(reader)}
     , subRunAux_{aux}
   {
     processHistoryModified_ = false;
     presentProducts_ = presentProducts.get();
     producedProducts_ = nullptr;
     enableLookupOfProducedProducts_ = false;
     delayedReader_->setPrincipal(this);
     eventAux_ = nullptr;
     subRunPrincipal_ = nullptr;
     ctor_create_groups(presentProducts);
     ctor_read_provenance();
     ctor_fetch_process_history(subRunAux_.processHistoryID());
   }

art::Principal::Principal	(	EventAuxiliary const &	aux,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< History > &&	history = `std::make_unique<History>()`,
		std::unique_ptr< DelayedReader > &&	reader = `std::make_unique<NoDelayedReader>()`,
		bool	lastInSubRun = `false`
	)

Definition at line 192 of file Principal.cc.

     : branchType_{InEvent}
     , processConfiguration_{pc}
     , delayedReader_{std::move(reader)}
     , history_{move(history)}
     , lastInSubRun_{lastInSubRun}
   {
     processHistoryModified_ = false;
     presentProducts_ = presentProducts.get();
     producedProducts_ = nullptr;
     enableLookupOfProducedProducts_ = false;
     delayedReader_->setPrincipal(this);
     eventAux_ = new EventAuxiliary(aux);
     subRunPrincipal_ = nullptr;
     ctor_create_groups(presentProducts);
     ctor_read_provenance();
     ctor_fetch_process_history(history_->processHistoryID());
   }

art::Principal::Principal	(	ResultsAuxiliary const &	aux,
		ProcessConfiguration const &	pc,
		cet::exempt_ptr< ProductTable const >	presentProducts,
		std::unique_ptr< DelayedReader > &&	reader = `std::make_unique<NoDelayedReader>()`
	)

Definition at line 219 of file Principal.cc.

     : branchType_{InResults}
     , processConfiguration_{pc}
     , delayedReader_{std::move(reader)}
     , resultsAux_{aux}
   {
     processHistoryModified_ = false;
     presentProducts_ = presentProducts.get();
     producedProducts_ = nullptr;
     enableLookupOfProducedProducts_ = false;
     delayedReader_->setPrincipal(this);
     eventAux_ = nullptr;
     subRunPrincipal_ = nullptr;
     ctor_create_groups(presentProducts);
     ctor_read_provenance();
     ctor_fetch_process_history(resultsAux_.processHistoryID());
   }

art::Principal::Principal ( Principal const & )

delete

Member Function Documentation

void art::Principal::addToProcessHistory ( )

Definition at line 563 of file Principal.cc.

   {
     bool expected = false;
     if (processHistoryModified_.compare_exchange_strong(expected, true)) {
       // MT note: We have now locked out any other task trying to
       //          modify the process history. Now we have to block
       //          tasks that already have a pointer to the process
       //          history from accessing its internals while we update
       //          it. We do not protect the iteration interface, the
       //          begin(), end(), and size() are all separate calls
       //          and we cannot lock in each one because there is no
       //          way to automatically unlock.
       std::lock_guard sentry{processHistory_.get_mutex()};
       string const& processName = processConfiguration_.processName();
       for (auto const& val : processHistory_) {
         if (processName == val.processName()) {
           throw art::Exception(errors::Configuration)
             << "The process name " << processName
             << " was previously used on these products.\n"
             << "Please modify the configuration file to use a "
             << "distinct process name.\n";
         }
       }
       processHistory_.push_back(processConfiguration_);
       // Optimization note: As of 0_9_0_pre3 For very simple Sources
       // (e.g. EmptyEvent) this routine takes up nearly 50% of the
       // time per event, and 96% of the time for this routine is spent
       // in computing the ProcessHistory id which happens because we
       // are reconstructing the ProcessHistory for each event.  It
       // would probably be better to move the ProcessHistory
       // construction out to somewhere which persists for longer than
       // one Event.
       auto const phid = processHistory_.id();
       ProcessHistoryRegistry::emplace(phid, processHistory_);
       // MT note: We must protect processHistory_!  The id() call can
       //          modify it! Note: threading: We are modifying Run,
       //          SubRun, Event, and Results principals here, and
       //          their *Auxiliary Note: threading: and the event
       //          principal art::History.
       setProcessHistoryIDcombined(processHistory_.id());
     }
   }

Principal::const_iterator art::Principal::begin ( ) const

Definition at line 386 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.begin();
   }

Timestamp const & art::Principal::beginTime ( ) const

Definition at line 1097 of file Principal.cc.

   {
     if (branchType_ == InRun) {
       return runAux_.beginTime();
     }
     return subRunAux_.beginTime();
   }

cet::exempt_ptr< ProductProvenance const > art::Principal::branchToProductProvenance ( ProductID const & pid ) const

Definition at line 438 of file Principal.cc.

   {
     // Note: The input source lock will be held when this routine is called.
     //
     // MT-TODO: For right now ignore the delay reading option for
     //          product provenance. If we do the delay reading then we
     //          must use a lock to interlock all fetches of provenance
     //          because the delay read fills the pp_by_pid_ one entry
     //          at a time, and we do not want other threads to find
     //          the info only partly there.
     cet::exempt_ptr<ProductProvenance const> ret;
     auto g = getGroupLocal(pid);
     if (g.get() != nullptr) {
       ret = g->productProvenance();
     }
     return ret;
   }

BranchType art::Principal::branchType ( ) const

Definition at line 1022 of file Principal.cc.

   {
     return branchType_;
   }

Principal::const_iterator art::Principal::cbegin ( ) const

Definition at line 393 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.cbegin();
   }

Principal::const_iterator art::Principal::cend ( ) const

Definition at line 407 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.cend();
   }

void art::Principal::createGroupsForProducedProducts ( ProductTables const & producedProducts )

Definition at line 314 of file Principal.cc.

   {
     auto const& produced = producedProducts.get(branchType_);
     producedProducts_ = &produced;
     if (produced.descriptions.empty()) {
       return;
     }
     // The process history is expanded if there is a product that is
     // produced in this process.
     addToProcessHistory();
     for (auto const& pr : produced.descriptions) {
       auto const& pd = pr.second;
       assert(pd.branchType() == branchType_);
       // Create a group for the produced product.
       fillGroup(pd);
     }
   }

void art::Principal::ctor_create_groups ( cet::exempt_ptr< ProductTable const > presentProducts )

private

Definition at line 72 of file Principal.cc.

   {
     if (!presentProducts) {
       return;
     }
     // Note: Dropped products are a problem. We should not create
     //       groups for them now because later we may open a secondary
     //       file which actually contains them and we want the
     //       secondary principal to have those groups. However some
     //       code expects to be able to find a group for dropped
     //       products, so getGroupTryAllFiles ignores groups for
     //       dropped products instead.
     for (auto const& pr : presentProducts->descriptions) {
       auto const& pd = pr.second;
       assert(pd.branchType() == branchType_);
       fillGroup(pd);
     }
   }

void art::Principal::ctor_fetch_process_history ( ProcessHistoryID const & phid )

private

Definition at line 114 of file Principal.cc.

   {
     if (!phid.isValid()) {
       return;
     }
     ProcessHistory processHistory;
     ProcessHistoryRegistry::get(phid, processHistory);
     std::swap(processHistory_, processHistory);
   }

void art::Principal::ctor_read_provenance ( )

private

Definition at line 93 of file Principal.cc.

   {
     auto ppv = delayedReader_->readProvenance();
     for (auto iter = ppv.begin(), end = ppv.end(); iter != end; ++iter) {
       auto g = getGroupLocal(iter->productID());
       if (g.get() == nullptr) {
         continue;
       }
       if (iter->productStatus() != productstatus::unknown()) {
         g->setProductProvenance(make_unique<ProductProvenance>(*iter));
       } else {
         // We have an old format file, convert.
         g->setProductProvenance(make_unique<ProductProvenance>(
           iter->productID(),
           productstatus::dummyToPreventDoubleCount(),
           iter->parentage().parents()));
       }
     }
   }

void art::Principal::enableLookupOfProducedProducts ( ProductTables const & producedProducts )

Definition at line 334 of file Principal.cc.

   {
     enableLookupOfProducedProducts_ = true;
   }

Principal::const_iterator art::Principal::end ( ) const

Definition at line 400 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.end();
   }

Timestamp const & art::Principal::endTime ( ) const

Definition at line 1106 of file Principal.cc.

   {
     if (branchType_ == InRun) {
       return runAux_.endTime();
     }
     return subRunAux_.endTime();
   }

void art::Principal::endTime ( Timestamp const & time )

Definition at line 1115 of file Principal.cc.

   {
     if (branchType_ == InRun) {
       runAux_.endTime(time);
       return;
     }
     subRunAux_.setEndTime(time);
   }

EventNumber_t art::Principal::event ( ) const

Definition at line 1091 of file Principal.cc.

   {
     return eventAux_.load()->id().event();
   }

EventAuxiliary const & art::Principal::eventAux ( ) const

Definition at line 1040 of file Principal.cc.

   {
     return *eventAux_.load();
   }

EventID const & art::Principal::eventID ( ) const

Definition at line 1064 of file Principal.cc.

   {
     return eventAux_.load()->id();
   }

EventSelectionIDVector const & art::Principal::eventSelectionIDs ( ) const

Definition at line 908 of file Principal.cc.

   {
     return history_->eventSelectionIDs();
   }

EventAuxiliary::ExperimentType art::Principal::ExperimentType ( ) const

Definition at line 896 of file Principal.cc.

   {
     return eventAux_.load()->experimentType();
   }

void art::Principal::fillGroup ( BranchDescription const & pd )

protected

Definition at line 242 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     auto it = groups_.find(pd.productID());
     if (it != std::cend(groups_)) {
       // The 'combinable' call does not require that the processing
       // history be the same, which is not what we are checking for here.
       auto const& found_pd = it->second->productDescription();
       if (combinable(found_pd, pd)) {
         throw Exception(errors::Configuration)
           << "The process name " << pd.processName()
           << " was previously used on these products.\n"
           << "Please modify the configuration file to use a "
           << "distinct process name.\n";
       }
       throw Exception(errors::ProductRegistrationFailure)
         << "The product ID " << pd.productID() << " of the new product:\n"
         << pd
         << " collides with the product ID of the already-existing product:\n"
         << found_pd
         << "Please modify the instance name of the new product so as to avoid "
            "the product ID collision.\n"
         << "In addition, please notify artists@fnal.gov of this error.\n";
     }
 
     unique_ptr<Group> group = create_group(delayedReader_.get(), pd);
     groups_[pd.productID()] = move(group);
   }

std::size_t art::Principal::findGroups	(	ProcessLookup const &	pl,
		ModuleContext const &	mc,
		SelectorBase const &	sel,
		std::vector< cet::exempt_ptr< Group >> &	groups
	)		const

private

Definition at line 607 of file Principal.cc.

   {
     // Loop over processes in reverse time order.  Sometimes we want
     // to stop after we find a process with matches so check for that
     // at each step.
     std::size_t found{};
     // MT note: We must protect the process history iterators here
     //          against possible invalidation by output modules
     //          inserting a process history entry while we are
     //          iterating.
     std::lock_guard sentry{processHistory_.get_mutex()};
     // We must skip over duplicate entries of the same process
     // configuration in the process history.  This unfortunately
     // happened with the SamplingInput source.
     for (auto const& h :
          ranges::views::reverse(processHistory_) | ranges::views::unique) {
       if (auto it = pl.find(h.processName()); it != pl.end()) {
         found += findGroupsForProcess(it->second, mc, sel, groups);
       }
     }
     return found;
   }

std::size_t art::Principal::findGroupsForProcess	(	std::vector< ProductID > const &	vpid,
		ModuleContext const &	mc,
		SelectorBase const &	selector,
		std::vector< cet::exempt_ptr< Group >> &	groups
	)		const

private

Definition at line 813 of file Principal.cc.

   {
     std::size_t found{}; // Horrible hack that should go away
     for (auto const pid : vpid) {
       auto group = getGroupLocal(pid);
       if (!group) {
         continue;
       }
       auto const& pd = group->productDescription();
       // If we are processing a trigger path, the only visible
       // produced products are those that originate from modules on
       // the same path we're currently processing.
       if (mc.onTriggerPath() && pd.produced() &&
           !mc.onSamePathAs(pd.moduleLabel())) {
         continue;
       }
       if (!sel.match(pd)) {
         continue;
       }
       // Found a good match, save it.
       res.emplace_back(group);
       ++found;
     }
     return found;
   }

std::vector< cet::exempt_ptr< Group > > art::Principal::findGroupsForProduct	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	selector,
		ProcessTag const &	processTag
	)		const

private

Definition at line 771 of file Principal.cc.

   {
     std::vector<cet::exempt_ptr<Group>> results;
     unsigned ret{};
     // Find groups from current process
     if (processTag.current_process_search_allowed() &&
         enableLookupOfProducedProducts_.load()) {
       auto const& lookup = producedProducts_.load()->productLookup;
       auto it = lookup.find(wrapped.product_type.friendlyClassName());
       if (it != lookup.end()) {
         ret += findGroups(it->second, mc, selector, results);
       }
     }
 
     if (!processTag.input_source_search_allowed()) {
       return results;
     }
 
     // Look through currently opened input files
     ret += findGroupsFromInputFile(mc, wrapped, selector, results);
     if (ret) {
       return results;
     }
     for (auto const& sp : secondaryPrincipals_) {
       if (sp->findGroupsFromInputFile(mc, wrapped, selector, results)) {
         return results;
       }
     }
     // Open more secondary files if necessary
     while (auto sp = tryNextSecondaryFile()) {
       auto& new_sp = secondaryPrincipals_.emplace_back(move(sp));
       if (new_sp->findGroupsFromInputFile(mc, wrapped, selector, results)) {
         return results;
       }
     }
     return results;
   }

std::size_t art::Principal::findGroupsFromInputFile	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	selector,
		std::vector< cet::exempt_ptr< Group >> &	results
	)		const

private

Definition at line 753 of file Principal.cc.

   {
     if (!presentProducts_.load()) {
       return 0;
     }
     auto const& lookup = presentProducts_.load()->productLookup;
     auto it = lookup.find(wrapped.product_type.friendlyClassName());
     if (it == lookup.end()) {
       return 0;
     }
     return findGroups(it->second, mc, selector, groups);
   }

GroupQueryResult art::Principal::getByLabel	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		std::string const &	label,
		std::string const &	productInstanceName,
		ProcessTag const &	processTag
	)		const

Definition at line 652 of file Principal.cc.

   {
     auto const& processName = processTag.name();
     Selector const sel{ModuleLabelSelector{label} &&
                        ProductInstanceNameSelector{productInstanceName} &&
                        ProcessNameSelector{processName}};
     return getBySelector(mc, wrapped, sel, processTag);
   }

GroupQueryResult art::Principal::getByProductID ( ProductID const pid ) const

Definition at line 1151 of file Principal.cc.

   {
     if (auto const g = getGroupTryAllFiles(pid)) {
       return GroupQueryResult{g};
     }
     auto whyFailed =
       make_shared<Exception>(errors::ProductNotFound, "InvalidID");
     *whyFailed << "Principal::getByProductID: no product with branch type: "
                << branchType_ << " product id: " << pid << '\n';
     return GroupQueryResult{whyFailed};
   }

GroupQueryResult art::Principal::getBySelector	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	sel,
		ProcessTag const &	processTag
	)		const

Definition at line 634 of file Principal.cc.

   {
     auto const groups = findGroupsForProduct(mc, wrapped, sel, processTag);
     auto const result = resolve_unique_product(groups, wrapped);
     if (!result.has_value()) {
       auto whyFailed = std::make_shared<Exception>(errors::ProductNotFound);
       *whyFailed << "Found zero products matching all selection criteria\n"
                  << indent << "C++ type: " << wrapped.product_type << "\n"
                  << sel.print(indent);
       return GroupQueryResult{whyFailed};
     }
     return *result;
   }

EDProductGetter const * art::Principal::getEDProductGetter_ ( ProductID const & pid ) const

overrideprivatevirtual

Implements art::PrincipalBase.

Definition at line 308 of file Principal.cc.

   {
     return productGetter(pid);
   }

OutputHandle art::Principal::getForOutput	(	ProductID const &	pid,
		bool	resolveProd
	)		const

Definition at line 965 of file Principal.cc.

   {
     // MT-FIXME: Uses of group!
     auto g = getGroupTryAllFiles(pid);
     if (g.get() == nullptr) {
       return OutputHandle::invalid();
     }
     if (resolveProd) {
       if (!g->resolveProductIfAvailable()) {
         // Behavior is the same as if the group wasn't there.
         return OutputHandle::invalid();
       }
       if (g->anyProduct() == nullptr) {
         return OutputHandle::invalid();
       }
       if (!g->anyProduct()->isPresent()) {
         return OutputHandle::invalid();
       }
     }
     if (!g->anyProduct() && !g->productProvenance()) {
       return OutputHandle{g->rangeOfValidity()};
     }
     return OutputHandle{g->anyProduct(),
                         &g->productDescription(),
                         g->productProvenance(),
                         g->rangeOfValidity()};
   }

cet::exempt_ptr< Group > art::Principal::getGroupLocal ( ProductID const pid ) const

private

Definition at line 1164 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     auto it = groups_.find(pid);
     return it != groups_.cend() ? it->second.get() : nullptr;
   }

cet::exempt_ptr< Group const > art::Principal::getGroupTryAllFiles ( ProductID const pid ) const

private

Definition at line 1172 of file Principal.cc.

   {
     // Look through current process and currently opened primary input file.
     if (producedInProcess(pid) || presentFromSource(pid)) {
       return getGroupLocal(pid);
     }
     // Look through secondary files
     for (auto const& sp : secondaryPrincipals_) {
       if (sp->presentFromSource(pid)) {
         return sp->getGroupLocal(pid);
       }
     }
     // Try new secondary files
     while (auto sp = tryNextSecondaryFile()) {
       auto& new_sp = secondaryPrincipals_.emplace_back(move(sp));
       if (new_sp->presentFromSource(pid)) {
         return new_sp->getGroupLocal(pid);
       }
     }
     return nullptr;
   }

std::vector< InputTag > art::Principal::getInputTags	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	sel,
		ProcessTag const &	processTag
	)		const

Definition at line 666 of file Principal.cc.

   {
     std::vector<InputTag> tags;
     auto const groups = findGroupsForProduct(mc, wrapped, sel, processTag);
     cet::transform_all(groups, back_inserter(tags), [](auto const g) {
       return g->productDescription().inputTag();
     });
     return tags;
   }

std::vector< GroupQueryResult > art::Principal::getMany	(	ModuleContext const &	mc,
		WrappedTypeID const &	wrapped,
		SelectorBase const &	sel,
		ProcessTag const &	processTag
	)		const

Definition at line 680 of file Principal.cc.

   {
     auto const groups = findGroupsForProduct(mc, wrapped, sel, processTag);
     return resolve_products(groups, wrapped.wrapped_product_type);
   }

std::vector< cet::exempt_ptr< Group > > art::Principal::getMatchingSequence	(	ModuleContext const &	mc,
		SelectorBase const &	selector,
		ProcessTag const &	processTag
	)		const

Definition at line 696 of file Principal.cc.

   {
     std::vector<cet::exempt_ptr<Group>> groups;
     // Find groups from current process
     if (processTag.current_process_search_allowed() &&
         enableLookupOfProducedProducts_.load()) {
       if (findGroups(
             producedProducts_.load()->viewLookup, mc, selector, groups) != 0) {
         return groups;
       }
     }
 
     if (!processTag.input_source_search_allowed()) {
       return groups;
     }
 
     // Look through currently opened input files
     if (groups.empty()) {
       groups = matchingSequenceFromInputFile(mc, selector);
       if (!groups.empty()) {
         return groups;
       }
       for (auto const& sp : secondaryPrincipals_) {
         groups = sp->matchingSequenceFromInputFile(mc, selector);
         if (!groups.empty()) {
           return groups;
         }
       }
     }
     // Open more secondary files if necessary
     if (groups.empty()) {
       while (auto sp = tryNextSecondaryFile()) {
         auto& new_sp = secondaryPrincipals_.emplace_back(move(sp));
         groups = new_sp->matchingSequenceFromInputFile(mc, selector);
         if (!groups.empty()) {
           return groups;
         }
       }
     }
     return groups;
   }

cet::exempt_ptr< BranchDescription const > art::Principal::getProductDescription	(	ProductID const	pid,
		bool const	alwaysEnableLookupOfProducedProducts = `false`
	)		const

Definition at line 994 of file Principal.cc.

   {
     // Find groups from current process
     if (alwaysEnableLookupOfProducedProducts ||
         enableLookupOfProducedProducts_.load()) {
       if (producedProducts_.load() != nullptr) {
         if (auto result = producedProducts_.load()->description(pid)) {
           return result;
         }
       }
     }
     if (presentProducts_.load()) {
       // Look through currently opened input files
       if (auto result = presentProducts_.load()->description(pid)) {
         return result;
       }
     }
     for (auto const& sp : secondaryPrincipals_) {
       if (auto result = sp->getProductDescription(pid)) {
         return result;
       }
     }
     return nullptr;
   }

History const & art::Principal::history ( ) const

Definition at line 902 of file Principal.cc.

   {
     return *history_;
   }

bool art::Principal::isLastInSubRun ( ) const

Definition at line 924 of file Principal.cc.

   {
     return lastInSubRun_;
   }

bool art::Principal::isReal ( ) const

Definition at line 890 of file Principal.cc.

   {
     return eventAux_.load()->isRealData();
   }

void art::Principal::markProcessHistoryAsModified ( )

Definition at line 290 of file Principal.cc.

   {
     processHistoryModified_ = true;
   }

std::vector< cet::exempt_ptr< Group > > art::Principal::matchingSequenceFromInputFile	(	ModuleContext const &	mc,
		SelectorBase const &	selector
	)		const

private

Definition at line 741 of file Principal.cc.

   {
     std::vector<cet::exempt_ptr<Group>> groups;
     if (!presentProducts_.load()) {
       return groups;
     }
     findGroups(presentProducts_.load()->viewLookup, mc, selector, groups);
     return groups;
   }

Principal& art::Principal::operator= ( Principal const & )

delete

bool art::Principal::presentFromSource ( ProductID pid ) const

private

Definition at line 1141 of file Principal.cc.

   {
     if (!presentProducts_.load()) {
       return false;
     }
     auto pd = presentProducts_.load()->description(pid);
     return pd == nullptr ? false : pd->present();
   }

ProcessConfiguration const & art::Principal::processConfiguration ( ) const

Definition at line 373 of file Principal.cc.

   {
     return processConfiguration_;
   }

ProcessHistory const & art::Principal::processHistory ( ) const

Definition at line 363 of file Principal.cc.

   {
     // MT note: We make no attempt to protect callers who use this
     //          call to get access to the iteration interface of the
     //          process history.  See the threading notes there and
     //          here for the reasons why.
     return processHistory_;
   }

bool art::Principal::producedInProcess ( ProductID pid ) const

private

Definition at line 1131 of file Principal.cc.

   {
     if (!enableLookupOfProducedProducts_.load()) {
       return false;
     }
     auto pd = producedProducts_.load()->description(pid);
     return pd == nullptr ? false : pd->produced();
   }

EDProductGetter const * art::Principal::productGetter ( ProductID const & pid ) const

Definition at line 297 of file Principal.cc.

   {
     auto g = getGroupTryAllFiles(pid);
     if (g.get() != nullptr) {
       // Note: All produced products should be found.
       return g.get();
     }
     return nullptr;
   }

void art::Principal::put	(	BranchDescription const &	bd,
		std::unique_ptr< ProductProvenance const > &&	pp,
		std::unique_ptr< EDProduct > &&	edp,
		std::unique_ptr< RangeSet > &&	rs
	)

Definition at line 930 of file Principal.cc.

   {
     assert(edp);
     if (detail::range_sets_supported(branchType_)) {
       // Note: We intentionally allow group and provenance replacement
       //       for run and subrun products.
       auto group = getGroupLocal(bd.productID());
       assert(group);
       group->setProductAndProvenance(move(pp), move(edp), move(rs));
     } else {
       auto group = getGroupLocal(bd.productID());
       assert(group);
       if (group->anyProduct() != nullptr) {
         throw art::Exception(art::errors::ProductRegistrationFailure,
                              "Principal::put:")
           << "Problem found during put of " << branchType_
           << " product: product already put for " << bd.branchName() << '\n';
       }
       group->setProductAndProvenance(
         move(pp), move(edp), make_unique<RangeSet>());
     }
   }

void art::Principal::readImmediate ( ) const

Definition at line 341 of file Principal.cc.

   {
     // Read all data products and provenance immediately, if
     // available.  Used only by RootInputFile to implement the
     // delayedRead*Products config options.
     //
     // Note: The input source lock will be held when this routine is called.
     //
     // MT-TODO: For right now ignore the delay reading option for
     //          product provenance. If we do the delay reading then we
     //          must use a lock to interlock all fetches of provenance
     //          because the delay read fills the pp_by_pid_ one entry
     //          at a time, and we do not want other threads to find
     //          the info only partly there.
     std::lock_guard sentry{groupMutex_};
     for (auto const& pid_and_group : groups_) {
       auto group = pid_and_group.second.get();
       group->resolveProductIfAvailable();
     }
   }

void art::Principal::removeCachedProduct ( ProductID pid ) const

Definition at line 417 of file Principal.cc.

   {
     // MT-FIXME: May be called by a module task, need to protect the
     //           group with a lock.
     if (auto g = getGroupLocal(pid)) {
       g->removeCachedProduct();
       return;
     }
     for (auto const& sp : secondaryPrincipals_) {
       if (auto g = sp->getGroupLocal(pid)) {
         g->removeCachedProduct();
         return;
       }
     }
     throw Exception(errors::ProductNotFound, "removeCachedProduct")
       << "Attempt to remove unknown product corresponding to ProductID: " << pid
       << '\n'
       << "Please contact artists@fnal.gov\n";
   }

ResultsAuxiliary const & art::Principal::resultsAux ( ) const

Definition at line 1046 of file Principal.cc.

   {
     return resultsAux_;
   }

RunNumber_t art::Principal::run ( ) const

Definition at line 1070 of file Principal.cc.

   {
     if (branchType_ == InRun) {
       return runAux_.run();
     }
     if (branchType_ == InSubRun) {
       return subRunAux_.run();
     }
     return eventAux_.load()->id().run();
   }

RunAuxiliary const & art::Principal::runAux ( ) const

Definition at line 1028 of file Principal.cc.

   {
     return runAux_;
   }

RunID const & art::Principal::runID ( ) const

Definition at line 1052 of file Principal.cc.

   {
     return runAux_.id();
   }

RunPrincipal const & art::Principal::runPrincipal ( ) const

Definition at line 914 of file Principal.cc.

   {
     if (!runPrincipal_) {
       throw Exception(errors::NullPointerError)
         << "Tried to obtain a NULL runPrincipal.\n";
     }
     return *runPrincipal_;
   }

cet::exempt_ptr< RunPrincipal const > art::Principal::runPrincipalExemptPtr ( ) const

Definition at line 854 of file Principal.cc.

   {
     return runPrincipal_;
   }

RangeSet art::Principal::seenRanges ( ) const

Definition at line 878 of file Principal.cc.

   {
     return rangeSet_;
   }

void art::Principal::setProcessHistoryIDcombined ( ProcessHistoryID const & phid )

protected

Definition at line 272 of file Principal.cc.

   {
     if (branchType_ == InRun) {
       runAux_.setProcessHistoryID(phid);
     } else if (branchType_ == InSubRun) {
       subRunAux_.setProcessHistoryID(phid);
     } else if (branchType_ == InEvent) {
       history_->setProcessHistoryID(phid);
     } else {
       resultsAux_.setProcessHistoryID(phid);
     }
   }

void art::Principal::setRunPrincipal ( cet::exempt_ptr< RunPrincipal const > rp )

Definition at line 866 of file Principal.cc.

   {
     runPrincipal_ = rp;
   }

void art::Principal::setSubRunPrincipal ( cet::exempt_ptr< SubRunPrincipal const > srp )

Definition at line 872 of file Principal.cc.

   {
     subRunPrincipal_ = srp.get();
   }

size_t art::Principal::size ( ) const

Definition at line 379 of file Principal.cc.

   {
     std::lock_guard sentry{groupMutex_};
     return groups_.size();
   }

SubRunNumber_t art::Principal::subRun ( ) const

Definition at line 1082 of file Principal.cc.

   {
     if (branchType_ == InSubRun) {
       return subRunAux_.subRun();
     }
     return eventAux_.load()->id().subRun();
   }

SubRunAuxiliary const & art::Principal::subRunAux ( ) const

Definition at line 1034 of file Principal.cc.

   {
     return subRunAux_;
   }

SubRunID art::Principal::subRunID ( ) const

Definition at line 1058 of file Principal.cc.

   {
     return subRunAux_.id();
   }

SubRunPrincipal const & art::Principal::subRunPrincipal ( ) const

Definition at line 844 of file Principal.cc.

   {
     if (subRunPrincipal_.load() == nullptr) {
       throw Exception(errors::NullPointerError)
         << "Tried to obtain a NULL subRunPrincipal.\n";
     }
     return *subRunPrincipal_.load();
   }

SubRunPrincipal const * art::Principal::subRunPrincipalPtr ( ) const

Definition at line 860 of file Principal.cc.

   {
     return subRunPrincipal_.load();
   }

Timestamp const & art::Principal::time ( ) const

Definition at line 1125 of file Principal.cc.

   {
     return eventAux_.load()->time();
   }

auto art::Principal::tryNextSecondaryFile ( ) const

private

Definition at line 690 of file Principal.cc.

   {
     return delayedReader_->readFromSecondaryFile(nextSecondaryFileIdx_);
   }

void art::Principal::updateSeenRanges ( RangeSet const & rs )

Definition at line 884 of file Principal.cc.

   {
     rangeSet_ = rs;
   }

Member Data Documentation

BranchType art::Principal::branchType_ {}

private

Definition at line 296 of file Principal.h.

std::unique_ptr<DelayedReader> art::Principal::delayedReader_ {nullptr}

private

Definition at line 316 of file Principal.h.

std::atomic<bool> art::Principal::enableLookupOfProducedProducts_

private

Definition at line 304 of file Principal.h.

std::atomic<EventAuxiliary*> art::Principal::eventAux_

private

Definition at line 337 of file Principal.h.

std::recursive_mutex art::Principal::groupMutex_ {}

mutableprivate

Definition at line 307 of file Principal.h.

GroupCollection art::Principal::groups_ {}

private

Definition at line 312 of file Principal.h.

std::unique_ptr<History> art::Principal::history_ {nullptr}

private

Definition at line 342 of file Principal.h.

bool art::Principal::lastInSubRun_ {false}

private

Definition at line 343 of file Principal.h.

int art::Principal::nextSecondaryFileIdx_ {}

mutableprivate

Definition at line 330 of file Principal.h.

std::atomic<ProductTable const*> art::Principal::presentProducts_

private

Definition at line 302 of file Principal.h.

ProcessConfiguration const& art::Principal::processConfiguration_

private

Definition at line 299 of file Principal.h.

ProcessHistory art::Principal::processHistory_ {}

private

Definition at line 297 of file Principal.h.

std::atomic<bool> art::Principal::processHistoryModified_

private

Definition at line 298 of file Principal.h.

std::atomic<ProductTable const*> art::Principal::producedProducts_

private

Definition at line 303 of file Principal.h.

RangeSet art::Principal::rangeSet_ {RangeSet::invalid()}

private

Definition at line 332 of file Principal.h.

ResultsAuxiliary art::Principal::resultsAux_ {}

private

Definition at line 339 of file Principal.h.

RunAuxiliary art::Principal::runAux_ {}

private

Definition at line 333 of file Principal.h.

cet::exempt_ptr<RunPrincipal const> art::Principal::runPrincipal_ {nullptr}

private

Definition at line 340 of file Principal.h.

std::vector<std::unique_ptr<Principal> > art::Principal::secondaryPrincipals_ {}

mutableprivate

Definition at line 326 of file Principal.h.

SubRunAuxiliary art::Principal::subRunAux_ {}

private

Definition at line 334 of file Principal.h.

std::atomic<SubRunPrincipal const*> art::Principal::subRunPrincipal_

private

Definition at line 341 of file Principal.h.

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

art/art/Framework/Principal/Principal.h
art/art/Framework/Principal/Principal.cc

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation