Inheritance diagram for DQMRootSource:

Classes
class	RunLumiPHIDKey

class	RunPHIDKey

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

virtual	~DQMRootSource ()

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...

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

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

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

void	doEndLumi (LuminosityBlockPrincipal &lbp, bool cleaningUpAfterException, ProcessContext const *)
	Called by framework at end of lumi block. More...

void	doEndRun (RunPrincipal &rp, bool cleaningUpAfterException, ProcessContext const *)
	Called by framework at end of run. More...

void	doPostForkReacquireResources (std::shared_ptr< multicore::MessageReceiverForSource >)

void	doPreForkReleaseResources ()
	Called by the framework before forking the process. 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)
	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

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)

bool	skipForForking ()

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
virtual void	closeFile_ () override

	DQMRootSource (const DQMRootSource &)

virtual edm::InputSource::ItemType	getNextItemType () override

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

const DQMRootSource &	operator= (const DQMRootSource &)

void	readElements ()

virtual void	readEvent_ (edm::EventPrincipal &) override

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

virtual void	readLuminosityBlock_ (edm::LuminosityBlockPrincipal &lbCache) override

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

void	readNextItemType ()

virtual void	readRun_ (edm::RunPrincipal &rpCache) override

virtual 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::auto_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

size_t	m_presentlyOpenFileIndex

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< boost::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 }

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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
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 302 of file DQMRootSource.cc.

Constructor & Destructor Documentation

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

Definition at line 443 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_presentlyOpenFileIndex(0),
   m_trees(kNIndicies,static_cast<TTree*>(0)),
   m_treeReaders(kNIndicies,boost::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 ( )

virtual

Definition at line 490 of file DQMRootSource.cc.

References edm::InputFileCatalog::fileNames(), logFileAction(), m_catalog, m_file, and m_presentlyOpenFileIndex.

 {
   if(m_file.get() != 0 && m_file->IsOpen()) {
     m_file->Close();
     logFileAction("  Closed file ", m_catalog.fileNames()[m_presentlyOpenFileIndex].c_str());
   }
 }

DQMRootSource::DQMRootSource ( const DQMRootSource & )

private

Member Function Documentation

void DQMRootSource::closeFile_ ( )

overrideprivatevirtual

Reimplemented from edm::InputSource.

Definition at line 680 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 424 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 518 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 1045 of file DQMRootSource.cc.

References 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 & )

private

void DQMRootSource::readElements ( )

private

Definition at line 686 of file DQMRootSource.cc.

References cmsHarvester::index, kNoTypesStored, m_orderedIndices, m_presentIndexItr, m_reducedHistoryIDs, m_runlumiToRange, m_shouldReadMEs, m_treeReaders, matplotRender::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) {
       boost::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 513 of file DQMRootSource.cc.

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

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

overrideprivatevirtual

Reimplemented from edm::InputSource.

Definition at line 651 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_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_catalog.fileNames()[m_fileIndex-1],
       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 614 of file DQMRootSource.cc.

References assert(), 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 540 of file DQMRootSource.cc.

References assert(), 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 727 of file DQMRootSource.cc.

References assert(), 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, 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 556 of file DQMRootSource.cc.

References assert(), 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) {
         // We do not want to reset here Lumi products, since a dedicated
         // resetting is done at every lumi transition.
         if (ME->getLumiFlag()) continue;
     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 524 of file DQMRootSource.cc.

References assert(), 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 788 of file DQMRootSource.cc.

References cms::Exception::addContext(), assert(), electronStore::configs, edm::InputFileCatalog::fileNames(), edm::errors::FileOpenError, edm::errors::FileReadError, i, edm::ProcessHistory::id(), cmsHarvester::index, 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_presentlyOpenFileIndex, m_reducedHistoryIDs, m_runlumiToRange, m_skipBadFiles, m_treeReaders, m_trees, edm::InputSource::processHistoryRegistryForUpdate(), FSQHLTOfflineSource_cfi::processName, edm::ProcessHistoryRegistry::reducedProcessHistoryID(), edm::ParameterSet::registerFromString(), edm::ProcessHistoryRegistry::registerProcessHistory(), AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

Referenced by readFile_().

 {
   if(m_file.get() != 0 && iIndex > 0) {
     m_file->Close();
     logFileAction("  Closed file ", m_catalog.fileNames()[iIndex-1].c_str());
   }
   logFileAction("  Initiating request to open file ", m_catalog.fileNames()[iIndex].c_str());
   m_presentlyOpenFileIndex = iIndex;
   m_file.reset();
   std::auto_ptr<TFile> newFile;
   try {
     newFile = std::auto_ptr<TFile>(TFile::Open(m_catalog.fileNames()[iIndex].c_str()));
   } catch(cms::Exception const& e) {
     if(!m_skipBadFiles) {
       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;
     }
     return 0;
   }
   if(not newFile->IsZombie()) {  
     logFileAction("  Successfully opened file ", m_catalog.fileNames()[iIndex].c_str());
   } else {
     if(!m_skipBadFiles) {
       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;
     }
     return 0;
   }
   //Check file format version, which is encoded in the Title of the TFile
   if(0 != strcmp(newFile->GetTitle(),"1")) {
     edm::Exception ex(edm::errors::FileReadError);
     ex<<"Input file "<<m_catalog.fileNames()[iIndex].c_str() <<" does not appear to be a DQM Root file.\n";
   }
   
   //Get meta Data
   TDirectory* metaDir = newFile->GetDirectory(kMetaDataDirectoryAbsolute);
   if(0==metaDir) {
     if(!m_skipBadFiles) {
       edm::Exception ex(edm::errors::FileReadError);
       ex<<"Input file "<<m_catalog.fileNames()[iIndex].c_str() <<" 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 0;}
   }
   m_file = newFile; //passed all tests so now we want to use this file
   TTree* parameterSetTree = dynamic_cast<TTree*>(metaDir->Get(kParameterSetTree));
   assert(0!=parameterSetTree);
 
   edm::pset::Registry* psr = edm::pset::Registry::instance();
   assert(0!=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(0!=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(0!=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(0!=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 1;
 }

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

private

Definition at line 1029 of file DQMRootSource.cc.

References edm::binary_search_all(), edm::lessThan(), lt, 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;
 }