edm::SubProcess Class Reference

#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 (ProcessHistoryID const &parentPhID, int runNumber, int lumiNumber)
void	deleteRunFromCache (ProcessHistoryID const &parentPhID, int runNumber)
void	doBeginJob ()
void	doBeginLuminosityBlock (LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts)
void	doBeginLuminosityBlockAsync (WaitingTaskHolder iHolder, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts)
void	doBeginRun (RunPrincipal const &principal, IOVSyncValue const &ts)
void	doBeginRunAsync (WaitingTaskHolder iHolder, RunPrincipal const &principal, IOVSyncValue const &ts)
void	doBeginStream (unsigned int)
void	doEndJob ()
void	doEndLuminosityBlock (LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)
void	doEndRun (RunPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)
void	doEndStream (unsigned int)
void	doEventAsync (WaitingTaskHolder iHolder, EventPrincipal const &principal)
void	doStreamBeginLuminosityBlock (unsigned int iID, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts)
void	doStreamBeginLuminosityBlockAsync (WaitingTaskHolder iHolder, unsigned int iID, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts)
void	doStreamBeginRun (unsigned int iID, RunPrincipal const &principal, IOVSyncValue const &ts)
void	doStreamBeginRunAsync (WaitingTaskHolder iHolder, unsigned int iID, RunPrincipal const &principal, IOVSyncValue const &ts)
void	doStreamEndLuminosityBlock (unsigned int iID, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)
void	doStreamEndLuminosityBlockAsync (WaitingTaskHolder iHolder, unsigned int iID, LuminosityBlockPrincipal const &principal, IOVSyncValue const &ts, bool cleaningUpAfterException)
void	doStreamEndRun (unsigned int iID, RunPrincipal 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	openNewOutputFilesIfNeeded ()
void	openOutputFiles (FileBlock &fb)
SubProcess &	operator= (SubProcess const &)=delete
SubProcess &	operator= (SubProcess &&)=default
void	postForkReacquireResources (unsigned int iChildIndex, unsigned int iNumberOfChildren)
void	preForkReleaseResources ()
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	writeLumi (ProcessHistoryID const &parentPhID, int runNumber, int lumiNumber)
void	writeRun (ProcessHistoryID const &parentPhID, int runNumber)
virtual	~SubProcess ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	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
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_
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 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 43 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 44 of file SubProcess.cc.

References edm::ScheduleItems::act_table_, act_table_, edm::ScheduleItems::actReg_, actReg_, edm::ScheduleItems::addCPRandTNS(), edm::ScheduleItems::branchIDListHelper(), branchIDListHelper(), branchIDListHelper_, edm::detail::configureEventSelector(), edm::ActivityRegistry::connectToSubProcess(), edm::EDConsumerBase::consumesCollector(), droppedBranchIDToKeptBranchID_, esp_, edm::ParameterSet::exists(), edm::getAllTriggerNames(), edm::ParameterSet::getUntrackedParameterSet(), historyAppenders_, historyRunOffset_, diffTreeTool::index, edm::ScheduleItems::initMisc(), edm::ScheduleItems::initSchedule(), edm::ScheduleItems::initServices(), edm::PrincipalCache::insert(), mps_monitormerge::items, edm::eventsetup::EventSetupsController::makeProvider(), Data_TkAlMuonIsolated_Run2015B_PromptReco_v1_cff::maxEvents, eostools::move(), edm::PreallocationConfiguration::numberOfStreams(), cmsPerfStripChart::operate(), edm::ParameterSet::popParameterSet(), edm::popSubProcessVParameterSet(), edm::ScheduleItems::preg(), preg_, principalCache_, edm::ScheduleItems::processConfiguration(), 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(), edm::IllegalParameters::setThrowAnException(), AlCaHLTBitMon_QueryRunRegistry::string, subProcesses_, edm::ScheduleItems::subProcessParentageHelper(), subProcessParentageHelper_, edm::ScheduleItems::thinnedAssociationsHelper(), thinnedAssociationsHelper(), thinnedAssociationsHelper_, ull, updateBranchIDListHelper(), 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;

    ScheduleItems items(*parentProductRegistry, *this);
    actReg_ = items.actReg_;

    ParameterSet const& optionsPset(processParameterSet_->getUntrackedParameterSet("options", ParameterSet()));
    IllegalParameters::setThrowAnException(optionsPset.getUntrackedParameter<bool>("throwIfIllegalParameter", true));

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

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

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

virtual

Definition at line 205 of file SubProcess.cc.

{}

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

delete

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

default

Member Function Documentation

void edm::SubProcess::beginJob ( void  )

private

Definition at line 219 of file SubProcess.cc.

References actReg_, edm::checkForModuleDependencyCorrectness(), droppedBranchIDToKeptBranchID(), fixBranchIDListsForEDAliases(), edm::for_all(), edm::InEvent, edm::PathsAndConsumesOfModules::initialize(), cmsPerfStripChart::operate(), parentPreg_, pathsAndConsumesOfModules_, preg_, 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_);
    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

