#include <EventPrincipal.h>

Inheritance diagram for edm::EventPrincipal:

Public Types
typedef EventAuxiliary	Auxiliary

typedef Principal	Base

typedef Base::ConstProductResolverPtr	ConstProductResolverPtr

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
EventAuxiliary const &	aux () const

ProductID	branchIDToProductID (BranchID const &bid) const

BranchListIndexes const &	branchListIndexes () const

int	bunchCrossing () const

void	clearEventPrincipal ()

	EventPrincipal (std::shared_ptr< ProductRegistry const > reg, std::shared_ptr< BranchIDListHelper const > branchIDListHelper, std::shared_ptr< ThinnedAssociationsHelper const > thinnedAssociationsHelper, ProcessConfiguration const &pc, HistoryAppender historyAppender, unsigned int streamIndex=0, bool isForPrimaryProcess=true, ProcessBlockHelperBase const processBlockHelper=nullptr)

EventSelectionIDVector const &	eventSelectionIDs () const

EventToProcessBlockIndexes const &	eventToProcessBlockIndexes () const

EventAuxiliary::ExperimentType	ExperimentType () const

void	fillEventPrincipal (EventAuxiliary const &aux, ProcessHistory const processHistory, DelayedReader reader=nullptr)

void	fillEventPrincipal (EventAuxiliary const &aux, ProcessHistory const processHistory, EventSelectionIDVector eventSelectionIDs, BranchListIndexes branchListIndexes, DelayedReader reader=nullptr)

void	fillEventPrincipal (EventAuxiliary const &aux, ProcessHistory const processHistory, EventSelectionIDVector eventSelectionIDs, BranchListIndexes branchListIndexes, EventToProcessBlockIndexes const &, ProductProvenanceRetriever const &provRetriever, DelayedReader reader=nullptr, bool deepCopyRetriever=true)

BasicHandle	getByProductID (ProductID const &oid) const

WrapperBase const *	getIt (ProductID const &pid) const override

Provenance const &	getProvenance (ProductID const &pid) const

Provenance const &	getProvenance (BranchID const &bid) const

StableProvenance const &	getStableProvenance (ProductID const &pid) const

StableProvenance const &	getStableProvenance (BranchID const &bid) const

OptionalThinnedKey	getThinnedKeyFrom (ProductID const &parent, unsigned int key, ProductID const &thinned) const override

std::optional< std::tuple< WrapperBase const *, unsigned int > >	getThinnedProduct (ProductID const &pid, unsigned int key) const override

void	getThinnedProducts (ProductID const &pid, std::vector< WrapperBase const *> &foundContainers, std::vector< unsigned int > &keys) const override

EventID const &	id () const

bool	isReal () const

LuminosityBlockNumber_t	luminosityBlock () const

LuminosityBlockPrincipal const &	luminosityBlockPrincipal () const

LuminosityBlockPrincipal &	luminosityBlockPrincipal ()

bool	luminosityBlockPrincipalPtrValid () const

void	mergeProvenanceRetrievers (EventPrincipal &other)

unsigned int	processBlockIndex (std::string const &processName) const override

ProductProvenanceRetriever const *	productProvenanceRetrieverPtr () const

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

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

void	putOnRead (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp, std::optional< ProductProvenance > productProvenance) const

RunNumber_t	run () const

RunPrincipal const &	runPrincipal () const

void	setLuminosityBlockPrincipal (LuminosityBlockPrincipal *lbp)

void	setRunAndLumiNumber (RunNumber_t run, LuminosityBlockNumber_t lumi)

int	storeNumber () const

StreamID	streamID () const

Timestamp const &	time () const

	~EventPrincipal () override

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

bool	adjustToNewProductRegistry (ProductRegistry const &reg)

const_iterator	begin () const

iterator	begin ()

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id) const

const_iterator	end () const

iterator	end ()

void	fillPrincipal (DelayedReader *reader)

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

