#include <SubProcess.h>

Inheritance diagram for edm::SubProcess:

Public Member Functions
void	clearCounters ()
	Clear all the counters in the trigger report. More...

void	closeOutputFiles ()

void	deleteLumiFromCache (LuminosityBlockPrincipal &)

void	deleteRunFromCache (ProcessHistoryID const &parentPhID, int runNumber)

void	doBeginJob ()

void	doBeginLuminosityBlockAsync (WaitingTaskHolder iHolder, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts)

void	doBeginRunAsync (WaitingTaskHolder iHolder, RunPrincipal const &principal, IOVSyncValue const &ts)

void	doBeginStream (unsigned int)

void	doEndJob ()

void	doEndLuminosityBlockAsync (WaitingTaskHolder iHolder, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)

void	doEndRunAsync (WaitingTaskHolder iHolder, RunPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)

void	doEndStream (unsigned int)

void	doEventAsync (WaitingTaskHolder iHolder, EventPrincipal const &principal)

void	doStreamBeginLuminosityBlockAsync (WaitingTaskHolder iHolder, unsigned int iID, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts)

void	doStreamBeginRunAsync (WaitingTaskHolder iHolder, unsigned int iID, RunPrincipal const &principal, IOVSyncValue const &ts)

void	doStreamEndLuminosityBlockAsync (WaitingTaskHolder iHolder, unsigned int iID, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)

void	doStreamEndRunAsync (WaitingTaskHolder iHolder, unsigned int iID, RunPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)

void	enableEndPaths (bool active)

bool	endPathsEnabled () const
	Return true if end_paths are active, and false if they are inactive. More...

std::vector< ModuleDescription const * >	getAllModuleDescriptions () const
	Return a vector allowing const access to all the ModuleDescriptions for this SubProcess. More...

void	getTriggerReport (TriggerReport &rep) const

SelectedProductsForBranchType const &	keptProducts () const

void	openOutputFiles (FileBlock &fb)

SubProcess &	operator= (SubProcess const &)=delete

SubProcess &	operator= (SubProcess &&)=default

void	respondToCloseInputFile (FileBlock const &fb)

void	respondToOpenInputFile (FileBlock const &fb)

void	selectProducts (ProductRegistry const &preg, ThinnedAssociationsHelper const &parentThinnedAssociationsHelper, std::map< BranchID, bool > &keepAssociation)

bool	shouldWeCloseOutput () const

	SubProcess (ParameterSet &parameterSet, ParameterSet const &topLevelParameterSet, std::shared_ptr< ProductRegistry const > parentProductRegistry, std::shared_ptr< BranchIDListHelper const > parentBranchIDListHelper, ThinnedAssociationsHelper const &parentThinnedAssociationsHelper, SubProcessParentageHelper const &parentSubProcessParentageHelper, eventsetup::EventSetupsController &esController, ActivityRegistry &parentActReg, ServiceToken const &token, serviceregistry::ServiceLegacy iLegacy, PreallocationConfiguration const &preallocConfig, ProcessContext const *parentProcessContext)

	SubProcess (SubProcess const &)=delete

	SubProcess (SubProcess &&)=default

bool	terminate () const

int	totalEvents () const

int	totalEventsFailed () const

int	totalEventsPassed () const
	Return the number of events which have been passed by one or more trigger paths. More...

void	updateBranchIDListHelper (BranchIDLists const &)

void	writeLumiAsync (WaitingTaskHolder, LuminosityBlockPrincipal &)

void	writeRunAsync (WaitingTaskHolder, ProcessHistoryID const &parentPhID, int runNumber, MergeableRunProductMetadata const *)

	~SubProcess () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob ()

void	beginLuminosityBlock (LuminosityBlockPrincipal const &lb, IOVSyncValue const &ts)

void	beginRun (RunPrincipal const &r, IOVSyncValue const &ts)

std::shared_ptr< BranchIDListHelper const >	branchIDListHelper () const

std::shared_ptr< BranchIDListHelper > &	branchIDListHelper ()

std::map< BranchID::value_type, BranchID::value_type > const &	droppedBranchIDToKeptBranchID ()

void	endJob ()

void	endLuminosityBlock (LuminosityBlockPrincipal const &lb, IOVSyncValue const &ts, bool cleaningUpAfterException)

void	endRun (RunPrincipal const &r, IOVSyncValue const &ts, bool cleaningUpAfterException)

void	fixBranchIDListsForEDAliases (std::map< BranchID::value_type, BranchID::value_type > const &droppedBranchIDToKeptBranchID)

void	keepThisBranch (BranchDescription const &desc, std::map< BranchID, BranchDescription const * > &trueBranchIDToKeptBranchDesc, std::set< BranchID > &keptProductsInEvent)

void	processAsync (WaitingTaskHolder iHolder, EventPrincipal const &e)

void	propagateProducts (BranchType type, Principal const &parentPrincipal, Principal &principal) const

std::shared_ptr< ThinnedAssociationsHelper const >	thinnedAssociationsHelper () const

std::shared_ptr< ThinnedAssociationsHelper >	thinnedAssociationsHelper ()

Private Attributes
std::unique_ptr< ExceptionToActionTable const >	act_table_

std::shared_ptr< ActivityRegistry >	actReg_

edm::propagate_const< std::shared_ptr< BranchIDListHelper > >	branchIDListHelper_

std::map< BranchID::value_type, BranchID::value_type >	droppedBranchIDToKeptBranchID_

edm::propagate_const< std::shared_ptr< eventsetup::EventSetupProvider > >	esp_

std::vector< HistoryAppender >	historyAppenders_

unsigned int	historyLumiOffset_

unsigned int	historyRunOffset_

std::vector< std::shared_ptr< LuminosityBlockPrincipal > >	inUseLumiPrincipals_

SelectedProductsForBranchType	keptProducts_

std::shared_ptr< ProductRegistry const >	parentPreg_

std::map< ProcessHistoryID, ProcessHistoryID >	parentToChildPhID_

PathsAndConsumesOfModules	pathsAndConsumesOfModules_

std::shared_ptr< ProductRegistry const >	preg_

PrincipalCache	principalCache_

std::shared_ptr< ProcessConfiguration const >	processConfiguration_

ProcessContext	processContext_

std::vector< ProcessHistoryRegistry >	processHistoryRegistries_

edm::propagate_const< std::unique_ptr< ParameterSet > >	processParameterSet_

ProductSelector	productSelector_

ProductSelectorRules	productSelectorRules_

edm::propagate_const< std::unique_ptr< Schedule > >	schedule_

