#include <EventPrincipal.h>

Inheritance diagram for edm::EventPrincipal:

Public Types
typedef EventAuxiliary	Auxiliary

typedef Principal	Base

typedef Base::ConstProductHolderPtr	ConstProductHolderPtr

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

typedef unsigned long	CacheIdentifier_t

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

typedef ProductHolderBase const *	ConstProductHolderPtr

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

typedef std::string	ProcessName

typedef ProcessHistory::const_iterator	ProcessNameConstIterator

typedef std::vector < propagate_const < std::shared_ptr < ProductHolderBase > > >	ProductHolderCollection

typedef std::shared_ptr < ProductHolderBase >	SharedProductPtr

typedef ProductHolderCollection::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)

EventSelectionIDVector const &	eventSelectionIDs () const

EventAuxiliary::ExperimentType	ExperimentType () const

void	fillEventPrincipal (EventAuxiliary const &aux, ProcessHistoryRegistry const &processHistoryRegistry, DelayedReader *reader=0)

void	fillEventPrincipal (EventAuxiliary const &aux, ProcessHistoryRegistry const &processHistoryRegistry, EventSelectionIDVector &&eventSelectionIDs, BranchListIndexes &&branchListIndexes)

void	fillEventPrincipal (EventAuxiliary const &aux, ProcessHistoryRegistry const &processHistoryRegistry, EventSelectionIDVector &&eventSelectionIDs, BranchListIndexes &&branchListIndexes, ProductProvenanceRetriever const &provRetriever, DelayedReader *reader=0)

BasicHandle	getByProductID (ProductID const &oid) const

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

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

virtual WrapperBase const *	getThinnedProduct (ProductID const &pid, unsigned int &key) const override

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

ProductProvenanceRetriever const *	productProvenanceRetrieverPtr () const

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

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

RunNumber_t	run () const

RunPrincipal const &	runPrincipal () const

void	setLuminosityBlockPrincipal (std::shared_ptr< LuminosityBlockPrincipal > const &lbp)

void	setRunAndLumiNumber (RunNumber_t run, LuminosityBlockNumber_t lumi)

void	setUnscheduledHandler (std::shared_ptr< UnscheduledHandler > iHandler)

int	storeNumber () const

StreamID	streamID () const

Timestamp const &	time () const

std::shared_ptr< const UnscheduledHandler >	unscheduledHandler () const

	~EventPrincipal ()

Public Member Functions inherited from edm::Principal
void	addAliasedProduct (std::shared_ptr< BranchDescription const > bd)

void	addInputProduct (std::shared_ptr< BranchDescription const > bd)

void	addScheduledProduct (std::shared_ptr< BranchDescription const > bd)

void	addSourceProduct (std::shared_ptr< BranchDescription const > bd)

void	addUnscheduledProduct (std::shared_ptr< BranchDescription const > bd)

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 (ProcessHistoryID const &hist, ProcessHistoryRegistry 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

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, ProductHolderIndex index, bool skipCurrentProcess, bool &ambiguous, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const

OutputHandle	getForOutput (BranchID const &bid, bool getProd, ModuleCallingContext const *mcc) const

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

ProductHolderBase *	getModifiableProductHolder (BranchID const &oid)

ConstProductHolderPtr	getProductHolder (BranchID const &oid) const

ConstProductHolderPtr	getProductHolderByIndex (ProductHolderIndex const &oid) const

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

bool	isComplete () const

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

void	prefetch (ProductHolderIndex index, bool skipCurrentProcess, ModuleCallingContext const *mcc) const

	Principal (std::shared_ptr< ProductRegistry const > reg, std::shared_ptr< ProductHolderIndexHelper const > productLookup, ProcessConfiguration const &pc, BranchType bt, HistoryAppender *historyAppender)

ProcessConfiguration const &	processConfiguration () const

ProcessHistory const &	processHistory () const

ProcessHistoryID const &	processHistoryID () const

EDProductGetter const *	prodGetter () const

ProductHolderIndexHelper const &	productLookup () const

ProductRegistry const &	productRegistry () const

void	readAllFromSourceAndMergeImmediately ()

DelayedReader *	reader () const

void	readFromSource (ProductHolderBase const &phb, ModuleCallingContext const *mcc) const

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

size_t	size () const

virtual	~Principal ()

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

	EDProductGetter (EDProductGetter const &)=delete

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

unsigned int	transitionIndex () const

virtual	~EDProductGetter ()

Public Attributes
signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)>	postModuleDelayedGetSignal_

signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)>	preModuleDelayedGetSignal_

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

static int const	invalidStoreNumber = EventAuxiliary::invalidStoreNumber

Private Member Functions
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 ()

virtual void	readFromSource_ (ProductHolderBase const &phb, ModuleCallingContext const *mcc) const override

virtual unsigned int	transitionIndex_ () const override

virtual bool	unscheduledFill (std::string const &moduleLabel, SharedResourcesAcquirer sra, ModuleCallingContext const mcc) const override

Private Attributes
EventAuxiliary	aux_

std::shared_ptr < BranchIDListHelper const >	branchIDListHelper_

BranchListIndexes	branchListIndexes_

std::map< BranchListIndex, ProcessIndex >	branchListIndexToProcessIndex_

EventSelectionIDVector	eventSelectionIDs_

edm::propagate_const < std::shared_ptr < LuminosityBlockPrincipal > >	luminosityBlockPrincipal_

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

StreamID	streamID_

std::shared_ptr < ThinnedAssociationsHelper const >	thinnedAssociationsHelper_

std::shared_ptr < UnscheduledHandler const >	unscheduledHandler_

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< ProductHolderBase > phb)

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

void	checkUniquenessAndType (WrapperBase const prod, ProductHolderBase const productHolder) const

ProductHolderBase *	getExistingProduct (BranchID const &branchID)

ProductHolderBase const *	getExistingProduct (BranchID const &branchID) const

ProductHolderBase const *	getExistingProduct (ProductHolderBase const &phb) const

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

Detailed Description

Definition at line 47 of file EventPrincipal.h.

Member Typedef Documentation

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 49 of file EventPrincipal.h.

typedef Principal edm::EventPrincipal::Base

Definition at line 50 of file EventPrincipal.h.

typedef Base::ConstProductHolderPtr edm::EventPrincipal::ConstProductHolderPtr

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

Definition at line 31 of file EventPrincipal.cc.

References assert(), and thinnedAssociationsHelper_.

                                   :
     Base(reg, reg->productLookup(InEvent), pc, InEvent, historyAppender),
           aux_(),
           luminosityBlockPrincipal_(),
           provRetrieverPtr_(new ProductProvenanceRetriever(streamIndex)),
           unscheduledHandler_(),
           eventSelectionIDs_(),
           branchIDListHelper_(branchIDListHelper),
           thinnedAssociationsHelper_(thinnedAssociationsHelper),
           branchListIndexes_(),
           branchListIndexToProcessIndex_(),
           streamID_(streamIndex) {
     assert(thinnedAssociationsHelper_);
   }

edm::EventPrincipal::~EventPrincipal ( )

inline

Definition at line 62 of file EventPrincipal.h.

62 {}

Member Function Documentation

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

inline

Definition at line 122 of file EventPrincipal.h.

References aux_.

Referenced by bunchCrossing(), ExperimentType(), fillEventPrincipal(), id(), isReal(), edm::isSameEvent(), edm::SubProcess::process(), edm::StreamSerializer::serializeEvent(), storeNumber(), time(), and edm::RootOutputFile::writeOne().

                                       {
       return aux_;
     }

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

Definition at line 225 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexToProcessIndex_, Exception, i, edm::BranchID::isValid(), and edm::errors::NotFound.

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

                                                                {
     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;
       std::map<BranchListIndex, ProcessIndex>::const_iterator i = branchListIndexToProcessIndex_.find(blix);
       if(i != branchListIndexToProcessIndex_.end()) {
         ProductIndex productIndex = it->second.second;
         ProcessIndex processIndex = i->second;
         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 430 of file EventPrincipal.cc.

References branchListIndexes_.

Referenced by fillEventPrincipal(), edm::SubProcess::process(), edm::StreamSerializer::serializeEvent(), and edm::RootOutputFile::writeOne().

                                           {
     return branchListIndexes_;
   }

int edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 114 of file EventPrincipal.h.

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

                               {
       return aux().bunchCrossing();
     }

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 53 of file EventPrincipal.cc.

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

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

                                       {
     clearPrincipal();
     aux_ = EventAuxiliary();
     luminosityBlockPrincipal_ = nullptr; // propagate_const<T> has no reset() function
     provRetrieverPtr_->reset();
     unscheduledHandler_.reset();
     branchListIndexToProcessIndex_.clear();
   }

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

Definition at line 425 of file EventPrincipal.cc.

References eventSelectionIDs_.

Referenced by edm::Event::eventSelectionIDs(), fillEventPrincipal(), edm::SubProcess::process(), edm::StreamSerializer::serializeEvent(), and edm::RootOutputFile::writeOne().

                                           {
     return eventSelectionIDs_;
   }

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

inline

Definition at line 110 of file EventPrincipal.h.

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

                                                         {
       return aux().experimentType();
     }

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistoryRegistry const &	processHistoryRegistry,
		DelayedReader *	reader = `0`
	)

Definition at line 94 of file EventPrincipal.cc.

References aux(), aux_, branchIDListHelper_, branchIDToProductID(), branchListIndexes_, branchListIndexToProcessIndex_, edm::EventAuxiliary::event(), Exception, edm::Principal::fillPrincipal(), edm::invalidEventNumber, edm::errors::LogicError, edm::Principal::processHistory(), edm::EventAuxiliary::processHistoryID(), edm::Principal::processHistoryID(), parseEventContent::prod, productProvenanceRetrieverPtr(), edm::Principal::reader(), and edm::EventAuxiliary::setProcessHistoryID().

Referenced by fillEventPrincipal(), edm::RawInputSource::makeEvent(), edm::SubProcess::process(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), LHESource::readEvent_(), and edm::ProducerSourceBase::readEvent_().

                                                             {
     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(), processHistoryRegistry, reader);
     aux_ = aux;
     aux_.setProcessHistoryID(processHistoryID());
     
     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_.push_back(branchIDListHelper_->producedBranchListIndex());
     }
 
     // Fill in helper map for Branch to ProductID mapping
     ProcessIndex pix = 0;
     for(auto const& blindex : branchListIndexes_) {
       branchListIndexToProcessIndex_.insert(std::make_pair(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->setProvenance(productProvenanceRetrieverPtr(),
                             processHistory(),
                             branchIDToProductID(bd.isAlias()?bd.originalBranchID(): bd.branchID()));
       }
     }
   }

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistoryRegistry const &	processHistoryRegistry,
		EventSelectionIDVector &&	eventSelectionIDs,
		BranchListIndexes &&	branchListIndexes
	)

Definition at line 80 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexes(), branchListIndexes_, eventSelectionIDs(), eventSelectionIDs_, and fillEventPrincipal().

                                                                             {
     eventSelectionIDs_ = eventSelectionIDs;
     branchListIndexes_ = branchListIndexes;
     if(branchIDListHelper_->hasProducedProducts()) {
       // Add index into BranchIDListRegistry for products produced this process
       branchListIndexes_.push_back(branchIDListHelper_->producedBranchListIndex());
     }
     fillEventPrincipal(aux,processHistoryRegistry,nullptr);
   }

void edm::EventPrincipal::fillEventPrincipal	(	EventAuxiliary const &	aux,
		ProcessHistoryRegistry const &	processHistoryRegistry,
		EventSelectionIDVector &&	eventSelectionIDs,
		BranchListIndexes &&	branchListIndexes,
		ProductProvenanceRetriever const &	provRetriever,
		DelayedReader *	reader = `0`
	)

Definition at line 63 of file EventPrincipal.cc.

References branchIDListHelper_, branchListIndexes(), branchListIndexes_, eventSelectionIDs(), eventSelectionIDs_, fillEventPrincipal(), and provRetrieverPtr_.

                                {
     eventSelectionIDs_ = eventSelectionIDs;
     provRetrieverPtr_->deepCopy(provRetriever);
     branchListIndexes_ = branchListIndexes;
     if(branchIDListHelper_->hasProducedProducts()) {
       // Add index into BranchIDListRegistry for products produced this process
       branchListIndexes_.push_back(branchIDListHelper_->producedBranchListIndex());
     }
     fillEventPrincipal(aux,processHistoryRegistry,reader);
   }

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