void	fillPrincipal (std::string const &processNameOfBlock, 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 const &	getProvenance (BranchID const &bid) const

StableProvenance const &	getStableProvenance (BranchID const &bid) const

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

void	prefetchAsync (WaitingTaskHolder 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 ()

Static Public Attributes
static int const	invalidBunchXing = EventAuxiliary::invalidBunchXing

static int const	invalidStoreNumber = EventAuxiliary::invalidStoreNumber

Private Member Functions
void	changedIndexes_ () final

void	commonFillEventPrincipal (EventAuxiliary const &aux, ProcessHistory const processHistory, DelayedReader reader)

edm::ThinnedAssociation const *	getThinnedAssociation (edm::BranchID const &branchID) const

BranchID	pidToBid (ProductID const &pid) const

std::shared_ptr< ProductProvenanceRetriever const >	provRetrieverPtr () const

std::shared_ptr< ProductProvenanceRetriever > &	provRetrieverPtr ()

unsigned int	transitionIndex_ () const override

void	updateBranchListIndexes (BranchListIndexes &&)

bool	wasBranchListIndexesChangedFromInput (BranchListIndexes const &) const

Private Attributes
EventAuxiliary	aux_

std::shared_ptr< BranchIDListHelper const >	branchIDListHelper_

BranchListIndexes	branchListIndexes_

std::vector< ProcessIndex >	branchListIndexToProcessIndex_

EventSelectionIDVector	eventSelectionIDs_

EventToProcessBlockIndexes	eventToProcessBlockIndexes_

edm::propagate_const< LuminosityBlockPrincipal * >	luminosityBlockPrincipal_

ProcessBlockHelperBase const *	processBlockHelper_

edm::propagate_const< std::shared_ptr< ProductProvenanceRetriever > >	provRetrieverPtr_

StreamID	streamID_

std::shared_ptr< ThinnedAssociationsHelper const >	thinnedAssociationsHelper_

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	put_ (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp) const

Detailed Description

Definition at line 48 of file EventPrincipal.h.

Member Typedef Documentation

◆ Auxiliary

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 50 of file EventPrincipal.h.

◆ Base

typedef Principal edm::EventPrincipal::Base

Definition at line 51 of file EventPrincipal.h.

◆ ConstProductResolverPtr

typedef Base::ConstProductResolverPtr edm::EventPrincipal::ConstProductResolverPtr

Definition at line 53 of file EventPrincipal.h.

Constructor & Destructor Documentation

◆ EventPrincipal()

edm::EventPrincipal::EventPrincipal	(	std::shared_ptr< ProductRegistry const >	reg,
		std::shared_ptr< BranchIDListHelper const >	branchIDListHelper,
		std::shared_ptr< ThinnedAssociationsHelper const >	thinnedAssociationsHelper,
		ProcessConfiguration const &	pc,
		HistoryAppender *	historyAppender,
		unsigned int	streamIndex = `0`,
		bool	isForPrimaryProcess = `true`,
		ProcessBlockHelperBase const *	processBlockHelper = `nullptr`
	)

Definition at line 34 of file EventPrincipal.cc.

References cms::cuda::assert(), dumpMFGeometry_cfg::prod, productProvenanceRetrieverPtr(), and thinnedAssociationsHelper_.

       : Base(reg, reg->productLookup(InEvent), pc, InEvent, historyAppender, isForPrimaryProcess),
         aux_(),
         luminosityBlockPrincipal_(nullptr),
         provRetrieverPtr_(new ProductProvenanceRetriever(streamIndex, *reg)),
         eventSelectionIDs_(),
         branchIDListHelper_(branchIDListHelper),
         processBlockHelper_(processBlockHelper),
         thinnedAssociationsHelper_(thinnedAssociationsHelper),
         branchListIndexes_(),
         branchListIndexToProcessIndex_(),
         streamID_(streamIndex) {
     assert(thinnedAssociationsHelper_);
 
     for (auto& prod : *this) {
       if (prod->singleProduct()) {
         prod->setProductProvenanceRetriever(productProvenanceRetrieverPtr());
       }
     }
   }

◆ ~EventPrincipal()

edm::EventPrincipal::~EventPrincipal ( )

inlineoverride

Definition at line 64 of file EventPrincipal.h.

64 {}

Member Function Documentation

◆ aux()

EventAuxiliary const& edm::EventPrincipal::aux ( ) const

inline

Definition at line 109 of file EventPrincipal.h.

References aux_.

Referenced by edm::RepeatingCachedRootSource::beginJob(), bunchCrossing(), commonFillEventPrincipal(), ExperimentType(), fillEventPrincipal(), id(), isReal(), edm::SubProcess::processAsync(), edm::RootFile::readEvent(), storeNumber(), and time().

109 { return aux_; }

edm::EventPrincipal::aux_

EventAuxiliary aux_

Definition: EventPrincipal.h:183

◆ branchIDToProductID()

ProductID edm::EventPrincipal::branchIDToProductID ( BranchID const & bid ) const

Definition at line 232 of file EventPrincipal.cc.

References branchIDListHelper_, edm::branchIDToProductID(), and branchListIndexToProcessIndex_.

Referenced by edm::RepeatingCachedRootSource::beginJob(), edm::Event::makeProductID(), and updateBranchListIndexes().

                                                                          {
     return edm::branchIDToProductID(bid, *branchIDListHelper_, branchListIndexToProcessIndex_);
   }

◆ branchListIndexes()

BranchListIndexes const & edm::EventPrincipal::branchListIndexes ( ) const

Definition at line 352 of file EventPrincipal.cc.

References branchListIndexes_.

Referenced by edm::RepeatingCachedRootSource::beginJob(), edm::EventForOutput::branchListIndexes(), fillEventPrincipal(), edm::SubProcess::processAsync(), and updateBranchListIndexes().

352 { return branchListIndexes_; }

edm::EventPrincipal::branchListIndexes_

BranchListIndexes branchListIndexes_

Definition: EventPrincipal.h:196

◆ bunchCrossing()

int edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 105 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::bunchCrossing().

105 { return aux().bunchCrossing(); }

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:109

edm::EventAuxiliary::bunchCrossing

int bunchCrossing() const

Definition: EventAuxiliary.h:76

◆ changedIndexes_()

void edm::EventPrincipal::changedIndexes_ ( )

finalprivatevirtual

Reimplemented from edm::Principal.

Definition at line 242 of file EventPrincipal.cc.

References edm::Principal::productRegistry(), and provRetrieverPtr_.

242 { provRetrieverPtr_->update(productRegistry()); }

edm::Principal::productRegistry

ProductRegistry const & productRegistry() const

Definition: Principal.h:146

edm::EventPrincipal::provRetrieverPtr_

edm::propagate_const< std::shared_ptr< ProductProvenanceRetriever > > provRetrieverPtr_

Definition: EventPrincipal.h:188

◆ clearEventPrincipal()

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 62 of file EventPrincipal.cc.

References aux_, edm::Principal::clearPrincipal(), and provRetrieverPtr_.

                                            {
     clearPrincipal();
     aux_ = EventAuxiliary();
     //do not clear luminosityBlockPrincipal_ since
     // it is only connected at beginLumi transition
     provRetrieverPtr_->reset();
   }

◆ commonFillEventPrincipal()

void edm::EventPrincipal::commonFillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistory const *	processHistory,
		DelayedReader *	reader
	)

private

Definition at line 125 of file EventPrincipal.cc.

References aux(), aux_, edm::EventAuxiliary::event(), Exception, edm::Principal::fillPrincipal(), edm::invalidEventNumber, edm::errors::LogicError, edm::Principal::processHistory(), edm::EventAuxiliary::processHistoryID(), edm::Principal::processHistoryID(), edm::Principal::reader(), and edm::EventAuxiliary::setProcessHistoryID().

Referenced by fillEventPrincipal().

                                                                        {
     if (aux.event() == invalidEventNumber) {
       throw Exception(errors::LogicError) << "EventPrincipal::fillEventPrincipal, Invalid event number provided in "
                                              "EventAuxiliary, It is illegal for the event number to be 0\n";
     }
 
     fillPrincipal(aux.processHistoryID(), processHistory, reader);
     aux_ = aux;
     aux_.setProcessHistoryID(processHistoryID());
   }

◆ eventSelectionIDs()

EventSelectionIDVector const & edm::EventPrincipal::eventSelectionIDs ( ) const

Definition at line 350 of file EventPrincipal.cc.

References eventSelectionIDs_.

Referenced by edm::RepeatingCachedRootSource::beginJob(), edm::EventForOutput::eventSelectionIDs(), edm::Event::eventSelectionIDs(), fillEventPrincipal(), and edm::SubProcess::processAsync().

350 { return eventSelectionIDs_; }

edm::EventPrincipal::eventSelectionIDs_

EventSelectionIDVector eventSelectionIDs_

Definition: EventPrincipal.h:190

◆ eventToProcessBlockIndexes()

EventToProcessBlockIndexes const & edm::EventPrincipal::eventToProcessBlockIndexes ( ) const

Definition at line 354 of file EventPrincipal.cc.

References eventToProcessBlockIndexes_.

Referenced by edm::EventForOutput::eventToProcessBlockIndexes(), fillEventPrincipal(), and edm::SubProcess::processAsync().

                                                                                      {
     return eventToProcessBlockIndexes_;
   }

◆ ExperimentType()

EventAuxiliary::ExperimentType edm::EventPrincipal::ExperimentType ( ) const

inline

Definition at line 103 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::experimentType().

103 { return aux().experimentType(); }

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:109

edm::EventAuxiliary::experimentType

ExperimentType experimentType() const

Definition: EventAuxiliary.h:75

◆ fillEventPrincipal() [1/3]

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistory const *	processHistory,
		DelayedReader *	reader = `nullptr`
	)

Definition at line 112 of file EventPrincipal.cc.

References aux(), branchIDListHelper_, branchListIndexes_, commonFillEventPrincipal(), eostools::move(), edm::Principal::processHistory(), edm::Principal::reader(), and updateBranchListIndexes().

Referenced by edm::IDGeneratorSourceBase< PuttableSourceBase >::doReadEvent(), edm::IDGeneratorSourceBase< PuttableSourceBase >::doReadEventWithDelayedReader(), edm::RawInputSource::makeEvent(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), edm::TestSource::readEvent_(), LH5Source::readEvent_(), LHESource::readEvent_(), and edm::RepeatingCachedRootSource::readEvent_().

                                                                  {
     if (branchListIndexes_.empty() and branchIDListHelper_->hasProducedProducts()) {
       // Add index into BranchIDListRegistry for products produced this process
       //  if it hasn't already been filled in by the other fillEventPrincipal or by an earlier call to this function
       BranchListIndexes indexes;
       indexes.push_back(branchIDListHelper_->producedBranchListIndex());
       updateBranchListIndexes(std::move(indexes));
     }
     commonFillEventPrincipal(aux, processHistory, reader);
   }

◆ fillEventPrincipal() [2/3]

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistory const *	processHistory,
		EventSelectionIDVector	eventSelectionIDs,
		BranchListIndexes	branchListIndexes,
		DelayedReader *	reader = `nullptr`
	)

Definition at line 95 of file EventPrincipal.cc.

References aux(), branchIDListHelper_, branchListIndexes(), commonFillEventPrincipal(), eventSelectionIDs(), eventSelectionIDs_, eostools::move(), edm::Principal::processHistory(), edm::Principal::reader(), updateBranchListIndexes(), and wasBranchListIndexesChangedFromInput().

                                                                  {
     eventSelectionIDs_ = std::move(eventSelectionIDs);
 
     if (wasBranchListIndexesChangedFromInput(branchListIndexes)) {
       if (branchIDListHelper_->hasProducedProducts()) {
         // Add index into BranchIDListRegistry for products produced this process
         branchListIndexes.push_back(branchIDListHelper_->producedBranchListIndex());
       }
       updateBranchListIndexes(std::move(branchListIndexes));
     }
     commonFillEventPrincipal(aux, processHistory, reader);
   }

◆ fillEventPrincipal() [3/3]

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistory const *	processHistory,
		EventSelectionIDVector	eventSelectionIDs,
		BranchListIndexes	branchListIndexes,
		EventToProcessBlockIndexes const &	eventToProcessBlockIndexes,
		ProductProvenanceRetriever const &	provRetriever,
		DelayedReader *	reader = `nullptr`,
		bool	deepCopyRetriever = `true`
	)

Definition at line 70 of file EventPrincipal.cc.

References aux(), branchIDListHelper_, branchListIndexes(), commonFillEventPrincipal(), eventSelectionIDs(), eventSelectionIDs_, eventToProcessBlockIndexes(), eventToProcessBlockIndexes_, eostools::move(), edm::Principal::processHistory(), provRetrieverPtr_, edm::Principal::reader(), updateBranchListIndexes(), and wasBranchListIndexesChangedFromInput().

                                                                   {
     eventSelectionIDs_ = std::move(eventSelectionIDs);
     if (deepCopyRetriever) {
       provRetrieverPtr_->deepCopy(provRetriever);
     } else {
       provRetrieverPtr_->mergeParentProcessRetriever(provRetriever);
     }
     if (wasBranchListIndexesChangedFromInput(branchListIndexes)) {
       if (branchIDListHelper_->hasProducedProducts()) {
         // Add index into BranchIDListRegistry for products produced this process
         branchListIndexes.push_back(branchIDListHelper_->producedBranchListIndex());
       }
       updateBranchListIndexes(std::move(branchListIndexes));
     }
     eventToProcessBlockIndexes_ = eventToProcessBlockIndexes;
     commonFillEventPrincipal(aux, processHistory, reader);
   }

