#include <RunPrincipal.h>

Inheritance diagram for edm::RunPrincipal:

Public Types
typedef RunAuxiliary	Auxiliary

typedef Principal	Base

Public Types inherited from edm::Principal
typedef std::vector< BasicHandle >	BasicHandleVec

typedef unsigned long	CacheIdentifier_t

typedef boost::filter_iterator< FilledProductPtr, ProductResolverCollection::const_iterator >	const_iterator

typedef ProductResolverBase const *	ConstProductResolverPtr

typedef boost::filter_iterator< FilledProductPtr, ProductResolverCollection::iterator >	iterator

typedef std::string	ProcessName

typedef ProcessHistory::const_iterator	ProcessNameConstIterator

typedef std::vector< propagate_const< std::shared_ptr< ProductResolverBase > > >	ProductResolverCollection

typedef std::shared_ptr< ProductResolverBase >	SharedProductPtr

typedef ProductResolverCollection::size_type	size_type

Public Member Functions
RunAuxiliary const &	aux () const

Timestamp const &	beginTime () const

Timestamp const &	endTime () const

void	fillRunPrincipal (ProcessHistoryRegistry const &processHistoryRegistry, DelayedReader *reader=nullptr)

RunID const &	id () const

RunIndex	index () const

MergeableRunProductMetadata *	mergeableRunProductMetadata ()

void	mergeAuxiliary (RunAuxiliary const &aux)

void	preReadFile ()

void	put (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp) const

void	put (ProductResolverIndex index, std::unique_ptr< WrapperBase > edp) const

ProcessHistoryID const &	reducedProcessHistoryID () const

RunNumber_t	run () const

	RunPrincipal (std::shared_ptr< RunAuxiliary > aux, std::shared_ptr< ProductRegistry const > reg, ProcessConfiguration const &pc, HistoryAppender historyAppender, unsigned int iRunIndex, bool isForPrimaryProcess=true, MergeableRunProductProcesses const mergeableRunProductProcesses=nullptr)

void	setEndTime (Timestamp const &time)

	~RunPrincipal () override

Public Member Functions inherited from edm::Principal
void	adjustIndexesAfterProductRegistryAddition ()

bool	adjustToNewProductRegistry (ProductRegistry const &reg)

iterator	begin ()

const_iterator	begin () const

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id) const

iterator	end ()

const_iterator	end () const

void	fillPrincipal (ProcessHistoryID const &hist, ProcessHistory const phr, DelayedReader reader)

ProductData const *	findProductByTag (TypeID const &typeID, InputTag const &tag, ModuleCallingContext const *mcc) const

void	getAllProvenance (std::vector< Provenance const * > &provenances) const

void	getAllStableProvenance (std::vector< StableProvenance const * > &provenances) const

