Inheritance diagram for DQMRootOutputModule:

Public Member Functions
void	beginJob () override

	DQMRootOutputModule (edm::ParameterSet const &pset)

	~DQMRootOutputModule () override

Public Member Functions inherited from edm::one::OutputModule<>
SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const OutputModule &	operator= (const OutputModule &)=delete

	OutputModule (edm::ParameterSet const &iPSet)

	OutputModule (const OutputModule &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

Public Member Functions inherited from edm::one::OutputModuleBase
OutputModuleBase &	operator= (OutputModuleBase const &)=delete

	OutputModuleBase (ParameterSet const &pset)

	OutputModuleBase (OutputModuleBase const &)=delete

SharedResourcesAcquirer &	sharedResourcesAcquirer ()

SubProcessParentageHelper const *	subProcessParentageHelper () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

Public Member Functions inherited from edm::core::OutputModuleCore
BranchIDLists const *	branchIDLists () const

std::array< bool, NumBranchTypes > const &	hasNewlyDroppedBranch () const

SelectedProductsForBranchType const &	keptProducts () const

int	maxEvents () const

const ModuleDescription &	moduleDescription () const

OutputModuleCore &	operator= (OutputModuleCore const &)=delete

	OutputModuleCore (ParameterSet const &pset)

	OutputModuleCore (OutputModuleCore const &)=delete

OutputProcessBlockHelper const &	outputProcessBlockHelper () const

std::string const &	processName () const

int	remainingEvents () const

bool	selected (BranchDescription const &desc) const

void	selectProducts (ProductRegistry const &preg, ThinnedAssociationsHelper const &, ProcessBlockHelperBase const &)

ThinnedAssociationsHelper const *	thinnedAssociationsHelper () const

bool	wantAllEvents () const

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

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

std::vector< ESProxyIndex > 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

bool	registeredToConsumeMany (TypeID const &, 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::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::core::OutputModuleCore
static const std::string &	baseType ()

static void	fillDescription (ParameterSetDescription &desc, std::vector< std::string > const &iDefaultOutputCommands=ProductSelectorRules::defaultSelectionStrings())

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
void	finishEndFile ()

bool	isFileOpen () const override

void	openFile (edm::FileBlock const &) override

void	reallyCloseFile () override

void	startEndFile ()

void	write (edm::EventForOutput const &e) override

void	writeLuminosityBlock (edm::LuminosityBlockForOutput const &) override

void	writeRun (edm::RunForOutput const &) override

Private Attributes
ULong64_t	m_beginTime

std::map< unsigned int, unsigned int >	m_dqmKindToTypeIndex

ULong64_t	m_endTime

std::unique_ptr< TFile >	m_file

std::string	m_fileName

unsigned int	m_filterOnRun

ULong64_t	m_firstIndex

std::string	m_fullNameBuffer

std::string *	m_fullNameBufferPtr

TTree *	m_indicesTree

edm::JobReport::Token	m_jrToken

ULong64_t	m_lastIndex

std::string	m_logicalFileName

unsigned int	m_lumi

unsigned int	m_presentHistoryIndex

edm::ProcessHistoryRegistry	m_processHistoryRegistry

unsigned int	m_run

std::vector < edm::ProcessHistoryID >	m_seenHistories

std::vector< std::shared_ptr < TreeHelperBase > >	m_treeHelpers

unsigned int	m_type

Additional Inherited Members
Public Types inherited from edm::one::OutputModuleBase
typedef OutputModuleBase	ModuleType

Public Types inherited from edm::core::OutputModuleCore
typedef OutputModuleCore	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::one::OutputModuleBase
void	configure (OutputModuleDescription const &desc)

void	doBeginJob ()

bool	doEvent (EventTransitionInfo const &, ActivityRegistry , ModuleCallingContext const )

void	doPreallocate (PreallocationConfiguration const &)

Protected Member Functions inherited from edm::core::OutputModuleCore
void	configure (OutputModuleDescription const &desc)

ModuleDescription const &	description () const

void	doAccessInputProcessBlock (ProcessBlockPrincipal const &, ModuleCallingContext const *)

void	doBeginJob_ ()

bool	doBeginLuminosityBlock (LumiTransitionInfo const &, ModuleCallingContext const *)

void	doBeginProcessBlock (ProcessBlockPrincipal const &, ModuleCallingContext const *)

bool	doBeginRun (RunTransitionInfo const &, ModuleCallingContext const *)

void	doEndJob ()

bool	doEndLuminosityBlock (LumiTransitionInfo const &, ModuleCallingContext const *)

void	doEndProcessBlock (ProcessBlockPrincipal const &, ModuleCallingContext const *)

bool	doEndRun (RunTransitionInfo const &, ModuleCallingContext const *)

bool	doEvent_ (EventTransitionInfo const &, ActivityRegistry , ModuleCallingContext const )

void	doPreallocate_ (PreallocationConfiguration const &)

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

virtual void	preallocLumis (unsigned int)

ParameterSetID	selectorConfig () const

void	setEventSelectionInfo (std::map< std::string, std::vector< std::pair< std::string, int >>> const &outputModulePathPositions, bool anyProductProduced)

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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

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

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

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

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

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

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)

Protected Attributes inherited from edm::core::OutputModuleCore
std::atomic< int >	remainingEvents_

Detailed Description

Definition at line 198 of file DQMRootOutputModule.cc.

Constructor & Destructor Documentation

DQMRootOutputModule::DQMRootOutputModule ( edm::ParameterSet const & pset )

explicit

Definition at line 282 of file DQMRootOutputModule.cc.

     : edm::one::OutputModuleBase::OutputModuleBase(pset),
       edm::one::OutputModule<>(pset),
       m_fileName(pset.getUntrackedParameter<std::string>("fileName")),
       m_logicalFileName(pset.getUntrackedParameter<std::string>("logicalFileName")),
       m_file(nullptr),
       m_treeHelpers(kNIndicies, std::shared_ptr<TreeHelperBase>()),
       m_presentHistoryIndex(0),
       m_filterOnRun(pset.getUntrackedParameter<unsigned int>("filterOnRun")),
       m_fullNameBufferPtr(&m_fullNameBuffer),
       m_indicesTree(nullptr) {
   // Declare dependencies for all Lumi and Run tokens here. In
   // principle could use the keep statements, but then DQMToken would
   // have to be made persistent (transient products are ignored),
   // which would lead to a need to (finally) remove underscores from
   // DQM module labels.
   consumesMany<DQMToken, edm::InLumi>();
   consumesMany<DQMToken, edm::InRun>();
 }

DQMRootOutputModule::~DQMRootOutputModule ( )

override

Definition at line 309 of file DQMRootOutputModule.cc.

309 {}

Member Function Documentation

void DQMRootOutputModule::beginJob ( void )

overridevirtual

Reimplemented from edm::core::OutputModuleCore.

Definition at line 307 of file DQMRootOutputModule.cc.

307 {}

void DQMRootOutputModule::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 563 of file DQMRootOutputModule.cc.

References edm::ConfigurationDescriptions::addDefault(), edm::ParameterSetDescription::addOptionalUntracked(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, edm::core::OutputModuleCore::fillDescription(), keep, edm::ParameterSetDescription::setAllowAnything(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                      {
   edm::ParameterSetDescription desc;
 
   desc.addUntracked<std::string>("fileName");
   desc.addUntracked<std::string>("logicalFileName", "");
   desc.addUntracked<unsigned int>("filterOnRun", 0)
       ->setComment("Only write the run with this run number. 0 means write all runs.");
   desc.addOptionalUntracked<int>("splitLevel", 99)
       ->setComment("UNUSED Only here to allow older configurations written for PoolOutputModule to work.");
   const std::vector<std::string> keep = {"drop *", "keep DQMToken_*_*_*"};
   edm::one::OutputModule<>::fillDescription(desc, keep);
 
   edm::ParameterSetDescription dataSet;
   dataSet.setAllowAnything();
   desc.addUntracked<edm::ParameterSetDescription>("dataset", dataSet)
       ->setComment("PSet is only used by Data Operations and not by this module.");
 
   descriptions.addDefault(desc);
 }

void DQMRootOutputModule::finishEndFile ( )

private

Definition at line 548 of file DQMRootOutputModule.cc.

References m_file, m_jrToken, and edm::JobReport::outputFileClosed().

Referenced by reallyCloseFile().

                                         {
   //std::cout << "DQMRootOutputModule::finishEndFile"<< std::endl;
   m_file->Write();
   m_file->Close();
   edm::Service<edm::JobReport> jr;
   jr->outputFileClosed(m_jrToken);
 }

bool DQMRootOutputModule::isFileOpen ( ) const

overrideprivatevirtual

Reimplemented from edm::core::OutputModuleCore.

Definition at line 326 of file DQMRootOutputModule.cc.

References m_file.

326 { return nullptr != m_file.get(); }

DQMRootOutputModule::m_file

std::unique_ptr< TFile > m_file

Definition: DQMRootOutputModule.cc:217

void DQMRootOutputModule::openFile ( edm::FileBlock const & )

overrideprivatevirtual

Reimplemented from edm::core::OutputModuleCore.

Definition at line 328 of file DQMRootOutputModule.cc.

                                                       {
   //NOTE: I need to also set the I/O performance settings
 
   m_file = std::make_unique<TFile>(m_fileName.c_str(),
                                    "RECREATE",
                                    "1"  //This is the file format version number
   );
 
   edm::Service<edm::JobReport> jr;
   cms::Digest branchHash;
   std::string guid{edm::createGlobalIdentifier()};
   std::transform(guid.begin(), guid.end(), guid.begin(), (int (*)(int))std::toupper);
 
   m_file->WriteObject(&guid, kCmsGuid);
   m_jrToken = jr->outputFileOpened(m_fileName,
                                    m_logicalFileName,
                                    std::string(),
                                    "DQMRootOutputModule",
                                    description().moduleLabel(),
                                    guid,
                                    std::string(),
                                    branchHash.digest().toString(),
                                    std::vector<std::string>());
 
   m_indicesTree = new TTree(kIndicesTree, kIndicesTree);
   m_indicesTree->Branch(kRunBranch, &m_run);
   m_indicesTree->Branch(kLumiBranch, &m_lumi);
   m_indicesTree->Branch(kProcessHistoryIndexBranch, &m_presentHistoryIndex);
   m_indicesTree->Branch(kBeginTimeBranch, &m_beginTime);
   m_indicesTree->Branch(kEndTimeBranch, &m_endTime);
   m_indicesTree->Branch(kTypeBranch, &m_type);
   m_indicesTree->Branch(kFirstIndex, &m_firstIndex);
   m_indicesTree->Branch(kLastIndex, &m_lastIndex);
   m_indicesTree->SetDirectory(m_file.get());
 
   unsigned int i = 0;
   for (std::vector<std::shared_ptr<TreeHelperBase> >::iterator it = m_treeHelpers.begin(), itEnd = m_treeHelpers.end();
        it != itEnd;
        ++it, ++i) {
     //std::cout <<"making "<<kTypeNames[i]<<std::endl;
     TTree* tree = new TTree(kTypeNames[i], kTypeNames[i]);
     *it = std::shared_ptr<TreeHelperBase>(makeHelper(i, tree, m_fullNameBufferPtr));
     tree->SetDirectory(m_file.get());  //TFile takes ownership
   }
 
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::INT] = kIntIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::REAL] = kFloatIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::STRING] = kStringIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1F] = kTH1FIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1S] = kTH1SIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH1D] = kTH1DIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2F] = kTH2FIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2S] = kTH2SIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH2D] = kTH2DIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TH3F] = kTH3FIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TPROFILE] = kTProfileIndex;
   m_dqmKindToTypeIndex[(int)MonitorElement::Kind::TPROFILE2D] = kTProfile2DIndex;
 }

