#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)

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

StableProvenance const &	getStableProvenance (ProductID const &pid) 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

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 50 of file EventPrincipal.h.

typedef Principal edm::EventPrincipal::Base

Definition at line 51 of file EventPrincipal.h.

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

Definition at line 53 of file EventPrincipal.h.

Constructor & Destructor Documentation

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 33 of file EventPrincipal.cc.

References cms::cuda::assert(), 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());
       }
     }
   }

edm::EventPrincipal::~EventPrincipal ( )

inlineoverride

Definition at line 64 of file EventPrincipal.h.

64 {}

Member Function Documentation

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

inline

Definition at line 108 of file EventPrincipal.h.

References aux_.

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

108 { return aux_; }

edm::EventPrincipal::aux_

EventAuxiliary aux_

Definition: EventPrincipal.h:182

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

Definition at line 236 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexToProcessIndex_, Exception, edm::BranchID::isValid(), SiStripPI::max, edm::errors::NotFound, sistrip::SpyUtilities::range(), and findQualityFiles::v.

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

                                                                          {
     if (!bid.isValid()) {
       throw Exception(errors::NotFound, "InvalidID") << "branchIDToProductID: invalid BranchID supplied\n";
     }
     typedef BranchIDListHelper::BranchIDToIndexMap BIDToIndexMap;
     typedef BIDToIndexMap::const_iterator Iter;
     typedef std::pair<Iter, Iter> IndexRange;
 
     IndexRange range = branchIDListHelper_->branchIDToIndexMap().equal_range(bid);
     for (Iter it = range.first; it != range.second; ++it) {
       BranchListIndex blix = it->second.first;
       if (blix < branchListIndexToProcessIndex_.size()) {
         auto v = branchListIndexToProcessIndex_[blix];
         if (v != std::numeric_limits<BranchListIndex>::max()) {
           ProductIndex productIndex = it->second.second;
           ProcessIndex processIndex = v;
           return ProductID(processIndex + 1, productIndex + 1);
         }
       }
     }
     // cannot throw, because some products may legitimately not have product ID's (e.g. pile-up).
     return ProductID();
   }

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

Definition at line 376 of file EventPrincipal.cc.

References branchListIndexes_.

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

376 { return branchListIndexes_; }

edm::EventPrincipal::branchListIndexes_

BranchListIndexes branchListIndexes_

Definition: EventPrincipal.h:195

int edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 104 of file EventPrincipal.h.

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

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

edm::EventAuxiliary::bunchCrossing

int bunchCrossing() const

Definition: EventAuxiliary.h:76

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:108

void edm::EventPrincipal::changedIndexes_ ( )

finalprivatevirtual

Reimplemented from edm::Principal.

Definition at line 266 of file EventPrincipal.cc.

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

266 { 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:187

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 61 of file EventPrincipal.cc.

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

Referenced by edm::VectorInputSource::clearEventPrincipal(), and edm::SubProcess::processAsync().

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

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

private

Definition at line 123 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());
   }

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

Definition at line 374 of file EventPrincipal.cc.

References eventSelectionIDs_.

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

374 { return eventSelectionIDs_; }

edm::EventPrincipal::eventSelectionIDs_

EventSelectionIDVector eventSelectionIDs_

Definition: EventPrincipal.h:189

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

Definition at line 378 of file EventPrincipal.cc.

References eventToProcessBlockIndexes_.

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

                                                                                      {
     return eventToProcessBlockIndexes_;
   }

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

inline

Definition at line 102 of file EventPrincipal.h.

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

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

edm::EventAuxiliary::experimentType

ExperimentType experimentType() const

Definition: EventAuxiliary.h:75

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:108

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

Definition at line 110 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexes_, commonFillEventPrincipal(), eostools::move(), and updateBranchListIndexes().

Referenced by edm::IDGeneratorSourceBase< PuttableSourceBase >::doReadEvent(), edm::RawInputSource::makeEvent(), edm::SubProcess::processAsync(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), edm::TestSource::readEvent_(), LHESource::readEvent_(), LH5Source::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);
   }

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistory const *	processHistory,
		EventSelectionIDVector	eventSelectionIDs,
		BranchListIndexes	branchListIndexes
	)

