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

EventSelectionIDVector const &	eventSelectionIDs () 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, ProductProvenanceRetriever const &provRetriever, DelayedReader reader=nullptr, bool deepCopyRetriever=true)

BasicHandle	getByProductID (ProductID const &oid) const

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

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

Provenance	getProvenance (ProductID const &pid, ModuleCallingContext const *mcc) const

WrapperBase const *	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 &	luminosityBlockPrincipal ()

LuminosityBlockPrincipal const &	luminosityBlockPrincipal () const

bool	luminosityBlockPrincipalPtrValid () const

void	mergeProvenanceRetrievers (EventPrincipal &other)

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)

iterator	begin ()

const_iterator	begin () const

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id) const

iterator	end ()

const_iterator	end () const

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

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

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

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

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

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

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

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

ProductResolverBase *	getModifiableProductResolver (BranchID const &oid)

ConstProductResolverPtr	getProductResolver (BranchID const &oid) const

ConstProductResolverPtr	getProductResolverByIndex (ProductResolverIndex const &oid) const

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

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

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

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

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductResolverIndexHelper const &	productLookup () const

ProductRegistry const &	productRegistry () const

void	readAllFromSourceAndMergeImmediately (MergeableRunProductMetadata const *mergeableRunProductMetadata=nullptr)

DelayedReader *	reader () const

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

void	setupUnscheduled (UnscheduledConfigurator const &)

size_t	size () const

	~Principal () override

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

	EDProductGetter (EDProductGetter const &)=delete

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

unsigned int	transitionIndex () const

virtual	~EDProductGetter ()

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

static const int	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 > &	provRetrieverPtr ()

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

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_

edm::propagate_const< LuminosityBlockPrincipal * >	luminosityBlockPrincipal_

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

Detailed Description

Definition at line 46 of file EventPrincipal.h.

Member Typedef Documentation

◆ Auxiliary

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 48 of file EventPrincipal.h.

◆ Base

typedef Principal edm::EventPrincipal::Base

Definition at line 49 of file EventPrincipal.h.

◆ ConstProductResolverPtr

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