Definition at line 509 of file SubProcess.cc.

References printConversionInfo::aux, edm::LuminosityBlockPrincipal::aux(), esp_, edm::for_all(), historyAppenders_, historyLumiOffset_, edm::LuminosityBlockPrincipal::index(), edm::InLumi, edm::PrincipalCache::insert(), edm::PrincipalCache::lumiPrincipalPtr(), preg_, principalCache_, processConfiguration_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, propagateProducts(), edm::Principal::reader(), edm::PrincipalCache::runPrincipalPtr(), schedule_, and subProcesses_.

Referenced by doBeginLuminosityBlock().

                                                                                                    {
    auto aux = std::make_shared<LuminosityBlockAuxiliary>(principal.aux());
    aux->setProcessHistoryID(principal.processHistoryID());
    auto lbpp = std::make_shared<LuminosityBlockPrincipal>(aux, preg_, *processConfiguration_, &(historyAppenders_[historyLumiOffset_+principal.index()]),principal.index(),false);
    auto & processHistoryRegistry = processHistoryRegistries_[historyLumiOffset_+principal.index()];
    processHistoryRegistry.registerProcessHistory(principal.processHistory());
    lbpp->fillLuminosityBlockPrincipal(processHistoryRegistry, principal.reader());
    lbpp->setRunPrincipal(principalCache_.runPrincipalPtr());
    principalCache_.insert(lbpp);
    LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
    propagateProducts(InLumi, principal, lbp);
    typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalBegin> Traits;
    schedule_->processOneGlobal<Traits>(lbp, esp_->eventSetupForInstance(ts));
    for_all(subProcesses_, [&lbp, &ts](auto& subProcess){ subProcess.doBeginLuminosityBlock(lbp, ts); });
  }

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

private

Definition at line 416 of file SubProcess.cc.

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

Referenced by doBeginRun().

                                                                            {
    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;
    schedule_->processOneGlobal<Traits>(rp, esp_->eventSetupForInstance(ts));
    for_all(subProcesses_, [&rp, &ts](auto& subProcess){ subProcess.doBeginRun(rp, ts); });
  }

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

inlineprivate

Definition at line 275 of file SubProcess.h.

References edm::get_underlying_safe().

Referenced by SubProcess().

{return get_underlying_safe(branchIDListHelper_);}

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

inlineprivate

Definition at line 276 of file SubProcess.h.

References edm::get_underlying_safe().

{return get_underlying_safe(branchIDListHelper_);}

void edm::SubProcess::clearCounters ( )

inline

Clear all the counters in the trigger report.

Definition at line 250 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 128 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	(	ProcessHistoryID const &	parentPhID,
		int	runNumber,
		int	lumiNumber
	)

Definition at line 576 of file SubProcess.cc.

References edm::PrincipalCache::deleteLumi(), 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_.deleteLumi(childPhID, runNumber, lumiNumber);
    for_all(subProcesses_, [&childPhID, runNumber, lumiNumber](auto& subProcess){ subProcess.deleteLumiFromCache(childPhID, runNumber, lumiNumber); });
  }

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

Definition at line 494 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 208 of file SubProcess.cc.

References beginJob().

                         {
    this->beginJob();
  }