◆ getByProductID()

BasicHandle edm::EventPrincipal::getByProductID ( ProductID const & oid ) const

Definition at line 254 of file EventPrincipal.cc.

References data, edm::Principal::getProductResolver(), edm::makeHandleExceptionFactory(), pidToBid(), edm::errors::ProductNotFound, L1TObjectsTimingClient_cff::resolution, and edm::throwProductDeletedException().

Referenced by edm::Event::getByProductID_(), and getIt().

                                                                        {
     BranchID bid = pidToBid(pid);
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       return BasicHandle(makeHandleExceptionFactory([pid]() -> std::shared_ptr<cms::Exception> {
         std::shared_ptr<cms::Exception> whyFailed(std::make_shared<Exception>(errors::ProductNotFound, "InvalidID"));
         *whyFailed << "get by product ID: no product with given id: " << pid << "\n";
         return whyFailed;
       }));
     }
 
     // Was this already deleted?
     if (phb->productWasDeleted()) {
       throwProductDeletedException(pid, phb);
     }
     // Check for case where we tried on demand production and
     // it failed to produce the object
     if (phb->unscheduledWasNotRun()) {
       return BasicHandle(makeHandleExceptionFactory([pid]() -> std::shared_ptr<cms::Exception> {
         std::shared_ptr<cms::Exception> whyFailed(std::make_shared<Exception>(errors::ProductNotFound, "InvalidID"));
         *whyFailed << "get by ProductID: could not get product with id: " << pid << "\n"
                    << "Unscheduled execution not allowed to get via ProductID.\n";
         return whyFailed;
       }));
     }
     auto resolution = phb->resolveProduct(*this, false, nullptr, nullptr);
 
     auto data = resolution.data();
     if (data) {
       return BasicHandle(data->wrapper(), &(data->provenance()));
     }
     return BasicHandle(nullptr, nullptr);
   }

◆ getIt()

WrapperBase const * edm::EventPrincipal::getIt ( ProductID const & pid ) const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 288 of file EventPrincipal.cc.

References getByProductID(), and edm::BasicHandle::wrapper().

Referenced by getThinnedProduct(), and getThinnedProducts().

288 { return getByProductID(pid).wrapper(); }

edm::EventPrincipal::getByProductID

BasicHandle getByProductID(ProductID const &oid) const

Definition: EventPrincipal.cc:254

edm::BasicHandle::wrapper

WrapperBase const * wrapper() const noexcept(true)

Definition: BasicHandle.h:73

◆ getProvenance() [1/2]

Provenance const & edm::EventPrincipal::getProvenance ( ProductID const & pid ) const

Definition at line 340 of file EventPrincipal.cc.

References pidToBid().

Referenced by edm::Event::getProvenance().

                                                                             {
     BranchID bid = pidToBid(pid);
     return getProvenance(bid);
   }

◆ getProvenance() [2/2]

Provenance const & edm::Principal::getProvenance

Definition at line 873 of file Principal.cc.

                                                                       {
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       throwProductNotFoundException("getProvenance", errors::ProductNotFound, bid);
     }
 
     if (phb->unscheduledWasNotRun()) {
       throw edm::Exception(errors::UnimplementedFeature)
           << "Requesting provenance from unrun EDProducer. The requested branch ID was: " << bid;
     }
     return *phb->provenance();
   }

◆ getStableProvenance() [1/2]

StableProvenance const & edm::EventPrincipal::getStableProvenance ( ProductID const & pid ) const

Definition at line 345 of file EventPrincipal.cc.

References pidToBid().

Referenced by edm::Event::getStableProvenance().

                                                                                         {
     BranchID bid = pidToBid(pid);
     return getStableProvenance(bid);
   }

◆ getStableProvenance() [2/2]

StableProvenance const & edm::Principal::getStableProvenance

Definition at line 886 of file Principal.cc.

                                                                                   {
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       throwProductNotFoundException("getStableProvenance", errors::ProductNotFound, bid);
     }
     //NOTE: in all implementations, this never returns a nullptr
     return *phb->stableProvenance();
   }

◆ getThinnedAssociation()

edm::ThinnedAssociation const * edm::EventPrincipal::getThinnedAssociation ( edm::BranchID const & branchID ) const

private

Definition at line 358 of file EventPrincipal.cc.

References runTheMatrix::const, data, edm::WrapperBase::dynamicTypeInfo(), Exception, edm::Principal::getProductResolver(), edm::errors::LogicError, edm::ProductData::wrapper(), and wrapper.

Referenced by getThinnedKeyFrom(), getThinnedProduct(), and getThinnedProducts().

                                                                                                       {
     ConstProductResolverPtr const phb = getProductResolver(branchID);
 
     if (phb == nullptr) {
       throw Exception(errors::LogicError)
           << "EventPrincipal::getThinnedAssociation, ThinnedAssociation ProductResolver cannot be found\n"
           << "This should never happen. Contact a Framework developer";
     }
     ProductData const* productData = (phb->resolveProduct(*this, false, nullptr, nullptr)).data();
     if (productData == nullptr) {
       return nullptr;
     }
     WrapperBase const* product = productData->wrapper();
     if (!(typeid(edm::ThinnedAssociation) == product->dynamicTypeInfo())) {
       throw Exception(errors::LogicError)
           << "EventPrincipal::getThinnedProduct, product has wrong type, not a ThinnedAssociation.\n";
     }
     Wrapper<ThinnedAssociation> const* wrapper = static_cast<Wrapper<ThinnedAssociation> const*>(product);
     return wrapper->product();
   }

◆ getThinnedKeyFrom()

