#include <SubProcess.h>

Inheritance diagram for edm::SubProcess:

Public Types
using	ProcessBlockType = PrincipalCache::ProcessBlockType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

void	clearLumiPrincipal (LuminosityBlockPrincipal &)

void	clearProcessBlockPrincipal (ProcessBlockType)

void	clearRunPrincipal (RunPrincipal &)

void	closeOutputFiles ()

void	doBeginJob ()

void	doBeginLuminosityBlockAsync (WaitingTaskHolder iHolder, LumiTransitionInfo const &iTransitionInfo)

template<typename Traits >
void	doBeginProcessBlockAsync (WaitingTaskHolder iHolder, ProcessBlockTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)

template<>
void	doBeginProcessBlockAsync (WaitingTaskHolder iHolder, ProcessBlockTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)

template<>
void	doBeginProcessBlockAsync (WaitingTaskHolder iHolder, ProcessBlockTransitionInfo const &iTransitionInfo, bool)

void	doBeginRunAsync (WaitingTaskHolder iHolder, RunTransitionInfo const &iTransitionInfo)

void	doBeginStream (unsigned int streamID)

void	doEndJob (ExceptionCollector &)

void	doEndLuminosityBlockAsync (WaitingTaskHolder iHolder, LumiTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)

void	doEndProcessBlockAsync (WaitingTaskHolder iHolder, ProcessBlockTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)

void	doEndRunAsync (WaitingTaskHolder iHolder, RunTransitionInfo const &iTransitionInfo, bool cleaningUpAfterException)

void	doEndStream (unsigned int streamID, ExceptionCollector &collector, std::mutex &collectorMutex) noexcept

void	doEventAsync (WaitingTaskHolder iHolder, EventPrincipal const &principal, std::vector< std::shared_ptr< const EventSetupImpl >> const *)

void	doStreamBeginLuminosityBlockAsync (WaitingTaskHolder iHolder, unsigned int iID, LumiTransitionInfo const &)

void	doStreamBeginRunAsync (WaitingTaskHolder iHolder, unsigned int iID, RunTransitionInfo const &)

void	doStreamEndLuminosityBlockAsync (WaitingTaskHolder iHolder, unsigned int iID, LumiTransitionInfo const &, bool cleaningUpAfterException)

void	doStreamEndRunAsync (WaitingTaskHolder iHolder, unsigned int iID, RunTransitionInfo const &, bool cleaningUpAfterException)

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

std::vector< ModuleProcessName >	keepOnlyConsumedUnscheduledModules (bool deleteModules)

SelectedProductsForBranchType const &	keptProducts () const

void	openOutputFiles (FileBlock &fb)

SubProcess &	operator= (SubProcess const &)=delete

SubProcess &	operator= (SubProcess &&)=delete

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, ProcessBlockHelperBase const &parentProcessBlockHelper, ThinnedAssociationsHelper const &parentThinnedAssociationsHelper, SubProcessParentageHelper const &parentSubProcessParentageHelper, eventsetup::EventSetupsController &esController, ActivityRegistry &parentActReg, ServiceToken const &token, serviceregistry::ServiceLegacy iLegacy, PreallocationConfiguration const &preallocConfig, ProcessContext const parentProcessContext, ModuleTypeResolverMaker const typeResolverMaker)

	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	writeProcessBlockAsync (edm::WaitingTaskHolder task, ProcessBlockType)

void	writeRunAsync (WaitingTaskHolder, RunPrincipal const &, 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

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	beginJob ()

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

std::shared_ptr< BranchIDListHelper > &	branchIDListHelper ()

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

void	endJob (ExceptionCollector &)

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)

bool	parentProducedProductIsKept (Principal const &parentPrincipal, Principal &principal) const

void	processAsync (WaitingTaskHolder iHolder, EventPrincipal const &e, std::vector< std::shared_ptr< const EventSetupImpl >> const *)

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_

std::vector< std::shared_ptr< RunPrincipal > >	inUseRunPrincipals_

SelectedProductsForBranchType	keptProducts_

std::shared_ptr< ProductRegistry const >	parentPreg_

PathsAndConsumesOfModules	pathsAndConsumesOfModules_

std::shared_ptr< ProductRegistry const >	preg_

PrincipalCache	principalCache_

edm::propagate_const< std::shared_ptr< SubProcessBlockHelper > >	processBlockHelper_

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 56 of file SubProcess.h.

Member Typedef Documentation

◆ ProcessBlockType

using edm::SubProcess::ProcessBlockType = PrincipalCache::ProcessBlockType

Definition at line 139 of file SubProcess.h.

Constructor & Destructor Documentation

◆ SubProcess() [1/3]

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

Definition at line 53 of file SubProcess.cc.

References act_table_, actReg_, branchIDListHelper(), branchIDListHelper_, edm::detail::configureEventSelector(), edm::ActivityRegistry::connectToSubProcess(), edm::EDConsumerBase::consumesCollector(), droppedBranchIDToKeptBranchID_, ecalHexDisplay_cfg::ep, esp_, edm::ParameterSet::exists(), edm::getAllTriggerNames(), edm::ParameterSet::getUntrackedParameterSet(), historyAppenders_, historyLumiOffset_, historyRunOffset_, edm::PrincipalCache::insert(), edm::PrincipalCache::insertForInput(), inUseLumiPrincipals_, inUseRunPrincipals_, mps_monitormerge::items, edm::eventsetup::EventSetupsController::makeProvider(), Data_TkAlMinBias_Run2018C_PromptReco_v3_cff::maxEvents, eostools::move(), edm::PreallocationConfiguration::numberOfLuminosityBlocks(), edm::PreallocationConfiguration::numberOfRuns(), edm::PreallocationConfiguration::numberOfStreams(), edm::parameterSet(), edm::ParameterSet::popParameterSet(), edm::popSubProcessVParameterSet(), preg_, principalCache_, processBlockHelper_, processConfiguration_, processContext_, processParameterSet_, edm::ParameterSet::registerIt(), edm::detail::registerProperSelectionInfo(), schedule_, selector_config_id_, selectors_, selectProducts(), serviceToken_, edm::PrincipalCache::setNumberOfConcurrentPrincipals(), edm::ProcessContext::setParentProcessContext(), edm::ProcessContext::setProcessConfiguration(), AlCaHLTBitMon_QueryRunRegistry::string, subProcesses_, subProcessParentageHelper_, thinnedAssociationsHelper(), thinnedAssociationsHelper_, unpackBuffers-CaloStage2::token, 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_(),
         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.empty();
 
     // 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());
 
     processBlockHelper_ = std::make_shared<SubProcessBlockHelper>();
 
     ScheduleItems items(*parentProductRegistry, *this, *processBlockHelper_, parentProcessBlockHelper);
     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_,
                                    typeResolverMaker,
                                    *processBlockHelper_);
 
     // set the items
     act_table_ = std::move(items.act_table_);
     preg_ = items.preg();
 
     subProcessParentageHelper_ = items.subProcessParentageHelper();
     subProcessParentageHelper_->update(parentSubProcessParentageHelper, *parentProductRegistry);
 
     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*/,
                                                  &*processBlockHelper_);
       principalCache_.insert(ep);
     }
 
     for (unsigned int index = 0; index < preallocConfig.numberOfRuns(); ++index) {
       auto rpp = std::make_unique<RunPrincipal>(
           preg_, *processConfiguration_, &(historyAppenders_[historyRunOffset_ + index]), index, false);
       principalCache_.insert(std::move(rpp));
     }
 
     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));
     }
 
     {
       auto pb = std::make_unique<ProcessBlockPrincipal>(preg_, *processConfiguration_, false);
       principalCache_.insert(std::move(pb));
 
       auto pbForInput = std::make_unique<ProcessBlockPrincipal>(preg_, *processConfiguration_, false);
       principalCache_.insertForInput(std::move(pbForInput));
     }
 
     inUseRunPrincipals_.resize(preallocConfig.numberOfRuns());
     inUseLumiPrincipals_.resize(preallocConfig.numberOfLuminosityBlocks());
 
     subProcesses_.reserve(subProcessVParameterSet.size());
     for (auto& subProcessPSet : subProcessVParameterSet) {
       subProcesses_.emplace_back(subProcessPSet,
                                  topLevelParameterSet,
                                  preg_,
                                  branchIDListHelper(),
                                  *processBlockHelper_,
                                  *thinnedAssociationsHelper_,
                                  *subProcessParentageHelper_,
                                  esController,
                                  *items.actReg_,
                                  newToken,
                                  iLegacy,
                                  preallocConfig,
                                  &processContext_,
                                  typeResolverMaker);
     }
   }