void edm::SubProcess::doBeginLuminosityBlock	(	LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 503 of file SubProcess.cc.

References beginLuminosityBlock(), cmsPerfStripChart::operate(), and serviceToken_.

                                                                                                      {
    ServiceRegistry::Operate operate(serviceToken_);
    beginLuminosityBlock(principal,ts);
  }

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

Definition at line 526 of file SubProcess.cc.

References printConversionInfo::aux, edm::LuminosityBlockPrincipal::aux(), esp_, historyAppenders_, historyLumiOffset_, edm::LuminosityBlockPrincipal::index(), edm::InLumi, edm::PrincipalCache::insert(), edm::PrincipalCache::lumiPrincipalPtr(), eostools::move(), cmsPerfStripChart::operate(), preg_, principalCache_, processConfiguration_, 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 = std::make_shared<LuminosityBlockAuxiliary>(principal.aux());
    aux->setProcessHistoryID(principal.processHistoryID());
    auto lbpp = std::make_shared<LuminosityBlockPrincipal>(aux, preg_, *processConfiguration_, &(historyAppenders_[historyLumiOffset_+principal.index()]),principal.index(),false);
    auto & processHistoryRegistry = processHistoryRegistries_[historyLumiOffset_+principal.index()];
    processHistoryRegistry.registerProcessHistory(principal.processHistory());
    lbpp->fillLuminosityBlockPrincipal(processHistoryRegistry, principal.reader());
    lbpp->setRunPrincipal(principalCache_.runPrincipalPtr());
    principalCache_.insert(lbpp);
    LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
    propagateProducts(InLumi, principal, lbp);
    typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalBegin> Traits;
    beginGlobalTransitionAsync<Traits>(std::move(iHolder),
                                       *schedule_,
                                       lbp,
                                       ts,
                                       esp_->eventSetupForInstance(ts),
                                       subProcesses_);
  }

void edm::SubProcess::doBeginRun	(	RunPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 410 of file SubProcess.cc.

References beginRun(), cmsPerfStripChart::operate(), and serviceToken_.

                                                                              {
    ServiceRegistry::Operate operate(serviceToken_);
    beginRun(principal,ts);
  }

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

Definition at line 438 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_->eventSetupForInstance(ts),
                                       subProcesses_);
  }

void edm::SubProcess::doBeginStream

(

unsigned int

iID

)

Definition at line 585 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 213 of file SubProcess.cc.

References endJob().

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

                       {
    endJob();
  }

void edm::SubProcess::doEndLuminosityBlock	(	LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

Definition at line 549 of file SubProcess.cc.

References endLuminosityBlock(), cmsPerfStripChart::operate(), and serviceToken_.

                                                                                                                                   {
    ServiceRegistry::Operate operate(serviceToken_);
    endLuminosityBlock(principal,ts,cleaningUpAfterException);
  }

void edm::SubProcess::doEndRun	(	RunPrincipal const &	principal,
		IOVSyncValue const &	ts,
		bool	cleaningUpAfterException
	)

Definition at line 467 of file SubProcess.cc.

References endRun(), cmsPerfStripChart::operate(), and serviceToken_.

                                                                                                           {
    ServiceRegistry::Operate operate(serviceToken_);
    endRun(principal,ts,cleaningUpAfterException);
  }

void edm::SubProcess::doEndStream

(

unsigned int

iID

)

Definition at line 592 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 333 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::doStreamBeginLuminosityBlock	(	unsigned int	iID,
		LuminosityBlockPrincipal const &	principal,
		IOVSyncValue const &	ts
	)

Definition at line 657 of file SubProcess.cc.

References esp_, edm::for_all(), hcalTTPDigis_cfi::id, edm::PrincipalCache::lumiPrincipalPtr(), cmsPerfStripChart::operate(), principalCache_, schedule_, serviceToken_, and subProcesses_.

                                                                                                                             {
    ServiceRegistry::Operate operate(serviceToken_);
    {
      LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
      typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamBegin> Traits;
      schedule_->processOneStream<Traits>(id,lbp, esp_->eventSetupForInstance(ts));
      for_all(subProcesses_, [id, &lbp, &ts](auto& subProcess){ subProcess.doStreamBeginLuminosityBlock(id,lbp, ts); });
    }
  }

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

Definition at line 667 of file SubProcess.cc.

References esp_, hcalTTPDigis_cfi::id, edm::PrincipalCache::lumiPrincipalPtr(), eostools::move(), cmsPerfStripChart::operate(), principalCache_, schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamBeginTransitionAsync().

                                                                                                                                    {
    ServiceRegistry::Operate operate(serviceToken_);
    
    typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamBegin> Traits;
    
    LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
    
    beginStreamTransitionAsync<Traits>(std::move(iHolder),
                                       *schedule_,
                                       id,
                                       lbp,
                                       ts,
                                       esp_->eventSetupForInstance(ts),
                                       subProcesses_);
  }

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

Definition at line 599 of file SubProcess.cc.

References esp_, edm::for_all(), hcalTTPDigis_cfi::id, cmsPerfStripChart::operate(), principalCache_, edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

                                                                                                     {
    ServiceRegistry::Operate operate(serviceToken_);
    {
      RunPrincipal& rp = *principalCache_.runPrincipalPtr();
      typedef OccurrenceTraits<RunPrincipal, BranchActionStreamBegin> Traits;
      schedule_->processOneStream<Traits>(id,rp, esp_->eventSetupForInstance(ts));
      for_all(subProcesses_, [id, &rp, &ts](auto& subProcess){ subProcess.doStreamBeginRun(id,rp, ts); });
    }
  }

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

Definition at line 609 of file SubProcess.cc.

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

Referenced by edm::subProcessDoStreamBeginTransitionAsync().

                                                                                                            {
    ServiceRegistry::Operate operate(serviceToken_);
    
    typedef OccurrenceTraits<RunPrincipal, BranchActionStreamBegin> Traits;

    RunPrincipal& rp = *principalCache_.runPrincipalPtr();

    beginStreamTransitionAsync<Traits>(std::move(iHolder),
                                       *schedule_,
                                       id,
                                       rp,
                                       ts,
                                       esp_->eventSetupForInstance(ts),
                                       subProcesses_);
    
  }

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

Definition at line 687 of file SubProcess.cc.

References esp_, edm::for_all(), hcalTTPDigis_cfi::id, edm::PrincipalCache::lumiPrincipalPtr(), cmsPerfStripChart::operate(), principalCache_, schedule_, serviceToken_, and subProcesses_.

                                                                                                                                                          {
    ServiceRegistry::Operate operate(serviceToken_);
    {
      LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
      typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamEnd> Traits;
      schedule_->processOneStream<Traits>(id,lbp, esp_->eventSetupForInstance(ts),cleaningUpAfterException);
      for_all(subProcesses_, [id, &lbp, &ts, cleaningUpAfterException](auto& subProcess){ subProcess.doStreamEndLuminosityBlock(id,lbp, ts,cleaningUpAfterException); });
    }
  }

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

Definition at line 698 of file SubProcess.cc.

References esp_, hcalTTPDigis_cfi::id, edm::PrincipalCache::lumiPrincipalPtr(), eostools::move(), cmsPerfStripChart::operate(), principalCache_, schedule_, serviceToken_, and subProcesses_.

Referenced by edm::subProcessDoStreamEndTransitionAsync().

                                                                                                                                                                 {
    ServiceRegistry::Operate operate(serviceToken_);
    
    LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
    typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamEnd> Traits;
    endStreamTransitionAsync<Traits>(std::move(iHolder),
                                       *schedule_,
                                       id,
                                       lbp,
                                       ts,
                                       esp_->eventSetupForInstance(ts),
                                       subProcesses_,
                                       cleaningUpAfterException);
  }

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

Definition at line 629 of file SubProcess.cc.

References esp_, edm::for_all(), hcalTTPDigis_cfi::id, cmsPerfStripChart::operate(), principalCache_, edm::PrincipalCache::runPrincipalPtr(), schedule_, serviceToken_, and subProcesses_.

                                                                                                                                  {
    ServiceRegistry::Operate operate(serviceToken_);
    {
      RunPrincipal& rp = *principalCache_.runPrincipalPtr();
      typedef OccurrenceTraits<RunPrincipal, BranchActionStreamEnd> Traits;
      schedule_->processOneStream<Traits>(id,rp, esp_->eventSetupForInstance(ts),cleaningUpAfterException);
      for_all(subProcesses_, [id, &rp, &ts, cleaningUpAfterException](auto& subProcess){ subProcess.doStreamEndRun(id,rp, ts,cleaningUpAfterException); });
    }
  }

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

Definition at line 640 of file SubProcess.cc.

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

Referenced by edm::subProcessDoStreamEndTransitionAsync().

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

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

inlineprivate

Definition at line 271 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 215 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 239 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

Definition at line 555 of file SubProcess.cc.

References esp_, edm::for_all(), edm::InLumi, edm::PrincipalCache::lumiPrincipalPtr(), principalCache_, propagateProducts(), schedule_, edm::Principal::setAtEndTransition(), edm::LuminosityBlockPrincipal::setComplete(), and subProcesses_.

Referenced by doEndLuminosityBlock().

                                                                                                                                 {
    LuminosityBlockPrincipal& lbp = *principalCache_.lumiPrincipalPtr();
    lbp.setComplete();
    propagateProducts(InLumi, principal, lbp);
    typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalEnd> Traits;
    lbp.setAtEndTransition(true);
    schedule_->processOneGlobal<Traits>(lbp, esp_->eventSetupForInstance(ts), cleaningUpAfterException);
    for_all(subProcesses_, [&lbp, &ts, cleaningUpAfterException](auto& subProcess){ subProcess.doEndLuminosityBlock(lbp, ts, cleaningUpAfterException); });
  }

bool edm::SubProcess::endPathsEnabled ( ) const

inline

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

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

Definition at line 473 of file SubProcess.cc.

References esp_, edm::for_all(), edm::InRun, principalCache_, propagateProducts(), edm::PrincipalCache::runPrincipalPtr(), schedule_, edm::Principal::setAtEndTransition(), edm::RunPrincipal::setComplete(), and subProcesses_.

Referenced by doEndRun().

                                                                                                         {
    RunPrincipal& rp = *principalCache_.runPrincipalPtr();
    rp.setComplete();
    propagateProducts(InRun, principal, rp);
    typedef OccurrenceTraits<RunPrincipal, BranchActionGlobalEnd> Traits;
    rp.setAtEndTransition(true);
    schedule_->processOneGlobal<Traits>(rp, esp_->eventSetupForInstance(ts), cleaningUpAfterException);
    for_all(subProcesses_, [&rp, &ts, cleaningUpAfterException](auto& subProcess){ subProcess.doEndRun(rp, ts, cleaningUpAfterException); });
  }

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

private

Definition at line 318 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 229 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 294 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 70 of file SubProcess.h.

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

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

{return keptProducts_;}

void edm::SubProcess::openNewOutputFilesIfNeeded ( )

inline

Definition at line 135 of file SubProcess.h.

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

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

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

inline

Definition at line 142 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::postForkReacquireResources ( unsigned int  iChildIndex, unsigned int  iNumberOfChildren  )

inline

Definition at line 180 of file SubProcess.h.

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

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

void edm::SubProcess::preForkReleaseResources ( )

inline

Definition at line 174 of file SubProcess.h.

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

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

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

private

Definition at line 349 of file SubProcess.cc.

References edm::ProductRegistry::anyProductProduced(), printConversionInfo::aux, edm::EventPrincipal::aux(), branchIDListHelper_, edm::EventPrincipal::branchListIndexes(), edm::EventPrincipal::clearEventPrincipal(), edm::WaitingTaskHolder::doneWaiting(), esp_, edm::PrincipalCache::eventPrincipal(), edm::EventPrincipal::eventSelectionIDs(), edm::EventPrincipal::fillEventPrincipal(), edm::InEvent, edm::PrincipalCache::lumiPrincipalPtr(), edm::make_waiting_task(), eostools::move(), principalCache_, edm::Principal::processHistory(), edm::Principal::processHistoryID(), processHistoryRegistries_, edm::EventPrincipal::productProvenanceRetrieverPtr(), edm::Principal::productRegistry(), propagateProducts(), edm::Principal::reader(), groupFilesInBlocks::reverse, schedule_, selector_config_id_, edm::EventPrincipal::setLuminosityBlockPrincipal(), edm::EventPrincipal::streamID(), subProcesses_, 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,
                          processHistoryRegistry,
                          std::move(esids),
                          std::move(bli),
                          *(principal.productProvenanceRetrieverPtr()),//NOTE: this transfers the per product provenance
                          principal.reader(),
                          deepCopyRetriever);
    ep.setLuminosityBlockPrincipal(principalCache_.lumiPrincipalPtr());
    propagateProducts(InEvent, principal, ep);
    
    WaitingTaskHolder finalizeEventTask( make_waiting_task(tbb::task::allocate_root(),
                                                           [this,&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());
  }

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

private

Definition at line 716 of file SubProcess.cc.

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

Referenced by beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), endLuminosityBlock(), endRun(), 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 154 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 739 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 252 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 161 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 236 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 277 of file SubProcess.h.

References edm::get_underlying_safe().

Referenced by SubProcess().

{return get_underlying_safe(thinnedAssociationsHelper_);}

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

inlineprivate

Definition at line 278 of file SubProcess.h.

References edm::get_underlying_safe().

{return get_underlying_safe(thinnedAssociationsHelper_);}

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

References cmsPerfStripChart::operate().

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

void edm::SubProcess::updateBranchIDListHelper

(

BranchIDLists const &

branchIDLists

)

Definition at line 732 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::writeLumi	(	ProcessHistoryID const &	parentPhID,
		int	runNumber,
		int	lumiNumber
	)

Definition at line 566 of file SubProcess.cc.

References edm::for_all(), edm::PrincipalCache::lumiPrincipal(), cmsPerfStripChart::operate(), parentToChildPhID_, principalCache_, processContext_, 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;
    schedule_->writeLumi(principalCache_.lumiPrincipal(childPhID, runNumber, lumiNumber), &processContext_);
    for_all(subProcesses_, [&childPhID, runNumber, lumiNumber](auto& subProcess){ subProcess.writeLumi(childPhID, runNumber, lumiNumber); });
  }

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

Definition at line 484 of file SubProcess.cc.

References edm::for_all(), cmsPerfStripChart::operate(), parentToChildPhID_, principalCache_, processContext_, edm::PrincipalCache::runPrincipal(), 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;
    schedule_->writeRun(principalCache_.runPrincipal(childPhID, runNumber), &processContext_);
    for_all(subProcesses_, [&childPhID, runNumber](auto& subProcess){ subProcess.writeRun(childPhID, runNumber); });
  }

Member Data Documentation

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

private

Definition at line 287 of file SubProcess.h.

Referenced by SubProcess().

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

private

Definition at line 280 of file SubProcess.h.

Referenced by beginJob(), and SubProcess().

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

private

Definition at line 284 of file SubProcess.h.

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

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

private

Definition at line 319 of file SubProcess.h.

Referenced by selectProducts(), and SubProcess().

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

private

Definition at line 298 of file SubProcess.h.

Referenced by beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), doStreamBeginLuminosityBlock(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRun(), doStreamBeginRunAsync(), doStreamEndLuminosityBlock(), doStreamEndLuminosityBlockAsync(), doStreamEndRun(), doStreamEndRunAsync(), endLuminosityBlock(), endRun(), processAsync(), and SubProcess().

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

private

Definition at line 296 of file SubProcess.h.

Referenced by beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), and SubProcess().

unsigned int edm::SubProcess::historyLumiOffset_

private

Definition at line 293 of file SubProcess.h.

Referenced by beginLuminosityBlock(), and doBeginLuminosityBlockAsync().

unsigned int edm::SubProcess::historyRunOffset_

private

Definition at line 294 of file SubProcess.h.

Referenced by beginRun(), doBeginRunAsync(), and SubProcess().

SelectedProductsForBranchType edm::SubProcess::keptProducts_

private

Definition at line 308 of file SubProcess.h.

Referenced by keepThisBranch().

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

private

Definition at line 282 of file SubProcess.h.

Referenced by beginJob().

std::map<ProcessHistoryID, ProcessHistoryID> edm::SubProcess::parentToChildPhID_

private

Definition at line 300 of file SubProcess.h.

Referenced by beginRun(), deleteLumiFromCache(), deleteRunFromCache(), doBeginRunAsync(), writeLumi(), and writeRun().

PathsAndConsumesOfModules edm::SubProcess::pathsAndConsumesOfModules_

private

Definition at line 290 of file SubProcess.h.

Referenced by beginJob().

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

private

Definition at line 283 of file SubProcess.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), and SubProcess().

PrincipalCache edm::SubProcess::principalCache_

private

Definition at line 297 of file SubProcess.h.

Referenced by beginLuminosityBlock(), beginRun(), deleteLumiFromCache(), deleteRunFromCache(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), doStreamBeginLuminosityBlock(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRun(), doStreamBeginRunAsync(), doStreamEndLuminosityBlock(), doStreamEndLuminosityBlockAsync(), doStreamEndRun(), doStreamEndRunAsync(), endLuminosityBlock(), endRun(), processAsync(), SubProcess(), writeLumi(), and writeRun().

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

private

Definition at line 288 of file SubProcess.h.

Referenced by beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), and SubProcess().

ProcessContext edm::SubProcess::processContext_

private

Definition at line 289 of file SubProcess.h.

Referenced by beginJob(), SubProcess(), writeLumi(), and writeRun().

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

private

Definition at line 295 of file SubProcess.h.

Referenced by beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), processAsync(), and SubProcess().

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

private

Definition at line 302 of file SubProcess.h.

Referenced by SubProcess().

ProductSelector edm::SubProcess::productSelector_

private

Definition at line 310 of file SubProcess.h.

Referenced by selectProducts().

ProductSelectorRules edm::SubProcess::productSelectorRules_

private

Definition at line 309 of file SubProcess.h.

Referenced by selectProducts().

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

private

Definition at line 299 of file SubProcess.h.

Referenced by Config.Process::_insertPaths(), Config.Process::_replaceInSchedule(), beginJob(), beginLuminosityBlock(), beginRun(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), doBeginStream(), doEndStream(), doStreamBeginLuminosityBlock(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRun(), doStreamBeginRunAsync(), doStreamEndLuminosityBlock(), doStreamEndLuminosityBlockAsync(), doStreamEndRun(), doStreamEndRunAsync(), Config.Process::dumpPython(), endJob(), endLuminosityBlock(), endRun(), processAsync(), Config.Process::prune(), respondToOpenInputFile(), SubProcess(), writeLumi(), and writeRun().

ParameterSetID edm::SubProcess::selector_config_id_

private

Definition at line 314 of file SubProcess.h.

Referenced by processAsync(), and SubProcess().

detail::TriggerResultsBasedEventSelector edm::SubProcess::selectors_

mutableprivate

Definition at line 315 of file SubProcess.h.

Referenced by doEventAsync(), and SubProcess().

ServiceToken edm::SubProcess::serviceToken_

private

Definition at line 281 of file SubProcess.h.

Referenced by beginJob(), doBeginLuminosityBlock(), doBeginLuminosityBlockAsync(), doBeginRun(), doBeginRunAsync(), doBeginStream(), doEndLuminosityBlock(), doEndRun(), doEndStream(), doEventAsync(), doStreamBeginLuminosityBlock(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRun(), doStreamBeginRunAsync(), doStreamEndLuminosityBlock(), doStreamEndLuminosityBlockAsync(), doStreamEndRun(), doStreamEndRunAsync(), endJob(), respondToOpenInputFile(), SubProcess(), writeLumi(), and writeRun().

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

private

Definition at line 301 of file SubProcess.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), deleteLumiFromCache(), deleteRunFromCache(), doBeginLuminosityBlockAsync(), doBeginRunAsync(), doBeginStream(), doEndStream(), doStreamBeginLuminosityBlock(), doStreamBeginLuminosityBlockAsync(), doStreamBeginRun(), doStreamBeginRunAsync(), doStreamEndLuminosityBlock(), doStreamEndLuminosityBlockAsync(), doStreamEndRun(), doStreamEndRunAsync(), Config.Process::dumpConfig(), Config.Process::dumpPython(), endJob(), endLuminosityBlock(), endRun(), fixBranchIDListsForEDAliases(), processAsync(), respondToOpenInputFile(), SubProcess(), updateBranchIDListHelper(), writeLumi(), and writeRun().

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

private

Definition at line 286 of file SubProcess.h.

Referenced by SubProcess().

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

private

Definition at line 285 of file SubProcess.h.

Referenced by SubProcess().

bool edm::SubProcess::wantAllEvents_

private

Definition at line 313 of file SubProcess.h.

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