BasicHandle	getByLabel (KindOfType kindOfType, TypeID const &typeID, InputTag const &inputTag, EDConsumerBase const consumes, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

BasicHandle	getByLabel (KindOfType kindOfType, TypeID const &typeID, std::string const &label, std::string const &instance, std::string const &process, EDConsumerBase const consumes, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

BasicHandle	getByToken (KindOfType kindOfType, TypeID const &typeID, ProductResolverIndex index, bool skipCurrentProcess, bool &ambiguous, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

void	getManyByType (TypeID const &typeID, BasicHandleVec &results, EDConsumerBase const consumes, SharedResourcesAcquirer sra, ModuleCallingContext const *mcc) const

ProductResolverBase *	getModifiableProductResolver (BranchID const &oid)

ConstProductResolverPtr	getProductResolver (BranchID const &oid) const

ConstProductResolverPtr	getProductResolverByIndex (ProductResolverIndex const &oid) const

Provenance	getProvenance (BranchID const &bid, ModuleCallingContext const *mcc) const

std::vector< unsigned int > const &	lookupProcessOrder () const

void	prefetchAsync (WaitingTask waitTask, ProductResolverIndex index, bool skipCurrentProcess, ServiceToken const &token, ModuleCallingContext const mcc) const

	Principal (std::shared_ptr< ProductRegistry const > reg, std::shared_ptr< ProductResolverIndexHelper const > productLookup, ProcessConfiguration const &pc, BranchType bt, HistoryAppender *historyAppender, bool isForPrimaryProcess=true)

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductResolverIndexHelper const &	productLookup () const

ProductRegistry const &	productRegistry () const

void	readAllFromSourceAndMergeImmediately (MergeableRunProductMetadata const *mergeableRunProductMetadata=nullptr)

DelayedReader *	reader () const

void	recombine (Principal &other, std::vector< BranchID > const &bids)

void	setupUnscheduled (UnscheduledConfigurator const &)

size_t	size () const

	~Principal () override

Public Member Functions inherited from edm::EDProductGetter
	EDProductGetter ()

	EDProductGetter (EDProductGetter const &)=delete

EDProductGetter const &	operator= (EDProductGetter const &)=delete

unsigned int	transitionIndex () const

virtual	~EDProductGetter ()

Private Member Functions
unsigned int	transitionIndex_ () const override

Private Attributes
edm::propagate_const< std::shared_ptr< RunAuxiliary > >	aux_

RunIndex	index_

ProcessHistoryID	m_reducedHistoryID

edm::propagate_const< std::unique_ptr< MergeableRunProductMetadata > >	mergeableRunProductMetadataPtr_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProductGetter
static void	assignEDProductGetter (EDProductGetter const *&)

static EDProductGetter const *	switchProductGetter (EDProductGetter const *)
	These can only be used internally by the framework. More...

Protected Member Functions inherited from edm::Principal
void	addProduct_ (std::unique_ptr< ProductResolverBase > phb)

void	addProductOrThrow (std::unique_ptr< ProductResolverBase > phb)

template<typename F >
void	applyToResolvers (F iFunc)

ProductResolverBase *	getExistingProduct (BranchID const &branchID)

ProductResolverBase const *	getExistingProduct (BranchID const &branchID) const

ProductResolverBase const *	getExistingProduct (ProductResolverBase const &phb) const

void	putOrMerge (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp) const

Detailed Description

Definition at line 34 of file RunPrincipal.h.

Member Typedef Documentation

◆ Auxiliary

typedef RunAuxiliary edm::RunPrincipal::Auxiliary

Definition at line 36 of file RunPrincipal.h.

◆ Base

typedef Principal edm::RunPrincipal::Base

Definition at line 37 of file RunPrincipal.h.

Constructor & Destructor Documentation

◆ RunPrincipal()

edm::RunPrincipal::RunPrincipal	(	std::shared_ptr< RunAuxiliary >	aux,
		std::shared_ptr< ProductRegistry const >	reg,
		ProcessConfiguration const &	pc,
		HistoryAppender *	historyAppender,
		unsigned int	iRunIndex,
		bool	isForPrimaryProcess = `true`,
		MergeableRunProductProcesses const *	mergeableRunProductProcesses = `nullptr`
	)

Definition at line 9 of file RunPrincipal.cc.

       : Base(reg, reg->productLookup(InRun), pc, InRun, historyAppender, isForPrimaryProcess),
         aux_(aux),
         index_(iRunIndex) {
     if (mergeableRunProductProcesses) {  // primary RunPrincipals of EventProcessor
       mergeableRunProductMetadataPtr_ = (std::make_unique<MergeableRunProductMetadata>(*mergeableRunProductProcesses));
     }
   }

References mergeableRunProductMetadataPtr_.

◆ ~RunPrincipal()

edm::RunPrincipal::~RunPrincipal ( )

override

Definition at line 24 of file RunPrincipal.cc.

24 {}

Member Function Documentation

◆ aux()

RunAuxiliary const& edm::RunPrincipal::aux ( ) const

inline

Definition at line 59 of file RunPrincipal.h.

59 { return *aux_; }

References aux_.

Referenced by beginTime(), edm::SubProcess::doBeginRunAsync(), endTime(), id(), mergeAuxiliary(), edm::PoolSource::readRun_(), and run().

◆ beginTime()

Timestamp const& edm::RunPrincipal::beginTime ( ) const

inline

Definition at line 67 of file RunPrincipal.h.

67 { return aux().beginTime(); }

References aux(), and edm::RunAuxiliary::beginTime().

Referenced by edm::EventProcessor::beginRun(), edm::test::TestProcessor::beginRun(), edm::EDLooperBase::doBeginRun(), EcalSignalGenerator< EEDigitizerTraits >::initializeEvent(), edm::OccurrenceTraits< RunPrincipal, BranchActionGlobalBegin >::makeGlobalContext(), and edm::OccurrenceTraits< RunPrincipal, BranchActionStreamBegin >::setStreamContext().

◆ endTime()

Timestamp const& edm::RunPrincipal::endTime ( ) const

inline

Definition at line 69 of file RunPrincipal.h.

69 { return aux().endTime(); }

References aux(), and edm::RunAuxiliary::endTime().

Referenced by edm::EDLooperBase::doEndRun(), edm::EventProcessor::endRun(), edm::test::TestProcessor::endRun(), edm::OccurrenceTraits< RunPrincipal, BranchActionGlobalEnd >::makeGlobalContext(), edm::OccurrenceTraits< RunPrincipal, BranchActionStreamEnd >::setStreamContext(), edm::OutputModuleCommunicatorT< T >::writeRunAsync(), and edm::Schedule::writeRunAsync().

◆ fillRunPrincipal()

void edm::RunPrincipal::fillRunPrincipal	(	ProcessHistoryRegistry const &	processHistoryRegistry,
		DelayedReader *	reader = `nullptr`
	)

Definition at line 26 of file RunPrincipal.cc.

                                                                                                                  {
     m_reducedHistoryID = processHistoryRegistry.reducedProcessHistoryID(aux_->processHistoryID());
     auto history = processHistoryRegistry.getMapped(aux_->processHistoryID());
     fillPrincipal(aux_->processHistoryID(), history, reader);
  
     for (auto& prod : *this) {
       prod->setMergeableRunProductMetadata(mergeableRunProductMetadataPtr_.get());
     }
   }

References aux_, edm::Principal::fillPrincipal(), edm::ProcessHistoryRegistry::getMapped(), m_reducedHistoryID, mergeableRunProductMetadataPtr_, dumpMFGeometry_cfg::prod, edm::Principal::reader(), and edm::ProcessHistoryRegistry::reducedProcessHistoryID().

Referenced by dqmservices::DQMProtobufReader::readRun_(), LHESource::readRun_(), edm::RootFile::readRun_(), DQMRootSource::readRun_(), and edm::InputSource::readRun_().

◆ id()

RunID const& edm::RunPrincipal::id ( void ) const

inline

Definition at line 65 of file RunPrincipal.h.

65 { return aux().id(); }

References aux(), and edm::RunAuxiliary::id().

Referenced by DQMRootSource::readRun_().

◆ index()

RunIndex edm::RunPrincipal::index ( ) const

inline

Multiple Runs may be processed simultaneously. The return value can be used to identify a particular Run. The value will range from 0 to one less than the maximum number of allowed simultaneous Runs. A particular value will be reused once the processing of the previous Run using that index has been completed.

Definition at line 57 of file RunPrincipal.h.

57 { return index_; }

References index_.

◆ mergeableRunProductMetadata()

MergeableRunProductMetadata* edm::RunPrincipal::mergeableRunProductMetadata ( )

inline

Definition at line 79 of file RunPrincipal.h.

79 { return mergeableRunProductMetadataPtr_.get(); }

References mergeableRunProductMetadataPtr_.

Referenced by edm::EventProcessor::endUnfinishedRun(), edm::RootFile::readRun_(), and edm::EventProcessor::writeLumiAsync().

◆ mergeAuxiliary()

void edm::RunPrincipal::mergeAuxiliary ( RunAuxiliary const & aux )

inline

Definition at line 73 of file RunPrincipal.h.

73 { return aux_->mergeAuxiliary(aux); }

References aux(), and aux_.

◆ preReadFile()

void edm::RunPrincipal::preReadFile ( )

Definition at line 47 of file RunPrincipal.cc.

                                  {
     if (mergeableRunProductMetadataPtr_) {
       mergeableRunProductMetadataPtr_->preReadFile();
     }
   }

References mergeableRunProductMetadataPtr_.

◆ put() [1/2]

void edm::RunPrincipal::put	(	BranchDescription const &	bd,
		std::unique_ptr< WrapperBase >	edp
	)		const

Definition at line 36 of file RunPrincipal.cc.

                                                                                           {
     putOrMerge(bd, std::move(edp));
   }

References eostools::move(), and edm::Principal::putOrMerge().

Referenced by edm::Run::commit_(), and LHESource::putRunInfoProduct().

◆ put() [2/2]

void edm::RunPrincipal::put	(	ProductResolverIndex	index,
		std::unique_ptr< WrapperBase >	edp
	)		const

Definition at line 40 of file RunPrincipal.cc.

                                                                                          {
     auto phb = getProductResolverByIndex(index);
     phb->putOrMergeProduct(std::move(edp));
   }