◆ ~SubProcess()

edm::SubProcess::~SubProcess ( )

override

Definition at line 240 of file SubProcess.cc.

240 {}

◆ SubProcess() [2/3]

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

delete

◆ SubProcess() [3/3]

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

default

Member Function Documentation

◆ beginJob()

void edm::SubProcess::beginJob ( void )

private

Definition at line 301 of file SubProcess.cc.

References CMS_SA_ALLOW, droppedBranchIDToKeptBranchID(), esp_, fixBranchIDListsForEDAliases(), edm::InEvent, parentPreg_, pathsAndConsumesOfModules_, preg_, processBlockHelper_, 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_);
 
     std::exception_ptr firstException;
     CMS_SA_ALLOW try {
       schedule_->beginJob(
           *preg_, esp_->recordsToResolverIndices(), *processBlockHelper_, pathsAndConsumesOfModules_, processContext_);
     } catch (...) {
       firstException = std::current_exception();
     }
     for (auto& subProcess : subProcesses_) {
       CMS_SA_ALLOW try { subProcess.doBeginJob(); } catch (...) {
         if (!firstException) {
           firstException = std::current_exception();
         }
       }
     }
     if (firstException) {
       std::rethrow_exception(firstException);
     }
   }

◆ branchIDListHelper() [1/2]

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

inlineprivate

Definition at line 261 of file SubProcess.h.

References branchIDListHelper_, and edm::get_underlying_safe().

Referenced by SubProcess().

                                                                        {
       return get_underlying_safe(branchIDListHelper_);
     }

◆ branchIDListHelper() [2/2]

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

inlineprivate

Definition at line 264 of file SubProcess.h.

References branchIDListHelper_, and edm::get_underlying_safe().

264 { return get_underlying_safe(branchIDListHelper_); }

edm::get_underlying_safe

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

Definition: get_underlying_safe.h:41

edm::SubProcess::branchIDListHelper_

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

Definition: SubProcess.h:276

◆ clearCounters()

void edm::SubProcess::clearCounters ( )

inline

Clear all the counters in the trigger report.

Definition at line 236 of file SubProcess.h.

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

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

◆ clearLumiPrincipal()

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

Definition at line 698 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.clearLumiPrincipal(*lb);
     }
     lb->setRunPrincipal(std::shared_ptr<RunPrincipal>());
     lb->clearPrincipal();
   }

◆ clearProcessBlockPrincipal()

void edm::SubProcess::clearProcessBlockPrincipal ( ProcessBlockType processBlockType )

Definition at line 639 of file SubProcess.cc.

References edm::Principal::clearPrincipal(), principalCache_, edm::PrincipalCache::processBlockPrincipal(), alignCSCRings::s, and subProcesses_.

                                                                                {
     ProcessBlockPrincipal& processBlockPrincipal = principalCache_.processBlockPrincipal(processBlockType);
     processBlockPrincipal.clearPrincipal();
     for (auto& s : subProcesses_) {
       s.clearProcessBlockPrincipal(processBlockType);
     }
   }

◆ clearRunPrincipal()

void edm::SubProcess::clearRunPrincipal ( RunPrincipal & parentPrincipal )

Definition at line 630 of file SubProcess.cc.

References edm::RunPrincipal::index(), inUseRunPrincipals_, eostools::move(), alignCSCRings::s, and subProcesses_.

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

◆ closeOutputFiles()

void edm::SubProcess::closeOutputFiles ( )

inline

Definition at line 149 of file SubProcess.h.

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

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

◆ doBeginJob()

void edm::SubProcess::doBeginJob ( )

Definition at line 297 of file SubProcess.cc.

References beginJob().

297 { beginJob(); }

edm::SubProcess::beginJob

void beginJob()

Definition: SubProcess.cc:301

◆ doBeginLuminosityBlockAsync()

void edm::SubProcess::doBeginLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		LumiTransitionInfo const &	iTransitionInfo
	)

Definition at line 647 of file SubProcess.cc.

