EcalDQMonitorTask Class Reference

#include <EcalDQMonitorTask.h>

Inheritance diagram for EcalDQMonitorTask:

Public Member Functions
void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
void	dqmBeginRun (edm::Run const &, edm::EventSetup const &) override
	EcalDQMonitorTask (edm::ParameterSet const &)
	~EcalDQMonitorTask ()
Public Member Functions inherited from DQMEDAnalyzer
void	beginRun (edm::Run const &, edm::EventSetup const &) final
void	beginStream (edm::StreamID id) final
	DQMEDAnalyzer (void)
void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
	~EDAnalyzerBase () 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
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)
Public Member Functions inherited from ecaldqm::EcalDQMonitor
	EcalDQMonitor (edm::ParameterSet const &)
virtual	~EcalDQMonitor ()(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from ecaldqm::EcalDQMonitor
static void	fillDescriptions (edm::ParameterSetDescription &)

Private Types
typedef void(EcalDQMonitorTask::*	Processor) (edm::Event const &, ecaldqm::Collections, std::set< ecaldqm::DQWorker * > const &)

Private Member Functions
void	analyze (edm::Event const &, edm::EventSetup const &) override
void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
void	endRun (edm::Run const &, edm::EventSetup const &) override
void	formSchedule (std::vector< ecaldqm::Collections > const &, edm::ParameterSet const &)
template<typename CollectionClass >
void	runOnCollection (edm::Event const &, ecaldqm::Collections, std::set< ecaldqm::DQWorker * > const &)

Private Attributes
bool	allowMissingCollections_
edm::EDGetToken	collectionTokens_ [ecaldqm::nCollections]
time_t	lastResetTime_
int	processedEvents_
float	resetInterval_
std::vector< std::pair< Processor, ecaldqm::Collections > >	schedule_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
Protected Member Functions inherited from ecaldqm::EcalDQMonitor
void	ecaldqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
void	ecaldqmBeginRun (edm::Run const &, edm::EventSetup const &)
void	ecaldqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)
void	ecaldqmEndRun (edm::Run const &, edm::EventSetup const &)
void	ecaldqmGetSetupObjects (edm::EventSetup const &)
template<typename FuncOnWorker >
void	executeOnWorkers_ (FuncOnWorker, std::string const &, std::string const &="", int=1)
Protected Attributes inherited from ecaldqm::EcalDQMonitor
std::string const	moduleName_
int const	verbosity_
std::vector< DQWorker * >	workers_

Detailed Description

Definition at line 19 of file EcalDQMonitorTask.h.

Member Typedef Documentation

typedef void(EcalDQMonitorTask::* EcalDQMonitorTask::Processor) (edm::Event const &, ecaldqm::Collections, std::set< ecaldqm::DQWorker * > const &)

private

Definition at line 35 of file EcalDQMonitorTask.h.

Constructor & Destructor Documentation

EcalDQMonitorTask::EcalDQMonitorTask

(

edm::ParameterSet const &

_ps

)

