#include <EventPrincipal.h>

Inheritance diagram for edm::EventPrincipal:

Classes
class	UnscheduledSentry

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 std::string	ProcessName

typedef ProcessHistory::const_iterator	ProcessNameConstIterator

typedef std::vector < 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, 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=nullptr)

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 &provRetriever, DelayedReader *reader=nullptr)

BasicHandle	getByProductID (ProductID const &oid) const

WrapperBase const *	getIt (ProductID const &pid) const

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

EventID const &	id () const

bool	isReal () const

LuminosityBlockNumber_t	luminosityBlock () const

LuminosityBlockPrincipal const &	luminosityBlockPrincipal () const

LuminosityBlockPrincipal &	luminosityBlockPrincipal ()

bool	luminosityBlockPrincipalPtrValid ()

void	mergeProvenanceRetrievers (EventPrincipal const &other)

std::shared_ptr < ProductProvenanceRetriever >	productProvenanceRetrieverPtr () const

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

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

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

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id)

const_iterator	end () const

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, 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, ModuleCallingContext const mcc) const

BasicHandle	getByToken (KindOfType kindOfType, TypeID const &typeID, ProductHolderIndex index, bool skipCurrentProcess, bool &ambiguous, 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, ModuleCallingContext const mcc) const

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

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

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
BranchID	pidToBid (ProductID const &pid) const

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

virtual unsigned int	transitionIndex_ () const override

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

Private Attributes
EventAuxiliary	aux_

std::shared_ptr < BranchIDListHelper const >	branchIDListHelper_

BranchListIndexes	branchListIndexes_

std::map< BranchListIndex, ProcessIndex >	branchListIndexToProcessIndex_

EventSelectionIDVector	eventSelectionIDs_

std::shared_ptr < LuminosityBlockPrincipal >	luminosityBlockPrincipal_

std::vector< std::string >	moduleLabelsRunning_

std::shared_ptr < ProductProvenanceRetriever >	provRetrieverPtr_

StreamID	streamID_

std::shared_ptr < UnscheduledHandler >	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::auto_ptr< ProductHolderBase > phb)

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

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

ProductHolderBase *	getExistingProduct (BranchID const &branchID)

ProductHolderBase *	getExistingProduct (ProductHolderBase const &phb)

void	putOrMerge (std::unique_ptr< WrapperBase > prod, ProductHolderBase const *productHolder) const

void	putOrMerge (std::unique_ptr< WrapperBase > prod, ProductProvenance &prov, ProductHolderBase *productHolder)

Detailed Description

Definition at line 42 of file EventPrincipal.h.

Member Typedef Documentation

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 44 of file EventPrincipal.h.

typedef Principal edm::EventPrincipal::Base

Definition at line 45 of file EventPrincipal.h.

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

Definition at line 47 of file EventPrincipal.h.

Constructor & Destructor Documentation

edm::EventPrincipal::EventPrincipal	(	std::shared_ptr< ProductRegistry const >	reg,
		std::shared_ptr< BranchIDListHelper const >	branchIDListHelper,
		ProcessConfiguration const &	pc,
		HistoryAppender *	historyAppender,
		unsigned int	streamIndex = `0`
	)

Definition at line 25 of file EventPrincipal.cc.

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

edm::EventPrincipal::~EventPrincipal ( )

inline

Definition at line 56 of file EventPrincipal.h.

56 {}

Member Function Documentation

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

inline

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

References branchIDListHelper_, branchListIndexToProcessIndex_, edm::hlt::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 309 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 108 of file EventPrincipal.h.

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

                               {
       return aux().bunchCrossing();
     }

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 44 of file EventPrincipal.cc.

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

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

                                       {
     clearPrincipal();
     aux_ = EventAuxiliary();
     luminosityBlockPrincipal_.reset();
     provRetrieverPtr_->reset();
     unscheduledHandler_.reset();
     moduleLabelsRunning_.clear();
     branchListIndexToProcessIndex_.clear();
   }

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

Definition at line 304 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 104 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 = `nullptr`
	)

Definition at line 86 of file EventPrincipal.cc.

References aux(), aux_, branchIDListHelper_, branchIDToProductID(), branchListIndexes_, branchListIndexToProcessIndex_, edm::EventAuxiliary::event(), edm::hlt::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 const& prod : *this) {
       if (prod->singleProduct()) {
         prod->setProvenance(productProvenanceRetrieverPtr(), processHistory(), branchIDToProductID(prod->branchDescription().branchID()));
       }
     }
   }

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

Definition at line 72 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 &	provRetriever,
		DelayedReader *	reader = `nullptr`
	)