References printConversionInfo::aux, edm::LuminosityBlockPrincipal::aux(), esp_, edm::LumiTransitionInfo::eventSetupImpls(), edm::PrincipalCache::getAvailableLumiPrincipalPtr(), historyLumiOffset_, edm::LuminosityBlockPrincipal::index(), edm::RunPrincipal::index(), edm::InLumi, inUseLumiPrincipals_, inUseRunPrincipals_, eostools::move(), edm::LumiTransitionInfo::principal(), principalCache_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, propagateProducts(), edm::Principal::reader(), edm::LuminosityBlockPrincipal::runPrincipal(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalBeginTransitionAsync().

                                                                                                                    {
     ServiceRegistry::Operate operate(serviceToken_);
 
     LuminosityBlockPrincipal const& parentPrincipal = iTransitionInfo.principal();
     auto aux = parentPrincipal.aux();
     aux.setProcessHistoryID(parentPrincipal.processHistoryID());
     auto lbpp = principalCache_.getAvailableLumiPrincipalPtr();
     lbpp->setAux(aux);
     auto& processHistoryRegistry = processHistoryRegistries_[historyLumiOffset_ + lbpp->index()];
     inUseLumiPrincipals_[parentPrincipal.index()] = lbpp;
     processHistoryRegistry.registerProcessHistory(parentPrincipal.processHistory());
     lbpp->fillLuminosityBlockPrincipal(&parentPrincipal.processHistory(), parentPrincipal.reader());
     lbpp->setRunPrincipal(inUseRunPrincipals_[parentPrincipal.runPrincipal().index()]);
     LuminosityBlockPrincipal& lbp = *lbpp;
     propagateProducts(InLumi, parentPrincipal, lbp);
 
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     LumiTransitionInfo transitionInfo(lbp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     using Traits = OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalBegin>;
     beginGlobalTransitionAsync<Traits>(std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_);
   }

◆ doBeginProcessBlockAsync() [1/3]

template<typename Traits >

void edm::SubProcess::doBeginProcessBlockAsync	(	WaitingTaskHolder	iHolder,
		ProcessBlockTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Referenced by edm::subProcessDoGlobalBeginTransitionAsync().

◆ doBeginProcessBlockAsync() [2/3]

template<>

void edm::SubProcess::doBeginProcessBlockAsync	(	WaitingTaskHolder	iHolder,
		ProcessBlockTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Definition at line 485 of file SubProcess.cc.

References edm::ProcessBlockPrincipal::fillProcessBlockPrincipal(), edm::InProcess, edm::PrincipalCache::inputProcessBlockPrincipal(), eostools::move(), principalCache_, edm::ProcessBlockPrincipal::processName(), propagateProducts(), edm::Principal::reader(), schedule_, serviceToken_, and subProcesses_.

                                                                                                                    {
     ServiceRegistry::Operate operate(serviceToken_);
 
     ProcessBlockPrincipal& processBlockPrincipal = principalCache_.inputProcessBlockPrincipal();
     ProcessBlockPrincipal const& parentPrincipal = iTransitionInfo.principal();
     processBlockPrincipal.fillProcessBlockPrincipal(parentPrincipal.processName(), parentPrincipal.reader());
     propagateProducts(InProcess, parentPrincipal, processBlockPrincipal);
 
     ProcessBlockTransitionInfo transitionInfo(processBlockPrincipal);
     using Traits = OccurrenceTraits<ProcessBlockPrincipal, BranchActionProcessBlockInput>;
     beginGlobalTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_, cleaningUpAfterException);
   }

◆ doBeginProcessBlockAsync() [3/3]

template<>

void edm::SubProcess::doBeginProcessBlockAsync	(	WaitingTaskHolder	iHolder,
		ProcessBlockTransitionInfo const &	iTransitionInfo,
		bool
	)

Definition at line 501 of file SubProcess.cc.

References edm::ProcessBlockPrincipal::fillProcessBlockPrincipal(), edm::InProcess, eostools::move(), principalCache_, edm::PrincipalCache::processBlockPrincipal(), processConfiguration_, propagateProducts(), schedule_, serviceToken_, and subProcesses_.

                                                                                           {
     ServiceRegistry::Operate operate(serviceToken_);
 
     ProcessBlockPrincipal& processBlockPrincipal = principalCache_.processBlockPrincipal();
     ProcessBlockPrincipal const& parentPrincipal = iTransitionInfo.principal();
     processBlockPrincipal.fillProcessBlockPrincipal(processConfiguration_->processName());
     propagateProducts(InProcess, parentPrincipal, processBlockPrincipal);
 
     ProcessBlockTransitionInfo transitionInfo(processBlockPrincipal);
     using Traits = OccurrenceTraits<ProcessBlockPrincipal, BranchActionGlobalBegin>;
     beginGlobalTransitionAsync<Traits>(std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_);
   }

◆ doBeginRunAsync()

void edm::SubProcess::doBeginRunAsync	(	WaitingTaskHolder	iHolder,
		RunTransitionInfo const &	iTransitionInfo
	)

Definition at line 563 of file SubProcess.cc.

References printConversionInfo::aux, edm::RunPrincipal::aux(), esp_, edm::RunTransitionInfo::eventSetupImpls(), edm::PrincipalCache::getAvailableRunPrincipalPtr(), historyRunOffset_, edm::RunPrincipal::index(), edm::InRun, inUseRunPrincipals_, eostools::move(), edm::RunTransitionInfo::principal(), principalCache_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, propagateProducts(), edm::Principal::reader(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalBeginTransitionAsync().

                                                                                                       {
     ServiceRegistry::Operate operate(serviceToken_);
 
     RunPrincipal const& parentPrincipal = iTransitionInfo.principal();
     auto aux = parentPrincipal.aux();
     aux.setProcessHistoryID(parentPrincipal.processHistoryID());
     auto rpp = principalCache_.getAvailableRunPrincipalPtr();
     rpp->setAux(aux);
     auto& processHistoryRegistry = processHistoryRegistries_[historyRunOffset_ + parentPrincipal.index()];
     inUseRunPrincipals_[parentPrincipal.index()] = rpp;
     processHistoryRegistry.registerProcessHistory(parentPrincipal.processHistory());
     rpp->fillRunPrincipal(processHistoryRegistry, parentPrincipal.reader());
 
     RunPrincipal& rp = *rpp;
     propagateProducts(InRun, parentPrincipal, rp);
 
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     RunTransitionInfo transitionInfo(rp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     using Traits = OccurrenceTraits<RunPrincipal, BranchActionGlobalBegin>;
     beginGlobalTransitionAsync<Traits>(std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_);
   }

◆ doBeginStream()

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

Definition at line 708 of file SubProcess.cc.

References CMS_SA_ALLOW, schedule_, serviceToken_, and subProcesses_.

                                                       {
     ServiceRegistry::Operate operate(serviceToken_);
     std::exception_ptr exceptionPtr;
     CMS_SA_ALLOW try { schedule_->beginStream(streamID); } catch (...) {
       exceptionPtr = std::current_exception();
     }
 
     for (auto& subProcess : subProcesses_) {
       CMS_SA_ALLOW try { subProcess.doBeginStream(streamID); } catch (...) {
         if (!exceptionPtr) {
           exceptionPtr = std::current_exception();
         }
       }
     }
     if (exceptionPtr) {
       std::rethrow_exception(exceptionPtr);
     }
   }

◆ doEndJob()

void edm::SubProcess::doEndJob ( ExceptionCollector & collector )

Definition at line 299 of file SubProcess.cc.

References endJob().

299 { endJob(collector); }

edm::SubProcess::endJob

void endJob(ExceptionCollector &)

Definition: SubProcess.cc:332

◆ doEndLuminosityBlockAsync()

void edm::SubProcess::doEndLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		LumiTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Definition at line 669 of file SubProcess.cc.

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

Referenced by edm::subProcessDoGlobalEndTransitionAsync().

                                                                             {
     LuminosityBlockPrincipal const& parentPrincipal = iTransitionInfo.principal();
     LuminosityBlockPrincipal& lbp = *inUseLumiPrincipals_[parentPrincipal.index()];
     propagateProducts(InLumi, parentPrincipal, lbp);
 
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     LumiTransitionInfo transitionInfo(lbp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     using Traits = OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalEnd>;
     endGlobalTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_, cleaningUpAfterException);
   }

◆ doEndProcessBlockAsync()

void edm::SubProcess::doEndProcessBlockAsync	(	WaitingTaskHolder	iHolder,
		ProcessBlockTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Definition at line 515 of file SubProcess.cc.

References edm::Principal::clearPrincipal(), edm::ProcessBlockPrincipal::fillProcessBlockPrincipal(), dqmdumpme::first, info(), edm::InProcess, edm::PrincipalCache::Input, edm::PrincipalCache::inputProcessBlockPrincipal(), eostools::move(), parentProducedProductIsKept(), edm::ProcessBlockTransitionInfo::principal(), principalCache_, edm::PrincipalCache::processBlockPrincipal(), edm::ProcessBlockPrincipal::processName(), propagateProducts(), edm::Principal::reader(), edm::waiting_task::chain::runLast(), alignCSCRings::s, schedule_, serviceToken_, subProcesses_, edm::waiting_task::chain::then(), and writeProcessBlockAsync().

Referenced by edm::subProcessDoGlobalEndTransitionAsync().

                                                                          {
     ProcessBlockPrincipal& processBlockPrincipal = principalCache_.processBlockPrincipal();
     ProcessBlockPrincipal const& parentPrincipal = iTransitionInfo.principal();
     propagateProducts(InProcess, parentPrincipal, processBlockPrincipal);
 
     ProcessBlockTransitionInfo transitionInfo(processBlockPrincipal);
 
     if (parentProducedProductIsKept(parentPrincipal, processBlockPrincipal)) {
       ProcessBlockPrincipal& inputProcessBlockPrincipal = principalCache_.inputProcessBlockPrincipal();
       inputProcessBlockPrincipal.fillProcessBlockPrincipal(parentPrincipal.processName(), parentPrincipal.reader());
       propagateProducts(InProcess, parentPrincipal, inputProcessBlockPrincipal);
       ProcessBlockTransitionInfo inputTransitionInfo(inputProcessBlockPrincipal);
 
       using namespace edm::waiting_task;
       chain::first([&](const std::exception_ptr*, auto nextTask) {
         using TraitsInput = OccurrenceTraits<ProcessBlockPrincipal, BranchActionProcessBlockInput>;
         beginGlobalTransitionAsync<TraitsInput>(std::move(nextTask),
                                                 *schedule_,
                                                 inputTransitionInfo,
                                                 serviceToken_,
                                                 subProcesses_,
                                                 cleaningUpAfterException);
       }) | chain::then([this](auto nextTask) { writeProcessBlockAsync(nextTask, ProcessBlockType::Input); }) |
           chain::then([this, info = transitionInfo, cleaningUpAfterException](std::exception_ptr const* iPtr,
                                                                               auto nextTask) mutable {
             ProcessBlockPrincipal& inputProcessBlockPrincipal = principalCache_.inputProcessBlockPrincipal();
             inputProcessBlockPrincipal.clearPrincipal();
             for (auto& s : subProcesses_) {
               s.clearProcessBlockPrincipal(ProcessBlockType::Input);
             }
             if (iPtr) {
               nextTask.doneWaiting(*iPtr);
             } else {
               using Traits = OccurrenceTraits<ProcessBlockPrincipal, BranchActionGlobalEnd>;
               endGlobalTransitionAsync<Traits>(
                   std::move(nextTask), *schedule_, info, serviceToken_, subProcesses_, cleaningUpAfterException);
             }
           }) |
           chain::runLast(std::move(iHolder));
     } else {
       using Traits = OccurrenceTraits<ProcessBlockPrincipal, BranchActionGlobalEnd>;
       endGlobalTransitionAsync<Traits>(
           std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_, cleaningUpAfterException);
     }
   }

◆ doEndRunAsync()

void edm::SubProcess::doEndRunAsync	(	WaitingTaskHolder	iHolder,
		RunTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Definition at line 585 of file SubProcess.cc.

References esp_, edm::RunTransitionInfo::eventSetupImpls(), edm::RunPrincipal::index(), edm::InRun, inUseRunPrincipals_, eostools::move(), edm::RunTransitionInfo::principal(), propagateProducts(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoGlobalEndTransitionAsync().

                                                                 {
     RunPrincipal const& parentPrincipal = iTransitionInfo.principal();
     RunPrincipal& rp = *inUseRunPrincipals_[parentPrincipal.index()];
     propagateProducts(InRun, parentPrincipal, rp);
 
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     RunTransitionInfo transitionInfo(rp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     using Traits = OccurrenceTraits<RunPrincipal, BranchActionGlobalEnd>;
     endGlobalTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, transitionInfo, serviceToken_, subProcesses_, cleaningUpAfterException);
   }

◆ doEndStream()

void edm::SubProcess::doEndStream	(	unsigned int	streamID,
		ExceptionCollector &	collector,
		std::mutex &	collectorMutex
	)

noexcept

Definition at line 727 of file SubProcess.cc.

References schedule_, serviceToken_, and subProcesses_.

                                                                   {
     ServiceRegistry::Operate operate(serviceToken_);
     schedule_->endStream(streamID, collector, collectorMutex);
     for (auto& subProcess : subProcesses_) {
       subProcess.doEndStream(streamID, collector, collectorMutex);
     }
   }

◆ doEventAsync()

void edm::SubProcess::doEventAsync	(	WaitingTaskHolder	iHolder,
		EventPrincipal const &	principal,
		std::vector< std::shared_ptr< const EventSetupImpl >> const *	iEventSetupImpls
	)

Definition at line 423 of file SubProcess.cc.

References MillePedeFileConverter_cfg::e, ecalHexDisplay_cfg::ep, eostools::move(), processAsync(), selectors_, serviceToken_, 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, iEventSetupImpls);
     /* END relevant bits from OutputModule::doEvent */
   }

◆ doStreamBeginLuminosityBlockAsync()

void edm::SubProcess::doStreamBeginLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		LumiTransitionInfo const &	iTransitionInfo
	)

Definition at line 766 of file SubProcess.cc.

References esp_, edm::LumiTransitionInfo::eventSetupImpls(), EcalPhiSymFlatTableProducers_cfi::id, edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, eostools::move(), edm::LumiTransitionInfo::principal(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamBeginTransitionAsync().

                                                                                                 {
     using Traits = OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamBegin>;
 
     LuminosityBlockPrincipal& lbp = *inUseLumiPrincipals_[iTransitionInfo.principal().index()];
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     LumiTransitionInfo transitionInfo(lbp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     beginStreamTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, id, transitionInfo, serviceToken_, subProcesses_);
   }

◆ doStreamBeginRunAsync()

void edm::SubProcess::doStreamBeginRunAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		RunTransitionInfo const &	iTransitionInfo
	)

Definition at line 737 of file SubProcess.cc.

References esp_, edm::RunTransitionInfo::eventSetupImpls(), EcalPhiSymFlatTableProducers_cfi::id, edm::RunPrincipal::index(), inUseRunPrincipals_, eostools::move(), edm::RunTransitionInfo::principal(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamBeginTransitionAsync().

                                                                                    {
     using Traits = OccurrenceTraits<RunPrincipal, BranchActionStreamBegin>;
 
     RunPrincipal const& parentPrincipal = iTransitionInfo.principal();
     RunPrincipal& rp = *inUseRunPrincipals_[parentPrincipal.index()];
 
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     RunTransitionInfo transitionInfo(rp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     beginStreamTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, id, transitionInfo, serviceToken_, subProcesses_);
   }

◆ doStreamEndLuminosityBlockAsync()

void edm::SubProcess::doStreamEndLuminosityBlockAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		LumiTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Definition at line 778 of file SubProcess.cc.

References esp_, edm::LumiTransitionInfo::eventSetupImpls(), EcalPhiSymFlatTableProducers_cfi::id, edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, eostools::move(), edm::LumiTransitionInfo::principal(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamEndTransitionAsync().

                                                                                   {
     LuminosityBlockPrincipal& lbp = *inUseLumiPrincipals_[iTransitionInfo.principal().index()];
     using Traits = OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamEnd>;
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     LumiTransitionInfo transitionInfo(lbp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     endStreamTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, id, transitionInfo, serviceToken_, subProcesses_, cleaningUpAfterException);
   }

◆ doStreamEndRunAsync()

void edm::SubProcess::doStreamEndRunAsync	(	WaitingTaskHolder	iHolder,
		unsigned int	iID,
		RunTransitionInfo const &	iTransitionInfo,
		bool	cleaningUpAfterException
	)

Definition at line 751 of file SubProcess.cc.

References esp_, edm::RunTransitionInfo::eventSetupImpls(), EcalPhiSymFlatTableProducers_cfi::id, edm::RunPrincipal::index(), inUseRunPrincipals_, eostools::move(), edm::RunTransitionInfo::principal(), schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamEndTransitionAsync().

                                                                       {
     using Traits = OccurrenceTraits<RunPrincipal, BranchActionStreamEnd>;
 
     RunPrincipal const& parentPrincipal = iTransitionInfo.principal();
     RunPrincipal& rp = *inUseRunPrincipals_[parentPrincipal.index()];
 
     std::vector<std::shared_ptr<const EventSetupImpl>> const* eventSetupImpls = iTransitionInfo.eventSetupImpls();
     RunTransitionInfo transitionInfo(rp, *((*eventSetupImpls)[esp_->subProcessIndex()]), eventSetupImpls);
     endStreamTransitionAsync<Traits>(
         std::move(iHolder), *schedule_, id, transitionInfo, serviceToken_, subProcesses_, cleaningUpAfterException);
   }

◆ droppedBranchIDToKeptBranchID()

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

inlineprivate

Definition at line 257 of file SubProcess.h.

References droppedBranchIDToKeptBranchID_.

Referenced by beginJob(), and fixBranchIDListsForEDAliases().

                                                                                           {
       return droppedBranchIDToKeptBranchID_;
     }

◆ endJob()

void edm::SubProcess::endJob ( ExceptionCollector & collector )

private

Definition at line 332 of file SubProcess.cc.

References edm::ExceptionCollector::addException(), schedule_, serviceToken_, subProcesses_, and edm::convertException::wrap().

Referenced by doEndJob().

                                                        {
     ServiceRegistry::Operate operate(serviceToken_);
     try {
       convertException::wrap([this, &collector]() { schedule_->endJob(collector); });
     } catch (cms::Exception const& ex) {
       collector.addException(ex);
     }
     for (auto& subProcess : subProcesses_) {
       subProcess.doEndJob(collector);
     }
   }

◆ fixBranchIDListsForEDAliases()

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

private

Definition at line 405 of file SubProcess.cc.

References branchIDListHelper_, droppedBranchIDToKeptBranchID(), 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);
     });
   }

◆ getAllModuleDescriptions()

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!

◆ getTriggerReport()

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 215 of file SubProcess.h.

References cuy::rep, schedule_, and serviceToken_.

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

◆ keepOnlyConsumedUnscheduledModules()

std::vector< ModuleProcessName > edm::SubProcess::keepOnlyConsumedUnscheduledModules ( bool deleteModules )

Definition at line 242 of file SubProcess.cc.

References actReg_, edm::PathsAndConsumesOfModulesBase::allModules(), DummyCfis::c, edm::checkForModuleDependencyCorrectness(), makeListRunsInFiles::description, edm::for_all(), edm::PathsAndConsumesOfModules::initialize(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, MainPageGenerator::l, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, merge(), edm::ModuleProcessName::moduleLabel(), edm::PathsAndConsumesOfModules::modulesInPreviousProcessesWhoseProductsAreConsumedBy(), edm::nonConsumedUnscheduledModules(), pathsAndConsumesOfModules_, preg_, processConfiguration_, edm::PathsAndConsumesOfModules::removeModules(), schedule_, subProcesses_, edm::swap(), and createJobs::tmp.

                                                                                                 {
     schedule_->convertCurrentProcessAlias(processConfiguration_->processName());
     pathsAndConsumesOfModules_.initialize(schedule_.get(), preg_);
 
     // Note: all these may throw
     checkForModuleDependencyCorrectness(pathsAndConsumesOfModules_, false);
 
     // Consumes information from the child SubProcesses
     std::vector<ModuleProcessName> consumedByChildren;
     for_all(subProcesses_, [&consumedByChildren, deleteModules](auto& subProcess) {
       auto c = subProcess.keepOnlyConsumedUnscheduledModules(deleteModules);
       if (consumedByChildren.empty()) {
         std::swap(consumedByChildren, c);
       } else if (not c.empty()) {
         std::vector<ModuleProcessName> tmp;
         tmp.reserve(consumedByChildren.size() + c.size());
         std::merge(consumedByChildren.begin(), consumedByChildren.end(), c.begin(), c.end(), std::back_inserter(tmp));
         std::swap(consumedByChildren, tmp);
       }
     });
 
     // Non-consumed unscheduled modules in this SubProcess, take into account of the consumes from child SubProcesses
     if (deleteModules) {
       if (auto const unusedModules = nonConsumedUnscheduledModules(pathsAndConsumesOfModules_, consumedByChildren);
           not unusedModules.empty()) {
         pathsAndConsumesOfModules_.removeModules(unusedModules);
 
         edm::LogInfo("DeleteModules").log([&unusedModules, this](auto& l) {
           l << "Following modules are not in any Path or EndPath, nor is their output consumed by any other module, "
                "and "
                "therefore they are deleted from SubProcess "
             << processConfiguration_->processName() << " before beginJob transition.";
           for (auto const& description : unusedModules) {
             l << "\n " << description->moduleLabel();
           }
         });
         for (auto const& description : unusedModules) {
           schedule_->deleteModule(description->moduleLabel(), actReg_.get());
         }
       }
     }
 
     // Products possibly consumed from the parent (Sub)Process
     for (auto const& description : pathsAndConsumesOfModules_.allModules()) {
       for (auto const& dep :
            pathsAndConsumesOfModules_.modulesInPreviousProcessesWhoseProductsAreConsumedBy(description->id())) {
         auto it = std::lower_bound(consumedByChildren.begin(),
                                    consumedByChildren.end(),
                                    ModuleProcessName{dep.moduleLabel(), dep.processName()});
         consumedByChildren.emplace(it, dep.moduleLabel(), dep.processName());
       }
     }
     return consumedByChildren;
   }

◆ keepThisBranch()

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

private

Definition at line 386 of file SubProcess.cc.

References edm::ProductSelector::checkForDuplicateKeptBranch(), edm::EDConsumerBase::consumes(), submitPVResolutionJobs::desc, edm::InEvent, keptProducts_, edm::PRODUCT_TYPE, and unpackBuffers-CaloStage2::token.

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

◆ keptProducts()

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

inline

Definition at line 85 of file SubProcess.h.

References keptProducts_.

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

85 { return keptProducts_; }

edm::SubProcess::keptProducts_

SelectedProductsForBranchType keptProducts_

Definition: SubProcess.h:303

◆ openOutputFiles()

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

inline

Definition at line 156 of file SubProcess.h.

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

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

◆ operator=() [1/2]

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

delete

◆ operator=() [2/2]

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

delete

◆ parentProducedProductIsKept()

bool edm::SubProcess::parentProducedProductIsKept	(	Principal const &	parentPrincipal,
		Principal &	principal
	)		const

private

Definition at line 805 of file SubProcess.cc.

References cms::cuda::assert(), submitPVResolutionJobs::desc, edm::Principal::getModifiableProductResolver(), edm::Principal::getProductResolver(), edm::InProcess, B2GTnPMonitor_cfi::item, and keptProducts().

Referenced by doEndProcessBlockAsync().

                                                                                                            {
     SelectedProducts const& keptVector = keptProducts()[InProcess];
     for (auto const& item : keptVector) {
       BranchDescription const& desc = *item.first;
       assert(desc.branchType() == InProcess);
       ProductResolverBase const* parentProductResolver = parentPrincipal.getProductResolver(desc.branchID());
       if (parentProductResolver != nullptr) {
         ProductResolverBase* productResolver = principal.getModifiableProductResolver(desc.branchID());
         if (productResolver != nullptr) {
           if (parentProductResolver->branchDescription().produced()) {
             return true;
           }
         }
       }
     }
     return false;
   }

◆ processAsync()

void edm::SubProcess::processAsync	(	WaitingTaskHolder	iHolder,
		EventPrincipal const &	e,
		std::vector< std::shared_ptr< const EventSetupImpl >> const *	iEventSetupImpls
	)

private

Definition at line 439 of file SubProcess.cc.

References edm::ProductRegistry::anyProductProduced(), printConversionInfo::aux, edm::EventPrincipal::aux(), branchIDListHelper_, edm::EventPrincipal::branchListIndexes(), ecalHexDisplay_cfg::ep, esp_, edm::PrincipalCache::eventPrincipal(), edm::EventPrincipal::eventSelectionIDs(), edm::EventPrincipal::eventToProcessBlockIndexes(), dqmdumpme::first, edm::waiting_task::chain::ifThen(), edm::LuminosityBlockPrincipal::index(), edm::InEvent, info(), inUseLumiPrincipals_, edm::EventPrincipal::luminosityBlockPrincipal(), eostools::move(), principalCache_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, edm::EventPrincipal::productProvenanceRetrieverPtr(), edm::Principal::productRegistry(), propagateProducts(), edm::Principal::reader(), groupFilesInBlocks::reverse, edm::waiting_task::chain::runLast(), schedule_, selector_config_id_, serviceToken_, edm::EventPrincipal::streamID(), subProcesses_, edm::waiting_task::chain::then(), edm::StreamID::value(), and wantAllEvents_.

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,
         &principal.processHistory(),
         std::move(esids),
         std::move(bli),
         principal.eventToProcessBlockIndexes(),
         *(principal.productProvenanceRetrieverPtr()),  //NOTE: this transfers the per product provenance
         principal.reader(),
         deepCopyRetriever);
     ep.setLuminosityBlockPrincipal(inUseLumiPrincipals_[principal.luminosityBlockPrincipal().index()].get());
     propagateProducts(InEvent, principal, ep);
 
     using namespace edm::waiting_task;
     chain::first([&](auto nextTask) {
       EventTransitionInfo info(ep, *((*iEventSetupImpls)[esp_->subProcessIndex()]));
       schedule_->processOneEventAsync(std::move(nextTask), ep.streamID().value(), info, serviceToken_);
     }) | chain::ifThen(not subProcesses_.empty(), [this, &ep, iEventSetupImpls](auto nextTask) {
       for (auto& subProcess : boost::adaptors::reverse(subProcesses_)) {
         subProcess.doEventAsync(nextTask, ep, iEventSetupImpls);
       }
     }) | chain::then([&ep](std::exception_ptr const* iPtr, auto nextTask) {
       ep.clearEventPrincipal();
       if (iPtr) {
         nextTask.doneWaiting(*iPtr);
       }
     }) | chain::runLast(std::move(iHolder));
   }

◆ propagateProducts()

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

private

Definition at line 790 of file SubProcess.cc.

References edm::ProductResolverBase::connectTo(), submitPVResolutionJobs::desc, edm::Principal::getModifiableProductResolver(), edm::Principal::getProductResolver(), B2GTnPMonitor_cfi::item, and keptProducts().

Referenced by doBeginLuminosityBlockAsync(), doBeginProcessBlockAsync(), doBeginRunAsync(), doEndLuminosityBlockAsync(), doEndProcessBlockAsync(), 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)(processBlock) data for this product to the subprocess.
           productResolver->connectTo(*parentProductResolver, &parentPrincipal);
         }
       }
     }
   }