Definition at line 27 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorkerTask::addDependencies(), ecaldqm::DQWorkerTask::analyze(), ecaldqm::collectionName, edm::EDConsumerBase::consumesCollector(), symbols::dependencies, Exception, ecaldqm::EcalDQMonitor::executeOnWorkers_(), formSchedule(), ecaldqm::DependencySet::formSequence(), ecaldqm::DQWorker::getName(), edm::ParameterSet::getUntrackedParameterSet(), ecaldqm::kEcalRawData, lastResetTime_, ecaldqm::EcalDQMonitor::moduleName_, ecaldqm::nCollections, ecaldqm::DependencySet::push_back(), schedule_, edm::second(), ecaldqm::DQWorkerTask::setTokens(), ntuplemaker::time, and ecaldqm::EcalDQMonitor::verbosity_.

                                                               :
  DQMEDAnalyzer(),
  ecaldqm::EcalDQMonitor(_ps),
  schedule_(),
  allowMissingCollections_(_ps.getUntrackedParameter<bool>("allowMissingCollections")),
  processedEvents_(0),
  lastResetTime_(0),
  resetInterval_(_ps.getUntrackedParameter<double>("resetInterval"))
{
  ecaldqm::DependencySet dependencies;
  std::bitset<ecaldqm::nCollections> hasTaskToRun;
  edm::ConsumesCollector collector(consumesCollector());

  executeOnWorkers_([&dependencies, &hasTaskToRun, &collector, this](ecaldqm::DQWorker* worker){
                      ecaldqm::DQWorkerTask* task(dynamic_cast<ecaldqm::DQWorkerTask*>(worker));
                      if(!task)
                        throw cms::Exception("InvalidConfiguration") << "Non-task DQWorker " << worker->getName() << " passed";

                      task->addDependencies(dependencies);
                      for(unsigned iCol(0); iCol < ecaldqm::nCollections; ++iCol){
                        if(task->analyze(nullptr, ecaldqm::Collections(iCol))) // "dry run" mode
                          hasTaskToRun.set(iCol);
                      }

                      task->setTokens(collector);
                    }, "initialization");

  edm::ParameterSet const& collectionTags(_ps.getUntrackedParameterSet("collectionTags"));

  for(unsigned iCol(0); iCol < ecaldqm::nCollections; iCol++){
    if(hasTaskToRun[iCol])
      dependencies.push_back(ecaldqm::Dependency(ecaldqm::Collections(iCol)));
  }
  if(collectionTags.existsAs<edm::InputTag>("EcalRawData", false))
    dependencies.push_back(ecaldqm::Dependency(ecaldqm::kEcalRawData));

  formSchedule(dependencies.formSequence(), collectionTags);

  if(verbosity_ > 0){
    std::stringstream ss;
    ss << moduleName_ << ": Using collections" << std::endl;
    for(unsigned iCol(0); iCol < schedule_.size(); iCol++)
      ss << ecaldqm::collectionName[schedule_[iCol].second] << std::endl;
    edm::LogInfo("EcalDQM") << ss.str();
  }

  edm::ParameterSet const& commonParams(_ps.getUntrackedParameterSet("commonParameters"));
  if(commonParams.getUntrackedParameter<bool>("onlineMode"))
    lastResetTime_ = time(nullptr);
}

EcalDQMonitorTask::~EcalDQMonitorTask ( )

inline

Definition at line 22 of file EcalDQMonitorTask.h.

References Vispa.Share.Profiling::analyze(), bookHistograms(), and Ecal2004TBTDCRanges_v1_cff::endRun.

{}

Member Function Documentation

void EcalDQMonitorTask::analyze ( edm::Event const &  _evt, edm::EventSetup const &  _es  )

overrideprivatevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 158 of file EcalDQMonitorTask.cc.

References edm::SortedCollection< T, SORT >::begin(), collectionTokens_, DEFINE_FWK_MODULE, edm::SortedCollection< T, SORT >::end(), edm::EventID::event(), ecaldqm::EcalDQMonitor::executeOnWorkers_(), plotBeamSpotDB::first, edm::Event::getByToken(), ecaldqm::DQWorker::getName(), edm::EventBase::id(), ecaldqm::kEcalRawData, edm::EventID::luminosityBlock(), ecaldqm::EcalDQMonitor::moduleName_, ecaldqm::nDCC, ecaldqm::DQWorker::onlineMode(), processedEvents_, processEvent(), edm::EventID::run(), schedule_, edm::second(), ecaldqm::DQWorker::setEventNumber(), ecaldqm::DQWorker::setTime(), ntuplemaker::time, and ecaldqm::EcalDQMonitor::verbosity_.