ParameterSetID	selector_config_id_

detail::TriggerResultsBasedEventSelector	selectors_

ServiceToken	serviceToken_

std::vector< SubProcess >	subProcesses_

edm::propagate_const< std::shared_ptr< SubProcessParentageHelper > >	subProcessParentageHelper_

edm::propagate_const< std::shared_ptr< ThinnedAssociationsHelper > >	thinnedAssociationsHelper_

bool	wantAllEvents_

Additional Inherited Members
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<typename ESProduct , Transition Tr = Transition::Event>
auto	esConsumes (eventsetup::EventSetupRecordKey const &, ESInputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 44 of file SubProcess.h.

Constructor & Destructor Documentation

edm::SubProcess::SubProcess	(	ParameterSet &	parameterSet,
		ParameterSet const &	topLevelParameterSet,
		std::shared_ptr< ProductRegistry const >	parentProductRegistry,
		std::shared_ptr< BranchIDListHelper const >	parentBranchIDListHelper,
		ThinnedAssociationsHelper const &	parentThinnedAssociationsHelper,
		SubProcessParentageHelper const &	parentSubProcessParentageHelper,
		eventsetup::EventSetupsController &	esController,
		ActivityRegistry &	parentActReg,
		ServiceToken const &	token,
		serviceregistry::ServiceLegacy	iLegacy,
		PreallocationConfiguration const &	preallocConfig,
		ProcessContext const *	parentProcessContext
	)

Definition at line 45 of file SubProcess.cc.

References act_table_, actReg_, branchIDListHelper(), branchIDListHelper_, edm::detail::configureEventSelector(), edm::ActivityRegistry::connectToSubProcess(), edm::EDConsumerBase::consumesCollector(), droppedBranchIDToKeptBranchID_, esp_, edm::ParameterSet::exists(), edm::getAllTriggerNames(), edm::ParameterSet::getUntrackedParameterSet(), historyAppenders_, historyLumiOffset_, historyRunOffset_, edm::PrincipalCache::insert(), inUseLumiPrincipals_, mps_monitormerge::items, edm::eventsetup::EventSetupsController::makeProvider(), Data_TkAlMinBias_Run2018C_PromptReco_v3_cff::maxEvents, eostools::move(), edm::PreallocationConfiguration::numberOfLuminosityBlocks(), edm::PreallocationConfiguration::numberOfStreams(), cmsPerfStripChart::operate(), edm::ParameterSet::popParameterSet(), edm::popSubProcessVParameterSet(), preg_, principalCache_, processConfiguration_, processContext_, processHistoryRegistries_, processParameterSet_, edm::ParameterSet::registerIt(), edm::detail::registerProperSelectionInfo(), schedule_, selector_config_id_, selectors_, selectProducts(), serviceToken_, edm::PrincipalCache::setNumberOfConcurrentPrincipals(), edm::ProcessContext::setParentProcessContext(), edm::ProcessContext::setProcessConfiguration(), edm::PrincipalCache::setProcessHistoryRegistry(), AlCaHLTBitMon_QueryRunRegistry::string, subProcesses_, subProcessParentageHelper_, thinnedAssociationsHelper(), thinnedAssociationsHelper_, updateBranchIDListHelper(), edm::validateTopLevelParameterSets(), and wantAllEvents_.

                                                                      :
     EDConsumerBase(),
     serviceToken_(),
     parentPreg_(parentProductRegistry),
     preg_(),
     branchIDListHelper_(),
     act_table_(),
     processConfiguration_(),
     historyLumiOffset_(preallocConfig.numberOfStreams()),
     historyRunOffset_(historyLumiOffset_+preallocConfig.numberOfLuminosityBlocks()),
     processHistoryRegistries_(historyRunOffset_+ preallocConfig.numberOfRuns()),
     historyAppenders_(historyRunOffset_+preallocConfig.numberOfRuns()),
     principalCache_(),
     esp_(),
     schedule_(),
     parentToChildPhID_(),
     subProcesses_(),
     processParameterSet_(),
     productSelectorRules_(parameterSet, "outputCommands", "OutputModule"),
     productSelector_(),
     wantAllEvents_(true) {
 
     //Setup the event selection
     Service<service::TriggerNamesService> tns;
 
     ParameterSet selectevents =
       parameterSet.getUntrackedParameterSet("SelectEvents", ParameterSet());
 
     selectevents.registerIt(); // Just in case this PSet is not registered
     wantAllEvents_ = detail::configureEventSelector(selectevents,
                                                     tns->getProcessName(),
                                                     getAllTriggerNames(),
                                                     selectors_,
                                                     consumesCollector());
     std::map<std::string, std::vector<std::pair<std::string, int> > > outputModulePathPositions;
     selector_config_id_ = detail::registerProperSelectionInfo(selectevents,
                                                               "",
                                                               outputModulePathPositions,
                                                               parentProductRegistry->anyProductProduced());
 
     std::map<BranchID, bool> keepAssociation;
     selectProducts(*parentProductRegistry, parentThinnedAssociationsHelper, keepAssociation);
 
     std::string const maxEvents("maxEvents");
     std::string const maxLumis("maxLuminosityBlocks");
 
     // propagate_const<T> has no reset() function
     processParameterSet_ = std::unique_ptr<ParameterSet>(parameterSet.popParameterSet(std::string("process")).release());
 
     // if this process has a maxEvents or maxLuminosityBlocks parameter set, remove them.
     if(processParameterSet_->exists(maxEvents)) {
       processParameterSet_->popParameterSet(maxEvents);
     }
     if(processParameterSet_->exists(maxLumis)) {
       processParameterSet_->popParameterSet(maxLumis);
     }
 
     // if the top level process has a maxEvents or maxLuminosityBlocks parameter set, add them to this process.
     if(topLevelParameterSet.exists(maxEvents)) {
       processParameterSet_->addUntrackedParameter<ParameterSet>(maxEvents, topLevelParameterSet.getUntrackedParameterSet(maxEvents));
     }
     if(topLevelParameterSet.exists(maxLumis)) {
       processParameterSet_->addUntrackedParameter<ParameterSet>(maxLumis, topLevelParameterSet.getUntrackedParameterSet(maxLumis));
     }
 
     // If there are subprocesses, pop the subprocess parameter sets out of the process parameter set
     auto subProcessVParameterSet = popSubProcessVParameterSet(*processParameterSet_);
     bool hasSubProcesses = subProcessVParameterSet.size() != 0ull;
 
     // Validates the parameters in the 'options', 'maxEvents', and 'maxLuminosityBlocks'
     // top level parameter sets. Default values are also set in here if the
     // parameters were not explicitly set.
     validateTopLevelParameterSets(processParameterSet_.get());
 
     ScheduleItems items(*parentProductRegistry, *this);
     actReg_ = items.actReg_;
 
     //initialize the services
     ServiceToken iToken;
 
     // get any configured services.
     auto serviceSets = processParameterSet_->popVParameterSet(std::string("services"));
 
     ServiceToken newToken = items.initServices(serviceSets, *processParameterSet_, token, iLegacy, false);
     parentActReg.connectToSubProcess(*items.actReg_);
     serviceToken_ = items.addCPRandTNS(*processParameterSet_, newToken);
 
 
     //make the services available
     ServiceRegistry::Operate operate(serviceToken_);
 
     // intialize miscellaneous items
     items.initMisc(*processParameterSet_);
 
     // intialize the event setup provider
     esp_ = esController.makeProvider(*processParameterSet_, actReg_.get());
 
     branchIDListHelper_ = items.branchIDListHelper();
     updateBranchIDListHelper(parentBranchIDListHelper->branchIDLists());
 
     thinnedAssociationsHelper_ = items.thinnedAssociationsHelper();
     thinnedAssociationsHelper_->updateFromParentProcess(parentThinnedAssociationsHelper, keepAssociation, droppedBranchIDToKeptBranchID_);
 
     // intialize the Schedule
     schedule_ = items.initSchedule(*processParameterSet_,hasSubProcesses,preallocConfig,&processContext_);
 
     // set the items
     act_table_ = std::move(items.act_table_);
     preg_ = items.preg();
 
     subProcessParentageHelper_ = items.subProcessParentageHelper();
     subProcessParentageHelper_->update(parentSubProcessParentageHelper, *parentProductRegistry);
 
     //CMS-THREADING this only works since Run/Lumis are synchronous so when principalCache asks for
     // the reducedProcessHistoryID from a full ProcessHistoryID that registry will not be in use by
     // another thread. We really need to change how this is done in the PrincipalCache.
     principalCache_.setProcessHistoryRegistry(processHistoryRegistries_[historyRunOffset_]);
 
 
     processConfiguration_ = items.processConfiguration();
     processContext_.setProcessConfiguration(processConfiguration_.get());
     processContext_.setParentProcessContext(parentProcessContext);
 
     principalCache_.setNumberOfConcurrentPrincipals(preallocConfig);
     for(unsigned int index = 0; index < preallocConfig.numberOfStreams(); ++index) {
       auto ep = std::make_shared<EventPrincipal>(preg_,
                                                  branchIDListHelper(),
                                                  thinnedAssociationsHelper(),
                                                  *processConfiguration_,
                                                  &(historyAppenders_[index]),
                                                  index,
                                                  false /*not primary process*/);
       principalCache_.insert(ep);
     }
     for(unsigned int index = 0; index < preallocConfig.numberOfLuminosityBlocks(); ++ index) {
       auto lbpp = std::make_unique<LuminosityBlockPrincipal>(preg_, *processConfiguration_, &(historyAppenders_[historyLumiOffset_+index]),index,false);
       principalCache_.insert(std::move(lbpp));
     }
       
     inUseLumiPrincipals_.resize(preallocConfig.numberOfLuminosityBlocks());
 
     subProcesses_.reserve(subProcessVParameterSet.size());
     for(auto& subProcessPSet : subProcessVParameterSet) {
       subProcesses_.emplace_back(subProcessPSet,
                                  topLevelParameterSet,
                                  preg_,
                                  branchIDListHelper(),
                                  *thinnedAssociationsHelper_,
                                  *subProcessParentageHelper_,
                                  esController,
                                  *items.actReg_,
                                  newToken,
                                  iLegacy,
                                  preallocConfig,
                                  &processContext_);
     }
   }

edm::SubProcess::~SubProcess ( )

override

Definition at line 214 of file SubProcess.cc.

214 {}

edm::SubProcess::SubProcess ( SubProcess const & )

delete

edm::SubProcess::SubProcess ( SubProcess && )

default

Member Function Documentation

void edm::SubProcess::beginJob ( void )

private

Definition at line 228 of file SubProcess.cc.

References actReg_, edm::checkForModuleDependencyCorrectness(), droppedBranchIDToKeptBranchID(), fixBranchIDListsForEDAliases(), edm::for_all(), edm::InEvent, edm::PathsAndConsumesOfModules::initialize(), cmsPerfStripChart::operate(), parentPreg_, pathsAndConsumesOfModules_, preg_, processConfiguration_, processContext_, schedule_, serviceToken_, subProcesses_, and edm::EDConsumerBase::updateLookup().

Referenced by doBeginJob().

                        {
     // If event selection is being used, the SubProcess class reads TriggerResults
     // object(s) in the parent process from the event. This next call is needed for
     // getByToken to work properly. Normally, this is done by the worker, but since
     // a SubProcess is not a module, it has no worker.
     updateLookup(InEvent, *parentPreg_->productLookup(InEvent),false);
 
     if(!droppedBranchIDToKeptBranchID().empty()) {
       fixBranchIDListsForEDAliases(droppedBranchIDToKeptBranchID());
     }
     ServiceRegistry::Operate operate(serviceToken_);
     schedule_->convertCurrentProcessAlias(processConfiguration_->processName());
     pathsAndConsumesOfModules_.initialize(schedule_.get(), preg_);
     //NOTE: this may throw
     checkForModuleDependencyCorrectness(pathsAndConsumesOfModules_, false);
     actReg_->preBeginJobSignal_(pathsAndConsumesOfModules_, processContext_);
     schedule_->beginJob(*preg_);
     for_all(subProcesses_, [](auto& subProcess){ subProcess.doBeginJob(); });
   }

void edm::SubProcess::beginLuminosityBlock	(	LuminosityBlockPrincipal const &	lb,
		IOVSyncValue const &	ts
	)

private

void edm::SubProcess::beginRun	(	RunPrincipal const &	r,
		IOVSyncValue const &	ts
	)

private

std::shared_ptr<BranchIDListHelper const> edm::SubProcess::branchIDListHelper ( ) const

inlineprivate

Definition at line 251 of file SubProcess.h.

References edm::get_underlying_safe().

Referenced by SubProcess().

251 {return get_underlying_safe(branchIDListHelper_);}

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

edm::SubProcess::branchIDListHelper_

edm::propagate_const< std::shared_ptr< BranchIDListHelper > > branchIDListHelper_

Definition: SubProcess.h:260

std::shared_ptr<BranchIDListHelper>& edm::SubProcess::branchIDListHelper ( )

inlineprivate

Definition at line 252 of file SubProcess.h.

References edm::get_underlying_safe().

252 {return get_underlying_safe(branchIDListHelper_);}

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

edm::SubProcess::branchIDListHelper_

edm::propagate_const< std::shared_ptr< BranchIDListHelper > > branchIDListHelper_

Definition: SubProcess.h:260

void edm::SubProcess::clearCounters ( )

inline

Clear all the counters in the trigger report.

Definition at line 226 of file SubProcess.h.

References bk::beginJob(), MillePedeFileConverter_cfg::e, Ecal2004TBTDCRanges_v1_cff::endRun, edm::for_all(), cmsPerfStripChart::operate(), and alignCSCRings::r.

                          {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->clearCounters();
       for_all(subProcesses_, [](auto& subProcess){ subProcess.clearCounters(); });
     }

void edm::SubProcess::closeOutputFiles ( )

inline

Definition at line 123 of file SubProcess.h.

References edm::for_all(), and cmsPerfStripChart::operate().

                             {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->closeOutputFiles();
       for_all(subProcesses_, [](auto& subProcess) { subProcess.closeOutputFiles(); });
     }

void edm::SubProcess::deleteLumiFromCache ( LuminosityBlockPrincipal & principal )

Definition at line 559 of file SubProcess.cc.

References edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, eostools::move(), alignCSCRings::s, and subProcesses_.

                                                                      {
     //release from list but stay around till end of routine
     auto lb = std::move(inUseLumiPrincipals_[principal.index()]);
     for(auto& s: subProcesses_) {
       s.deleteLumiFromCache(*lb);
     }
     lb->clearPrincipal();
   }

void edm::SubProcess::deleteRunFromCache	(	ProcessHistoryID const &	parentPhID,
		int	runNumber
	)

Definition at line 490 of file SubProcess.cc.

References edm::PrincipalCache::deleteRun(), edm::for_all(), parentToChildPhID_, principalCache_, and subProcesses_.

                                                                                   {
     std::map<ProcessHistoryID, ProcessHistoryID>::const_iterator it = parentToChildPhID_.find(parentPhID);
     assert(it != parentToChildPhID_.end());
     auto const& childPhID = it->second;
     principalCache_.deleteRun(childPhID, runNumber);
     for_all(subProcesses_, [&childPhID, runNumber](auto& subProcess){ subProcess.deleteRunFromCache(childPhID, runNumber); });
   }

void edm::SubProcess::doBeginJob ( )

Definition at line 217 of file SubProcess.cc.

References beginJob().

                          {
     this->beginJob();
   }

void edm::SubProcess::doBeginLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 499 of file SubProcess.cc.

References printConversionInfo::aux, edm::LuminosityBlockPrincipal::aux(), esp_, edm::PrincipalCache::getAvailableLumiPrincipalPtr(), historyLumiOffset_, edm::LuminosityBlockPrincipal::index(), edm::InLumi, inUseLumiPrincipals_, eostools::move(), cmsPerfStripChart::operate(), principalCache_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, propagateProducts(), edm::Principal::reader(), edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalBeginTransitionAsync().

                                                                                                                                       {
     ServiceRegistry::Operate operate(serviceToken_);
 
     auto aux = principal.aux();
     aux.setProcessHistoryID(principal.processHistoryID());
     auto lbpp = principalCache_.getAvailableLumiPrincipalPtr();
     lbpp->setAux(aux);
     auto & processHistoryRegistry = processHistoryRegistries_[historyLumiOffset_+lbpp->index()];
     inUseLumiPrincipals_[principal.index()] = lbpp;
     processHistoryRegistry.registerProcessHistory(principal.processHistory());
     lbpp->fillLuminosityBlockPrincipal(processHistoryRegistry, principal.reader());
     lbpp->setRunPrincipal(principalCache_.runPrincipalPtr());
     LuminosityBlockPrincipal& lbp = *lbpp;
     propagateProducts(InLumi, principal, lbp);
     typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalBegin> Traits;
     beginGlobalTransitionAsync<Traits>(std::move(iHolder),
                                        *schedule_,
                                        lbp,
                                        ts,
                                        esp_->eventSetup(),
                                        serviceToken_,
                                        subProcesses_);
   }

void edm::SubProcess::doBeginRunAsync	(	WaitingTaskHolder	iHolder,
		RunPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 420 of file SubProcess.cc.

References printConversionInfo::aux, edm::RunPrincipal::aux(), esp_, historyAppenders_, historyRunOffset_, edm::RunPrincipal::index(), edm::InRun, edm::PrincipalCache::insert(), eostools::move(), cmsPerfStripChart::operate(), parentToChildPhID_, preg_, principalCache_, processConfiguration_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, propagateProducts(), edm::Principal::reader(), edm::RunPrincipal::reducedProcessHistoryID(), edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalBeginTransitionAsync().

                                                                                                               {
     ServiceRegistry::Operate operate(serviceToken_);
 
     auto aux = std::make_shared<RunAuxiliary>(principal.aux());
     aux->setProcessHistoryID(principal.processHistoryID());
     auto rpp = std::make_shared<RunPrincipal>(aux, preg_, *processConfiguration_, &(historyAppenders_[historyRunOffset_+principal.index()]),principal.index(),false);
     auto & processHistoryRegistry = processHistoryRegistries_[historyRunOffset_+principal.index()];
     processHistoryRegistry.registerProcessHistory(principal.processHistory());
     rpp->fillRunPrincipal(processHistoryRegistry, principal.reader());
     principalCache_.insert(rpp);
     
     ProcessHistoryID const& parentInputReducedPHID = principal.reducedProcessHistoryID();
     ProcessHistoryID const& inputReducedPHID       = rpp->reducedProcessHistoryID();
     
     parentToChildPhID_.insert(std::make_pair(parentInputReducedPHID,inputReducedPHID));
     
     RunPrincipal& rp = *principalCache_.runPrincipalPtr();
     propagateProducts(InRun, principal, rp);
     typedef OccurrenceTraits<RunPrincipal, BranchActionGlobalBegin> Traits;
     beginGlobalTransitionAsync<Traits>(std::move(iHolder),
                                        *schedule_,
                                        rp,
                                        ts,
                                        esp_->eventSetup(),
                                        serviceToken_,
                                        subProcesses_);
   }

void edm::SubProcess::doBeginStream ( unsigned int iID )

Definition at line 569 of file SubProcess.cc.

References edm::for_all(), cmsPerfStripChart::operate(), schedule_, serviceToken_, and subProcesses_.

                                             {
     ServiceRegistry::Operate operate(serviceToken_);
     schedule_->beginStream(iID);
     for_all(subProcesses_, [iID](auto& subProcess){ subProcess.doBeginStream(iID); });
   }

void edm::SubProcess::doEndJob ( )

Definition at line 222 of file SubProcess.cc.

References endJob().

Referenced by edm::EventProcessor::endJob().

                        {
     endJob();
   }

void edm::SubProcess::doEndLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

Definition at line 524 of file SubProcess.cc.

References esp_, edm::LuminosityBlockPrincipal::index(), edm::InLumi, inUseLumiPrincipals_, eostools::move(), propagateProducts(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalEndTransitionAsync().

                                                                                                                                                                   {
     
     LuminosityBlockPrincipal& lbp = *inUseLumiPrincipals_[principal.index()];
     propagateProducts(InLumi, principal, lbp);
     typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalEnd> Traits;
     endGlobalTransitionAsync<Traits>(std::move(iHolder),
                                      *schedule_,
                                      lbp,
                                      ts,
                                      esp_->eventSetup(),
                                      serviceToken_,
                                      subProcesses_,
                                      cleaningUpAfterException);
   }

void edm::SubProcess::doEndRunAsync	(	WaitingTaskHolder	iHolder,
		RunPrincipal const &	principal,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

Definition at line 450 of file SubProcess.cc.

References esp_, edm::InRun, eostools::move(), principalCache_, propagateProducts(), edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalEndTransitionAsync().

                                                            {
     RunPrincipal& rp = *principalCache_.runPrincipalPtr();
     propagateProducts(InRun, principal, rp);
     typedef OccurrenceTraits<RunPrincipal, BranchActionGlobalEnd> Traits;
     endGlobalTransitionAsync<Traits>(std::move(iHolder),
                                      *schedule_,
                                      rp,
                                      ts,
                                      esp_->eventSetup(),
                                      serviceToken_,
                                      subProcesses_,
                                      cleaningUpAfterException);
   }

void edm::SubProcess::doEndStream ( unsigned int iID )

Definition at line 576 of file SubProcess.cc.

References edm::for_all(), cmsPerfStripChart::operate(), schedule_, serviceToken_, and subProcesses_.

                                           {
     ServiceRegistry::Operate operate(serviceToken_);
     schedule_->endStream(iID);
     for_all(subProcesses_, [iID](auto& subProcess){ subProcess.doEndStream(iID); });
   }

void edm::SubProcess::doEventAsync	(	WaitingTaskHolder	iHolder,
		EventPrincipal const &	principal
	)

Definition at line 343 of file SubProcess.cc.

References MillePedeFileConverter_cfg::e, eostools::move(), cmsPerfStripChart::operate(), processAsync(), selectors_, serviceToken_, edm::OccurrenceForOutput::setConsumer(), wantAllEvents_, and edm::detail::TriggerResultsBasedEventSelector::wantEvent().

                                                      {
     ServiceRegistry::Operate operate(serviceToken_);
     /* BEGIN relevant bits from OutputModule::doEvent */
     if(!wantAllEvents_) {
       EventForOutput e(ep, ModuleDescription(), nullptr);
       e.setConsumer(this);
       if(!selectors_.wantEvent(e)) {
         return;
       }
     }
     processAsync(std::move(iHolder),ep);
     /* END relevant bits from OutputModule::doEvent */
   }

void edm::SubProcess::doStreamBeginLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 619 of file SubProcess.cc.

References esp_, triggerObjects_cff::id, edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, eostools::move(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamBeginTransitionAsync().

                                                                                                                                     {
     typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamBegin> Traits;
     
     LuminosityBlockPrincipal& lbp = *inUseLumiPrincipals_[principal.index()];
     
     beginStreamTransitionAsync<Traits>(std::move(iHolder),
                                        *schedule_,
                                        id,
                                        lbp,
                                        ts,
                                        esp_->eventSetup(),
                                        serviceToken_,
                                        subProcesses_);
   }

void edm::SubProcess::doStreamBeginRunAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		RunPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 583 of file SubProcess.cc.

References esp_, triggerObjects_cff::id, eostools::move(), principalCache_, edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamBeginTransitionAsync().

                                                                                                             {
     typedef OccurrenceTraits<RunPrincipal, BranchActionStreamBegin> Traits;
 
     RunPrincipal& rp = *principalCache_.runPrincipalPtr();
 
     beginStreamTransitionAsync<Traits>(std::move(iHolder),
                                        *schedule_,
                                        id,
                                        rp,
                                        ts,
                                        esp_->eventSetup(),
                                        serviceToken_,
                                        subProcesses_);
     
   }

void edm::SubProcess::doStreamEndLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

Definition at line 638 of file SubProcess.cc.

References esp_, triggerObjects_cff::id, edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, eostools::move(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamEndTransitionAsync().

                                                                                                                                                                  {
     LuminosityBlockPrincipal& lbp = *inUseLumiPrincipals_[principal.index()];
     typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamEnd> Traits;
     endStreamTransitionAsync<Traits>(std::move(iHolder),
                                        *schedule_,
                                        id,
                                        lbp,
                                        ts,
                                        esp_->eventSetup(),
                                        serviceToken_,
                                        subProcesses_,
                                        cleaningUpAfterException);
   }

void edm::SubProcess::doStreamEndRunAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		RunPrincipal const &	principal,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

Definition at line 602 of file SubProcess.cc.

References esp_, triggerObjects_cff::id, eostools::move(), principalCache_, edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamEndTransitionAsync().

                                                                                                                                          {
     RunPrincipal& rp = *principalCache_.runPrincipalPtr();
     typedef OccurrenceTraits<RunPrincipal, BranchActionStreamEnd> Traits;
     
     endStreamTransitionAsync<Traits>(std::move(iHolder),
                                       *schedule_,
                                        id,
                                        rp,
                                        ts,
                                        esp_->eventSetup(),
                                        serviceToken_,
                                        subProcesses_,
                                      cleaningUpAfterException);
   }

std::map<BranchID::value_type, BranchID::value_type> const& edm::SubProcess::droppedBranchIDToKeptBranchID ( )

inlineprivate

Definition at line 247 of file SubProcess.h.

Referenced by beginJob().

                                                                                           {
       return droppedBranchIDToKeptBranchID_;
     }

void edm::SubProcess::enableEndPaths ( bool active )

inline

Turn end_paths "off" if "active" is false; Turn end_paths "on" if "active" is true.

Definition at line 191 of file SubProcess.h.

References edm::for_all(), and cmsPerfStripChart::operate().

                                      {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->enableEndPaths(active);
       for_all(subProcesses_, [active](auto& subProcess){ subProcess.enableEndPaths(active); });
     }

void edm::SubProcess::endJob ( void )

private

Definition at line 249 of file SubProcess.cc.

References EnergyCorrector::c, edm::ExceptionCollector::call(), edm::ExceptionCollector::hasThrown(), cmsPerfStripChart::operate(), edm::ExceptionCollector::rethrow(), schedule_, serviceToken_, and subProcesses_.

Referenced by doEndJob().

                      {
     ServiceRegistry::Operate operate(serviceToken_);
     ExceptionCollector c("Multiple exceptions were thrown while executing endJob. An exception message follows for each.");
     schedule_->endJob(c);
     for(auto& subProcess : subProcesses_) {
       c.call([&subProcess](){ subProcess.doEndJob();});
     }
     if(c.hasThrown()) {
       c.rethrow();
     }
   }

void edm::SubProcess::endLuminosityBlock	(	LuminosityBlockPrincipal const &	lb,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

private

bool edm::SubProcess::endPathsEnabled ( ) const

inline

Return true if end_paths are active, and false if they are inactive.

Definition at line 198 of file SubProcess.h.

References cmsPerfStripChart::operate().

                                  {
       ServiceRegistry::Operate operate(serviceToken_);
       return schedule_->endPathsEnabled();
     }

void edm::SubProcess::endRun	(	RunPrincipal const &	r,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

private

void edm::SubProcess::fixBranchIDListsForEDAliases ( std::map< BranchID::value_type, BranchID::value_type > const & droppedBranchIDToKeptBranchID )

private

Definition at line 328 of file SubProcess.cc.

References branchIDListHelper_, edm::for_all(), and subProcesses_.

Referenced by beginJob().

                                                                                                                               {
     // Check for branches dropped while an EDAlias was kept.
     // Replace BranchID of each dropped branch with that of the kept alias.
     for(BranchIDList& branchIDList : branchIDListHelper_->mutableBranchIDLists()) {
       for(BranchID::value_type& branchID : branchIDList) {
         std::map<BranchID::value_type, BranchID::value_type>::const_iterator iter = droppedBranchIDToKeptBranchID.find(branchID);
         if(iter != droppedBranchIDToKeptBranchID.end()) {
           branchID = iter->second;
         }
       }
     }
     for_all(subProcesses_, [&droppedBranchIDToKeptBranchID](auto& subProcess){ subProcess.fixBranchIDListsForEDAliases(droppedBranchIDToKeptBranchID); });
   }

std::vector<ModuleDescription const*> edm::SubProcess::getAllModuleDescriptions ( ) const

Return a vector allowing const access to all the ModuleDescriptions for this SubProcess.

*** N.B. *** Ownership of the ModuleDescriptions is not *** passed to the caller. Do not call delete on these *** pointers!

void edm::SubProcess::getTriggerReport ( TriggerReport & rep ) const

inline

Return the trigger report information on paths, modules-in-path, modules-in-endpath, and modules.

Definition at line 205 of file SubProcess.h.

References cmsPerfStripChart::operate().

                                                     {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->getTriggerReport(rep);
     }

void edm::SubProcess::keepThisBranch	(	BranchDescription const &	desc,
		std::map< BranchID, BranchDescription const * > &	trueBranchIDToKeptBranchDesc,
		std::set< BranchID > &	keptProductsInEvent
	)

private

Definition at line 304 of file SubProcess.cc.

References edm::BranchDescription::branchID(), edm::BranchDescription::branchType(), edm::ProductSelector::checkForDuplicateKeptBranch(), edm::EDConsumerBase::consumes(), edm::InEvent, keptProducts_, edm::BranchDescription::moduleLabel(), edm::BranchDescription::originalBranchID(), edm::BranchDescription::processName(), edm::BranchDescription::produced(), edm::PRODUCT_TYPE, edm::BranchDescription::productInstanceName(), and edm::BranchDescription::unwrappedTypeID().

Referenced by selectProducts().

                                                                          {
 
     ProductSelector::checkForDuplicateKeptBranch(desc,
                                                  trueBranchIDToKeptBranchDesc);
 
     if(desc.branchType() == InEvent) {
       if(desc.produced()) {
         keptProductsInEvent.insert(desc.originalBranchID());
       } else {
         keptProductsInEvent.insert(desc.branchID());
       }
     }
     EDGetToken token = consumes(TypeToGet{desc.unwrappedTypeID(),PRODUCT_TYPE},
                                 InputTag{desc.moduleLabel(),
                                     desc.productInstanceName(),
                                     desc.processName()});
 
     // Now put it in the list of selected branches.
     keptProducts_[desc.branchType()].push_back(std::make_pair(&desc, token));
   }

SelectedProductsForBranchType const& edm::SubProcess::keptProducts ( ) const

inline

Definition at line 71 of file SubProcess.h.

References cmsRelvalreport::principal(), and convertSQLiteXML::runNumber.

Referenced by propagateProducts(), and edm::ScheduleItems::ScheduleItems().

71 {return keptProducts_;}

edm::SubProcess::keptProducts_

SelectedProductsForBranchType keptProducts_

Definition: SubProcess.h:286

void edm::SubProcess::openOutputFiles ( FileBlock & fb )

inline

Definition at line 130 of file SubProcess.h.

References benchmark_cfg::fb, edm::for_all(), and cmsPerfStripChart::operate().

                                         {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->openOutputFiles(fb);
       for_all(subProcesses_, [&fb](auto& subProcess) { subProcess.openOutputFiles(fb); });
     }

SubProcess& edm::SubProcess::operator= ( SubProcess const & )

delete

SubProcess& edm::SubProcess::operator= ( SubProcess && )

default

void edm::SubProcess::processAsync	(	WaitingTaskHolder	iHolder,
		EventPrincipal const &	e
	)

private

Definition at line 359 of file SubProcess.cc.

Referenced by doEventAsync().

                                                             {
     EventAuxiliary aux(principal.aux());
     aux.setProcessHistoryID(principal.processHistoryID());
     
     EventSelectionIDVector esids{principal.eventSelectionIDs()};
     if (principal.productRegistry().anyProductProduced() || !wantAllEvents_) {
       esids.push_back(selector_config_id_);
     }
     
     EventPrincipal& ep = principalCache_.eventPrincipal(principal.streamID().value());
     auto & processHistoryRegistry = processHistoryRegistries_[principal.streamID().value()];
     processHistoryRegistry.registerProcessHistory(principal.processHistory());
     BranchListIndexes bli(principal.branchListIndexes());
     branchIDListHelper_->fixBranchListIndexes(bli);
     bool deepCopyRetriever = false;
     ep.fillEventPrincipal(aux,
                           processHistoryRegistry,
                           std::move(esids),
                           std::move(bli),
                           *(principal.productProvenanceRetrieverPtr()),//NOTE: this transfers the per product provenance
                           principal.reader(),
                           deepCopyRetriever);
     ep.setLuminosityBlockPrincipal(inUseLumiPrincipals_[principal.luminosityBlockPrincipal().index()].get());
     propagateProducts(InEvent, principal, ep);
     
     WaitingTaskHolder finalizeEventTask( make_waiting_task(tbb::task::allocate_root(),
                                                            [&ep,iHolder](std::exception_ptr const* iPtr) mutable
       {
         ep.clearEventPrincipal();
         if(iPtr) {
           iHolder.doneWaiting(*iPtr);
         } else {
           iHolder.doneWaiting(std::exception_ptr());
         }
       }
                                                            )
                                         );
     WaitingTaskHolder afterProcessTask;
     if(subProcesses_.empty()) {
       afterProcessTask = std::move(finalizeEventTask);
     } else {
       afterProcessTask = WaitingTaskHolder(
                                            make_waiting_task(tbb::task::allocate_root(),
                                                              [this,&ep,finalizeEventTask] (std::exception_ptr const* iPtr) mutable{
         if(not iPtr) {
           for(auto& subProcess: boost::adaptors::reverse(subProcesses_)) {
             subProcess.doEventAsync(finalizeEventTask,ep);
           }
         } else {
           finalizeEventTask.doneWaiting(*iPtr);
         }
       })
                                            );
     }
     
     schedule_->processOneEventAsync(std::move(afterProcessTask),
                                     ep.streamID().value(),ep, esp_->eventSetup(),serviceToken_);
   }

void edm::SubProcess::propagateProducts	(	BranchType	type,
		Principal const &	parentPrincipal,
		Principal &	principal
	)		const

private

Definition at line 655 of file SubProcess.cc.

References edm::BranchDescription::branchID(), edm::ProductResolverBase::connectTo(), edm::Principal::getModifiableProductResolver(), edm::Principal::getProductResolver(), and keptProducts().

Referenced by doBeginLuminosityBlockAsync(), doBeginRunAsync(), doEndLuminosityBlockAsync(), doEndRunAsync(), and processAsync().

                                                                                                              {
     SelectedProducts const& keptVector = keptProducts()[type];
     for(auto const& item : keptVector) {
       BranchDescription const& desc = *item.first;
       ProductResolverBase const* parentProductResolver = parentPrincipal.getProductResolver(desc.branchID());
       if(parentProductResolver != nullptr) {
         ProductResolverBase* productResolver = principal.getModifiableProductResolver(desc.branchID());
         if(productResolver != nullptr) {
           //Propagate the per event(run)(lumi) data for this product to the subprocess.
           //First, the product itself.
           productResolver->connectTo(*parentProductResolver, &parentPrincipal);
         }
       }
     }
   }

void edm::SubProcess::respondToCloseInputFile ( FileBlock const & fb )

inline

Definition at line 142 of file SubProcess.h.

References edm::for_all(), and cmsPerfStripChart::operate().

                                                       {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->respondToCloseInputFile(fb);
       for_all(subProcesses_, [&fb](auto& subProcess) { subProcess.respondToCloseInputFile(fb); });
     }

void edm::SubProcess::respondToOpenInputFile ( FileBlock const & fb )

Definition at line 678 of file SubProcess.cc.

References edm::for_all(), cmsPerfStripChart::operate(), schedule_, serviceToken_, and subProcesses_.

                                                         {
     ServiceRegistry::Operate operate(serviceToken_);
     schedule_->respondToOpenInputFile(fb);
     for_all(subProcesses_, [&fb](auto& subProcess){ subProcess.respondToOpenInputFile(fb); });
   }

void edm::SubProcess::selectProducts	(	ProductRegistry const &	preg,
		ThinnedAssociationsHelper const &	parentThinnedAssociationsHelper,
		std::map< BranchID, bool > &	keepAssociation
	)

Definition at line 262 of file SubProcess.cc.

References edm::ProductRegistry::allBranchDescriptions(), TrackValidation_cff::association, droppedBranchIDToKeptBranchID_, edm::ProductSelector::fillDroppedToKept(), edm::ProductSelector::initialize(), edm::ProductSelector::initialized(), keepThisBranch(), edm::BranchDescription::present(), edm::BranchDescription::produced(), edm::ProductRegistry::productList(), productSelector_, productSelectorRules_, edm::ThinnedAssociationsHelper::selectAssociationProducts(), edm::ProductSelector::selected(), edm::BranchDescription::transient(), and edm::BranchDescription::unwrappedType().

Referenced by SubProcess().

                                                                       {
     if(productSelector_.initialized()) return;
     productSelector_.initialize(productSelectorRules_, preg.allBranchDescriptions());
 
     // TODO: See if we can collapse keptProducts_ and productSelector_ into a
     // single object. See the notes in the header for ProductSelector
     // for more information.
 
     std::map<BranchID, BranchDescription const*> trueBranchIDToKeptBranchDesc;
     std::vector<BranchDescription const*> associationDescriptions;
     std::set<BranchID> keptProductsInEvent;
 
     for(auto const& it : preg.productList()) {
       BranchDescription const& desc = it.second;
       if(desc.transient()) {
         // if the class of the branch is marked transient, output nothing
       } else if(!desc.present() && !desc.produced()) {
         // else if the branch containing the product has been previously dropped,
         // output nothing
       } else if(desc.unwrappedType() == typeid(ThinnedAssociation)) {
         associationDescriptions.push_back(&desc);
       } else if(productSelector_.selected(desc)) {
         keepThisBranch(desc, trueBranchIDToKeptBranchDesc, keptProductsInEvent);
       }
     }
 
     parentThinnedAssociationsHelper.selectAssociationProducts(associationDescriptions,
                                                               keptProductsInEvent,
                                                               keepAssociation);
 
     for(auto association : associationDescriptions) {
       if(keepAssociation[association->branchID()]) {
         keepThisBranch(*association, trueBranchIDToKeptBranchDesc, keptProductsInEvent);
       }
     }
 
     // Now fill in a mapping needed in the case that a branch was dropped while its EDAlias was kept.
     ProductSelector::fillDroppedToKept(preg, trueBranchIDToKeptBranchDesc, droppedBranchIDToKeptBranchID_);
   }

bool edm::SubProcess::shouldWeCloseOutput ( ) const

inline

Definition at line 149 of file SubProcess.h.

References cmsPerfStripChart::operate().

                                      {
       ServiceRegistry::Operate operate(serviceToken_);
       if(schedule_->shouldWeCloseOutput()) {
         return true;
       }
       for(auto const& subProcess : subProcesses_) {
         if(subProcess.shouldWeCloseOutput()) {
           return true;
         }
       }
       return false;
     }

bool edm::SubProcess::terminate ( void ) const

inline

Return whether each output module has reached its maximum count. If there is a subprocess, get this information from the subprocess.

Definition at line 212 of file SubProcess.h.

References cmsPerfStripChart::operate().

                            {
       ServiceRegistry::Operate operate(serviceToken_);
       if(schedule_->terminate()) {
         return true;
       }
       for(auto const& subProcess : subProcesses_) {
         if(subProcess.terminate()) {
           return true;
         }
       }
       return false;
     }

std::shared_ptr<ThinnedAssociationsHelper const> edm::SubProcess::thinnedAssociationsHelper ( ) const

inlineprivate

Definition at line 253 of file SubProcess.h.

References edm::get_underlying_safe().

Referenced by SubProcess().

253 {return get_underlying_safe(thinnedAssociationsHelper_);}

edm::SubProcess::thinnedAssociationsHelper_

edm::propagate_const< std::shared_ptr< ThinnedAssociationsHelper > > thinnedAssociationsHelper_

Definition: SubProcess.h:261

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<ThinnedAssociationsHelper> edm::SubProcess::thinnedAssociationsHelper ( )

inlineprivate

Definition at line 254 of file SubProcess.h.

References edm::get_underlying_safe().

254 {return get_underlying_safe(thinnedAssociationsHelper_);}

edm::SubProcess::thinnedAssociationsHelper_

edm::propagate_const< std::shared_ptr< ThinnedAssociationsHelper > > thinnedAssociationsHelper_

Definition: SubProcess.h:261

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:39

int edm::SubProcess::totalEvents ( ) const

inline

Return the number of events this SubProcess has tried to process (inclues both successes and failures, including failures due to exceptions during processing).

Definition at line 172 of file SubProcess.h.

                             {
       return schedule_->totalEvents();
     }

int edm::SubProcess::totalEventsFailed ( ) const

inline

Return the number of events that have not passed any trigger. (N.B. totalEventsFailed() + totalEventsPassed() == totalEvents()

Definition at line 184 of file SubProcess.h.

References cmsPerfStripChart::operate().

                                   {
       ServiceRegistry::Operate operate(serviceToken_);
       return schedule_->totalEventsFailed();
     }

int edm::SubProcess::totalEventsPassed ( ) const

inline

Return the number of events which have been passed by one or more trigger paths.

Definition at line 177 of file SubProcess.h.

References cmsPerfStripChart::operate().

                                   {
       ServiceRegistry::Operate operate(serviceToken_);
       return schedule_->totalEventsPassed();
     }

void edm::SubProcess::updateBranchIDListHelper ( BranchIDLists const & branchIDLists )

Definition at line 671 of file SubProcess.cc.

References branchIDListHelper_, edm::for_all(), and subProcesses_.

Referenced by SubProcess().

                                                                               {
     branchIDListHelper_->updateFromParent(branchIDLists);
     for_all(subProcesses_, [this](auto& subProcess){ subProcess.updateBranchIDListHelper(branchIDListHelper_->branchIDLists()); });
   }

void edm::SubProcess::writeLumiAsync	(	WaitingTaskHolder	task,
		LuminosityBlockPrincipal &	principal
	)

Definition at line 541 of file SubProcess.cc.

References actReg_, edm::WaitingTaskHolder::doneWaiting(), edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, checklumidiff::l, edm::make_waiting_task(), cmsPerfStripChart::operate(), processContext_, alignCSCRings::s, schedule_, serviceToken_, and subProcesses_.

                                                                                         {
     ServiceRegistry::Operate operate(serviceToken_);
 
     auto l =inUseLumiPrincipals_[principal.index()];
     auto subTasks = edm::make_waiting_task(tbb::task::allocate_root(), [this,l, task](std::exception_ptr const* iExcept) mutable {
       if( iExcept) {
         task.doneWaiting(*iExcept);
       } else {
         ServiceRegistry::Operate operate(serviceToken_);
         for(auto& s: subProcesses_) {
           s.writeLumiAsync(task, *l);
         }
       }
     });
     schedule_->writeLumiAsync(WaitingTaskHolder(subTasks),*l, &processContext_, actReg_.get());
   }

void edm::SubProcess::writeRunAsync	(	edm::WaitingTaskHolder	task,
		ProcessHistoryID const &	parentPhID,
		int	runNumber,
		MergeableRunProductMetadata const *	mergeableRunProductMetadata
	)

Definition at line 468 of file SubProcess.cc.

References actReg_, edm::WaitingTaskHolder::doneWaiting(), edm::make_waiting_task(), cmsPerfStripChart::operate(), parentToChildPhID_, principalCache_, processContext_, edm::PrincipalCache::runPrincipal(), alignCSCRings::s, schedule_, serviceToken_, and subProcesses_.

                                                                                             {
     ServiceRegistry::Operate operate(serviceToken_);
     std::map<ProcessHistoryID, ProcessHistoryID>::const_iterator it = parentToChildPhID_.find(parentPhID);
     assert(it != parentToChildPhID_.end());
     auto const& childPhID = it->second;
     
     auto subTasks = edm::make_waiting_task(tbb::task::allocate_root(), [this,childPhID,runNumber, task, mergeableRunProductMetadata](std::exception_ptr const* iExcept) mutable {
       if( iExcept) {
         task.doneWaiting(*iExcept);
       } else {
         ServiceRegistry::Operate operate(serviceToken_);
         for(auto& s: subProcesses_) {
           s.writeRunAsync(task, childPhID, runNumber, mergeableRunProductMetadata);
         }
       }
     });
     schedule_->writeRunAsync(WaitingTaskHolder(subTasks),principalCache_.runPrincipal(childPhID, runNumber),
                              &processContext_, actReg_.get(), mergeableRunProductMetadata);
   }