Definition at line 94 of file EventPrincipal.cc.

References branchIDListHelper_, commonFillEventPrincipal(), eventSelectionIDs_, eostools::move(), 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, nullptr);
   }

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 69 of file EventPrincipal.cc.

References branchIDListHelper_, commonFillEventPrincipal(), eventSelectionIDs_, eventToProcessBlockIndexes(), eventToProcessBlockIndexes_, eostools::move(), provRetrieverPtr_, 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);
   }

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

Definition at line 278 of file EventPrincipal.cc.

References data, edm::Principal::getProductResolver(), edm::makeHandleExceptionFactory(), pidToBid(), edm::errors::ProductNotFound, dtDQMClient_cfg::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);
   }

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

overridevirtual

Implements edm::EDProductGetter.

Definition at line 312 of file EventPrincipal.cc.

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

Referenced by getThinnedProduct(), and getThinnedProducts().

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

edm::EventPrincipal::getByProductID

BasicHandle getByProductID(ProductID const &oid) const

Definition: EventPrincipal.cc:278

edm::BasicHandle::wrapper

WrapperBase const * wrapper() const noexcept(true)

Definition: BasicHandle.h:73

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

Definition at line 364 of file EventPrincipal.cc.

References pidToBid().

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

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

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

Definition at line 369 of file EventPrincipal.cc.

References pidToBid().

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

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

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

private

Definition at line 382 of file EventPrincipal.cc.

References runTheMatrix::const, data, edm::WrapperBase::dynamicTypeInfo(), Exception, edm::Principal::getProductResolver(), edm::errors::LogicError, edm::Wrapper< T >::product(), 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();
   }

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

overridevirtual

Implements edm::EDProductGetter.

Definition at line 338 of file EventPrincipal.cc.

References cms::Exception::addContext(), cms::cuda::func, getThinnedAssociation(), edm::detail::getThinnedKeyFrom_implementation(), SpecificationBuilder_cfi::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;
     }
   }

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 314 of file EventPrincipal.cc.

References b, getIt(), getThinnedAssociation(), edm::detail::getThinnedProduct(), 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); });
   }

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 325 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);
   }

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

inline

Definition at line 96 of file EventPrincipal.h.

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

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

edm::EventAuxiliary::id

EventID const & id() const

Definition: EventAuxiliary.h:63

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:108

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 100 of file EventPrincipal.h.

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

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

edm::EventAuxiliary::isRealData

bool isRealData() const

Definition: EventAuxiliary.h:74

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:108

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 112 of file EventPrincipal.h.

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

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

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

edm::EventPrincipal::id

EventID const & id() const

Definition: EventPrincipal.h:96

edm::EventID::luminosityBlock

LuminosityBlockNumber_t luminosityBlock() const

Definition: EventID.h:39

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

inline

Definition at line 85 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

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

85 { return *luminosityBlockPrincipal_; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:184

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 87 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

87 { return *luminosityBlockPrincipal_; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:184

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( ) const

inline

Definition at line 89 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

89 { return luminosityBlockPrincipal_ != nullptr; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:184

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

inline

Definition at line 153 of file EventPrincipal.h.

References provRetrieverPtr(), and provRetrieverPtr_.

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

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

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

private

Definition at line 229 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_);
   }

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

overridevirtual

Reimplemented from edm::Principal.

Definition at line 260 of file EventPrincipal.cc.

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

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

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

inline

Definition at line 118 of file EventPrincipal.h.

References provRetrieverPtr_.

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

118 { return provRetrieverPtr_.get(); }

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:187

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

inlineprivate

Definition at line 170 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

Referenced by mergeProvenanceRetrievers().

                                                                              {
       return get_underlying_safe(provRetrieverPtr_);
     }

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

inlineprivate

Definition at line 173 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

173 { 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:187

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

Definition at line 185 of file EventPrincipal.cc.

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

Referenced by FedRawDataInputSource::read(), LHESource::readEvent_(), and LH5Source::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));
   }

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

Definition at line 201 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));
   }

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

Definition at line 216 of file EventPrincipal.cc.

References cms::cuda::assert(), edm::BranchDescription::branchID(), runTheMatrix::const, edm::Principal::getExistingProduct(), edm::ProductProvenanceLookup::insertIntoSet(), eostools::move(), edm::BranchDescription::produced(), 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));
   }

RunNumber_t edm::EventPrincipal::run ( ) const

inline

Definition at line 114 of file EventPrincipal.h.

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

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

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

edm::EventID::run

RunNumber_t run() const

Definition: EventID.h:38

edm::EventPrincipal::id

EventID const & id() const

Definition: EventPrincipal.h:96

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

Definition at line 183 of file EventPrincipal.cc.

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

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

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

edm::LuminosityBlockPrincipal::runPrincipal

RunPrincipal const & runPrincipal() const

Definition: LuminosityBlockPrincipal.h:45

edm::EventPrincipal::luminosityBlockPrincipal

LuminosityBlockPrincipal const & luminosityBlockPrincipal() const

Definition: EventPrincipal.h:85

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

Definition at line 174 of file EventPrincipal.cc.

References luminosityBlockPrincipal_.

Referenced by edm::SubProcess::processAsync().

174 { luminosityBlockPrincipal_ = lbp; }

edm::EventPrincipal::luminosityBlockPrincipal_

edm::propagate_const< LuminosityBlockPrincipal * > luminosityBlockPrincipal_

Definition: EventPrincipal.h:184

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

Definition at line 176 of file EventPrincipal.cc.

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

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);
   }

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 106 of file EventPrincipal.h.

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

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

edm::EventAuxiliary::storeNumber

int storeNumber() const

Definition: EventAuxiliary.h:78

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:108

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 110 of file EventPrincipal.h.

References streamID_.

Referenced by PreMixingDigiAccumulatorWorker::addPileups(), edm::stream::EDProducerAdaptorBase::doAcquire(), edm::stream::EDFilterAdaptorBase::doAcquire(), edm::stream::EDProducerAdaptorBase::doEvent(), edm::stream::EDFilterAdaptorBase::doEvent(), edm::stream::EDAnalyzerAdaptorBase::doEvent(), edm::PreMixingModule::pileWorker(), edm::UnscheduledProductResolver::prefetchAsync_(), edm::SubProcess::processAsync(), edm::EventProcessor::processEventWithLooper(), FedRawDataInputSource::read(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), edm::InputSource::readEvent(), edm::PoolSource::readEvent_(), and edm::RepeatingCachedRootSource::readEvent_().

110 { return streamID_; }

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:201

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

inline

Definition at line 98 of file EventPrincipal.h.

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

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

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

edm::EventAuxiliary::time

Timestamp const & time() const

Definition: EventAuxiliary.h:66

edm::EventPrincipal::aux

EventAuxiliary const & aux() const

Definition: EventPrincipal.h:108

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 264 of file EventPrincipal.cc.

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

264 { return streamID_.value(); }

edm::StreamID::value

unsigned int value() const

Definition: StreamID.h:43

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:201

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

private

Definition at line 146 of file EventPrincipal.cc.

References branchIDToProductID(), branchListIndexes(), branchListIndexes_, branchListIndexToProcessIndex_, SiStripPI::max, and eostools::move().

Referenced by fillEventPrincipal().

                                                                                     {
     branchListIndexes_ = std::move(branchListIndexes);
     branchListIndexToProcessIndex_.clear();
     // Fill in helper map for Branch to ProductID mapping
     if (not branchListIndexes_.empty()) {
       ProcessIndex pix = 0;
       branchListIndexToProcessIndex_.resize(1 + *std::max_element(branchListIndexes_.begin(), branchListIndexes_.end()),
                                             std::numeric_limits<BranchListIndex>::max());
       for (auto const& blindex : branchListIndexes_) {
         branchListIndexToProcessIndex_[blindex] = pix;
         ++pix;
       }
     }
 
     // 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()));
       }
     }
   }

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

private

Definition at line 136 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);
   }