Definition at line 51 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`
	)

Definition at line 30 of file EventPrincipal.cc.

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

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

◆ ~EventPrincipal()

edm::EventPrincipal::~EventPrincipal ( )

inlineoverride

Definition at line 61 of file EventPrincipal.h.

61 {}

Member Function Documentation

◆ aux()

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

inline

Definition at line 104 of file EventPrincipal.h.

104 { return aux_; }

References aux_.

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

◆ branchIDToProductID()

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

Definition at line 229 of file EventPrincipal.cc.

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

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

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

◆ branchListIndexes()

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

Definition at line 417 of file EventPrincipal.cc.

417 { return branchListIndexes_; }

References branchListIndexes_.

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

◆ bunchCrossing()

int edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 100 of file EventPrincipal.h.

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

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

◆ changedIndexes_()

void edm::EventPrincipal::changedIndexes_ ( )

finalprivatevirtual

Reimplemented from edm::Principal.

Definition at line 255 of file EventPrincipal.cc.

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

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

◆ clearEventPrincipal()

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 56 of file EventPrincipal.cc.

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

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

◆ commonFillEventPrincipal()

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

private

Definition at line 116 of file EventPrincipal.cc.

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

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().

◆ eventSelectionIDs()

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

Definition at line 415 of file EventPrincipal.cc.

415 { return eventSelectionIDs_; }

References eventSelectionIDs_.

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

◆ ExperimentType()

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

inline

Definition at line 98 of file EventPrincipal.h.

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

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

◆ fillEventPrincipal() [1/3]

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

Definition at line 103 of file EventPrincipal.cc.

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

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

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

◆ fillEventPrincipal() [2/3]

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

Definition at line 87 of file EventPrincipal.cc.

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

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

◆ fillEventPrincipal() [3/3]

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

Definition at line 64 of file EventPrincipal.cc.

                                                                   {
     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));
     }
     commonFillEventPrincipal(aux, processHistory, reader);
   }

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

◆ getByProductID()

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

Definition at line 267 of file EventPrincipal.cc.

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

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

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

◆ getIt()

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

overridevirtual

Implements edm::EDProductGetter.

Definition at line 301 of file EventPrincipal.cc.

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

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

◆ getProvenance() [1/2]

Provenance edm::Principal::getProvenance

Definition at line 796 of file Principal.cc.

                                                                                                 {
     ConstProductResolverPtr const phb = getProductResolver(bid);
     if (phb == nullptr) {
       throwProductNotFoundException("getProvenance", errors::ProductNotFound, bid);
     }
  
     if (phb->unscheduledWasNotRun()) {
       if (not phb->resolveProduct(*this, false, nullptr, mcc).data()) {
         throwProductNotFoundException("getProvenance(onDemand)", errors::ProductNotFound, bid);
       }
     }
     return *phb->provenance();
   }

◆ getProvenance() [2/2]

Provenance edm::EventPrincipal::getProvenance	(	ProductID const &	pid,
		ModuleCallingContext const *	mcc
	)		const

Definition at line 410 of file EventPrincipal.cc.

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

References pidToBid().

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

◆ getThinnedAssociation()

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

private

Definition at line 419 of file EventPrincipal.cc.

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

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

Referenced by getThinnedProduct(), and getThinnedProducts().

◆ getThinnedProduct()

WrapperBase const * edm::EventPrincipal::getThinnedProduct	(	ProductID const &	pid,
		unsigned int &	key
	)		const

overridevirtual

Implements edm::EDProductGetter.

Definition at line 303 of file EventPrincipal.cc.

                                                                                                     {
     BranchID parent = pidToBid(pid);
  
     // Loop over thinned containers which were made by selecting elements from the parent container
     for (auto associatedBranches = thinnedAssociationsHelper_->parentBegin(parent),
               iEnd = thinnedAssociationsHelper_->parentEnd(parent);
          associatedBranches != iEnd;
          ++associatedBranches) {
       ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(associatedBranches->association());
       if (thinnedAssociation == nullptr)
         continue;
  
       if (associatedBranches->parent() != pidToBid(thinnedAssociation->parentCollectionID())) {
         continue;
       }
  
       unsigned int thinnedIndex = 0;
       // Does this thinned container have the element referenced by key?
       // If yes, thinnedIndex is set to point to it in the thinned container
       if (!thinnedAssociation->hasParentIndex(key, thinnedIndex)) {
         continue;
       }
       // Get the thinned container and return a pointer if we can find it
       ProductID const& thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
       BasicHandle bhThinned = getByProductID(thinnedCollectionPID);
       if (!bhThinned.isValid()) {
         // Thinned container is not found, try looking recursively in thinned containers
         // which were made by selecting elements from this thinned container.
         WrapperBase const* wrapperBase = getThinnedProduct(thinnedCollectionPID, thinnedIndex);
         if (wrapperBase != nullptr) {
           key = thinnedIndex;
           return wrapperBase;
         } else {
           continue;
         }
       }
       key = thinnedIndex;
       return bhThinned.wrapper();
     }
     return nullptr;
   }

References getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BasicHandle::isValid(), crabWrapper::key, class-composition::parent, edm::ThinnedAssociation::parentCollectionID(), pidToBid(), thinnedAssociationsHelper_, edm::ThinnedAssociation::thinnedCollectionID(), and edm::BasicHandle::wrapper().

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

                                                                                {
     BranchID parent = pidToBid(pid);
  
     // Loop over thinned containers which were made by selecting elements from the parent container
     for (auto associatedBranches = thinnedAssociationsHelper_->parentBegin(parent),
               iEnd = thinnedAssociationsHelper_->parentEnd(parent);
          associatedBranches != iEnd;
          ++associatedBranches) {
       ThinnedAssociation const* thinnedAssociation = getThinnedAssociation(associatedBranches->association());
       if (thinnedAssociation == nullptr)
         continue;
  
       if (associatedBranches->parent() != pidToBid(thinnedAssociation->parentCollectionID())) {
         continue;
       }
  
       unsigned nKeys = keys.size();
       unsigned int doNotLookForThisIndex = std::numeric_limits<unsigned int>::max();
       std::vector<unsigned int> thinnedIndexes(nKeys, doNotLookForThisIndex);
       bool hasAny = false;
       for (unsigned k = 0; k < nKeys; ++k) {
         // Already found this one
         if (foundContainers[k] != nullptr)
           continue;
         // Already know this one is not in this thinned container
         if (keys[k] == doNotLookForThisIndex)
           continue;
         // Does the thinned container hold the entry of interest?
         // Modifies thinnedIndexes[k] only if it returns true and
         // sets it to the index in the thinned collection.
         if (thinnedAssociation->hasParentIndex(keys[k], thinnedIndexes[k])) {
           hasAny = true;
         }
       }
       if (!hasAny) {
         continue;
       }
       // Get the thinned container and set the pointers and indexes into
       // it (if we can find it)
       ProductID thinnedCollectionPID = thinnedAssociation->thinnedCollectionID();
       BasicHandle bhThinned = getByProductID(thinnedCollectionPID);
       if (!bhThinned.isValid()) {
         // Thinned container is not found, try looking recursively in thinned containers
         // which were made by selecting elements from this thinned container.
         getThinnedProducts(thinnedCollectionPID, foundContainers, thinnedIndexes);
         for (unsigned k = 0; k < nKeys; ++k) {
           if (foundContainers[k] == nullptr)
             continue;
           if (thinnedIndexes[k] == doNotLookForThisIndex)
             continue;
           keys[k] = thinnedIndexes[k];
         }
       } else {
         for (unsigned k = 0; k < nKeys; ++k) {
           if (thinnedIndexes[k] == doNotLookForThisIndex)
             continue;
           keys[k] = thinnedIndexes[k];
           foundContainers[k] = bhThinned.wrapper();
         }
       }
     }
   }

References getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BasicHandle::isValid(), dqmdumpme::k, relativeConstraints::keys, SiStripPI::max, class-composition::parent, edm::ThinnedAssociation::parentCollectionID(), pidToBid(), thinnedAssociationsHelper_, edm::ThinnedAssociation::thinnedCollectionID(), and edm::BasicHandle::wrapper().

◆ id()

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

inline

◆ isReal()

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 96 of file EventPrincipal.h.

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

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

◆ luminosityBlock()

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 108 of file EventPrincipal.h.

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

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

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

◆ luminosityBlockPrincipal() [1/2]

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 83 of file EventPrincipal.h.

83 { return *luminosityBlockPrincipal_; }

References luminosityBlockPrincipal_.

◆ luminosityBlockPrincipal() [2/2]

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

inline

Definition at line 81 of file EventPrincipal.h.

81 { return *luminosityBlockPrincipal_; }

References luminosityBlockPrincipal_.

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

◆ luminosityBlockPrincipalPtrValid()

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( ) const

inline

Definition at line 85 of file EventPrincipal.h.

85 { return luminosityBlockPrincipal_ != nullptr; }

References luminosityBlockPrincipal_.

◆ mergeProvenanceRetrievers()

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

inline

Definition at line 142 of file EventPrincipal.h.

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

References trackingPlots::other, and provRetrieverPtr_.

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

◆ pidToBid()

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

private

Definition at line 222 of file EventPrincipal.cc.

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

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

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

◆ productProvenanceRetrieverPtr()

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

inline

Definition at line 114 of file EventPrincipal.h.

114 { return provRetrieverPtr_.get(); }

References provRetrieverPtr_.

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

◆ provRetrieverPtr() [1/2]

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

inlineprivate

Definition at line 159 of file EventPrincipal.h.

159 { return get_underlying_safe(provRetrieverPtr_); }

References edm::get_underlying_safe(), and provRetrieverPtr_.

◆ provRetrieverPtr() [2/2]

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

inlineprivate

Definition at line 156 of file EventPrincipal.h.

                                                                              {
       return get_underlying_safe(provRetrieverPtr_);
     }

References edm::get_underlying_safe(), and provRetrieverPtr_.

◆ put() [1/2]

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

Definition at line 178 of file EventPrincipal.cc.

                                                                              {
     // 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
     phb->putProduct(std::move(edp));
   }

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

Referenced by FedRawDataInputSource::read(), and LHESource::readEvent_().

◆ put() [2/2]

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

Definition at line 194 of file EventPrincipal.cc.

                                                                                                                   {
     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
     phb->putProduct(std::move(edp));
   }

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

◆ putOnRead()

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

Definition at line 209 of file EventPrincipal.cc.

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

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

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

◆ run()

RunNumber_t edm::EventPrincipal::run ( ) const

inline

Definition at line 110 of file EventPrincipal.h.

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

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

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

◆ runPrincipal()

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

Definition at line 176 of file EventPrincipal.cc.

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

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

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

◆ setLuminosityBlockPrincipal()

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

Definition at line 167 of file EventPrincipal.cc.

167 { luminosityBlockPrincipal_ = lbp; }

References luminosityBlockPrincipal_.

◆ setRunAndLumiNumber()

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

Definition at line 169 of file EventPrincipal.cc.

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

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

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

◆ storeNumber()

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 102 of file EventPrincipal.h.

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

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

◆ streamID()

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 106 of file EventPrincipal.h.

106 { return streamID_; }

References streamID_.

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

◆ time()

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

inline

Definition at line 94 of file EventPrincipal.h.

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

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

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

◆ transitionIndex_()

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 253 of file EventPrincipal.cc.

253 { return streamID_.value(); }

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

◆ updateBranchListIndexes()

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

private

Definition at line 139 of file EventPrincipal.cc.

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

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

Referenced by fillEventPrincipal().

◆ wasBranchListIndexesChangedFromInput()

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

private

Definition at line 129 of file EventPrincipal.cc.

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

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

Referenced by fillEventPrincipal().

Member Data Documentation

◆ aux_

EventAuxiliary edm::EventPrincipal::aux_

private

Definition at line 168 of file EventPrincipal.h.

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

◆ branchIDListHelper_

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

private

Definition at line 177 of file EventPrincipal.h.

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

◆ branchListIndexes_

BranchListIndexes edm::EventPrincipal::branchListIndexes_

private

Definition at line 180 of file EventPrincipal.h.

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

◆ branchListIndexToProcessIndex_

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

private

Definition at line 182 of file EventPrincipal.h.

Referenced by branchIDToProductID(), and updateBranchListIndexes().

◆ eventSelectionIDs_

EventSelectionIDVector edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 175 of file EventPrincipal.h.

Referenced by eventSelectionIDs(), and fillEventPrincipal().

◆ invalidBunchXing

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

static

Definition at line 52 of file EventPrincipal.h.

◆ invalidStoreNumber

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

static

Definition at line 53 of file EventPrincipal.h.

◆ luminosityBlockPrincipal_

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

private

Definition at line 170 of file EventPrincipal.h.

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

◆ provRetrieverPtr_

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

private

Definition at line 173 of file EventPrincipal.h.

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

◆ streamID_

StreamID edm::EventPrincipal::streamID_

private

Definition at line 184 of file EventPrincipal.h.

Referenced by streamID(), and transitionIndex_().

◆ thinnedAssociationsHelper_

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

private

Definition at line 178 of file EventPrincipal.h.

Referenced by EventPrincipal(), 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()

◆ ExperimentType()

◆ fillEventPrincipal() [1/3]

◆ fillEventPrincipal() [2/3]

◆ fillEventPrincipal() [3/3]

◆ getByProductID()

◆ getIt()

◆ getProvenance() [1/2]

◆ getProvenance() [2/2]

◆ getThinnedAssociation()

◆ getThinnedProduct()

◆ getThinnedProducts()

◆ id()

◆ isReal()

◆ luminosityBlock()

◆ luminosityBlockPrincipal() [1/2]

◆ luminosityBlockPrincipal() [2/2]

◆ luminosityBlockPrincipalPtrValid()

◆ mergeProvenanceRetrievers()

◆ pidToBid()

◆ 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_

◆ invalidBunchXing

◆ invalidStoreNumber

◆ luminosityBlockPrincipal_

◆ provRetrieverPtr_

◆ streamID_

◆ thinnedAssociationsHelper_