◆ respondToCloseInputFile()

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

inline

Definition at line 168 of file SubProcess.h.

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

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

◆ respondToOpenInputFile()

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

Definition at line 830 of file SubProcess.cc.

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

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

◆ selectProducts()

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

Definition at line 344 of file SubProcess.cc.

References edm::ProductRegistry::allBranchDescriptions(), submitPVResolutionJobs::desc, droppedBranchIDToKeptBranchID_, edm::ProductSelector::fillDroppedToKept(), edm::ProductSelector::initialize(), edm::ProductSelector::initialized(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, keepThisBranch(), edm::ProductRegistry::productList(), productSelector_, productSelectorRules_, edm::ThinnedAssociationsHelper::selectAssociationProducts(), and edm::ProductSelector::selected().

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_);
   }

◆ shouldWeCloseOutput()

bool edm::SubProcess::shouldWeCloseOutput ( ) const

inline

Definition at line 175 of file SubProcess.h.

References schedule_, serviceToken_, and subProcesses_.

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

◆ terminate()

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 222 of file SubProcess.h.

References schedule_, serviceToken_, and subProcesses_.

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

◆ thinnedAssociationsHelper() [1/2]

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

inlineprivate

Definition at line 265 of file SubProcess.h.

References edm::get_underlying_safe(), and thinnedAssociationsHelper_.

Referenced by SubProcess().

                                                                                      {
       return get_underlying_safe(thinnedAssociationsHelper_);
     }

◆ thinnedAssociationsHelper() [2/2]

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

inlineprivate

Definition at line 268 of file SubProcess.h.

References edm::get_underlying_safe(), and thinnedAssociationsHelper_.

                                                                          {
       return get_underlying_safe(thinnedAssociationsHelper_);
     }

◆ totalEvents()

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 198 of file SubProcess.h.

References schedule_.

198 { return schedule_->totalEvents(); }

edm::SubProcess::schedule_

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

Definition: SubProcess.h:295

◆ totalEventsFailed()

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 208 of file SubProcess.h.

References schedule_, and serviceToken_.

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

◆ totalEventsPassed()

int edm::SubProcess::totalEventsPassed ( ) const

inline

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

Definition at line 201 of file SubProcess.h.

References schedule_, and serviceToken_.

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

◆ updateBranchIDListHelper()

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

Definition at line 823 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()); });
   }

◆ writeLumiAsync()

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

Definition at line 683 of file SubProcess.cc.

References actReg_, dqmdumpme::first, edm::waiting_task::chain::ifThen(), edm::LuminosityBlockPrincipal::index(), inUseLumiPrincipals_, MainPageGenerator::l, eostools::move(), processContext_, edm::waiting_task::chain::runLast(), alignCSCRings::s, schedule_, serviceToken_, subProcesses_, and TrackValidation_cff::task.

                                                                                              {
     using namespace edm::waiting_task;
 
     auto l = inUseLumiPrincipals_[principal.index()];
     chain::first([&](std::exception_ptr const*, auto nextTask) {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->writeLumiAsync(nextTask, *l, &processContext_, actReg_.get());
     }) | chain::ifThen(not subProcesses_.empty(), [this, l](auto nextTask) {
       ServiceRegistry::Operate operateWriteLumi(serviceToken_);
       for (auto& s : subProcesses_) {
         s.writeLumiAsync(nextTask, *l);
       }
     }) | chain::runLast(std::move(task));
   }

