Inheritance diagram for DQMRootSource:

Classes
class	RunLumiPHIDKey

class	RunPHIDKey

Public Member Functions
	DQMRootSource (edm::ParameterSet const &, const edm::InputSourceDescription &)

	~DQMRootSource () override

Public Member Functions inherited from edm::InputSource
std::shared_ptr< ActivityRegistry >	actReg () const
	Accessor for Activity Registry. More...

std::shared_ptr< BranchIDListHelper const >	branchIDListHelper () const
	Accessors for branchIDListHelper. More...

std::shared_ptr< BranchIDListHelper > &	branchIDListHelper ()

void	closeFile (FileBlock *, bool cleaningUpAfterException)
	close current file More...

void	doBeginJob ()
	Called by framework at beginning of job. More...

virtual void	doBeginLumi (LuminosityBlockPrincipal &lbp, ProcessContext const *)
	Called by framework at beginning of lumi block. More...

virtual void	doBeginRun (RunPrincipal &rp, ProcessContext const *)
	Called by framework at beginning of run. More...

void	doEndJob ()
	Called by framework at end of job. More...

ProcessingController::ForwardState	forwardState () const

bool	goToEvent (EventID const &eventID)

	InputSource (ParameterSet const &, InputSourceDescription const &)
	Constructor. More...

	InputSource (InputSource const &)=delete

void	issueReports (EventID const &eventID, StreamID streamID)
	issue an event report More...

LuminosityBlockNumber_t	luminosityBlock () const
	Accessor for current luminosity block number. More...

std::shared_ptr< LuminosityBlockAuxiliary >	luminosityBlockAuxiliary () const
	Called by the framework to merge or insert lumi in principal cache. More...

int	maxEvents () const

int	maxLuminosityBlocks () const

ModuleDescription const &	moduleDescription () const
	Accessor for 'module' description. More...

ItemType	nextItemType ()
	Advances the source to the next item. More...

InputSource &	operator= (InputSource const &)=delete

ProcessConfiguration const &	processConfiguration () const
	Accessor for Process Configuration. More...

std::string const &	processGUID () const
	Accessor for global process identifier. More...

ProcessHistoryRegistry const &	processHistoryRegistry () const
	Accessors for process history registry. More...

ProcessHistoryRegistry &	processHistoryRegistry ()

ProcessingMode	processingMode () const
	RunsLumisAndEvents (default), RunsAndLumis, or Runs. More...

std::shared_ptr< ProductRegistry const >	productRegistry () const
	Accessors for product registry. More...

std::shared_ptr< ProductRegistry > &	productRegistry ()

bool	randomAccess () const

void	readAndMergeLumi (LuminosityBlockPrincipal &lbp)
	Read next luminosity block (same as a prior lumi) More...

void	readAndMergeRun (RunPrincipal &rp)
	Read next run (same as a prior run) More...

void	readEvent (EventPrincipal &ep, StreamContext &)
	Read next event. More...

bool	readEvent (EventPrincipal &ep, EventID const &, StreamContext &)
	Read a specific event. More...

std::unique_ptr< FileBlock >	readFile ()
	Read next file. More...

void	readLuminosityBlock (LuminosityBlockPrincipal &lumiPrincipal, HistoryAppender &historyAppender)
	Read next luminosity block (new lumi) More...

std::shared_ptr< LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary ()
	Read next luminosity block Auxilary. More...

void	readRun (RunPrincipal &runPrincipal, HistoryAppender &historyAppender)
	Read next run (new run) More...

std::shared_ptr< RunAuxiliary >	readRunAuxiliary ()
	Read next run Auxiliary. More...

ProcessHistoryID const &	reducedProcessHistoryID () const

virtual void	registerProducts ()
	Register any produced products. More...

int	remainingEvents () const

int	remainingLuminosityBlocks () const

void	repeat ()
	Reset the remaining number of events/lumis to the maximum number. More...

std::pair< SharedResourcesAcquirer , std::recursive_mutex >	resourceSharedWithDelayedReader ()
	Returns nullptr if no resource shared between the Source and a DelayedReader. More...

ProcessingController::ReverseState	reverseState () const

void	rewind ()
	Begin again at the first event. More...

RunNumber_t	run () const
	Accessor for current run number. More...

std::shared_ptr< RunAuxiliary >	runAuxiliary () const
	Called by the framework to merge or insert run in principal cache. More...

void	setLuminosityBlockNumber_t (LuminosityBlockNumber_t lb)
	Set the luminosity block ID. More...

void	setRunNumber (RunNumber_t r)
	Set the run number. More...

void	skipEvents (int offset)

std::shared_ptr< ThinnedAssociationsHelper const >	thinnedAssociationsHelper () const
	Accessors for thinnedAssociationsHelper. More...

std::shared_ptr< ThinnedAssociationsHelper > &	thinnedAssociationsHelper ()

Timestamp const &	timestamp () const
	Accessor for the current time, as seen by the input source. More...

virtual	~InputSource () noexcept(false)
	Destructor. More...

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

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

static void	fillDescription (ParameterSetDescription &desc)

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Private Member Functions
void	closeFile_ () override

	DQMRootSource (const DQMRootSource &)=delete

edm::InputSource::ItemType	getNextItemType () override

void	logFileAction (char const msg, char const fileName) const

const DQMRootSource &	operator= (const DQMRootSource &)=delete

void	readElements ()

void	readEvent_ (edm::EventPrincipal &) override

std::unique_ptr< edm::FileBlock >	readFile_ () override

void	readLuminosityBlock_ (edm::LuminosityBlockPrincipal &lbCache) override

std::shared_ptr< edm::LuminosityBlockAuxiliary >	readLuminosityBlockAuxiliary_ () override

void	readNextItemType ()

void	readRun_ (edm::RunPrincipal &rpCache) override

std::shared_ptr< edm::RunAuxiliary >	readRunAuxiliary_ () override

bool	setupFile (unsigned int iIndex)

bool	skipIt (edm::RunNumber_t, edm::LuminosityBlockNumber_t) const