{
  if(verbosity_ > 2) edm::LogInfo("EcalDQM") << moduleName_ << "::analyze: Run " << _evt.id().run() << " Lumisection " << _evt.id().luminosityBlock() << " Event " << _evt.id().event() << ": processed " << processedEvents_;

  if(schedule_.empty()) return;

  std::set<ecaldqm::DQWorker*> enabledTasks;

  edm::Handle<EcalRawDataCollection> dcchsHndl;
  if(_evt.getByToken(collectionTokens_[ecaldqm::kEcalRawData], dcchsHndl)){
    // determine event type (called run type in DCCHeader for some reason) for each FED
    std::stringstream ss;
    if(verbosity_ > 2) ss << moduleName_ << ": Event type ";

    short runType[ecaldqm::nDCC];
    std::fill_n(runType, ecaldqm::nDCC, -1);
    for(EcalRawDataCollection::const_iterator dcchItr = dcchsHndl->begin(); dcchItr != dcchsHndl->end(); ++dcchItr){
      if(verbosity_ > 2) ss << dcchItr->getRunType() << " ";
      runType[dcchItr->id() - 1] = dcchItr->getRunType();
    }
    if(verbosity_ > 2) edm::LogInfo("EcalDQM") << ss.str();

    bool processEvent(false);

    executeOnWorkers_([&enabledTasks, &runType, &processEvent, this](ecaldqm::DQWorker* worker){
                        if(static_cast<ecaldqm::DQWorkerTask*>(worker)->filterRunType(runType)){
                          if(this->verbosity_ > 2) edm::LogInfo("EcalDQM") << worker->getName() << " will run on this event";
                          enabledTasks.insert(worker);
                          processEvent = true;
                        }
                      }, "filterRunType");

    if(!processEvent) return;
  }
  else{
    edm::LogWarning("EcalDQM") << "EcalRawDataCollection does not exist. No event-type filtering will be applied";
    executeOnWorkers_([&enabledTasks](ecaldqm::DQWorker* worker){
                        enabledTasks.insert(worker);
                      }, "");
  }

  ++processedEvents_;

  // start event processing
  executeOnWorkers_([&_evt, &_es, &enabledTasks](ecaldqm::DQWorker* worker){
                      if(enabledTasks.find(worker) != enabledTasks.end()){
                        if(worker->onlineMode()) worker->setTime(time(nullptr));
                        worker->setEventNumber(_evt.id().event());
                        static_cast<ecaldqm::DQWorkerTask*>(worker)->beginEvent(_evt, _es);
                      }
                    }, "beginEvent");

  // run on collections
  for(unsigned iSch(0); iSch < schedule_.size(); iSch++){
    Processor processor(schedule_[iSch].first);
    (this->*processor)(_evt, schedule_[iSch].second, enabledTasks);
  }

  // close event processing
  executeOnWorkers_([&_evt, &_es, &enabledTasks](ecaldqm::DQWorker* worker){
                      if(enabledTasks.find(worker) != enabledTasks.end())
                        static_cast<ecaldqm::DQWorkerTask*>(worker)->endEvent(_evt, _es);
                    }, "endEvent");

  if(verbosity_ > 2) edm::LogInfo("EcalDQM") << moduleName_ << "::analyze: Closing Event " << _evt.id().event();
}

void EcalDQMonitorTask::beginLuminosityBlock ( edm::LuminosityBlock const &  _lumi, edm::EventSetup const &  _es  )

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 137 of file EcalDQMonitorTask.cc.

References ecaldqm::EcalDQMonitor::ecaldqmBeginLuminosityBlock().

{
  ecaldqmBeginLuminosityBlock(_lumi, _es);
}

void EcalDQMonitorTask::bookHistograms ( DQMStore::IBooker &  _ibooker, edm::Run const &  , edm::EventSetup const &  _es  )

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 102 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorker::bookMEs(), ecaldqm::EcalDQMonitor::ecaldqmGetSetupObjects(), and ecaldqm::EcalDQMonitor::executeOnWorkers_().

{
  ecaldqmGetSetupObjects(_es);

  executeOnWorkers_([&_ibooker](ecaldqm::DQWorker* worker){
      worker->bookMEs(_ibooker);
    }, "bookMEs", "Booking MEs");
}

void EcalDQMonitorTask::dqmBeginRun ( edm::Run const &  _run, edm::EventSetup const &  _es  )

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 112 of file EcalDQMonitorTask.cc.

References ecaldqm::EcalDQMonitor::ecaldqmBeginRun(), lastResetTime_, processedEvents_, and ntuplemaker::time.