◆ writeProcessBlockAsync()

void edm::SubProcess::writeProcessBlockAsync	(	edm::WaitingTaskHolder	task,
		ProcessBlockType	processBlockType
	)

Definition at line 599 of file SubProcess.cc.

References actReg_, dqmdumpme::first, edm::waiting_task::chain::ifThen(), eostools::move(), principalCache_, edm::PrincipalCache::processBlockPrincipal(), processContext_, edm::waiting_task::chain::runLast(), alignCSCRings::s, schedule_, serviceToken_, subProcesses_, and TrackValidation_cff::task.

Referenced by doEndProcessBlockAsync().

                                                                                                       {
     using namespace edm::waiting_task;
     chain::first([&](std::exception_ptr const*, auto nextTask) {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->writeProcessBlockAsync(
           nextTask, principalCache_.processBlockPrincipal(processBlockType), &processContext_, actReg_.get());
     }) | chain::ifThen(not subProcesses_.empty(), [this, processBlockType](auto nextTask) {
       ServiceRegistry::Operate operate(serviceToken_);
       for (auto& s : subProcesses_) {
         s.writeProcessBlockAsync(nextTask, processBlockType);
       }
     }) | chain::runLast(std::move(task));
   }

◆ writeRunAsync()

void edm::SubProcess::writeRunAsync	(	edm::WaitingTaskHolder	task,
		RunPrincipal const &	principal,
		MergeableRunProductMetadata const *	mergeableRunProductMetadata
	)

Definition at line 613 of file SubProcess.cc.

References actReg_, dqmdumpme::first, edm::waiting_task::chain::ifThen(), edm::RunPrincipal::index(), inUseRunPrincipals_, eostools::move(), processContext_, edm::waiting_task::chain::runLast(), alignCSCRings::s, schedule_, serviceToken_, subProcesses_, and TrackValidation_cff::task.

                                                                                                  {
     using namespace edm::waiting_task;
 
     auto rp = inUseRunPrincipals_[principal.index()];
     chain::first([&](std::exception_ptr const*, auto nextTask) {
       ServiceRegistry::Operate operate(serviceToken_);
       schedule_->writeRunAsync(nextTask, *rp, &processContext_, actReg_.get(), mergeableRunProductMetadata);
     }) | chain::ifThen(not subProcesses_.empty(), [this, rp, mergeableRunProductMetadata](auto nextTask) {
       ServiceRegistry::Operate operateWriteRun(serviceToken_);
       for (auto& s : subProcesses_) {
         s.writeRunAsync(nextTask, *rp, mergeableRunProductMetadata);
       }
     }) | chain::runLast(std::move(task));
   }

Member Data Documentation

◆ act_table_

std::unique_ptr<ExceptionToActionTable const> edm::SubProcess::act_table_

private

Definition at line 280 of file SubProcess.h.

Referenced by SubProcess().

◆ actReg_

std::shared_ptr<ActivityRegistry> edm::SubProcess::actReg_

private

Definition at line 272 of file SubProcess.h.

Referenced by keepOnlyConsumedUnscheduledModules(), SubProcess(), writeLumiAsync(), writeProcessBlockAsync(), and writeRunAsync().

◆ branchIDListHelper_

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

private

Definition at line 276 of file SubProcess.h.

Referenced by branchIDListHelper(), fixBranchIDListsForEDAliases(), processAsync(), SubProcess(), and updateBranchIDListHelper().

◆ droppedBranchIDToKeptBranchID_

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

private

Definition at line 314 of file SubProcess.h.

Referenced by droppedBranchIDToKeptBranchID(), selectProducts(), and SubProcess().

◆ esp_

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

private

Definition at line 294 of file SubProcess.h.

Referenced by beginJob(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), doEndLuminosityBlockAsync(), doEndRunAsync(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRunAsync(), doStreamEndLuminosityBlockAsync(), doStreamEndRunAsync(), processAsync(), and SubProcess().

◆ historyAppenders_

std::vector<HistoryAppender> edm::SubProcess::historyAppenders_

private

Definition at line 289 of file SubProcess.h.

Referenced by SubProcess().

◆ historyLumiOffset_

unsigned int edm::SubProcess::historyLumiOffset_

private

Definition at line 286 of file SubProcess.h.

Referenced by doBeginLuminosityBlockAsync(), and SubProcess().

◆ historyRunOffset_

unsigned int edm::SubProcess::historyRunOffset_

private

Definition at line 287 of file SubProcess.h.

Referenced by doBeginRunAsync(), and SubProcess().

◆ inUseLumiPrincipals_

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

private

Definition at line 293 of file SubProcess.h.

Referenced by clearLumiPrincipal(), doBeginLuminosityBlockAsync(), doEndLuminosityBlockAsync(), doStreamBeginLuminosityBlockAsync(), doStreamEndLuminosityBlockAsync(), processAsync(), SubProcess(), and writeLumiAsync().

◆ inUseRunPrincipals_

std::vector<std::shared_ptr<RunPrincipal> > edm::SubProcess::inUseRunPrincipals_

private

Definition at line 292 of file SubProcess.h.

Referenced by clearRunPrincipal(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), doEndRunAsync(), doStreamBeginRunAsync(), doStreamEndRunAsync(), SubProcess(), and writeRunAsync().

◆ keptProducts_

SelectedProductsForBranchType edm::SubProcess::keptProducts_

private

Definition at line 303 of file SubProcess.h.

Referenced by keepThisBranch(), and keptProducts().

◆ parentPreg_

std::shared_ptr<ProductRegistry const> edm::SubProcess::parentPreg_

private

Definition at line 274 of file SubProcess.h.

Referenced by beginJob().

◆ pathsAndConsumesOfModules_

PathsAndConsumesOfModules edm::SubProcess::pathsAndConsumesOfModules_

private

Definition at line 283 of file SubProcess.h.

Referenced by beginJob(), and keepOnlyConsumedUnscheduledModules().

◆ preg_

std::shared_ptr<ProductRegistry const> edm::SubProcess::preg_

private

Definition at line 275 of file SubProcess.h.

Referenced by beginJob(), keepOnlyConsumedUnscheduledModules(), and SubProcess().

◆ principalCache_

PrincipalCache edm::SubProcess::principalCache_

private

Definition at line 290 of file SubProcess.h.

Referenced by clearProcessBlockPrincipal(), doBeginLuminosityBlockAsync(), doBeginProcessBlockAsync(), doBeginRunAsync(), doEndProcessBlockAsync(), processAsync(), SubProcess(), and writeProcessBlockAsync().

◆ processBlockHelper_

edm::propagate_const<std::shared_ptr<SubProcessBlockHelper> > edm::SubProcess::processBlockHelper_

private

Definition at line 277 of file SubProcess.h.

Referenced by beginJob(), and SubProcess().

◆ processConfiguration_

std::shared_ptr<ProcessConfiguration const> edm::SubProcess::processConfiguration_

private

Definition at line 281 of file SubProcess.h.

Referenced by doBeginProcessBlockAsync(), keepOnlyConsumedUnscheduledModules(), and SubProcess().

◆ processContext_

ProcessContext edm::SubProcess::processContext_

private

Definition at line 282 of file SubProcess.h.

Referenced by beginJob(), SubProcess(), writeLumiAsync(), writeProcessBlockAsync(), and writeRunAsync().

◆ processHistoryRegistries_

std::vector<ProcessHistoryRegistry> edm::SubProcess::processHistoryRegistries_

private

Definition at line 288 of file SubProcess.h.

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

◆ processParameterSet_

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

private

Definition at line 297 of file SubProcess.h.

Referenced by SubProcess().

◆ productSelector_

ProductSelector edm::SubProcess::productSelector_

private

Definition at line 305 of file SubProcess.h.

Referenced by selectProducts().

◆ productSelectorRules_

ProductSelectorRules edm::SubProcess::productSelectorRules_

private

Definition at line 304 of file SubProcess.h.

Referenced by selectProducts().

◆ schedule_

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

private

Definition at line 295 of file SubProcess.h.

Referenced by Config.Process::_insertPaths(), Config.Process::_replaceInSchedule(), Config.Process::_replaceInScheduleDirectly(), beginJob(), clearCounters(), closeOutputFiles(), doBeginLuminosityBlockAsync(), doBeginProcessBlockAsync(), doBeginRunAsync(), doBeginStream(), doEndLuminosityBlockAsync(), doEndProcessBlockAsync(), doEndRunAsync(), doEndStream(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRunAsync(), doStreamEndLuminosityBlockAsync(), doStreamEndRunAsync(), Config.Process::dumpPython(), endJob(), getTriggerReport(), keepOnlyConsumedUnscheduledModules(), openOutputFiles(), processAsync(), Config.Process::prune(), Config.Process::resolve(), respondToCloseInputFile(), respondToOpenInputFile(), shouldWeCloseOutput(), Config.Process::splitPython(), SubProcess(), terminate(), totalEvents(), totalEventsFailed(), totalEventsPassed(), writeLumiAsync(), writeProcessBlockAsync(), and writeRunAsync().

◆ selector_config_id_

ParameterSetID edm::SubProcess::selector_config_id_

private

Definition at line 309 of file SubProcess.h.

Referenced by processAsync(), and SubProcess().

◆ selectors_

detail::TriggerResultsBasedEventSelector edm::SubProcess::selectors_

mutableprivate

Definition at line 310 of file SubProcess.h.

Referenced by doEventAsync(), and SubProcess().

◆ serviceToken_

◆ subProcesses_

std::vector<SubProcess> edm::SubProcess::subProcesses_

private

Definition at line 296 of file SubProcess.h.

Referenced by beginJob(), clearCounters(), clearLumiPrincipal(), clearProcessBlockPrincipal(), clearRunPrincipal(), closeOutputFiles(), doBeginLuminosityBlockAsync(), doBeginProcessBlockAsync(), doBeginRunAsync(), doBeginStream(), doEndLuminosityBlockAsync(), doEndProcessBlockAsync(), doEndRunAsync(), doEndStream(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRunAsync(), doStreamEndLuminosityBlockAsync(), doStreamEndRunAsync(), Config.Process::dumpConfig(), Config.Process::dumpPython(), endJob(), fixBranchIDListsForEDAliases(), keepOnlyConsumedUnscheduledModules(), openOutputFiles(), processAsync(), respondToCloseInputFile(), respondToOpenInputFile(), shouldWeCloseOutput(), Config.Process::splitPython(), SubProcess(), terminate(), updateBranchIDListHelper(), writeLumiAsync(), writeProcessBlockAsync(), and writeRunAsync().

◆ subProcessParentageHelper_

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

private

Definition at line 279 of file SubProcess.h.

Referenced by SubProcess().

◆ thinnedAssociationsHelper_

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

private

Definition at line 278 of file SubProcess.h.

Referenced by SubProcess(), and thinnedAssociationsHelper().

◆ wantAllEvents_

bool edm::SubProcess::wantAllEvents_

private

Definition at line 308 of file SubProcess.h.

Referenced by doEventAsync(), processAsync(), and SubProcess().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ProcessBlockType

Constructor & Destructor Documentation

◆ SubProcess() [1/3]

◆ ~SubProcess()

◆ SubProcess() [2/3]

◆ SubProcess() [3/3]

Member Function Documentation

◆ beginJob()

◆ branchIDListHelper() [1/2]

◆ branchIDListHelper() [2/2]

◆ clearCounters()

◆ clearLumiPrincipal()

◆ clearProcessBlockPrincipal()

◆ clearRunPrincipal()

◆ closeOutputFiles()

◆ doBeginJob()

◆ doBeginLuminosityBlockAsync()

◆ doBeginProcessBlockAsync() [1/3]

◆ doBeginProcessBlockAsync() [2/3]

◆ doBeginProcessBlockAsync() [3/3]

◆ doBeginRunAsync()

◆ doBeginStream()

◆ doEndJob()

◆ doEndLuminosityBlockAsync()

◆ doEndProcessBlockAsync()

◆ doEndRunAsync()

◆ doEndStream()

◆ doEventAsync()

◆ doStreamBeginLuminosityBlockAsync()

◆ doStreamBeginRunAsync()

◆ doStreamEndLuminosityBlockAsync()

◆ doStreamEndRunAsync()

◆ droppedBranchIDToKeptBranchID()

◆ endJob()

◆ fixBranchIDListsForEDAliases()

◆ getAllModuleDescriptions()

◆ getTriggerReport()

◆ keepOnlyConsumedUnscheduledModules()

◆ keepThisBranch()

◆ keptProducts()

◆ openOutputFiles()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ parentProducedProductIsKept()

◆ processAsync()

◆ propagateProducts()

◆ respondToCloseInputFile()

◆ respondToOpenInputFile()

◆ selectProducts()

◆ shouldWeCloseOutput()

◆ terminate()

◆ thinnedAssociationsHelper() [1/2]

◆ thinnedAssociationsHelper() [2/2]

◆ totalEvents()

◆ totalEventsFailed()

◆ totalEventsPassed()

◆ updateBranchIDListHelper()

◆ writeLumiAsync()

◆ writeProcessBlockAsync()

◆ writeRunAsync()

Member Data Documentation

◆ act_table_

◆ actReg_

◆ branchIDListHelper_

◆ droppedBranchIDToKeptBranchID_

◆ esp_

◆ historyAppenders_

◆ historyLumiOffset_

◆ historyRunOffset_

◆ inUseLumiPrincipals_

◆ inUseRunPrincipals_

◆ keptProducts_

◆ parentPreg_