Definition at line 264 of file EventPrincipal.cc.

References edm::Principal::getProductHolder(), edm::makeHandleExceptionFactory(), pidToBid(), edm::errors::ProductNotFound, mps_update::status, and edm::throwProductDeletedException().

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

                                                            {
     BranchID bid = pidToBid(pid);
     ConstProductHolderPtr const phb = getProductHolder(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->onDemand()) {
       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;
       }));
     }
     ProductHolderBase::ResolveStatus status;
     phb->resolveProduct(status,*this,false,nullptr,nullptr);
 
     return BasicHandle(phb->productData());
   }

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

overridevirtual

Reimplemented from edm::Principal.

Definition at line 298 of file EventPrincipal.cc.

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

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

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

Definition at line 409 of file EventPrincipal.cc.

References pidToBid().

Referenced by edm::Event::getProvenance(), and edm::RootOutputFile::insertAncestors().

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

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

private

Definition at line 435 of file EventPrincipal.cc.

References compareJSON::const, edm::WrapperBase::dynamicTypeInfo(), Exception, edm::Principal::getProductHolder(), edm::errors::LogicError, edm::Wrapper< T >::product(), mps_update::status, edm::ProductData::wrapper(), and wrapper.

Referenced by getThinnedProduct(), and getThinnedProducts().

                                                                          {
 
     ConstProductHolderPtr const phb = getProductHolder(branchID);
 
     if(phb == nullptr) {
       throw Exception(errors::LogicError)
         << "EventPrincipal::getThinnedAssociation, ThinnedAssociation ProductHolder cannot be found\n"
         << "This should never happen. Contact a Framework developer";
     }
     ProductHolderBase::ResolveStatus status;
     ProductData const* productData = phb->resolveProduct(status,*this,false,nullptr,nullptr);
     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();
   }

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

overridevirtual

Reimplemented from edm::Principal.

Definition at line 303 of file EventPrincipal.cc.

References getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BasicHandle::isValid(), edm::ThinnedAssociation::parentCollectionID(), pidToBid(), thinnedAssociationsHelper_, edm::ThinnedAssociation::thinnedCollectionID(), and edm::BasicHandle::wrapper().

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

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

overridevirtual

Reimplemented from edm::Principal.

Definition at line 347 of file EventPrincipal.cc.

References getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BasicHandle::isValid(), relval_2017::k, bookConverter::max, edm::ThinnedAssociation::parentCollectionID(), pidToBid(), thinnedAssociationsHelper_, edm::ThinnedAssociation::thinnedCollectionID(), and edm::BasicHandle::wrapper().

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

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

inline

Definition at line 98 of file EventPrincipal.h.

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

                               {
       return aux().id();
     }

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 106 of file EventPrincipal.h.

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

                         {
       return aux().isRealData();
     }

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 128 of file EventPrincipal.h.

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

Referenced by Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), edm::PoolSource::readEvent_(), edm::StreamerOutputModuleBase::serializeEvent(), and RawEventOutputModuleForBU< Consumer >::write().

                                                     {
       return id().luminosityBlock();
     }

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

inline

Definition at line 82 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

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

                                                                      {
       return *luminosityBlockPrincipal_;
     }

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 86 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

                                                          {
       return *luminosityBlockPrincipal_;
     }

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( ) const

inline

Definition at line 90 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

                                                   {
       return (luminosityBlockPrincipal_) ? true : false;
     }

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

inline

Definition at line 171 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 216 of file EventPrincipal.cc.

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

Referenced by getByProductID(), getProvenance(), 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_);
   }

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

inline

Definition at line 138 of file EventPrincipal.h.

References provRetrieverPtr_.

Referenced by fillEventPrincipal(), edm::RootOutputFile::insertAncestors(), edm::SubProcess::process(), put(), putOnRead(), and edm::ProvenanceCheckerOutputModule::write().

138 {return provRetrieverPtr_.get();}

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:205

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

inlineprivate

Definition at line 195 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

Referenced by mergeProvenanceRetrievers().

195 {return get_underlying_safe(provRetrieverPtr_);}

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:205

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:41

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