Private Attributes
edm::InputFileCatalog	m_catalog

std::unique_ptr< TFile >	m_file

size_t	m_fileIndex

unsigned int	m_filterOnRun

std::vector< edm::ProcessHistoryID >	m_historyIDs

edm::JobReport::Token	m_jrToken

bool	m_justOpenedFileSoNeedToGenerateRunTransition

unsigned int	m_lastSeenLumi2

edm::ProcessHistoryID	m_lastSeenReducedPHID

edm::ProcessHistoryID	m_lastSeenReducedPHID2

unsigned int	m_lastSeenRun

unsigned int	m_lastSeenRun2

edm::LuminosityBlockAuxiliary	m_lumiAux

std::set< MonitorElement * >	m_lumiElements

std::vector< edm::LuminosityBlockRange >	m_lumisToProcess

std::list< unsigned int >::iterator	m_nextIndexItr

edm::InputSource::ItemType	m_nextItemType

std::list< unsigned int >	m_orderedIndices

std::list< unsigned int >::iterator	m_presentIndexItr

std::string	m_presentlyOpenFileName

std::vector< edm::ProcessHistoryID >	m_reducedHistoryIDs

edm::RunAuxiliary	m_runAux

std::set< MonitorElement * >	m_runElements

std::vector< RunLumiToRange >	m_runlumiToRange

std::vector< edm::RunNumber_t >	m_runsToProcess

bool	m_shouldReadMEs

bool	m_skipBadFiles

std::vector< std::shared_ptr< TreeReaderBase > >	m_treeReaders

std::vector< TTree * >	m_trees

Additional Inherited Members
Public Types inherited from edm::InputSource
enum	ItemType { IsInvalid, IsStop, IsFile, IsRun, IsLumi, IsEvent, IsRepeat, IsSynchronize }

enum	ProcessingMode { Runs, RunsAndLumis, RunsLumisAndEvents }

Public Attributes inherited from edm::InputSource
signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)>	postEventReadFromSourceSignal_

signalslot::Signal< void(StreamContext const &, ModuleCallingContext const &)>	preEventReadFromSourceSignal_

Protected Member Functions inherited from edm::InputSource
virtual void	beginJob ()
	Begin protected makes it easier to do template programming. More...

void	decreaseRemainingEventsBy (int iSkipped)

bool	eventCached () const

bool	newLumi () const

bool	newRun () const

ProcessHistoryRegistry &	processHistoryRegistryForUpdate ()

ProductRegistry &	productRegistryUpdate ()

void	reset () const

void	resetEventCached ()

void	resetLuminosityBlockAuxiliary (bool isNewLumi=true) const

void	resetNewLumi ()

void	resetNewRun ()

void	resetRunAuxiliary (bool isNewRun=true) const

void	setEventCached ()
	Called by the framework to merge or ached() const {return eventCached_;}. More...

void	setLuminosityBlockAuxiliary (LuminosityBlockAuxiliary *lbp)

void	setNewLumi ()

void	setNewRun ()

void	setRunAuxiliary (RunAuxiliary *rp)

void	setTimestamp (Timestamp const &theTime)
	To set the current time, as seen by the input source. More...

virtual void	skip (int offset)

ItemType	state () const

Detailed Description

Definition at line 294 of file DQMRootSource.cc.

Constructor & Destructor Documentation

DQMRootSource::DQMRootSource	(	edm::ParameterSet const &	iPSet,
		const edm::InputSourceDescription &	iDesc
	)

Definition at line 429 of file DQMRootSource.cc.

References edm::InputFileCatalog::fileNames(), edm::InputSource::IsStop, kFloatIndex, kIntIndex, kStringIndex, kTH1DIndex, kTH1FIndex, kTH1SIndex, kTH2DIndex, kTH2FIndex, kTH2SIndex, kTH3FIndex, kTProfile2DIndex, kTProfileIndex, m_catalog, m_fileIndex, m_lumisToProcess, m_nextItemType, m_runsToProcess, m_treeReaders, and edm::sortAndRemoveOverlaps().

     : edm::InputSource(iPSet, iDesc),
       m_catalog(iPSet.getUntrackedParameter<std::vector<std::string> >("fileNames"),
                 iPSet.getUntrackedParameter<std::string>("overrideCatalog")),
       m_nextItemType(edm::InputSource::IsFile),
       m_fileIndex(0),
       m_trees(kNIndicies, static_cast<TTree*>(nullptr)),
       m_treeReaders(kNIndicies, std::shared_ptr<TreeReaderBase>()),
       m_lastSeenReducedPHID(),
       m_lastSeenRun(0),
       m_lastSeenReducedPHID2(),
       m_lastSeenRun2(0),
       m_lastSeenLumi2(0),
       m_filterOnRun(iPSet.getUntrackedParameter<unsigned int>("filterOnRun", 0)),
       m_skipBadFiles(iPSet.getUntrackedParameter<bool>("skipBadFiles", false)),
       m_lumisToProcess(iPSet.getUntrackedParameter<std::vector<edm::LuminosityBlockRange> >(
           "lumisToProcess", std::vector<edm::LuminosityBlockRange>())),
       m_justOpenedFileSoNeedToGenerateRunTransition(false),
       m_shouldReadMEs(true) {
   edm::sortAndRemoveOverlaps(m_lumisToProcess);
   for (std::vector<edm::LuminosityBlockRange>::const_iterator itr = m_lumisToProcess.begin();
        itr != m_lumisToProcess.end();
        ++itr)
     m_runsToProcess.push_back(itr->startRun());
 
   if (m_fileIndex == m_catalog.fileNames().size()) {
     m_nextItemType = edm::InputSource::IsStop;
   } else {
     m_treeReaders[kIntIndex].reset(new TreeSimpleReader<Long64_t>());
     m_treeReaders[kFloatIndex].reset(new TreeSimpleReader<double>());
     m_treeReaders[kStringIndex].reset(new TreeObjectReader<std::string>());
     m_treeReaders[kTH1FIndex].reset(new TreeObjectReader<TH1F>());
     m_treeReaders[kTH1SIndex].reset(new TreeObjectReader<TH1S>());
     m_treeReaders[kTH1DIndex].reset(new TreeObjectReader<TH1D>());
     m_treeReaders[kTH2FIndex].reset(new TreeObjectReader<TH2F>());
     m_treeReaders[kTH2SIndex].reset(new TreeObjectReader<TH2S>());
     m_treeReaders[kTH2DIndex].reset(new TreeObjectReader<TH2D>());
     m_treeReaders[kTH3FIndex].reset(new TreeObjectReader<TH3F>());
     m_treeReaders[kTProfileIndex].reset(new TreeObjectReader<TProfile>());
     m_treeReaders[kTProfile2DIndex].reset(new TreeObjectReader<TProfile2D>());
   }
 }

DQMRootSource::~DQMRootSource ( )

override

Definition at line 477 of file DQMRootSource.cc.

References logFileAction(), m_file, and m_presentlyOpenFileName.

                               {
   if (m_file.get() != nullptr && m_file->IsOpen()) {
     m_file->Close();
     logFileAction("  Closed file ", m_presentlyOpenFileName.c_str());
   }
 }

DQMRootSource::DQMRootSource ( const DQMRootSource & )

privatedelete

Member Function Documentation

void DQMRootSource::closeFile_ ( )

overrideprivatevirtual

Reimplemented from edm::InputSource.

Definition at line 647 of file DQMRootSource.cc.

References edm::JobReport::inputFileClosed(), m_file, m_jrToken, and edm::Primary.

                                {
   if (m_file.get() == nullptr) {
     return;
   }
   edm::Service<edm::JobReport> jr;
   jr->inputFileClosed(edm::InputType::Primary, m_jrToken);
 }

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

static

Definition at line 413 of file DQMRootSource.cc.

References edm::ConfigurationDescriptions::addDefault(), edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
   edm::ParameterSetDescription desc;
   desc.addUntracked<std::vector<std::string> >("fileNames")->setComment("Names of files to be processed.");
   desc.addUntracked<unsigned int>("filterOnRun", 0)->setComment("Just limit the process to the selected run.");
   desc.addUntracked<bool>("skipBadFiles", false)->setComment("Skip the file if it is not valid");
   desc.addUntracked<std::string>("overrideCatalog", std::string())
       ->setComment("An alternate file catalog to use instead of the standard site one.");
   std::vector<edm::LuminosityBlockRange> defaultLumis;
   desc.addUntracked<std::vector<edm::LuminosityBlockRange> >("lumisToProcess", defaultLumis)
       ->setComment("Skip any lumi inside the specified run:lumi range.");
 
   descriptions.addDefault(desc);
 }

edm::InputSource::ItemType DQMRootSource::getNextItemType ( )

overrideprivatevirtual

Implements edm::InputSource.

Definition at line 503 of file DQMRootSource.cc.

References m_nextItemType.

                                                       {
   //std::cout <<"getNextItemType "<<m_nextItemType<<std::endl;
   return m_nextItemType;
 }

void DQMRootSource::logFileAction	(	char const *	msg,
		char const *	fileName
	)		const

private

Definition at line 1074 of file DQMRootSource.cc.

References DEFINE_FWK_INPUT_SOURCE, MillePedeFileConverter_cfg::fileName, and edm::FlushMessageLog().

Referenced by setupFile(), and ~DQMRootSource().

                                                                              {
   edm::LogAbsolute("fileAction") << std::setprecision(0) << edm::TimeOfDay() << msg << fileName;
   edm::FlushMessageLog();
 }

const DQMRootSource& DQMRootSource::operator= ( const DQMRootSource & )

privatedelete

void DQMRootSource::readElements ( )

private

Definition at line 655 of file DQMRootSource.cc.

References kNoTypesStored, m_orderedIndices, m_presentIndexItr, m_reducedHistoryIDs, RunInfoPI::m_run, m_runlumiToRange, m_shouldReadMEs, m_treeReaders, DQM::reader, and skipIt().

Referenced by readLuminosityBlock_(), and readRun_().

                                  {
   edm::Service<DQMStore> store;
   RunLumiToRange runLumiRange = m_runlumiToRange[*m_presentIndexItr];
   bool shouldContinue = false;
   do {
     shouldContinue = false;
     ++m_presentIndexItr;
     while (m_presentIndexItr != m_orderedIndices.end() &&
            skipIt(m_runlumiToRange[*m_presentIndexItr].m_run, m_runlumiToRange[*m_presentIndexItr].m_lumi))
       ++m_presentIndexItr;
 
     if (runLumiRange.m_type != kNoTypesStored) {
       std::shared_ptr<TreeReaderBase> reader = m_treeReaders[runLumiRange.m_type];
       ULong64_t index = runLumiRange.m_firstIndex;
       ULong64_t endIndex = runLumiRange.m_lastIndex + 1;
       for (; index != endIndex; ++index) {
         bool isLumi = runLumiRange.m_lumi != 0;
         if (m_shouldReadMEs)
           reader->read(index, *store, isLumi);
 
         //std::cout << runLumiRange.m_run << " " << runLumiRange.m_lumi <<" "<<index<< " " << runLumiRange.m_type << std::endl;
       }
     }
 
     if (m_presentIndexItr != m_orderedIndices.end()) {
       //are there more parts to this same run/lumi?
       const RunLumiToRange nextRunLumiRange = m_runlumiToRange[*m_presentIndexItr];
       //continue to the next item if that item is either
       if ((m_reducedHistoryIDs.at(nextRunLumiRange.m_historyIDIndex) ==
            m_reducedHistoryIDs.at(runLumiRange.m_historyIDIndex)) &&
           (nextRunLumiRange.m_run == runLumiRange.m_run) && (nextRunLumiRange.m_lumi == runLumiRange.m_lumi)) {
         shouldContinue = true;
         runLumiRange = nextRunLumiRange;
       }
     }
   } while (shouldContinue);
 }

void DQMRootSource::readEvent_ ( edm::EventPrincipal & )

overrideprivatevirtual

Implements edm::InputSource.

Definition at line 499 of file DQMRootSource.cc.

                                                  {
   //std::cout << "readEvent_" << std::endl;
 }

std::unique_ptr< edm::FileBlock > DQMRootSource::readFile_ ( )

overrideprivatevirtual

Reimplemented from edm::InputSource.

Definition at line 618 of file DQMRootSource.cc.

References edm::InputFileCatalog::fileNames(), edm::JobReport::inputFileOpened(), edm::InputSource::IsStop, edm::InputFileCatalog::logicalFileNames(), m_catalog, m_file, m_fileIndex, m_jrToken, m_nextItemType, m_orderedIndices, m_presentIndexItr, m_presentlyOpenFileName, RunInfoPI::m_run, m_runlumiToRange, readNextItemType(), setupFile(), skipIt(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                      {
   auto const numFiles = m_catalog.fileNames().size();
   while (m_fileIndex < numFiles && not setupFile(m_fileIndex++)) {
   }
 
   if (m_file.get() == nullptr) {
     //last file in list was bad
     m_nextItemType = edm::InputSource::IsStop;
     return std::unique_ptr<edm::FileBlock>(new edm::FileBlock);
   }
 
   readNextItemType();
   while (m_presentIndexItr != m_orderedIndices.end() &&
          skipIt(m_runlumiToRange[*m_presentIndexItr].m_run, m_runlumiToRange[*m_presentIndexItr].m_lumi))
     ++m_presentIndexItr;
 
   edm::Service<edm::JobReport> jr;
   m_jrToken = jr->inputFileOpened(m_presentlyOpenFileName,
                                   m_catalog.logicalFileNames()[m_fileIndex - 1],
                                   std::string(),
                                   std::string(),
                                   "DQMRootSource",
                                   "source",
                                   m_file->GetUUID().AsString(),  //edm::createGlobalIdentifier(),
                                   std::vector<std::string>());
 
   return std::unique_ptr<edm::FileBlock>(new edm::FileBlock);
 }

void DQMRootSource::readLuminosityBlock_ ( edm::LuminosityBlockPrincipal & lbCache )

overrideprivatevirtual

Reimplemented from edm::InputSource.

Definition at line 586 of file DQMRootSource.cc.

References edm::LuminosityBlockPrincipal::fillLuminosityBlockPrincipal(), edm::LuminosityBlockPrincipal::id(), edm::LuminosityBlockID::luminosityBlock(), m_lastSeenLumi2, m_lastSeenReducedPHID2, m_lastSeenRun2, m_orderedIndices, m_presentIndexItr, m_reducedHistoryIDs, m_runlumiToRange, m_shouldReadMEs, edm::InputSource::processHistoryRegistryForUpdate(), readElements(), readNextItemType(), edm::JobReport::reportInputLumiSection(), and edm::LuminosityBlockID::run().

                                                                              {
   assert(m_presentIndexItr != m_orderedIndices.end());
   RunLumiToRange runLumiRange = m_runlumiToRange[*m_presentIndexItr];
   assert(runLumiRange.m_run == lbCache.id().run());
   assert(runLumiRange.m_lumi == lbCache.id().luminosityBlock());
 
   //NOTE: need to reset all lumi block elements at this point
   if ((m_lastSeenLumi2 != runLumiRange.m_lumi || m_lastSeenRun2 != runLumiRange.m_run ||
        m_lastSeenReducedPHID2 != m_reducedHistoryIDs.at(runLumiRange.m_historyIDIndex)) &&
       m_shouldReadMEs) {
     edm::Service<DQMStore> store;
     std::vector<MonitorElement*> allMEs = (*store).getAllContents("");
     //for(auto const& ME : allMEs) {
     //  // We do not want to reset Run Products here!
     //  if (ME->getLumiFlag()) {
     //    ME->Reset();
     //  }
     //}
     m_lastSeenReducedPHID2 = m_reducedHistoryIDs.at(runLumiRange.m_historyIDIndex);
     m_lastSeenRun2 = runLumiRange.m_run;
     m_lastSeenLumi2 = runLumiRange.m_lumi;
   }
 
   readNextItemType();
   readElements();
 
   edm::Service<edm::JobReport> jr;
   jr->reportInputLumiSection(lbCache.id().run(), lbCache.id().luminosityBlock());
 
   lbCache.fillLuminosityBlockPrincipal(processHistoryRegistryForUpdate());
 }

std::shared_ptr< edm::LuminosityBlockAuxiliary > DQMRootSource::readLuminosityBlockAuxiliary_ ( )

overrideprivatevirtual

Implements edm::InputSource.

Definition at line 523 of file DQMRootSource.cc.

References m_historyIDs, m_lumiAux, m_nextIndexItr, m_orderedIndices, m_runlumiToRange, and edm::LuminosityBlockAuxiliary::setProcessHistoryID().

                                                                                         {
   //std::cout <<"readLuminosityBlockAuxiliary_"<<std::endl;
   assert(m_nextIndexItr != m_orderedIndices.end());
   const RunLumiToRange runLumiRange = m_runlumiToRange[*m_nextIndexItr];
   m_lumiAux = edm::LuminosityBlockAuxiliary(edm::LuminosityBlockID(runLumiRange.m_run, runLumiRange.m_lumi),
                                             edm::Timestamp(runLumiRange.m_beginTime),
                                             edm::Timestamp(runLumiRange.m_endTime));
   assert(m_historyIDs.size() > runLumiRange.m_historyIDIndex);
   //std::cout <<"lumi "<<m_lumiAux.beginTime().value()<<" "<<runLumiRange.m_beginTime<<std::endl;
   m_lumiAux.setProcessHistoryID(m_historyIDs[runLumiRange.m_historyIDIndex]);
 
   return std::make_shared<edm::LuminosityBlockAuxiliary>(m_lumiAux);
 }

void DQMRootSource::readNextItemType ( )

private

Definition at line 693 of file DQMRootSource.cc.

References edm::InputFileCatalog::fileNames(), edm::InputSource::IsFile, edm::InputSource::IsLumi, edm::InputSource::IsRun, edm::InputSource::IsStop, m_catalog, m_fileIndex, m_justOpenedFileSoNeedToGenerateRunTransition, m_lastSeenReducedPHID, m_lastSeenRun, m_nextIndexItr, m_nextItemType, m_orderedIndices, m_reducedHistoryIDs, RunInfoPI::m_run, m_runlumiToRange, and skipIt().

Referenced by readFile_(), readLuminosityBlock_(), and readRun_().

                                      {
   //Do the work of actually figuring out where next to go
 
   assert(m_nextIndexItr != m_orderedIndices.end());
   RunLumiToRange runLumiRange = m_runlumiToRange[*m_nextIndexItr];
 
   if (m_nextItemType != edm::InputSource::IsFile) {
     if (runLumiRange.m_lumi != 0 && m_nextItemType == edm::InputSource::IsRun) {
       m_nextItemType = edm::InputSource::IsLumi;
       return;
     }
     ++m_nextIndexItr;
   } else {
     //NOTE: the following makes the iterator not be advanced in the
     //do while loop below.
     runLumiRange.m_run = 0;
   }
 
   bool shouldContinue = false;
   do {
     shouldContinue = false;
     while (m_nextIndexItr != m_orderedIndices.end() &&
            skipIt(m_runlumiToRange[*m_nextIndexItr].m_run, m_runlumiToRange[*m_nextIndexItr].m_lumi))
       ++m_nextIndexItr;
 
     if (m_nextIndexItr == m_orderedIndices.end()) {
       //go to next file
       m_nextItemType = edm::InputSource::IsFile;
       //std::cout <<"going to next file"<<std::endl;
       if (m_fileIndex == m_catalog.fileNames().size()) {
         m_nextItemType = edm::InputSource::IsStop;
       }
       break;
     }
     const RunLumiToRange nextRunLumiRange = m_runlumiToRange[*m_nextIndexItr];
     //continue to the next item if that item is the same run or lumi as we just did
     if ((m_reducedHistoryIDs.at(nextRunLumiRange.m_historyIDIndex) ==
          m_reducedHistoryIDs.at(runLumiRange.m_historyIDIndex)) &&
         (nextRunLumiRange.m_run == runLumiRange.m_run) && (nextRunLumiRange.m_lumi == runLumiRange.m_lumi)) {
       shouldContinue = true;
       ++m_nextIndexItr;
       //std::cout <<"advancing " <<nextRunLumiRange.m_run<<" "<<nextRunLumiRange.m_lumi<<std::endl;
     }
   } while (shouldContinue);
 
   if (m_nextIndexItr != m_orderedIndices.end()) {
     if (m_justOpenedFileSoNeedToGenerateRunTransition || m_lastSeenRun != m_runlumiToRange[*m_nextIndexItr].m_run ||
         m_lastSeenReducedPHID != m_reducedHistoryIDs.at(m_runlumiToRange[*m_nextIndexItr].m_historyIDIndex)) {
       m_nextItemType = edm::InputSource::IsRun;
     } else {
       m_nextItemType = edm::InputSource::IsLumi;
     }
   }
 }

void DQMRootSource::readRun_ ( edm::RunPrincipal & rpCache )

overrideprivatevirtual

If the collate option is not set for the DQMStore, we should indeed be sure to reset all histograms after a run transition, but we should definitely avoid doing it using a local, private copy of the actual content of the DQMStore. Clients are completely free to delete/add MonitorElements from the DQMStore and the local copy stored in the std::set will never notice it until it will try to reset a deleted object. That's why the resetting directly queries the DQMStore for its current content.

Reimplemented from edm::InputSource.

Definition at line 537 of file DQMRootSource.cc.

References edm::RunPrincipal::fillRunPrincipal(), edm::RunPrincipal::id(), m_filterOnRun, m_justOpenedFileSoNeedToGenerateRunTransition, m_lastSeenReducedPHID, m_lastSeenRun, m_orderedIndices, m_presentIndexItr, m_reducedHistoryIDs, m_runlumiToRange, m_shouldReadMEs, edm::InputSource::processHistoryRegistryForUpdate(), readElements(), readNextItemType(), edm::JobReport::reportInputRunNumber(), and edm::RunID::run().

                                                      {
   assert(m_presentIndexItr != m_orderedIndices.end());
   RunLumiToRange runLumiRange = m_runlumiToRange[*m_presentIndexItr];
 
   m_justOpenedFileSoNeedToGenerateRunTransition = false;
   unsigned int runID = rpCache.id().run();
   assert(runID == runLumiRange.m_run);
 
   m_shouldReadMEs = (m_filterOnRun == 0 || (m_filterOnRun != 0 && m_filterOnRun == runID));
   //   std::cout <<"readRun_"<<std::endl;
   //   std::cout <<"m_shouldReadMEs " << m_shouldReadMEs <<std::endl;
 
   //NOTE: need to reset all run elements at this point
   if (m_lastSeenRun != runID || m_lastSeenReducedPHID != m_reducedHistoryIDs.at(runLumiRange.m_historyIDIndex)) {
     if (m_shouldReadMEs) {
       edm::Service<DQMStore> store;
       std::vector<MonitorElement*> allMEs = (*store).getAllContents("");
       for (auto const& ME : allMEs) {
         if (!(*store).isCollate())
           ME->Reset();
       }
     }
     m_lastSeenReducedPHID = m_reducedHistoryIDs.at(runLumiRange.m_historyIDIndex);
     m_lastSeenRun = runID;
   }
 
   readNextItemType();
 
   //NOTE: it is possible to have a Run when all we have stored is lumis
   if (runLumiRange.m_lumi == 0) {
     readElements();
   }
 
   edm::Service<edm::JobReport> jr;
   jr->reportInputRunNumber(rpCache.id().run());
 
   rpCache.fillRunPrincipal(processHistoryRegistryForUpdate());
 }

std::shared_ptr< edm::RunAuxiliary > DQMRootSource::readRunAuxiliary_ ( )

overrideprivatevirtual

Implements edm::InputSource.

Definition at line 508 of file DQMRootSource.cc.

References m_historyIDs, m_nextIndexItr, m_orderedIndices, m_runAux, m_runlumiToRange, and edm::RunAuxiliary::setProcessHistoryID().

                                                                 {
   //std::cout <<"readRunAuxiliary_"<<std::endl;
   assert(m_nextIndexItr != m_orderedIndices.end());
   RunLumiToRange runLumiRange = m_runlumiToRange[*m_nextIndexItr];
 
   //NOTE: the setBeginTime and setEndTime functions of RunAuxiliary only work if the previous value was invalid
   // therefore we must copy
   m_runAux = edm::RunAuxiliary(
       runLumiRange.m_run, edm::Timestamp(runLumiRange.m_beginTime), edm::Timestamp(runLumiRange.m_endTime));
   assert(m_historyIDs.size() > runLumiRange.m_historyIDIndex);
   //std::cout <<"readRunAuxiliary_ "<<m_historyIDs[runLumiRange.m_historyIDIndex]<<std::endl;
   m_runAux.setProcessHistoryID(m_historyIDs[runLumiRange.m_historyIDIndex]);
   return std::make_shared<edm::RunAuxiliary>(m_runAux);
 }

bool DQMRootSource::setupFile ( unsigned int iIndex )

private

Definition at line 748 of file DQMRootSource.cc.

References cms::Exception::addAdditionalInfo(), cms::Exception::addContext(), cms::Exception::additionalInfo(), trigObjTnPSource_cfi::configs, edm::InputFileCatalog::fallbackFileNames(), edm::InputFileCatalog::fileNames(), edm::errors::FileOpenError, edm::errors::FileReadError, edm::threadLocalException::getException(), mps_fire::i, edm::ProcessHistory::id(), edm::pset::Registry::instance(), kBeginTimeBranch, kEndTimeBranch, kFirstIndex, kIndicesTree, kLastIndex, kLumiBranch, kMetaDataDirectoryAbsolute, kNIndicies, kParameterSetBranch, kParameterSetTree, kPHIndexBranch, kProcessConfigurationParameterSetIDBranch, kProcessConfigurationPassID, kProcessConfigurationProcessNameBranch, kProcessConfigurationReleaseVersion, kProcessHistoryIndexBranch, kProcessHistoryTree, kRunBranch, kTypeBranch, kTypeNames, logFileAction(), m_catalog, m_file, m_historyIDs, m_justOpenedFileSoNeedToGenerateRunTransition, m_nextIndexItr, m_orderedIndices, m_presentIndexItr, m_presentlyOpenFileName, m_reducedHistoryIDs, m_runlumiToRange, m_skipBadFiles, m_treeReaders, m_trees, eostools::move(), edm::InputSource::processHistoryRegistryForUpdate(), SimL1EmulatorRepack_CalouGT_cff::processName, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ParameterSet::registerFromString(), edm::ProcessHistoryRegistry::registerProcessHistory(), alignCSCRings::s, edm::threadLocalException::setException(), AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by readFile_().

                                                  {
   if (m_file.get() != nullptr && iIndex > 0) {
     m_file->Close();
     logFileAction("  Closed file ", m_presentlyOpenFileName.c_str());
   }
   logFileAction("  Initiating request to open file ", m_catalog.fileNames()[iIndex].c_str());
 
   auto fallbackFileName = m_catalog.fallbackFileNames()[iIndex];
   bool hasFallback = !fallbackFileName.empty() && fallbackFileName != m_catalog.fileNames()[iIndex];
 
   m_presentlyOpenFileName.clear();
   m_file.reset();
 
   std::unique_ptr<TFile> newFile;
   std::list<std::string> originalInfo;
   try {
     // ROOT's context management implicitly assumes that a file is opened and
     // closed on the same thread.  To avoid the problem, we declare a local
     // TContext object; when it goes out of scope, its destructor unregisters
     // the context, guaranteeing the context is unregistered in the same thread
     // it was registered in.
     {
       TDirectory::TContext contextEraser;
       newFile = std::unique_ptr<TFile>(TFile::Open(m_catalog.fileNames()[iIndex].c_str()));
     }
     //Since ROOT6, we can not propagate an exception through ROOT's plugin
     // system so we trap them and then pull from this function
     std::exception_ptr e = edm::threadLocalException::getException();
     if (e != std::exception_ptr()) {
       edm::threadLocalException::setException(std::exception_ptr());
       std::rethrow_exception(e);
     }
 
   } catch (cms::Exception const& e) {
     if (!hasFallback) {
       if (m_skipBadFiles) {
         return false;
       } else {
         edm::Exception ex(edm::errors::FileOpenError, "", e);
         ex.addContext("Opening DQM Root file");
         ex << "\nInput file " << m_catalog.fileNames()[iIndex]
            << " was not found, could not be opened, or is corrupted.\n";
         throw ex;
       }
     }
     originalInfo = e.additionalInfo();  // save in case of fallback error
     newFile.reset();
   }
   if (newFile && not newFile->IsZombie()) {
     m_presentlyOpenFileName = m_catalog.fileNames()[iIndex];
     logFileAction("  Successfully opened file ", m_presentlyOpenFileName.c_str());
   } else {
     if (!hasFallback) {
       if (m_skipBadFiles) {
         return false;
       } else {
         edm::Exception ex(edm::errors::FileOpenError);
         ex << "Input file " << m_catalog.fileNames()[iIndex].c_str() << " could not be opened.\n";
         ex.addContext("Opening DQM Root file");
         throw ex;
       }
     }
     newFile.reset();
   }
 
   if (!newFile && hasFallback) {
     logFileAction("  Initiating request to open fallback file ", fallbackFileName.c_str());
     try {
       {
         TDirectory::TContext contextEraser;
         newFile = std::unique_ptr<TFile>(TFile::Open(fallbackFileName.c_str()));
       }
       std::exception_ptr e = edm::threadLocalException::getException();
       if (e != std::exception_ptr()) {
         edm::threadLocalException::setException(std::exception_ptr());
         std::rethrow_exception(e);
       }
     } catch (cms::Exception const& e) {
       if (m_skipBadFiles) {
         return false;
       } else {
         edm::Exception ex(edm::errors::FileOpenError, "", e);
         ex.addContext("Opening DQM Root file");
         ex << "\nInput file " << m_catalog.fileNames()[iIndex] << " and fallback input file " << fallbackFileName
            << " were not found, could not be opened, or are corrupted.\n";
         for (auto const& s : originalInfo) {
           ex.addAdditionalInfo(s);
         }
         throw ex;
       }
     }
     if (not newFile->IsZombie()) {
       m_presentlyOpenFileName = fallbackFileName;
       logFileAction("  Successfully opened fallback file ", m_presentlyOpenFileName.c_str());
     } else {
       if (m_skipBadFiles) {
         return false;
       } else {
         edm::Exception ex(edm::errors::FileOpenError);
         ex << "Input file " << m_catalog.fileNames()[iIndex] << " and fallback input file " << fallbackFileName
            << " could not be opened.\n";
         ex.addContext("Opening DQM Root file");
         for (auto const& s : originalInfo) {
           ex.addAdditionalInfo(s);
         }
         throw ex;
       }
     }
   }
 
   //Check file format version, which is encoded in the Title of the TFile
   if (0 != strcmp(newFile->GetTitle(), "1")) {
     if (m_skipBadFiles) {
       return false;
     } else {
       edm::Exception ex(edm::errors::FileReadError);
       ex << "Input file " << m_presentlyOpenFileName << " does not appear to be a DQM Root file.\n";
       throw ex;
     }
   }
 
   //Get meta Data
   TDirectory* metaDir = newFile->GetDirectory(kMetaDataDirectoryAbsolute);
   if (nullptr == metaDir) {
     if (!m_skipBadFiles) {
       edm::Exception ex(edm::errors::FileReadError);
       ex << "Input file " << m_presentlyOpenFileName
          << " appears to be corrupted since it does not have the proper internal structure.\n"
             " Check to see if the file was closed properly.\n";
       ex.addContext("Opening DQM Root file");
       throw ex;
     } else {
       return false;
     }
   }
   m_file = std::move(newFile);  //passed all tests so now we want to use this file
   TTree* parameterSetTree = dynamic_cast<TTree*>(metaDir->Get(kParameterSetTree));
   assert(nullptr != parameterSetTree);
 
   edm::pset::Registry* psr = edm::pset::Registry::instance();
   assert(nullptr != psr);
   {
     std::string blob;
     std::string* pBlob = &blob;
     parameterSetTree->SetBranchAddress(kParameterSetBranch, &pBlob);
     for (unsigned int index = 0; index != parameterSetTree->GetEntries(); ++index) {
       parameterSetTree->GetEntry(index);
       edm::ParameterSet::registerFromString(blob);
     }
   }
 
   {
     TTree* processHistoryTree = dynamic_cast<TTree*>(metaDir->Get(kProcessHistoryTree));
     assert(nullptr != processHistoryTree);
     unsigned int phIndex = 0;
     processHistoryTree->SetBranchAddress(kPHIndexBranch, &phIndex);
     std::string processName;
     std::string* pProcessName = &processName;
     processHistoryTree->SetBranchAddress(kProcessConfigurationProcessNameBranch, &pProcessName);
     std::string parameterSetIDBlob;
     std::string* pParameterSetIDBlob = &parameterSetIDBlob;
     processHistoryTree->SetBranchAddress(kProcessConfigurationParameterSetIDBranch, &pParameterSetIDBlob);
     std::string releaseVersion;
     std::string* pReleaseVersion = &releaseVersion;
     processHistoryTree->SetBranchAddress(kProcessConfigurationReleaseVersion, &pReleaseVersion);
     std::string passID;
     std::string* pPassID = &passID;
     processHistoryTree->SetBranchAddress(kProcessConfigurationPassID, &pPassID);
 
     edm::ProcessHistoryRegistry& phr = processHistoryRegistryForUpdate();
     std::vector<edm::ProcessConfiguration> configs;
     configs.reserve(5);
     m_historyIDs.clear();
     m_reducedHistoryIDs.clear();
     for (unsigned int i = 0; i != processHistoryTree->GetEntries(); ++i) {
       processHistoryTree->GetEntry(i);
       if (phIndex == 0) {
         if (not configs.empty()) {
           edm::ProcessHistory ph(configs);
           m_historyIDs.push_back(ph.id());
           phr.registerProcessHistory(ph);
           m_reducedHistoryIDs.push_back(phr.reducedProcessHistoryID(ph.id()));
         }
         configs.clear();
       }
       edm::ParameterSetID psetID(parameterSetIDBlob);
       edm::ProcessConfiguration pc(processName, psetID, releaseVersion, passID);
       configs.push_back(pc);
     }
     if (not configs.empty()) {
       edm::ProcessHistory ph(configs);
       m_historyIDs.push_back(ph.id());
       phr.registerProcessHistory(ph);
       m_reducedHistoryIDs.push_back(phr.reducedProcessHistoryID(ph.id()));
       //std::cout <<"inserted "<<ph.id()<<std::endl;
     }
   }
 
   //Setup the indices
   TTree* indicesTree = dynamic_cast<TTree*>(m_file->Get(kIndicesTree));
   assert(nullptr != indicesTree);
 
   m_runlumiToRange.clear();
   m_runlumiToRange.reserve(indicesTree->GetEntries());
   m_orderedIndices.clear();
 
   RunLumiToRange temp;
   indicesTree->SetBranchAddress(kRunBranch, &temp.m_run);
   indicesTree->SetBranchAddress(kLumiBranch, &temp.m_lumi);
   indicesTree->SetBranchAddress(kBeginTimeBranch, &temp.m_beginTime);
   indicesTree->SetBranchAddress(kEndTimeBranch, &temp.m_endTime);
   indicesTree->SetBranchAddress(kProcessHistoryIndexBranch, &temp.m_historyIDIndex);
   indicesTree->SetBranchAddress(kTypeBranch, &temp.m_type);
   indicesTree->SetBranchAddress(kFirstIndex, &temp.m_firstIndex);
   indicesTree->SetBranchAddress(kLastIndex, &temp.m_lastIndex);
 
   //Need to reorder items since if there was a merge done the same Run
   //and/or Lumi can appear multiple times but we want to process them
   //all at once
 
   //We use a std::list for m_orderedIndices since inserting into the
   //middle of a std::list does not disrupt the iterators to already
   //existing entries
 
   //The Map is used to see if a Run/Lumi pair has appeared before
   typedef std::map<RunLumiPHIDKey, std::list<unsigned int>::iterator> RunLumiToLastEntryMap;
   RunLumiToLastEntryMap runLumiToLastEntryMap;
 
   //Need to group all lumis for the same run together and move the run
   //entry to the beginning
   typedef std::map<RunPHIDKey, std::pair<std::list<unsigned int>::iterator, std::list<unsigned int>::iterator> >
       RunToFirstLastEntryMap;
   RunToFirstLastEntryMap runToFirstLastEntryMap;
 
   for (Long64_t index = 0; index != indicesTree->GetEntries(); ++index) {
     indicesTree->GetEntry(index);
     //     std::cout <<"read r:"<<temp.m_run
     //        <<" l:"<<temp.m_lumi
     //        <<" b:"<<temp.m_beginTime
     //        <<" e:"<<temp.m_endTime
     //        <<" fi:" << temp.m_firstIndex
     //        <<" li:" << temp.m_lastIndex
     //        <<" type:" << temp.m_type << std::endl;
     m_runlumiToRange.push_back(temp);
 
     RunLumiPHIDKey runLumi(m_reducedHistoryIDs.at(temp.m_historyIDIndex), temp.m_run, temp.m_lumi);
     RunPHIDKey runKey(m_reducedHistoryIDs.at(temp.m_historyIDIndex), temp.m_run);
 
     RunLumiToLastEntryMap::iterator itFind = runLumiToLastEntryMap.find(runLumi);
     if (itFind == runLumiToLastEntryMap.end()) {
       //does not already exist
       //does the run for this already exist?
       std::list<unsigned int>::iterator itLastOfRun = m_orderedIndices.end();
 
       RunToFirstLastEntryMap::iterator itRunFirstLastEntryFind = runToFirstLastEntryMap.find(runKey);
       bool needNewEntryInRunFirstLastEntryMap = true;
       if (itRunFirstLastEntryFind != runToFirstLastEntryMap.end()) {
         needNewEntryInRunFirstLastEntryMap = false;
         if (temp.m_lumi != 0) {
           //lumis go to the end
           itLastOfRun = itRunFirstLastEntryFind->second.second;
           //we want to insert after this one so must advance the iterator
           ++itLastOfRun;
         } else {
           //runs go at the beginning
           itLastOfRun = itRunFirstLastEntryFind->second.first;
         }
       }
       std::list<unsigned int>::iterator iter = m_orderedIndices.insert(itLastOfRun, index);
       runLumiToLastEntryMap[runLumi] = iter;
       if (needNewEntryInRunFirstLastEntryMap)
         runToFirstLastEntryMap[runKey] = std::make_pair(iter, iter);
       else {
         if (temp.m_lumi != 0) {
           //lumis go at end
           runToFirstLastEntryMap[runKey].second = iter;
         } else {
           //since we haven't yet seen this run/lumi combination it means we haven't yet seen
           // a run so we can put this first
           runToFirstLastEntryMap[runKey].first = iter;
         }
       }
     } else {
       //We need to do a merge since the run/lumi already appeared. Put it after the existing entry
       //std::cout <<" found a second instance of "<<runLumi.first<<" "<<runLumi.second<<" at "<<index<<std::endl;
       std::list<unsigned int>::iterator itNext = itFind->second;
       ++itNext;
       std::list<unsigned int>::iterator iter = m_orderedIndices.insert(itNext, index);
       RunToFirstLastEntryMap::iterator itRunFirstLastEntryFind = runToFirstLastEntryMap.find(runKey);
       if (itRunFirstLastEntryFind->second.second == itFind->second) {
         //if the previous one was the last in the run, we need to update to make this one the last
         itRunFirstLastEntryFind->second.second = iter;
       }
       itFind->second = iter;
     }
   }
   m_nextIndexItr = m_orderedIndices.begin();
   m_presentIndexItr = m_orderedIndices.begin();
 
   if (m_nextIndexItr != m_orderedIndices.end()) {
     for (size_t index = 0; index < kNIndicies; ++index) {
       m_trees[index] = dynamic_cast<TTree*>(m_file->Get(kTypeNames[index]));
       assert(nullptr != m_trees[index]);
       m_treeReaders[index]->setTree(m_trees[index]);
     }
   }
   //After a file open, the framework expects to see a new 'IsRun'
   m_justOpenedFileSoNeedToGenerateRunTransition = true;
 
   return true;
 }

bool DQMRootSource::skipIt	(	edm::RunNumber_t	run,
		edm::LuminosityBlockNumber_t	lumi
	)		const

private

Definition at line 1060 of file DQMRootSource.cc.

References edm::binary_search_all(), electrons_cff::bool, edm::lessThan(), m_lumisToProcess, m_runsToProcess, and edm::search_all().

Referenced by readElements(), readFile_(), and readNextItemType().

                                                                                     {
   if (!m_runsToProcess.empty() && edm::search_all(m_runsToProcess, run) && lumi == 0) {
     return false;
   }
 
   edm::LuminosityBlockID lumiID = edm::LuminosityBlockID(run, lumi);
   edm::LuminosityBlockRange lumiRange = edm::LuminosityBlockRange(lumiID, lumiID);
   bool (*lt)(edm::LuminosityBlockRange const&, edm::LuminosityBlockRange const&) = &edm::lessThan;
   if (!m_lumisToProcess.empty() && !binary_search_all(m_lumisToProcess, lumiRange, lt)) {
     return true;
   }
   return false;
 }