{
  ecaldqmBeginRun(_run, _es);

  processedEvents_ = 0;

  if(lastResetTime_ != 0) lastResetTime_ = time(nullptr);
}

void EcalDQMonitorTask::endLuminosityBlock ( edm::LuminosityBlock const &  _lumi, edm::EventSetup const &  _es  )

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 143 of file EcalDQMonitorTask.cc.

References ecaldqm::EcalDQMonitor::ecaldqmEndLuminosityBlock(), ecaldqm::EcalDQMonitor::executeOnWorkers_(), lastResetTime_, ecaldqm::EcalDQMonitor::moduleName_, resetInterval_, ntuplemaker::time, and ecaldqm::EcalDQMonitor::verbosity_.

{
  ecaldqmEndLuminosityBlock(_lumi, _es);
  
  if(lastResetTime_ != 0 && (time(nullptr) - lastResetTime_) / 3600. > resetInterval_){
    if(verbosity_ > 0) edm::LogInfo("EcalDQM") << moduleName_ << ": Soft-resetting the histograms";
    executeOnWorkers_([](ecaldqm::DQWorker* worker){
                        static_cast<ecaldqm::DQWorkerTask*>(worker)->softReset();
                      }, "softReset");

    lastResetTime_ = time(nullptr);
  }
}

void EcalDQMonitorTask::endRun ( edm::Run const &  _run, edm::EventSetup const &  _es  )

overrideprivatevirtual

Reimplemented from edm::stream::EDAnalyzerBase.

Definition at line 122 of file EcalDQMonitorTask.cc.

References ecaldqm::EcalDQMonitor::ecaldqmEndRun(), ecaldqm::EcalDQMonitor::executeOnWorkers_(), lastResetTime_, and ecaldqm::DQWorker::releaseMEs().

{
  if(lastResetTime_ != 0)
    executeOnWorkers_([](ecaldqm::DQWorker* worker){
                        static_cast<ecaldqm::DQWorkerTask*>(worker)->recoverStats();
                      }, "recoverStats");

  ecaldqmEndRun(_run, _es);

  executeOnWorkers_([](ecaldqm::DQWorker* worker){
      worker->releaseMEs();
    }, "releaseMEs", "releasing histograms");
}

void EcalDQMonitorTask::fillDescriptions ( edm::ConfigurationDescriptions &  _descs )

static

Definition at line 80 of file EcalDQMonitorTask.cc.