inlineprivate

Definition at line 196 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

196 {return get_underlying_safe(provRetrieverPtr_);}

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:205

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:41

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

Definition at line 153 of file EventPrincipal.cc.

References assert(), edm::BranchDescription::branchID(), edm::Principal::checkUniquenessAndType(), Exception, edm::Principal::getExistingProduct(), edm::errors::InsertFailure, edm::ProductProvenanceRetriever::insertIntoSet(), eostools::move(), and productProvenanceRetrieverPtr().

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

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

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

Definition at line 174 of file EventPrincipal.cc.

References assert(), edm::BranchDescription::branchID(), edm::Principal::checkUniquenessAndType(), edm::Principal::getExistingProduct(), edm::ProductProvenanceRetriever::insertIntoSet(), eostools::move(), edm::BranchDescription::produced(), and productProvenanceRetrieverPtr().

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

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

void edm::EventPrincipal::readFromSource_	(	ProductHolderBase const &	phb,
		ModuleCallingContext const *	mcc
	)		const

overrideprivatevirtual

Reimplemented from edm::Principal.

Definition at line 189 of file EventPrincipal.cc.

References edm::ProductHolderBase::branchDescription(), edm::Principal::checkUniquenessAndType(), edm::signalslot::Signal< T >::emit(), edm::getProduct(), edm::ModuleCallingContext::getStreamContext(), eostools::move(), postModuleDelayedGetSignal_, preModuleDelayedGetSignal_, edm::BranchDescription::produced(), edm::ProductHolderBase::product(), edm::ProductHolderBase::productUnavailable(), edm::ProductHolderBase::putProduct(), and edm::Principal::reader().

                                                                                                      {
     if(phb.branchDescription().produced()) return; // nothing to do.
     if(phb.product()) return; // nothing to do.
     if(phb.productUnavailable()) return; // nothing to do.
     if(!reader()) return; // nothing to do.
     
     // must attempt to load from persistent store
     BranchKey const bk = BranchKey(phb.branchDescription());
     {
       if(mcc) {
         preModuleDelayedGetSignal_.emit(*(mcc->getStreamContext()),*mcc);
       }
       std::shared_ptr<void> guard(nullptr,[this,mcc](const void*){
         if(mcc) {
           postModuleDelayedGetSignal_.emit(*(mcc->getStreamContext()),*mcc);
         }
       });
       
       std::unique_ptr<WrapperBase> edp(reader()->getProduct(bk, this));
       
       // Now fix up the ProductHolder
       checkUniquenessAndType(edp.get(), &phb);
       phb.putProduct(std::move(edp));
     }
   }

RunNumber_t edm::EventPrincipal::run ( void ) const

inline

Definition at line 132 of file EventPrincipal.h.

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

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

                             {
       return id().run();
     }

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

Definition at line 148 of file EventPrincipal.cc.

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

                                      {
     return luminosityBlockPrincipal().runPrincipal();
   }

void edm::EventPrincipal::setLuminosityBlockPrincipal ( std::shared_ptr< LuminosityBlockPrincipal > const & lbp )

Definition at line 135 of file EventPrincipal.cc.

References luminosityBlockPrincipal_.

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

                                                                                                 {
     luminosityBlockPrincipal_ = lbp;
   }

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

Definition at line 140 of file EventPrincipal.cc.

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

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

void edm::EventPrincipal::setUnscheduledHandler ( std::shared_ptr< UnscheduledHandler > iHandler )

Definition at line 415 of file EventPrincipal.cc.

References unscheduledHandler_.

Referenced by edm::WorkerManager::setupOnDemandSystem().

                                                                                   {
     unscheduledHandler_ = iHandler;
   }

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 118 of file EventPrincipal.h.

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

                             {
       return aux().storeNumber();
     }

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 126 of file EventPrincipal.h.

References streamID_.

Referenced by edm::stream::EDFilterAdaptorBase::doEvent(), edm::stream::EDProducerAdaptorBase::doEvent(), edm::stream::EDAnalyzerAdaptorBase::doEvent(), edm::DataMixingModule::pileWorker(), edm::SubProcess::process(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), and edm::PoolSource::readEvent_().

126 { return streamID_;}

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:219

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

inline

Definition at line 102 of file EventPrincipal.h.

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

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

                                   {
       return aux().time();
     }

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 249 of file EventPrincipal.cc.

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

                                          {
     return streamID_.value();
   }

bool edm::EventPrincipal::unscheduledFill	(	std::string const &	moduleLabel,
		SharedResourcesAcquirer *	sra,
		ModuleCallingContext const *	mcc
	)		const

overrideprivatevirtual

Implements edm::Principal.

Definition at line 459 of file EventPrincipal.cc.

References edm::signalslot::Signal< T >::emit(), Exception, edm::ModuleCallingContext::getStreamContext(), edm::errors::LogicError, postModuleDelayedGetSignal_, preModuleDelayedGetSignal_, edm::SharedResourcesAcquirer::temporaryUnlock(), and unscheduledHandler_.

                                                                          {
     if(unscheduledHandler_) {
       if(mcc == nullptr) {
         throw Exception(errors::LogicError)
           << "EventPrincipal::unscheduledFill, Attempting to run unscheduled production\n"
           << "with a null pointer to the ModuleCalling Context. This should never happen.\n"
           << "Contact a Framework developer";
       }
       preModuleDelayedGetSignal_.emit(*(mcc->getStreamContext()),*mcc);
       std::shared_ptr<void> guard(nullptr,[this,mcc](const void*){
         postModuleDelayedGetSignal_.emit(*(mcc->getStreamContext()),*mcc);
       });
       auto handlerCall = [this,&moduleLabel,&mcc]() {
         unscheduledHandler_->tryToFill(moduleLabel, *this, mcc);
       };
       if (sra) {
         sra->temporaryUnlock(handlerCall);
       } else {
         handlerCall();
       }
     }
     return true;
   }

std::shared_ptr< const UnscheduledHandler > edm::EventPrincipal::unscheduledHandler ( ) const

Definition at line 420 of file EventPrincipal.cc.

References unscheduledHandler_.

Referenced by edm::getUnscheduledHandler().

                                            {
      return unscheduledHandler_;
   }

Member Data Documentation

EventAuxiliary edm::EventPrincipal::aux_

private

Definition at line 200 of file EventPrincipal.h.

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

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

private

Definition at line 212 of file EventPrincipal.h.

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

BranchListIndexes edm::EventPrincipal::branchListIndexes_

private

Definition at line 215 of file EventPrincipal.h.

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

std::map<BranchListIndex, ProcessIndex> edm::EventPrincipal::branchListIndexToProcessIndex_

private

Definition at line 217 of file EventPrincipal.h.

Referenced by branchIDToProductID(), clearEventPrincipal(), and fillEventPrincipal().

EventSelectionIDVector edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 210 of file EventPrincipal.h.

Referenced by eventSelectionIDs(), and fillEventPrincipal().

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

static

Definition at line 53 of file EventPrincipal.h.

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

static

Definition at line 54 of file EventPrincipal.h.

edm::propagate_const<std::shared_ptr<LuminosityBlockPrincipal> > edm::EventPrincipal::luminosityBlockPrincipal_

private

Definition at line 202 of file EventPrincipal.h.

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

signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> edm::EventPrincipal::postModuleDelayedGetSignal_

Definition at line 178 of file EventPrincipal.h.

Referenced by readFromSource_(), and unscheduledFill().

signalslot::Signal<void(StreamContext const&, ModuleCallingContext const&)> edm::EventPrincipal::preModuleDelayedGetSignal_

Definition at line 177 of file EventPrincipal.h.

Referenced by readFromSource_(), and unscheduledFill().

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

private

Definition at line 205 of file EventPrincipal.h.

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

StreamID edm::EventPrincipal::streamID_

private

Definition at line 219 of file EventPrincipal.h.

Referenced by streamID(), and transitionIndex_().

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

private

Definition at line 213 of file EventPrincipal.h.

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

std::shared_ptr<UnscheduledHandler const> edm::EventPrincipal::unscheduledHandler_

private

Definition at line 208 of file EventPrincipal.h.

Referenced by clearEventPrincipal(), setUnscheduledHandler(), unscheduledFill(), and unscheduledHandler().

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation