#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, 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	setupUnscheduled (UnscheduledConfigurator const &)

int	storeNumber () const

StreamID	streamID () const

Timestamp const &	time () const

	~EventPrincipal ()

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

bool	adjustToNewProductRegistry (ProductRegistry const &reg)

const_iterator	begin () const

iterator	begin ()

BranchType const &	branchType () const

CacheIdentifier_t	cacheIdentifier () const

void	clearPrincipal ()

void	deleteProduct (BranchID const &id) const

const_iterator	end () const

iterator	end ()

void	fillPrincipal (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

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

bool	isComplete () const

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

void	prefetchAsync (WaitingTask waitTask, ProductResolverIndex index, bool skipCurrentProcess, 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 ()

DelayedReader *	reader () const

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

void	resetFailedFromThisProcess ()

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

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 unsigned int	transitionIndex_ () 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_

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 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::ConstProductResolverPtr edm::EventPrincipal::ConstProductResolverPtr

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`,
		bool	isForPrimaryProcess = `true`
	)

Definition at line 30 of file EventPrincipal.cc.

References assert(), and thinnedAssociationsHelper_.

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

edm::EventPrincipal::~EventPrincipal ( )

inline

Definition at line 63 of file EventPrincipal.h.

63 {}

Member Function Documentation

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

inline

Definition at line 123 of file EventPrincipal.h.

References aux_.

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

                                       {
       return aux_;
     }

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

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

References branchListIndexes_.

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

                                           {
     return branchListIndexes_;
   }

int edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 115 of file EventPrincipal.h.

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

                               {
       return aux().bunchCrossing();
     }

void edm::EventPrincipal::clearEventPrincipal ( )

Definition at line 52 of file EventPrincipal.cc.

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

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

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

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

Definition at line 394 of file EventPrincipal.cc.

References eventSelectionIDs_.

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

                                           {
     return eventSelectionIDs_;
   }

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

inline

Definition at line 111 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 92 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 78 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 61 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 233 of file EventPrincipal.cc.

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

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

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

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

overridevirtual

Reimplemented from edm::Principal.

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

References pidToBid().

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

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

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

private

Definition at line 404 of file EventPrincipal.cc.

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

Referenced by getThinnedProduct(), and getThinnedProducts().

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

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

overridevirtual

Reimplemented from edm::Principal.

Definition at line 275 of file EventPrincipal.cc.

References getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BasicHandle::isValid(), SpecificationBuilder_cfi::parent(), 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 319 of file EventPrincipal.cc.

References getByProductID(), getThinnedAssociation(), edm::ThinnedAssociation::hasParentIndex(), edm::BasicHandle::isValid(), relval_2017::k, bookConverter::max, SpecificationBuilder_cfi::parent(), 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 99 of file EventPrincipal.h.

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

                               {
       return aux().id();
     }

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 107 of file EventPrincipal.h.

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

                         {
       return aux().isRealData();
     }

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

Definition at line 129 of file EventPrincipal.h.

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

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

                                                     {
       return id().luminosityBlock();
     }

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

inline

Definition at line 83 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

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

                                                                      {
       return *luminosityBlockPrincipal_;
     }

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 87 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

                                                          {
       return *luminosityBlockPrincipal_;
     }

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( ) const

inline

Definition at line 91 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 185 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 139 of file EventPrincipal.h.

References provRetrieverPtr_.

Referenced by fillEventPrincipal(), edm::SubProcess::process(), edm::EventForOutput::productProvenanceRetrieverPtr(), put(), and putOnRead().

139 {return provRetrieverPtr_.get();}

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:195

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

inlineprivate

Definition at line 185 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

Referenced by mergeProvenanceRetrievers().

185 {return get_underlying_safe(provRetrieverPtr_);}

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:195

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

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

inlineprivate

Definition at line 186 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

186 {return get_underlying_safe(provRetrieverPtr_);}

edm::EventPrincipal::provRetrieverPtr_

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

Definition: EventPrincipal.h:195

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

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

Definition at line 151 of file EventPrincipal.cc.

References assert(), edm::BranchDescription::branchID(), 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);
     // ProductResolver assumes ownership
     phb->putProduct(std::move(edp));
   }

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

Definition at line 171 of file EventPrincipal.cc.

References assert(), edm::BranchDescription::branchID(), 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);
     // ProductResolver assumes ownership
     phb->putProduct(std::move(edp));
   }

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

inline

Definition at line 133 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 146 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 133 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 138 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::setupUnscheduled ( UnscheduledConfigurator const & iConfigure )

Definition at line 387 of file EventPrincipal.cc.

References edm::Principal::applyToResolvers(), and edm::ProductResolverBase::setupUnscheduled().

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

                                                                             {
     applyToResolvers([&iConfigure](ProductResolverBase* iResolver) {
       iResolver->setupUnscheduled(iConfigure);
     });
   }

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 119 of file EventPrincipal.h.

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

                             {
       return aux().storeNumber();
     }

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 127 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_().

127 { return streamID_;}

edm::EventPrincipal::streamID_

StreamID streamID_

Definition: EventPrincipal.h:206

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

inline

Definition at line 103 of file EventPrincipal.h.

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

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

                                   {
       return aux().time();
     }

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

overrideprivatevirtual

Implements edm::EDProductGetter.

Definition at line 218 of file EventPrincipal.cc.

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

                                          {
     return streamID_.value();
   }

Member Data Documentation

EventAuxiliary edm::EventPrincipal::aux_

private

Definition at line 190 of file EventPrincipal.h.

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

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

private

Definition at line 199 of file EventPrincipal.h.

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

BranchListIndexes edm::EventPrincipal::branchListIndexes_

private

Definition at line 202 of file EventPrincipal.h.

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

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

private

Definition at line 204 of file EventPrincipal.h.

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

EventSelectionIDVector edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 197 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 192 of file EventPrincipal.h.

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

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

private

Definition at line 195 of file EventPrincipal.h.

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

StreamID edm::EventPrincipal::streamID_

private

Definition at line 206 of file EventPrincipal.h.

Referenced by streamID(), and transitionIndex_().

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

private

Definition at line 200 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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation