edm::EventPrincipal Class Reference

#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, bool deepCopyRetriever=true)
BasicHandle	getByProductID (ProductID const &oid) const
WrapperBase const *	getIt (ProductID const &pid) const override
Provenance	getProvenance (ProductID const &pid, ModuleCallingContext const *mcc) const
WrapperBase const *	getThinnedProduct (ProductID const &pid, unsigned int &key) const override
void	getThinnedProducts (ProductID const &pid, std::vector< WrapperBase const * > &foundContainers, std::vector< unsigned int > &keys) const override
EventID const &	id () const
bool	isReal () const
LuminosityBlockNumber_t	luminosityBlock () const
LuminosityBlockPrincipal 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	put (ProductResolverIndex index, std::unique_ptr< WrapperBase > edp, ParentageID 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 (LuminosityBlockPrincipal *lbp)
void	setRunAndLumiNumber (RunNumber_t run, LuminosityBlockNumber_t lumi)
int	storeNumber () const
StreamID	streamID () const
Timestamp const &	time () const
	~EventPrincipal () override
Public Member Functions inherited from edm::Principal
void	adjustIndexesAfterProductRegistryAddition ()
bool	adjustToNewProductRegistry (ProductRegistry const &reg)
const_iterator	begin () const
iterator	begin ()
BranchType const &	branchType () const
CacheIdentifier_t	cacheIdentifier () const
void	clearPrincipal ()
void	deleteProduct (BranchID const &id) const
const_iterator	end () const
iterator	end ()
void	fillPrincipal (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
std::vector< unsigned int > const &	lookupProcessOrder () const
void	prefetchAsync (WaitingTask *waitTask, ProductResolverIndex index, bool skipCurrentProcess, ServiceToken const &token, ModuleCallingContext const *mcc) const
	Principal (std::shared_ptr< ProductRegistry const > reg, std::shared_ptr< ProductResolverIndexHelper const > productLookup, ProcessConfiguration const &pc, BranchType bt, HistoryAppender *historyAppender, bool isForPrimaryProcess=true)
ProcessConfiguration const &	processConfiguration () const
ProcessHistory const &	processHistory () const
ProcessHistoryID const &	processHistoryID () const
EDProductGetter const *	prodGetter () const
ProductResolverIndexHelper const &	productLookup () const
ProductRegistry const &	productRegistry () const
void	readAllFromSourceAndMergeImmediately (MergeableRunProductMetadata const *mergeableRunProductMetadata=0)
DelayedReader *	reader () const
void	recombine (Principal &other, std::vector< BranchID > const &bids)
void	setupUnscheduled (UnscheduledConfigurator const &)
size_t	size () const
	~Principal () override
Public Member Functions inherited from edm::EDProductGetter
	EDProductGetter ()
	EDProductGetter (EDProductGetter const &)=delete
EDProductGetter const &	operator= (EDProductGetter const &)=delete
unsigned int	transitionIndex () const
virtual	~EDProductGetter ()

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

Private Member Functions
edm::ThinnedAssociation const *	getThinnedAssociation (edm::BranchID const &branchID) const
BranchID	pidToBid (ProductID const &pid) const
std::shared_ptr< ProductProvenanceRetriever const >	provRetrieverPtr () const
std::shared_ptr< ProductProvenanceRetriever > &	provRetrieverPtr ()
unsigned int	transitionIndex_ () const override

Private Attributes
EventAuxiliary	aux_
std::shared_ptr< BranchIDListHelper const >	branchIDListHelper_
BranchListIndexes	branchListIndexes_
std::map< BranchListIndex, ProcessIndex >	branchListIndexToProcessIndex_
EventSelectionIDVector	eventSelectionIDs_
edm::propagate_const< LuminosityBlockPrincipal * >	luminosityBlockPrincipal_
edm::propagate_const< std::shared_ptr< ProductProvenanceRetriever > >	provRetrieverPtr_
StreamID	streamID_
std::shared_ptr< ThinnedAssociationsHelper const >	thinnedAssociationsHelper_

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProductGetter
static void	assignEDProductGetter (EDProductGetter const *&)
static EDProductGetter const *	switchProductGetter (EDProductGetter const *)
	These can only be used internally by the framework. More...
Protected Member Functions inherited from edm::Principal
void	addProduct_ (std::unique_ptr< ProductResolverBase > phb)
void	addProductOrThrow (std::unique_ptr< ProductResolverBase > phb)
template<typename F >
void	applyToResolvers (F iFunc)
ProductResolverBase *	getExistingProduct (BranchID const &branchID)
ProductResolverBase const *	getExistingProduct (BranchID const &branchID) const
ProductResolverBase const *	getExistingProduct (ProductResolverBase const &phb) const
void	putOrMerge (BranchDescription const &bd, std::unique_ptr< WrapperBase > edp) const

Detailed Description

Definition at line 46 of file EventPrincipal.h.

Member Typedef Documentation

typedef EventAuxiliary edm::EventPrincipal::Auxiliary

Definition at line 48 of file EventPrincipal.h.

typedef Principal edm::EventPrincipal::Base

Definition at line 49 of file EventPrincipal.h.

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

Definition at line 51 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 thinnedAssociationsHelper_.

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

edm::EventPrincipal::~EventPrincipal ( )

inlineoverride

Definition at line 61 of file EventPrincipal.h.

References aux(), branchListIndexes(), clearEventPrincipal(), eventSelectionIDs(), fillEventPrincipal(), and edm::Principal::reader().

{}

Member Function Documentation

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

inline

Definition at line 104 of file EventPrincipal.h.

References aux_.

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

{ return aux_; }

ProductID edm::EventPrincipal::branchIDToProductID

(

BranchID const &

bid

)

const

Definition at line 195 of file EventPrincipal.cc.

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

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

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

References branchListIndexes_.

Referenced by edm::EventForOutput::branchListIndexes(), fillEventPrincipal(), edm::SubProcess::processAsync(), productProvenanceRetrieverPtr(), and ~EventPrincipal().

{ return branchListIndexes_; }

int edm::EventPrincipal::bunchCrossing ( ) const

inline

Definition at line 100 of file EventPrincipal.h.

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

{ return aux().bunchCrossing(); }

void edm::EventPrincipal::clearEventPrincipal

(

)

Definition at line 50 of file EventPrincipal.cc.

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

Referenced by edm::VectorInputSource::clearEventPrincipal(), edm::SubProcess::processAsync(), edm::PoolSource::readEvent_(), and ~EventPrincipal().

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

EventSelectionIDVector const & edm::EventPrincipal::eventSelectionIDs

(

)

const

Definition at line 377 of file EventPrincipal.cc.

References eventSelectionIDs_.

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

{ return eventSelectionIDs_; }

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

inline

Definition at line 98 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 93 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::processAsync(), edm::StreamerInputSource::read(), edm::RootFile::readCurrentEvent(), edm::TestSource::readEvent_(), LHESource::readEvent_(), edm::ProducerSourceBase::readEvent_(), and ~EventPrincipal().

                                                                 {
    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,
		bool	deepCopyRetriever = true
	)

Definition at line 59 of file EventPrincipal.cc.

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

                                                                  {
    eventSelectionIDs_ = eventSelectionIDs;
    if (deepCopyRetriever) {
      provRetrieverPtr_->deepCopy(provRetriever);
    } else {
      provRetrieverPtr_->mergeParentProcessRetriever(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 229 of file EventPrincipal.cc.

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

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

                                                                       {
    BranchID bid = pidToBid(pid);
    ConstProductResolverPtr const phb = getProductResolver(bid);
    if (phb == nullptr) {
      return BasicHandle(makeHandleExceptionFactory([pid]() -> std::shared_ptr<cms::Exception> {
        std::shared_ptr<cms::Exception> whyFailed(std::make_shared<Exception>(errors::ProductNotFound, "InvalidID"));
        *whyFailed << "get by product ID: no product with given id: " << pid << "\n";
        return whyFailed;
      }));
    }

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

    auto data = resolution.data();
    if (data) {
      return BasicHandle(data->wrapper(), &(data->provenance()));
    }
    return BasicHandle(nullptr, nullptr);
  }

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

overridevirtual

Implements edm::EDProductGetter.

Definition at line 263 of file EventPrincipal.cc.

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

Referenced by edm::StreamerInputSource::EventPrincipalHolder::getIt(), and productProvenanceRetrieverPtr().

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

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

Definition at line 372 of file EventPrincipal.cc.

References pidToBid().

Referenced by edm::Event::getProvenance(), and productProvenanceRetrieverPtr().

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

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

private

Definition at line 381 of file EventPrincipal.cc.

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

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

                                                                                                      {
    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

Implements edm::EDProductGetter.

Definition at line 265 of file EventPrincipal.cc.

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

Referenced by edm::StreamerInputSource::EventPrincipalHolder::getThinnedProduct(), and productProvenanceRetrieverPtr().

                                                                                                    {
    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

Implements edm::EDProductGetter.

Definition at line 307 of file EventPrincipal.cc.

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

Referenced by edm::StreamerInputSource::EventPrincipalHolder::getThinnedProducts(), and productProvenanceRetrieverPtr().

                                                                               {
    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 92 of file EventPrincipal.h.

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

Referenced by edm::DataMixingEMWorker::addEMPileups(), edm::DataMixingEMDigiWorker::addEMPileups(), edm::DataMixingGeneralTrackWorker::addGeneralTrackPileups(), edm::DataMixingHcalWorker::addHcalPileups(), edm::DataMixingHcalDigiWorker::addHcalPileups(), edm::DataMixingHcalDigiWorkerProd::addHcalPileups(), edm::DataMixingMuonWorker::addMuonPileups(), sistrip::SpyEventMatcher::addNextEventToMap(), edm::PreMixingPileupCopy::addPileupInfo(), edm::DataMixingPileupCopy::addPileupInfo(), PreMixingTrackingParticleWorker::addPileups(), PreMixingEcalWorker::addPileups(), PreMixingSiPixelWorker::addPileups(), PreMixingSiStripWorker::addPileups(), edm::DataMixingSiPixelWorker::addSiPixelPileups(), edm::DataMixingSiStripWorker::addSiStripPileups(), edm::DataMixingSiStripRawWorker::addSiStripPileups(), edm::EDLooperBase::doDuringLoop(), edm::StreamSchedule::finishedPaths(), edm::SecSourceAnalyzer::getBranches(), luminosityBlock(), edm::RecordEventID< T >::operator()(), edm::MixingModule::pileAllWorkers(), edm::DataMixingModule::pileWorker(), edm::PreMixingModule::pileWorker(), edm::InputSource::readEvent(), edm::PoolSource::readEvent_(), edm::StreamSchedule::reportSkipped(), run(), edm::OccurrenceTraits< EventPrincipal, BranchActionStreamBegin >::setStreamContext(), and edm::Path::workerFinished().

{ return aux().id(); }

bool edm::EventPrincipal::isReal ( ) const

inline

Definition at line 96 of file EventPrincipal.h.

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

{ return aux().isRealData(); }

LuminosityBlockNumber_t edm::EventPrincipal::luminosityBlock ( ) const

inline

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

References luminosityBlockPrincipal_.

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

{ return *luminosityBlockPrincipal_; }

LuminosityBlockPrincipal& edm::EventPrincipal::luminosityBlockPrincipal ( )

inline

Definition at line 83 of file EventPrincipal.h.

References luminosityBlockPrincipal_.

{ return *luminosityBlockPrincipal_; }

bool edm::EventPrincipal::luminosityBlockPrincipalPtrValid ( ) const

inline

Definition at line 85 of file EventPrincipal.h.

References luminosityBlockPrincipal_, run(), setLuminosityBlockPrincipal(), and setRunAndLumiNumber().

{ return luminosityBlockPrincipal_ != nullptr; }

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

inline

Definition at line 142 of file EventPrincipal.h.

References edm::Principal::getProvenance(), getThinnedAssociation(), pidToBid(), provRetrieverPtr(), provRetrieverPtr_, and transitionIndex_().

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

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

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

private

Definition at line 188 of file EventPrincipal.cc.

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

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

                                                              {
    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 114 of file EventPrincipal.h.

References branchIDToProductID(), branchListIndexes(), eventSelectionIDs(), getByProductID(), getIt(), getProvenance(), getThinnedProduct(), getThinnedProducts(), crabWrapper::key, relativeConstraints::keys, sysUtil::pid, provRetrieverPtr_, put(), and putOnRead().

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

{ return provRetrieverPtr_.get(); }

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

inlineprivate

Definition at line 155 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

Referenced by mergeProvenanceRetrievers().

                                                                             {
      return get_underlying_safe(provRetrieverPtr_);
    }

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

inlineprivate

Definition at line 158 of file EventPrincipal.h.

References edm::get_underlying_safe(), and provRetrieverPtr_.

{ return get_underlying_safe(provRetrieverPtr_); }

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

Definition at line 144 of file EventPrincipal.cc.

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

Referenced by productProvenanceRetrieverPtr(), 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::put	(	ProductResolverIndex	index,
		std::unique_ptr< WrapperBase >	edp,
		ParentageID	productProvenance
	)		const

Definition at line 160 of file EventPrincipal.cc.

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

                                                                                                                  {
    if (edp.get() == nullptr) {
      throw Exception(errors::InsertFailure, "Null Pointer") << "put: Cannot put because ptr to product is null."
                                                             << "\n";
    }
    auto phb = getProductResolverByIndex(index);

    productProvenanceRetrieverPtr()->insertIntoSet(
        ProductProvenance(phb->branchDescription().branchID(), std::move(parentage)));

    assert(phb);
    // ProductResolver assumes ownership
    phb->putProduct(std::move(edp));
  }

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

Definition at line 175 of file EventPrincipal.cc.

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

Referenced by productProvenanceRetrieverPtr(), and edm::StreamerInputSource::read().

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

RunNumber_t edm::EventPrincipal::run ( ) const

inline

Definition at line 110 of file EventPrincipal.h.

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

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

{ return id().run(); }

RunPrincipal const & edm::EventPrincipal::runPrincipal

(

)

const

Definition at line 142 of file EventPrincipal.cc.

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

Referenced by run().

{ return luminosityBlockPrincipal().runPrincipal(); }

void edm::EventPrincipal::setLuminosityBlockPrincipal

(

LuminosityBlockPrincipal *

lbp

)

Definition at line 133 of file EventPrincipal.cc.

References luminosityBlockPrincipal_.

Referenced by luminosityBlockPrincipalPtrValid(), and edm::SubProcess::processAsync().

{ luminosityBlockPrincipal_ = lbp; }

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

Definition at line 135 of file EventPrincipal.cc.

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

Referenced by luminosityBlockPrincipalPtrValid(), and edm::OneLumiPoolSource::readEvent_().

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

int edm::EventPrincipal::storeNumber ( ) const

inline

Definition at line 102 of file EventPrincipal.h.

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

{ return aux().storeNumber(); }

StreamID edm::EventPrincipal::streamID ( ) const

inline

Definition at line 106 of file EventPrincipal.h.

References streamID_.

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

{ return streamID_; }

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

inline

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

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

Referenced by mergeProvenanceRetrievers().

{ return streamID_.value(); }

Member Data Documentation

EventAuxiliary edm::EventPrincipal::aux_

private

Definition at line 161 of file EventPrincipal.h.

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

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

private

Definition at line 170 of file EventPrincipal.h.

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

BranchListIndexes edm::EventPrincipal::branchListIndexes_

private

Definition at line 173 of file EventPrincipal.h.

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

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

private

Definition at line 175 of file EventPrincipal.h.

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

EventSelectionIDVector edm::EventPrincipal::eventSelectionIDs_

private

Definition at line 168 of file EventPrincipal.h.

Referenced by eventSelectionIDs(), and fillEventPrincipal().

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

static

Definition at line 52 of file EventPrincipal.h.

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

static

Definition at line 53 of file EventPrincipal.h.

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

private

Definition at line 163 of file EventPrincipal.h.

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

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

private

Definition at line 166 of file EventPrincipal.h.

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

StreamID edm::EventPrincipal::streamID_

private

Definition at line 177 of file EventPrincipal.h.

Referenced by streamID(), and transitionIndex_().

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

private

Definition at line 171 of file EventPrincipal.h.

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