Definition at line 55 of file EventPrincipal.cc.

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

                                {
     eventSelectionIDs_ = eventSelectionIDs;
     provRetrieverPtr_->deepSwap(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 249 of file EventPrincipal.cc.

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

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

                                                            {
     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,false,nullptr);
 
     return BasicHandle(phb->productData());
   }

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

virtual

Reimplemented from edm::Principal.

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

References pidToBid().

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

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

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

inline

Definition at line 92 of file EventPrincipal.h.

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

                               {
       return aux().id();
     }

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 100 of file EventPrincipal.h.

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

                         {
       return aux().isRealData();
     }

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 122 of file EventPrincipal.h.

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

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

                                                     {
       return id().luminosityBlock();
     }

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

inline

Definition at line 76 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

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

                                                                      {
       return *luminosityBlockPrincipal_;
     }

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 80 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

                                                          {
       return *luminosityBlockPrincipal_;
     }

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( )

inline

Definition at line 84 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

                                             {
       return (luminosityBlockPrincipal_) ? true : false;
     }

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

inline

Definition at line 161 of file EventPrincipal.h.

References productProvenanceRetrieverPtr(), and provRetrieverPtr_.

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

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

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

private

Definition at line 201 of file EventPrincipal.cc.

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

Referenced by getByProductID(), and getProvenance().

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

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

inline

Definition at line 132 of file EventPrincipal.h.

References provRetrieverPtr_.

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

132 {return provRetrieverPtr_;}

edm::EventPrincipal::provRetrieverPtr_

std::shared_ptr< ProductProvenanceRetriever > provRetrieverPtr_

Definition: EventPrincipal.h:202

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

Definition at line 138 of file EventPrincipal.cc.

References edm::BranchDescription::branchID(), edm::Principal::checkUniquenessAndType(), edm::hlt::Exception, edm::Principal::getExistingProduct(), edm::errors::InsertFailure, productProvenanceRetrieverPtr(), and edm::ProductHolderBase::putProduct().

Referenced by edm::Event::commit_aux(), 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);
     ProductHolderBase* 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
	)

Definition at line 159 of file EventPrincipal.cc.

References edm::BranchDescription::branchID(), edm::Principal::checkUniquenessAndType(), edm::Principal::getExistingProduct(), edm::BranchDescription::produced(), productProvenanceRetrieverPtr(), and edm::ProductHolderBase::putProduct().

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

                                                     {
 
     assert(!bd.produced());
     productProvenanceRetrieverPtr()->insertIntoSet(productProvenance);
     ProductHolderBase* 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 174 of file EventPrincipal.cc.

References edm::ProductHolderBase::branchDescription(), edm::Principal::checkUniquenessAndType(), edm::signalslot::Signal< T >::emit(), edm::getProduct(), edm::ModuleCallingContext::getStreamContext(), 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 126 of file EventPrincipal.h.

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

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

                             {
       return id().run();
     }

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

Definition at line 133 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 120 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 125 of file EventPrincipal.cc.

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

References unscheduledHandler_.

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

                                                                                   {
     unscheduledHandler_ = iHandler;
   }

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 112 of file EventPrincipal.h.

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

                             {
       return aux().storeNumber();
     }

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 120 of file EventPrincipal.h.

References streamID_.

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

120 { return streamID_;}

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:217

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

inline

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

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

                                          {
     return streamID_.value();
   }

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

overrideprivatevirtual

Implements edm::Principal.

Definition at line 314 of file EventPrincipal.cc.

References edm::signalslot::Signal< T >::emit(), edm::hlt::Exception, edm::find_in_all(), edm::ModuleCallingContext::getStreamContext(), i, edm::errors::LogicError, moduleLabelsRunning_, postModuleDelayedGetSignal_, preModuleDelayedGetSignal_, and unscheduledHandler_.

                                                                          {
 
     // If it is a module already currently running in unscheduled
     // mode, then there is a circular dependency related to which
     // EDProducts modules require and produce.  There is no safe way
     // to recover from this.  Here we check for this problem and throw
     // an exception.
     std::vector<std::string>::const_iterator i =
       find_in_all(moduleLabelsRunning_, moduleLabel);
 
     if(i != moduleLabelsRunning_.end()) {
       throw Exception(errors::LogicError)
         << "Hit circular dependency while trying to run an unscheduled module.\n"
         << "The last module on the stack shown above requested data from the\n"
         << "module with label: '" << moduleLabel << "'.\n"
         << "This is illegal because this module is already running (it is in the\n"
         << "stack shown above, it might or might not be asking for data from itself).\n"
         << "More information related to resolving circular dependences can be found here:\n"
         << "https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuideUnscheduledExecution#Circular_Dependence_Errors.";
     }
 
     UnscheduledSentry sentry(&moduleLabelsRunning_, moduleLabel);
 
     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);
       });
       unscheduledHandler_->tryToFill(moduleLabel, *const_cast<EventPrincipal*>(this), mcc);
     }
     return true;
   }

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

Definition at line 299 of file EventPrincipal.cc.

References unscheduledHandler_.

Referenced by edm::getUnscheduledHandler().

                                            {
      return unscheduledHandler_;
   }

Member Data Documentation

EventAuxiliary edm::EventPrincipal::aux_

private

Definition at line 197 of file EventPrincipal.h.

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

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

private

Definition at line 211 of file EventPrincipal.h.

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

BranchListIndexes edm::EventPrincipal::branchListIndexes_

private

Definition at line 213 of file EventPrincipal.h.

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

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

private

Definition at line 215 of file EventPrincipal.h.

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

EventSelectionIDVector edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 209 of file EventPrincipal.h.

Referenced by eventSelectionIDs(), and fillEventPrincipal().

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

static

Definition at line 48 of file EventPrincipal.h.

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

static

Definition at line 49 of file EventPrincipal.h.

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

private

Definition at line 199 of file EventPrincipal.h.

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

std::vector<std::string> edm::EventPrincipal::moduleLabelsRunning_

mutableprivate

Definition at line 207 of file EventPrincipal.h.

Referenced by clearEventPrincipal(), and unscheduledFill().

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

Definition at line 168 of file EventPrincipal.h.

Referenced by readFromSource_(), and unscheduledFill().

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

Definition at line 167 of file EventPrincipal.h.

Referenced by readFromSource_(), and unscheduledFill().

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

private

Definition at line 202 of file EventPrincipal.h.

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

StreamID edm::EventPrincipal::streamID_

private

Definition at line 217 of file EventPrincipal.h.

Referenced by streamID(), and transitionIndex_().

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

private

Definition at line 205 of file EventPrincipal.h.

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

Classes

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