void DQMRootOutputModule::reallyCloseFile ( )

overrideprivatevirtual

Reimplemented from edm::core::OutputModuleCore.

Definition at line 490 of file DQMRootOutputModule.cc.

References finishEndFile(), and startEndFile().

                                           {
   startEndFile();
   finishEndFile();
 }

void DQMRootOutputModule::startEndFile ( )

private

Definition at line 495 of file DQMRootOutputModule.cc.

References cms::cuda::assert(), edm::ProcessHistory::begin(), edm::pset::Registry::begin(), edm::ProcessHistory::end(), edm::pset::Registry::end(), edm::ProcessHistoryRegistry::getMapped(), isotrackTrainRegressor::history, edm::pset::Registry::instance(), kMetaDataDirectory, kParameterSetBranch, kParameterSetTree, kPHIndexBranch, kProcessConfigurationParameterSetIDBranch, kProcessConfigurationPassID, kProcessConfigurationProcessNameBranch, kProcessConfigurationReleaseVersion, kProcessHistoryTree, m_file, m_processHistoryRegistry, m_seenHistories, edm::core::OutputModuleCore::processName(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by reallyCloseFile().

                                        {
   //std::cout << "DQMRootOutputModule::startEndFile"<< std::endl;
   //fill in the meta data
   m_file->cd();
   TDirectory* metaDataDirectory = m_file->mkdir(kMetaDataDirectory);
 
   //Write out the Process History
   TTree* processHistoryTree = new TTree(kProcessHistoryTree, kProcessHistoryTree);
   processHistoryTree->SetDirectory(metaDataDirectory);
 
   unsigned int index = 0;
   processHistoryTree->Branch(kPHIndexBranch, &index);
   std::string processName;
   processHistoryTree->Branch(kProcessConfigurationProcessNameBranch, &processName);
   std::string parameterSetID;
   processHistoryTree->Branch(kProcessConfigurationParameterSetIDBranch, &parameterSetID);
   std::string releaseVersion;
   processHistoryTree->Branch(kProcessConfigurationReleaseVersion, &releaseVersion);
   std::string passID;
   processHistoryTree->Branch(kProcessConfigurationPassID, &passID);
 
   for (std::vector<edm::ProcessHistoryID>::iterator it = m_seenHistories.begin(), itEnd = m_seenHistories.end();
        it != itEnd;
        ++it) {
     const edm::ProcessHistory* history = m_processHistoryRegistry.getMapped(*it);
     assert(nullptr != history);
     index = 0;
     for (edm::ProcessHistory::collection_type::const_iterator itPC = history->begin(), itPCEnd = history->end();
          itPC != itPCEnd;
          ++itPC, ++index) {
       processName = itPC->processName();
       releaseVersion = itPC->releaseVersion();
       passID = itPC->passID();
       parameterSetID = itPC->parameterSetID().compactForm();
       tbb::this_task_arena::isolate([&] { processHistoryTree->Fill(); });
     }
   }
 
   //Store the ParameterSets
   TTree* parameterSetsTree = new TTree(kParameterSetTree, kParameterSetTree);
   parameterSetsTree->SetDirectory(metaDataDirectory);
   std::string blob;
   parameterSetsTree->Branch(kParameterSetBranch, &blob);
 
   edm::pset::Registry* psr = edm::pset::Registry::instance();
   assert(nullptr != psr);
   for (edm::pset::Registry::const_iterator it = psr->begin(), itEnd = psr->end(); it != itEnd; ++it) {
     blob.clear();
     it->second.toString(blob);
     tbb::this_task_arena::isolate([&] { parameterSetsTree->Fill(); });
   }
 }

void DQMRootOutputModule::write ( edm::EventForOutput const & e )

overrideprivatevirtual

Implements edm::core::OutputModuleCore.

Definition at line 387 of file DQMRootOutputModule.cc.

Referenced by pkg.AbstractPkg::generate().

387 {}

void DQMRootOutputModule::writeLuminosityBlock ( edm::LuminosityBlockForOutput const & iLumi )

overrideprivatevirtual

Implements edm::core::OutputModuleCore.

Definition at line 389 of file DQMRootOutputModule.cc.

References cms::cuda::assert(), edm::LuminosityBlockForOutput::beginTime(), edm::LuminosityBlockForOutput::endTime(), spr::find(), dqm::implementation::IGetter::getAllContents(), gpuClustering::id, edm::LuminosityBlockForOutput::id(), mps_monitormerge::items, kNoTypesStored, m_beginTime, m_dqmKindToTypeIndex, m_endTime, m_filterOnRun, m_firstIndex, m_indicesTree, m_jrToken, m_lastIndex, m_lumi, m_presentHistoryIndex, m_processHistoryRegistry, m_run, m_seenHistories, m_treeHelpers, m_type, edm::OccurrenceForOutput::processHistory(), edm::OccurrenceForOutput::processHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), edm::JobReport::reportLumiSection(), edm::LuminosityBlockID::run(), edm::LuminosityBlockID::value(), edm::Timestamp::value(), and trackerHitRTTI::vector.

                                                                                        {
   //std::cout << "DQMRootOutputModule::writeLuminosityBlock"<< std::endl;
   edm::Service<DQMStore> dstore;
   m_run = iLumi.id().run();
   m_lumi = iLumi.id().value();
   m_beginTime = iLumi.beginTime().value();
   m_endTime = iLumi.endTime().value();
   bool shouldWrite = (m_filterOnRun == 0 || (m_filterOnRun != 0 && m_filterOnRun == m_run));
 
   if (!shouldWrite)
     return;
   std::vector<MonitorElement*> items(dstore->getAllContents("", m_run, m_lumi));
   for (std::vector<MonitorElement*>::iterator it = items.begin(), itEnd = items.end(); it != itEnd; ++it) {
     assert((*it)->getScope() == MonitorElementData::Scope::LUMI);
     std::map<unsigned int, unsigned int>::iterator itFound = m_dqmKindToTypeIndex.find((int)(*it)->kind());
     assert(itFound != m_dqmKindToTypeIndex.end());
     m_treeHelpers[itFound->second]->fill(*it);
   }
 
   const edm::ProcessHistoryID& id = iLumi.processHistoryID();
   std::vector<edm::ProcessHistoryID>::iterator itFind = std::find(m_seenHistories.begin(), m_seenHistories.end(), id);
   if (itFind == m_seenHistories.end()) {
     m_processHistoryRegistry.registerProcessHistory(iLumi.processHistory());
     m_presentHistoryIndex = m_seenHistories.size();
     m_seenHistories.push_back(id);
   } else {
     m_presentHistoryIndex = itFind - m_seenHistories.begin();
   }
 
   //Now store the relationship between run/lumi and indices in the other TTrees
   bool storedLumiIndex = false;
   unsigned int typeIndex = 0;
   for (std::vector<std::shared_ptr<TreeHelperBase> >::iterator it = m_treeHelpers.begin(), itEnd = m_treeHelpers.end();
        it != itEnd;
        ++it, ++typeIndex) {
     if ((*it)->wasFilled()) {
       m_type = typeIndex;
       (*it)->getRangeAndReset(m_firstIndex, m_lastIndex);
       storedLumiIndex = true;
       tbb::this_task_arena::isolate([&] { m_indicesTree->Fill(); });
     }
   }
   if (not storedLumiIndex) {
     //need to record lumis even if we stored no MonitorElements since some later DQM modules
     // look to see what lumis were processed
     m_type = kNoTypesStored;
     m_firstIndex = 0;
     m_lastIndex = 0;
     tbb::this_task_arena::isolate([&] { m_indicesTree->Fill(); });
   }
 
   edm::Service<edm::JobReport> jr;
   jr->reportLumiSection(m_jrToken, m_run, m_lumi);
 }

void DQMRootOutputModule::writeRun ( edm::RunForOutput const & iRun )

overrideprivatevirtual

Implements edm::core::OutputModuleCore.

Definition at line 444 of file DQMRootOutputModule.cc.

References cms::cuda::assert(), edm::RunForOutput::beginTime(), edm::RunForOutput::endTime(), spr::find(), dqm::implementation::IGetter::getAllContents(), gpuClustering::id, edm::RunForOutput::id(), mps_monitormerge::items, m_beginTime, m_dqmKindToTypeIndex, m_endTime, m_filterOnRun, m_firstIndex, m_indicesTree, m_jrToken, m_lastIndex, m_lumi, m_presentHistoryIndex, m_processHistoryRegistry, m_run, m_seenHistories, m_treeHelpers, m_type, edm::OccurrenceForOutput::processHistory(), edm::OccurrenceForOutput::processHistoryID(), edm::ProcessHistoryRegistry::registerProcessHistory(), edm::JobReport::reportRunNumber(), edm::RunID::run(), edm::Timestamp::value(), and trackerHitRTTI::vector.

                                                               {
   //std::cout << "DQMRootOutputModule::writeRun"<< std::endl;
   edm::Service<DQMStore> dstore;
   m_run = iRun.id().run();
   m_lumi = 0;
   m_beginTime = iRun.beginTime().value();
   m_endTime = iRun.endTime().value();
   bool shouldWrite = (m_filterOnRun == 0 || (m_filterOnRun != 0 && m_filterOnRun == m_run));
 
   if (!shouldWrite)
     return;
 
   std::vector<MonitorElement*> items(dstore->getAllContents("", m_run, 0));
   for (std::vector<MonitorElement*>::iterator it = items.begin(), itEnd = items.end(); it != itEnd; ++it) {
     assert((*it)->getScope() == MonitorElementData::Scope::RUN);
     std::map<unsigned int, unsigned int>::iterator itFound = m_dqmKindToTypeIndex.find((int)(*it)->kind());
     assert(itFound != m_dqmKindToTypeIndex.end());
     m_treeHelpers[itFound->second]->fill(*it);
   }
 
   const edm::ProcessHistoryID& id = iRun.processHistoryID();
   std::vector<edm::ProcessHistoryID>::iterator itFind = std::find(m_seenHistories.begin(), m_seenHistories.end(), id);
   if (itFind == m_seenHistories.end()) {
     m_processHistoryRegistry.registerProcessHistory(iRun.processHistory());
     m_presentHistoryIndex = m_seenHistories.size();
     m_seenHistories.push_back(id);
   } else {
     m_presentHistoryIndex = itFind - m_seenHistories.begin();
   }
 
   //Now store the relationship between run/lumi and indices in the other TTrees
   unsigned int typeIndex = 0;
   for (std::vector<std::shared_ptr<TreeHelperBase> >::iterator it = m_treeHelpers.begin(), itEnd = m_treeHelpers.end();
        it != itEnd;
        ++it, ++typeIndex) {
     if ((*it)->wasFilled()) {
       m_type = typeIndex;
       (*it)->getRangeAndReset(m_firstIndex, m_lastIndex);
       tbb::this_task_arena::isolate([&] { m_indicesTree->Fill(); });
     }
   }
 
   edm::Service<edm::JobReport> jr;
   jr->reportRunNumber(m_jrToken, m_run);
 }