#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 one::DQMEDAnalyzer< one::DQMLuminosityBlockElements >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

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 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
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, 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(), TrackValidation_cff::task, 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](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 analyze(), bookHistograms(), Ecal2004TBTDCRanges_v1_cff::endRun, and fillDescriptions().

22 {}

Member Function Documentation

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

overrideprivate

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
	)

overrideprivate

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
	)

override

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
	)

override

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
	)

overrideprivate

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
	)

overrideprivate

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_, 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_, universalConfigTemplate::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](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";
 }