OptionalThinnedKey edm::EventPrincipal::getThinnedKeyFrom	(	ProductID const &	parent,
		unsigned int	key,
		ProductID const &	thinned
	)		const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 314 of file EventPrincipal.cc.

References cms::Exception::addContext(), EcalMonitorTask_cff::func, getThinnedAssociation(), edm::detail::getThinnedKeyFrom_implementation(), crabWrapper::key, class-composition::parent, pidToBid(), runTheMatrix::ret, and thinnedAssociationsHelper_.

                                                                                          {
     BranchID parent = pidToBid(parentID);
     BranchID thinned = pidToBid(thinnedID);
 
     try {
       auto ret = detail::getThinnedKeyFrom_implementation(
           parentID, parent, key, thinnedID, thinned, *thinnedAssociationsHelper_, [this](BranchID const& branchID) {
             return getThinnedAssociation(branchID);
           });
       if (auto factory = std::get_if<detail::GetThinnedKeyFromExceptionFactory>(&ret)) {
         return [func = *factory]() {
           auto ex = func();
           ex.addContext("Calling EventPrincipal::getThinnedKeyFrom()");
           return ex;
         };
       } else {
         return ret;
       }
     } catch (Exception& ex) {
       ex.addContext("Calling EventPrincipal::getThinnedKeyFrom()");
       throw ex;
     }
   }

◆ getThinnedProduct()

std::optional< std::tuple< WrapperBase const *, unsigned int > > edm::EventPrincipal::getThinnedProduct	(	ProductID const &	pid,
		unsigned int	key
	)		const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 290 of file EventPrincipal.cc.

References b, getIt(), getThinnedAssociation(), edm::detail::getThinnedProduct(), crabWrapper::key, AlCaHLTBitMon_ParallelJobs::p, pidToBid(), and thinnedAssociationsHelper_.

                                                     {
     return detail::getThinnedProduct(
         pid,
         key,
         *thinnedAssociationsHelper_,
         [this](ProductID const& p) { return pidToBid(p); },
         [this](BranchID const& b) { return getThinnedAssociation(b); },
         [this](ProductID const& p) { return getIt(p); });
   }

◆ getThinnedProducts()

void edm::EventPrincipal::getThinnedProducts	(	ProductID const &	pid,
		std::vector< WrapperBase const *> &	foundContainers,
		std::vector< unsigned int > &	keys
	)		const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 301 of file EventPrincipal.cc.

References b, getIt(), getThinnedAssociation(), edm::detail::getThinnedProducts(), relativeConstraints::keys, AlCaHLTBitMon_ParallelJobs::p, pidToBid(), and thinnedAssociationsHelper_.

                                                                                {
     detail::getThinnedProducts(
         pid,
         *thinnedAssociationsHelper_,
         [this](ProductID const& p) { return pidToBid(p); },
         [this](BranchID const& b) { return getThinnedAssociation(b); },
         [this](ProductID const& p) { return getIt(p); },
         foundContainers,
         keys);
   }

◆ id()

EventID const& edm::EventPrincipal::id ( void ) const

inline

Definition at line 97 of file EventPrincipal.h.

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

Referenced by sistrip::SpyEventMatcher::addNextEventToMap(), edm::PreMixingPileupCopy::addPileupInfo(), PreMixingTrackingParticleWorker::addPileups(), PreMixingEcalWorker::addPileups(), PreMixingSiPixelWorker::addPileups(), PreMixingSiStripWorker::addPileups(), edm::EDLooperBase::doDuringLoop(), luminosityBlock(), edm::RecordEventID< T >::operator()(), edm::MixingModule::pileAllWorkers(), edm::PoolSource::readEvent_(), run(), edm::OccurrenceTraits< EventPrincipal, BranchActionStreamBegin >::setStreamContext(), and edm::Path::workerFinished().

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

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:109

edm::EventAuxiliary::id

EventID const & id() const

Definition: EventAuxiliary.h:63

◆ isReal()

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 101 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::isRealData().

101 { return aux().isRealData(); }

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:109

edm::EventAuxiliary::isRealData

bool isRealData() const

Definition: EventAuxiliary.h:74

◆ luminosityBlock()

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 113 of file EventPrincipal.h.

References id(), and edm::EventID::luminosityBlock().

Referenced by Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), and edm::PoolSource::readEvent_().

113 { return id().luminosityBlock(); }

edm::EventID::luminosityBlock

LuminosityBlockNumber_t luminosityBlock() const

Definition: EventID.h:39

edm::EventPrincipal::id

EventID const & id() const

Definition: EventPrincipal.h:97

◆ luminosityBlockPrincipal() [1/2]

LuminosityBlockPrincipal const& edm::EventPrincipal::luminosityBlockPrincipal ( ) const

inline

Definition at line 86 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

Referenced by edm::EDLooperBase::doDuringLoop(), edm::SubProcess::processAsync(), and runPrincipal().