References edm::ConfigurationDescriptions::addDefault(), edm::ParameterSetDescription::addNode(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSetDescription::addWildcardUntracked(), ecaldqm::EcalDQMonitor::fillDescriptions(), ecaldqm::DQWorkerTask::fillDescriptions(), and edm::RequireZeroOrMore.

{
  edm::ParameterSetDescription desc;
  ecaldqm::EcalDQMonitor::fillDescriptions(desc);

  edm::ParameterSetDescription taskParameters;
  ecaldqm::DQWorkerTask::fillDescriptions(taskParameters);
  edm::ParameterSetDescription allWorkers;
  allWorkers.addNode(edm::ParameterWildcard<edm::ParameterSetDescription>("*", edm::RequireZeroOrMore, false, taskParameters));
  desc.addUntracked("workerParameters", allWorkers);

  edm::ParameterSetDescription collectionTags;
  collectionTags.addWildcardUntracked<edm::InputTag>("*");
  desc.addUntracked("collectionTags", collectionTags);

  desc.addUntracked<bool>("allowMissingCollections", true);
  desc.addUntracked<double>("resetInterval", 0.);

  _descs.addDefault(desc);
}

void EcalDQMonitorTask::formSchedule ( std::vector< ecaldqm::Collections > const &  _preSchedule, edm::ParameterSet const &  _tagPSet  )

private

Definition at line 42 of file EcalDQMonitorTask2.cc.

References ecaldqm::collectionName, collectionTokens_, edm::EDConsumerBase::consumes(), Exception, edm::ParameterSet::getUntrackedParameter(), ecaldqm::kBlockSizeErrors, ecaldqm::kEBBasicCluster, ecaldqm::kEBChIdErrors, ecaldqm::kEBDigi, ecaldqm::kEBGainErrors, ecaldqm::kEBGainSwitchErrors, ecaldqm::kEBLaserLedUncalibRecHit, ecaldqm::kEBRecHit, ecaldqm::kEBReducedRecHit, ecaldqm::kEBSrFlag, ecaldqm::kEBSuperCluster, ecaldqm::kEBTestPulseUncalibRecHit, ecaldqm::kEBUncalibRecHit, ecaldqm::kEcalRawData, ecaldqm::kEEBasicCluster, ecaldqm::kEEChIdErrors, ecaldqm::kEEDigi, ecaldqm::kEEGainErrors, ecaldqm::kEEGainSwitchErrors, ecaldqm::kEELaserLedUncalibRecHit, ecaldqm::kEERecHit, ecaldqm::kEEReducedRecHit, ecaldqm::kEESrFlag, ecaldqm::kEESuperCluster, ecaldqm::kEETestPulseUncalibRecHit, ecaldqm::kEEUncalibRecHit, ecaldqm::kMEMBlockSizeErrors, ecaldqm::kMEMChIdErrors, ecaldqm::kMEMGainErrors, ecaldqm::kMEMTowerIdErrors, ecaldqm::kPnDiodeDigi, ecaldqm::kSource, ecaldqm::kTowerIdErrors, ecaldqm::kTrigPrimDigi, ecaldqm::kTrigPrimEmulDigi, schedule_, and GlobalPosition_Frontier_DevDB_cff::tag.

Referenced by EcalDQMonitorTask().

{
  for(std::vector<ecaldqm::Collections>::const_iterator colItr(_preSchedule.begin()); colItr != _preSchedule.end(); ++colItr){
    std::pair<Processor, ecaldqm::Collections> sch;

    edm::InputTag tag(_tagPSet.getUntrackedParameter<edm::InputTag>(ecaldqm::collectionName[*colItr]));

    switch(*colItr){
    case ecaldqm::kSource:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<FEDRawDataCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<FEDRawDataCollection>;
      break;
    case ecaldqm::kEcalRawData:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EcalRawDataCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EcalRawDataCollection>;
      break;
    case ecaldqm::kEBGainErrors:
    case ecaldqm::kEBChIdErrors:
    case ecaldqm::kEBGainSwitchErrors:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EBDetIdCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EBDetIdCollection>;
      break;
    case ecaldqm::kEEGainErrors:
    case ecaldqm::kEEChIdErrors:
    case ecaldqm::kEEGainSwitchErrors:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EEDetIdCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EEDetIdCollection>;
      break;
    case ecaldqm::kTowerIdErrors:
    case ecaldqm::kBlockSizeErrors:
    case ecaldqm::kMEMTowerIdErrors:
    case ecaldqm::kMEMBlockSizeErrors:
    case ecaldqm::kMEMChIdErrors:
    case ecaldqm::kMEMGainErrors:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>;
      break;
    case ecaldqm::kEBSrFlag:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EBSrFlagCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EBSrFlagCollection>;
      break;
    case ecaldqm::kEESrFlag:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EESrFlagCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EESrFlagCollection>;
      break;
    case ecaldqm::kEBDigi:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EBDigiCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EBDigiCollection>;
      break;
    case ecaldqm::kEEDigi:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EEDigiCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EEDigiCollection>;
      break;
    case ecaldqm::kPnDiodeDigi:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EcalPnDiodeDigiCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EcalPnDiodeDigiCollection>;
      break;
    case ecaldqm::kTrigPrimDigi:
    case ecaldqm::kTrigPrimEmulDigi:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EcalTrigPrimDigiCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EcalTrigPrimDigiCollection>;
      break;
    case ecaldqm::kEBUncalibRecHit:
    case ecaldqm::kEEUncalibRecHit:
    case ecaldqm::kEBLaserLedUncalibRecHit:
    case ecaldqm::kEELaserLedUncalibRecHit:
    case ecaldqm::kEBTestPulseUncalibRecHit:
    case ecaldqm::kEETestPulseUncalibRecHit:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EcalUncalibratedRecHitCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EcalUncalibratedRecHitCollection>;
      break;
    case ecaldqm::kEBRecHit:
    case ecaldqm::kEBReducedRecHit:
    case ecaldqm::kEERecHit:
    case ecaldqm::kEEReducedRecHit:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<EcalRecHitCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<EcalRecHitCollection>;
      break;
    case ecaldqm::kEBBasicCluster:
    case ecaldqm::kEEBasicCluster:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<edm::View<reco::CaloCluster> >(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<edm::View<reco::CaloCluster> >;
      break;
    case ecaldqm::kEBSuperCluster:
    case ecaldqm::kEESuperCluster:
      collectionTokens_[*colItr] = edm::EDGetToken(consumes<reco::SuperClusterCollection>(tag));
      sch.first = &EcalDQMonitorTask::runOnCollection<reco::SuperClusterCollection>;
      break;
    default:
      throw cms::Exception("InvalidConfiguration") << "Undefined collection " << *colItr;
    }

    sch.second = *colItr;

    schedule_.push_back(sch);
  }
}

template<typename CollectionClass >

void EcalDQMonitorTask::runOnCollection ( edm::Event const &  _evt, ecaldqm::Collections  _col, std::set< ecaldqm::DQWorker * > const &  _enabledTasks  )

private

Definition at line 21 of file EcalDQMonitorTask2.cc.

References allowMissingCollections_, mps_alisetup::collection, ecaldqm::collectionName, collectionTokens_, Exception, ecaldqm::EcalDQMonitor::executeOnWorkers_(), edm::Event::getByToken(), ecaldqm::EcalDQMonitor::moduleName_, edm::Handle< T >::product(), and ecaldqm::EcalDQMonitor::verbosity_.

{
  edm::Handle<CollectionClass> hndl;
  if(!_evt.getByToken(collectionTokens_[_col], hndl)){
    if(!allowMissingCollections_)
      throw cms::Exception("ObjectNotFound") << moduleName_ << "::runOnCollection: " << ecaldqm::collectionName[_col] << " does not exist";
    edm::LogWarning("EcalDQM") << moduleName_ << "::runOnCollection: " << ecaldqm::collectionName[_col] << " does not exist";
    return;
  }

  CollectionClass const* collection(hndl.product());

  executeOnWorkers_([collection, _col, &_enabledTasks, this](ecaldqm::DQWorker* worker){
                      if(_enabledTasks.find(worker) != _enabledTasks.end())
                        static_cast<ecaldqm::DQWorkerTask*>(worker)->analyze(collection, _col);
                    }, "analyze");

  if(verbosity_ > 1) edm::LogInfo("EcalDQM") << moduleName_ << "::runOn" << ecaldqm::collectionName[_col] << " returning";
}

Member Data Documentation

bool EcalDQMonitorTask::allowMissingCollections_

private

Definition at line 45 of file EcalDQMonitorTask.h.

Referenced by runOnCollection().

edm::EDGetToken EcalDQMonitorTask::collectionTokens_[ecaldqm::nCollections]

private

Definition at line 43 of file EcalDQMonitorTask.h.

Referenced by analyze(), formSchedule(), and runOnCollection().

time_t EcalDQMonitorTask::lastResetTime_

private

Definition at line 49 of file EcalDQMonitorTask.h.

Referenced by dqmBeginRun(), EcalDQMonitorTask(), endLuminosityBlock(), and endRun().

int EcalDQMonitorTask::processedEvents_

private

Definition at line 46 of file EcalDQMonitorTask.h.

Referenced by analyze(), and dqmBeginRun().

float EcalDQMonitorTask::resetInterval_

private

Definition at line 50 of file EcalDQMonitorTask.h.

Referenced by endLuminosityBlock().

std::vector<std::pair<Processor, ecaldqm::Collections> > EcalDQMonitorTask::schedule_

private

Definition at line 44 of file EcalDQMonitorTask.h.

Referenced by Config.Process::_insertPaths(), Config.Process::_replaceInSchedule(), analyze(), Config.Process::dumpPython(), EcalDQMonitorTask(), formSchedule(), Config.Process::prune(), and Config.Process::resolve().