86 { return *luminosityBlockPrincipal_; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:185

◆ luminosityBlockPrincipal() [2/2]

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 88 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

88 { return *luminosityBlockPrincipal_; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:185

◆ luminosityBlockPrincipalPtrValid()

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( ) const

inline

Definition at line 90 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

90 { return luminosityBlockPrincipal_ != nullptr; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:185

◆ mergeProvenanceRetrievers()

void edm::EventPrincipal::mergeProvenanceRetrievers ( EventPrincipal & other )

inline

Definition at line 154 of file EventPrincipal.h.

References trackingPlots::other, and provRetrieverPtr_.

Referenced by edm::PoolSource::readEvent_().

                                                           {
       provRetrieverPtr_->mergeProvenanceRetrievers(other.provRetrieverPtr());
     }

◆ pidToBid()

BranchID edm::EventPrincipal::pidToBid ( ProductID const & pid ) const

private

Definition at line 225 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexes_, Exception, edm::ProductID::isValid(), edm::productIDToBranchID(), and edm::errors::ProductNotFound.

Referenced by getByProductID(), getProvenance(), getStableProvenance(), getThinnedKeyFrom(), getThinnedProduct(), and getThinnedProducts().

                                                               {
     if (!pid.isValid()) {
       throw Exception(errors::ProductNotFound, "InvalidID") << "get by product ID: invalid ProductID supplied\n";
     }
     return productIDToBranchID(pid, branchIDListHelper_->branchIDLists(), branchListIndexes_);
   }

◆ processBlockIndex()

unsigned int edm::EventPrincipal::processBlockIndex ( std::string const & processName ) const

overridevirtual

Reimplemented from edm::Principal.

Definition at line 236 of file EventPrincipal.cc.

References eventToProcessBlockIndexes_, processBlockHelper_, edm::ProcessBlockHelperBase::processBlockIndex(), and SimL1EmulatorRepack_CalouGT_cff::processName.

                                                                                    {
     return processBlockHelper_->processBlockIndex(processName, eventToProcessBlockIndexes_);
   }

◆ productProvenanceRetrieverPtr()

ProductProvenanceRetriever const* edm::EventPrincipal::productProvenanceRetrieverPtr ( ) const

inline

Definition at line 119 of file EventPrincipal.h.

References provRetrieverPtr_.

Referenced by EventPrincipal(), edm::SubProcess::processAsync(), edm::EventForOutput::productProvenanceRetrieverPtr(), put(), and putOnRead().

119 { return provRetrieverPtr_.get(); }

edm::EventPrincipal::provRetrieverPtr_

edm::propagate_const< std::shared_ptr< ProductProvenanceRetriever > > provRetrieverPtr_

Definition: EventPrincipal.h:188

◆ provRetrieverPtr() [1/2]

std::shared_ptr<ProductProvenanceRetriever const> edm::EventPrincipal::provRetrieverPtr ( ) const

inlineprivate

Definition at line 171 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

                                                                              {
       return get_underlying_safe(provRetrieverPtr_);
     }

◆ provRetrieverPtr() [2/2]

std::shared_ptr<ProductProvenanceRetriever>& edm::EventPrincipal::provRetrieverPtr ( )

inlineprivate

Definition at line 174 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

174 { return get_underlying_safe(provRetrieverPtr_); }

edm::get_underlying_safe

constexpr std::shared_ptr< T > & get_underlying_safe(propagate_const< std::shared_ptr< T >> &iP)

Definition: get_underlying_safe.h:41

edm::EventPrincipal::provRetrieverPtr_

edm::propagate_const< std::shared_ptr< ProductProvenanceRetriever > > provRetrieverPtr_

Definition: EventPrincipal.h:188

◆ put() [1/2]

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

Definition at line 181 of file EventPrincipal.cc.

References cms::cuda::assert(), runTheMatrix::const, Exception, edm::Principal::getExistingProduct(), edm::errors::InsertFailure, edm::ProductProvenanceLookup::insertIntoSet(), eostools::move(), and productProvenanceRetrieverPtr().

Referenced by edm::EventForTransformer::put(), FedRawDataInputSource::read(), LH5Source::readEvent_(), and LHESource::readEvent_().

                                                                              {
     // assert commented out for DaqSource.  When DaqSource no longer uses put(), the assert can be restored.
     //assert(produced());
     if (edp.get() == nullptr) {
       throw Exception(errors::InsertFailure, "Null Pointer") << "put: Cannot put because ptr to product is null."
                                                              << "\n";
     }
     productProvenanceRetrieverPtr()->insertIntoSet(productProvenance);
     auto phb = getExistingProduct(bd.branchID());
     assert(phb);
     // ProductResolver assumes ownership
     dynamic_cast<ProductPutterBase const*>(phb)->putProduct(std::move(edp));
   }

◆ put() [2/2]

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

Definition at line 197 of file EventPrincipal.cc.

References cms::cuda::assert(), runTheMatrix::const, Exception, edm::Principal::getProductResolverByIndex(), edm::errors::InsertFailure, edm::ProductProvenanceLookup::insertIntoSet(), eostools::move(), and productProvenanceRetrieverPtr().

                                                                                                                   {
     if (edp.get() == nullptr) {
       throw Exception(errors::InsertFailure, "Null Pointer") << "put: Cannot put because ptr to product is null."
                                                              << "\n";
     }
     auto phb = getProductResolverByIndex(index);
 
     productProvenanceRetrieverPtr()->insertIntoSet(
         ProductProvenance(phb->branchDescription().branchID(), std::move(parentage)));
 
     assert(phb);
     // ProductResolver assumes ownership
     dynamic_cast<ProductPutterBase const*>(phb)->putProduct(std::move(edp));
   }

◆ putOnRead()

void edm::EventPrincipal::putOnRead	(	BranchDescription const &	bd,
		std::unique_ptr< WrapperBase >	edp,
		std::optional< ProductProvenance >	productProvenance
	)		const

Definition at line 212 of file EventPrincipal.cc.

References cms::cuda::assert(), runTheMatrix::const, edm::Principal::getExistingProduct(), edm::ProductProvenanceLookup::insertIntoSet(), eostools::move(), and productProvenanceRetrieverPtr().

Referenced by edm::StreamerInputSource::read().

                                                                                          {
     assert(!bd.produced());
     if (productProvenance) {
       productProvenanceRetrieverPtr()->insertIntoSet(std::move(*productProvenance));
     }
     auto phb = getExistingProduct(bd.branchID());
     assert(phb);
     // ProductResolver assumes ownership
     dynamic_cast<ProductPutterBase const*>(phb)->putProduct(std::move(edp));
   }

◆ run()

RunNumber_t edm::EventPrincipal::run ( ) const

inline

Definition at line 115 of file EventPrincipal.h.

References id(), and edm::EventID::run().

Referenced by Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), edm::OneLumiPoolSource::readEvent_(), edm::PoolSource::readEvent_(), and setRunAndLumiNumber().

115 { return id().run(); }

edm::EventID::run

RunNumber_t run() const

Definition: EventID.h:38

edm::EventPrincipal::id

EventID const & id() const

Definition: EventPrincipal.h:97

◆ runPrincipal()

RunPrincipal const & edm::EventPrincipal::runPrincipal ( ) const

Definition at line 179 of file EventPrincipal.cc.

References luminosityBlockPrincipal(), and edm::LuminosityBlockPrincipal::runPrincipal().

Referenced by EcalSignalGenerator< EEDigitizerTraits >::initializeEvent().

179 { return luminosityBlockPrincipal().runPrincipal(); }

edm::LuminosityBlockPrincipal::runPrincipal

RunPrincipal const & runPrincipal() const

Definition: LuminosityBlockPrincipal.h:46

edm::EventPrincipal::luminosityBlockPrincipal

LuminosityBlockPrincipal const & luminosityBlockPrincipal() const

Definition: EventPrincipal.h:86

◆ setLuminosityBlockPrincipal()

void edm::EventPrincipal::setLuminosityBlockPrincipal ( LuminosityBlockPrincipal * lbp )

Definition at line 170 of file EventPrincipal.cc.

References luminosityBlockPrincipal_.

170 { luminosityBlockPrincipal_ = lbp; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:185

◆ setRunAndLumiNumber()

void edm::EventPrincipal::setRunAndLumiNumber	(	RunNumber_t	run,
		LuminosityBlockNumber_t	lumi
	)

Definition at line 172 of file EventPrincipal.cc.

References cms::cuda::assert(), aux_, edm::EventID::event(), edm::EventAuxiliary::id(), luminosityBlockPrincipal_, and run().

Referenced by edm::OneLumiPoolSource::readEvent_().

                                                                                         {
     assert(run == luminosityBlockPrincipal_->run());
     assert(lumi == luminosityBlockPrincipal_->luminosityBlock());
     EventNumber_t event = aux_.id().event();
     aux_.id() = EventID(run, lumi, event);
   }

◆ storeNumber()

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 107 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::storeNumber().

107 { return aux().storeNumber(); }

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:109

edm::EventAuxiliary::storeNumber

int storeNumber() const

Definition: EventAuxiliary.h:78

◆ streamID()

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 111 of file EventPrincipal.h.

References streamID_.

Referenced by PreMixingDigiAccumulatorWorker::addPileups(), PreMixingSiPixelWorker::addPileups(), edm::SubProcess::processAsync(), edm::EventProcessor::processEventWithLooper(), FedRawDataInputSource::read(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), edm::PoolSource::readEvent_(), and edm::RepeatingCachedRootSource::readEvent_().

111 { return streamID_; }

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:202

◆ time()

Timestamp const& edm::EventPrincipal::time ( ) const

inline

Definition at line 99 of file EventPrincipal.h.

References aux(), and edm::EventAuxiliary::time().

Referenced by edm::EDLooperBase::doDuringLoop(), and edm::OccurrenceTraits< EventPrincipal, BranchActionStreamBegin >::setStreamContext().

99 { return aux().time(); }

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:109

edm::EventAuxiliary::time

Timestamp const & time() const

Definition: EventAuxiliary.h:66

◆ transitionIndex_()

unsigned int edm::EventPrincipal::transitionIndex_ ( ) const

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 240 of file EventPrincipal.cc.

References streamID_, and edm::StreamID::value().

240 { return streamID_.value(); }

edm::StreamID::value

unsigned int value() const

Definition: StreamID.h:43

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:202

◆ updateBranchListIndexes()

void edm::EventPrincipal::updateBranchListIndexes ( BranchListIndexes && branchListIndexes )

private

Definition at line 148 of file EventPrincipal.cc.

References branchIDToProductID(), branchListIndexes(), branchListIndexes_, branchListIndexToProcessIndex_, edm::makeBranchListIndexToProcessIndex(), eostools::move(), and dumpMFGeometry_cfg::prod.

Referenced by fillEventPrincipal().

                                                                                     {
     branchListIndexes_ = std::move(branchListIndexes);
     branchListIndexToProcessIndex_.clear();
     // Fill in helper map for Branch to ProductID mapping
     if (not branchListIndexes_.empty()) {
       branchListIndexToProcessIndex_ = makeBranchListIndexToProcessIndex(branchListIndexes_);
     }
 
     // Fill in the product ID's in the product holders.
     for (auto& prod : *this) {
       if (prod->singleProduct()) {
         // If an alias is in the same process as the original then isAlias will be true.
         //  Under that condition, we want the ProductID to be the same as the original.
         //  If not, then we've internally changed the original BranchID to the alias BranchID
         //  in the ProductID lookup so we need the alias BranchID.
 
         auto const& bd = prod->branchDescription();
         prod->setProductID(branchIDToProductID(bd.isAlias() ? bd.originalBranchID() : bd.branchID()));
       }
     }
   }

◆ wasBranchListIndexesChangedFromInput()

bool edm::EventPrincipal::wasBranchListIndexesChangedFromInput ( BranchListIndexes const & fromInput ) const

private

Definition at line 138 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexes_, edm::Principal::end(), and cond::serialization::equal().

Referenced by fillEventPrincipal().

                                                                                                     {
     //fromInput does not contain entries for what is being produced in this job.
     auto end = branchListIndexes_.end();
     if (end != branchListIndexes_.begin() and branchIDListHelper_->hasProducedProducts()) {
       --end;
     }
 
     return not std::equal(fromInput.begin(), fromInput.end(), branchListIndexes_.begin(), end);
   }

Member Data Documentation

◆ aux_

EventAuxiliary edm::EventPrincipal::aux_

private

Definition at line 183 of file EventPrincipal.h.

Referenced by aux(), clearEventPrincipal(), commonFillEventPrincipal(), and setRunAndLumiNumber().

◆ branchIDListHelper_

std::shared_ptr<BranchIDListHelper const> edm::EventPrincipal::branchIDListHelper_

private

Definition at line 192 of file EventPrincipal.h.

Referenced by branchIDToProductID(), fillEventPrincipal(), pidToBid(), and wasBranchListIndexesChangedFromInput().

◆ branchListIndexes_

BranchListIndexes edm::EventPrincipal::branchListIndexes_

private

Definition at line 196 of file EventPrincipal.h.

Referenced by branchListIndexes(), fillEventPrincipal(), pidToBid(), updateBranchListIndexes(), and wasBranchListIndexesChangedFromInput().

◆ branchListIndexToProcessIndex_

std::vector<ProcessIndex> edm::EventPrincipal::branchListIndexToProcessIndex_

private

Definition at line 200 of file EventPrincipal.h.

Referenced by branchIDToProductID(), and updateBranchListIndexes().

◆ eventSelectionIDs_

EventSelectionIDVector edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 190 of file EventPrincipal.h.

Referenced by eventSelectionIDs(), and fillEventPrincipal().

◆ eventToProcessBlockIndexes_

EventToProcessBlockIndexes edm::EventPrincipal::eventToProcessBlockIndexes_

private

Definition at line 198 of file EventPrincipal.h.

Referenced by eventToProcessBlockIndexes(), fillEventPrincipal(), and processBlockIndex().

◆ invalidBunchXing

int const edm::EventPrincipal::invalidBunchXing = EventAuxiliary::invalidBunchXing

static

Definition at line 54 of file EventPrincipal.h.

◆ invalidStoreNumber

int const edm::EventPrincipal::invalidStoreNumber = EventAuxiliary::invalidStoreNumber

static

Definition at line 55 of file EventPrincipal.h.

◆ luminosityBlockPrincipal_

edm::propagate_const<LuminosityBlockPrincipal*> edm::EventPrincipal::luminosityBlockPrincipal_

private

Definition at line 185 of file EventPrincipal.h.

Referenced by luminosityBlockPrincipal(), luminosityBlockPrincipalPtrValid(), setLuminosityBlockPrincipal(), and setRunAndLumiNumber().

◆ processBlockHelper_

ProcessBlockHelperBase const* edm::EventPrincipal::processBlockHelper_

private

Definition at line 193 of file EventPrincipal.h.

Referenced by processBlockIndex().

◆ provRetrieverPtr_

edm::propagate_const<std::shared_ptr<ProductProvenanceRetriever> > edm::EventPrincipal::provRetrieverPtr_

private

Definition at line 188 of file EventPrincipal.h.

Referenced by changedIndexes_(), clearEventPrincipal(), fillEventPrincipal(), mergeProvenanceRetrievers(), productProvenanceRetrieverPtr(), and provRetrieverPtr().

◆ streamID_

StreamID edm::EventPrincipal::streamID_

private

Definition at line 202 of file EventPrincipal.h.

Referenced by streamID(), and transitionIndex_().

◆ thinnedAssociationsHelper_

std::shared_ptr<ThinnedAssociationsHelper const> edm::EventPrincipal::thinnedAssociationsHelper_

private

Definition at line 194 of file EventPrincipal.h.

Referenced by EventPrincipal(), getThinnedKeyFrom(), getThinnedProduct(), and getThinnedProducts().

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Auxiliary

◆ Base

◆ ConstProductResolverPtr

Constructor & Destructor Documentation

◆ EventPrincipal()

◆ ~EventPrincipal()

Member Function Documentation

◆ aux()

◆ branchIDToProductID()

◆ branchListIndexes()

◆ bunchCrossing()

◆ changedIndexes_()

◆ clearEventPrincipal()

◆ commonFillEventPrincipal()

◆ eventSelectionIDs()

◆ eventToProcessBlockIndexes()

◆ ExperimentType()

◆ fillEventPrincipal() [1/3]

◆ fillEventPrincipal() [2/3]

◆ fillEventPrincipal() [3/3]

◆ getByProductID()

◆ getIt()

◆ getProvenance() [1/2]

◆ getProvenance() [2/2]

◆ getStableProvenance() [1/2]

◆ getStableProvenance() [2/2]

◆ getThinnedAssociation()

◆ getThinnedKeyFrom()

◆ getThinnedProduct()

◆ getThinnedProducts()

◆ id()

◆ isReal()

◆ luminosityBlock()

◆ luminosityBlockPrincipal() [1/2]

◆ luminosityBlockPrincipal() [2/2]

◆ luminosityBlockPrincipalPtrValid()

◆ mergeProvenanceRetrievers()

◆ pidToBid()

◆ processBlockIndex()

◆ productProvenanceRetrieverPtr()

◆ provRetrieverPtr() [1/2]

◆ provRetrieverPtr() [2/2]

◆ put() [1/2]

◆ put() [2/2]

◆ putOnRead()

◆ run()

◆ runPrincipal()

◆ setLuminosityBlockPrincipal()

◆ setRunAndLumiNumber()

◆ storeNumber()

◆ streamID()

◆ time()

◆ transitionIndex_()

◆ updateBranchListIndexes()

◆ wasBranchListIndexesChangedFromInput()

Member Data Documentation

◆ aux_

◆ branchIDListHelper_

◆ branchListIndexes_

◆ branchListIndexToProcessIndex_

◆ eventSelectionIDs_

◆ eventToProcessBlockIndexes_

◆ invalidBunchXing

◆ invalidStoreNumber

◆ luminosityBlockPrincipal_

◆ processBlockHelper_

◆ provRetrieverPtr_

◆ streamID_

◆ thinnedAssociationsHelper_