#include <EcalDQMonitorTask.h>

Inheritance diagram for EcalDQMonitorTask:

Public Member Functions
	EcalDQMonitorTask (edm::ParameterSet const &)

	~EcalDQMonitorTask ()

Public Member Functions inherited from EcalDQMonitor
	EcalDQMonitor (const edm::ParameterSet &)

virtual	~EcalDQMonitor ()

Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Private Types
typedef void(EcalDQMonitorTask::*	Processor )(edm::Event const &, ecaldqm::Collections)

Private Member Functions
void	analyze (edm::Event const &, edm::EventSetup const &)

void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

void	beginRun (edm::Run const &, edm::EventSetup const &)

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

void	endRun (edm::Run const &, edm::EventSetup const &)

void	formSchedule_ (std::vector< ecaldqm::Collections > const &, std::multimap< ecaldqm::Collections, ecaldqm::Collections > const &)

void	registerCollection (ecaldqm::Collections, edm::InputTag const &)

template<class C >
void	runOnCollection (edm::Event const &, ecaldqm::Collections)

template<>
void	runOnCollection (edm::Event const &_evt, ecaldqm::Collections _collection)

Private Attributes
bool	allowMissingCollections_

edm::EDGetToken	collectionTokens_ [ecaldqm::nCollections]

std::map < ecaldqm::DQWorkerTask *, bool >	enabled_

bool	evaluateTime_

int	ievt_

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

std::vector < ecaldqm::DQWorkerTask * >	taskLists_ [ecaldqm::nCollections]

std::map < ecaldqm::DQWorkerTask *, double >	taskTimes_

std::vector < ecaldqm::DQWorkerTask * >	workers_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

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 Attributes inherited from EcalDQMonitor
bool	initialized_

const bool	mergeRuns_

std::string	moduleName_

const int	verbosity_

Detailed Description

Definition at line 24 of file EcalDQMonitorTask.h.

Member Typedef Documentation

typedef void(EcalDQMonitorTask::* EcalDQMonitorTask::Processor)(edm::Event const &, ecaldqm::Collections)

private

Definition at line 40 of file EcalDQMonitorTask.h.

Constructor & Destructor Documentation

EcalDQMonitorTask::EcalDQMonitorTask ( edm::ParameterSet const & _ps )

Definition at line 27 of file EcalDQMonitorTask.cc.

References ecaldqm::collectionName, collectionTokens_, gather_cfg::cout, ecaldqm::SetWorker::findFactory(), formSchedule_(), ecaldqm::DQWorkerTask::getDependencies(), ecaldqm::DQWorker::getName(), edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSet(), ecaldqm::kEcalRawData, EcalDQMonitor::moduleName_, ecaldqm::nCollections, registerCollection(), schedule_, edm::second(), ecaldqm::DQWorker::setVerbosity(), taskLists_, EcalDQMonitor::verbosity_, and workers_.

                                                                :
   EcalDQMonitor(_ps),
   ievt_(0),
   workers_(0),
   schedule_(),
   enabled_(),
   taskTimes_(),
   evaluateTime_(_ps.getUntrackedParameter<bool>("evaluateTime")),
   allowMissingCollections_(_ps.getUntrackedParameter<bool>("allowMissingCollections"))
 {
   std::vector<std::string> taskNames(_ps.getUntrackedParameter<std::vector<std::string> >("tasks"));
   edm::ParameterSet const& taskParams(_ps.getUntrackedParameterSet("taskParameters"));
   edm::ParameterSet const& mePaths(_ps.getUntrackedParameterSet("mePaths"));
 
   ecaldqm::WorkerFactory factory(0);
   std::multimap<ecaldqm::Collections, ecaldqm::Collections> dependencies;
 
   for(std::vector<std::string>::iterator tItr(taskNames.begin()); tItr != taskNames.end(); ++tItr){
     if(!(factory = ecaldqm::SetWorker::findFactory(*tItr))) continue;
 
     if(verbosity_ > 0) std::cout << moduleName_ << ": Setting up " << *tItr << std::endl;
 
     ecaldqm::DQWorker* worker(factory(taskParams, mePaths.getUntrackedParameterSet(*tItr)));
     if(worker->getName() != *tItr){
       delete worker;
 
       if(verbosity_ > 0) std::cout << moduleName_ << ": " << *tItr << " could not be configured" << std::endl; 
       continue;
     }
     ecaldqm::DQWorkerTask* task(static_cast<ecaldqm::DQWorkerTask*>(worker));
     task->setVerbosity(verbosity_);
 
     workers_.push_back(task);
 
     std::vector<std::pair<ecaldqm::Collections, ecaldqm::Collections> > const& dep(task->getDependencies());
     for(std::vector<std::pair<ecaldqm::Collections, ecaldqm::Collections> >::const_iterator depItr(dep.begin()); depItr != dep.end(); ++depItr)
       dependencies.insert(*depItr);
   }
 
   edm::ParameterSet const& collectionTags(_ps.getUntrackedParameterSet("collectionTags"));
 
   std::vector<ecaldqm::Collections> usedCollections;
 
   for(unsigned iCol(0); iCol < ecaldqm::nCollections; iCol++){
 
     collectionTokens_[iCol] = edm::EDGetToken();
     taskLists_[iCol] = std::vector<ecaldqm::DQWorkerTask*>();
 
     bool use(iCol == ecaldqm::kEcalRawData);
 
     for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
       if((*wItr)->runsOn(iCol)){
     taskLists_[iCol].push_back(*wItr);
     use = true;
       }
     }
     if(use){
       registerCollection(ecaldqm::Collections(iCol), collectionTags.getUntrackedParameter<edm::InputTag>(ecaldqm::collectionName[iCol]));
       usedCollections.push_back(ecaldqm::Collections(iCol));
     }
 
   }
 
   formSchedule_(usedCollections, dependencies);
 
   if(verbosity_ > 0){
     std::cout << moduleName_ << ": Using collections" << std::endl;
     for(unsigned iCol(0); iCol < schedule_.size(); iCol++)
       std::cout << ecaldqm::collectionName[schedule_[iCol].second] << std::endl;
     std::cout << std::endl;
   }
 }

EcalDQMonitorTask::~EcalDQMonitorTask ( )

Definition at line 100 of file EcalDQMonitorTask.cc.

References workers_.

 {
   for(std::vector<ecaldqm::DQWorkerTask *>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr)
     delete *wItr;
 }

Member Function Documentation

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

privatevirtual

Implements edm::EDAnalyzer.

Definition at line 182 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorkerTask::beginEvent(), ecaldqm::DQWorker::bookMEs(), collectionTokens_, gather_cfg::cout, enabled_, ecaldqm::DQWorkerTask::endEvent(), ecaldqm::DQWorkerTask::filterRunType(), first, edm::Event::getByToken(), ecaldqm::DQWorker::getName(), ievt_, ecaldqm::DQWorker::isInitialized(), ecaldqm::kEcalRawData, EcalDQMonitor::moduleName_, environment_file_cff::runType, schedule_, edm::second(), ecaldqm::DQWorker::setInitialized(), EcalDQMonitor::verbosity_, and workers_.

 {
   ievt_++;
 
   edm::Handle<EcalRawDataCollection> dcchsHndl;
   if(!_evt.getByToken(collectionTokens_[ecaldqm::kEcalRawData], dcchsHndl))
     throw cms::Exception("ObjectNotFound") << "EcalRawDataCollection does not exist";
  
   // determine event type (called run type in DCCHeader for some reason) for each FED
   std::vector<short> runType(54, -1);
   for(EcalRawDataCollection::const_iterator dcchItr = dcchsHndl->begin(); dcchItr != dcchsHndl->end(); ++dcchItr){
     runType[dcchItr->id() - 1] = dcchItr->getRunType();
   }
 
   bool atLeastOne(false);
 
   ecaldqm::DQWorkerTask* task(0);
 
   // set up task modules
   for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
     task = *wItr;
 
     if(task->filterRunType(runType)){
       enabled_[task] = true;
 
       if(!task->isInitialized()){
     if(verbosity_ > 1) std::cout << moduleName_ << ": Booking MEs for " << task->getName() << std::endl;
     task->bookMEs();
     task->setInitialized(true);
       }
 
       task->beginEvent(_evt, _es);
       atLeastOne = true;
     }else{
       enabled_[task] = false;
     }
   }
 
   if(!atLeastOne) return;
 
   // run on collections
   for(unsigned iSch(0); iSch < schedule_.size(); iSch++){
     Processor processor(schedule_[iSch].first);
     (this->*processor)(_evt, schedule_[iSch].second);
   }
 
   // close event
   for(std::vector<ecaldqm::DQWorkerTask *>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
     task = *wItr;
     if(enabled_[task]) task->endEvent(_evt, _es);
   }
 
 }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 164 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorker::beginLuminosityBlock(), ecaldqm::DQWorker::isInitialized(), ecaldqm::kLumiSection, ecaldqm::DQWorkerTask::runsOn(), and workers_.

 {
   for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
     ecaldqm::DQWorkerTask* task(*wItr);
     if(task->isInitialized() && task->runsOn(ecaldqm::kLumiSection)) task->beginLuminosityBlock(_lumi, _es);
   }
 }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 116 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorker::beginRun(), gather_cfg::cout, edm::EventSetup::get(), ievt_, ecaldqm::kRun, EcalDQMonitor::moduleName_, edm::ESHandle< class >::product(), ecaldqm::DQWorker::reset(), edm::RunBase::run(), ecaldqm::DQWorkerTask::runsOn(), ecaldqm::setElectronicsMap(), ecaldqm::setTrigTowerMap(), taskTimes_, EcalDQMonitor::verbosity_, and workers_.

 {
   // set up ecaldqm::electronicsMap in EcalDQMCommonUtils
   edm::ESHandle<EcalElectronicsMapping> elecMapHandle;
   _es.get<EcalMappingRcd>().get(elecMapHandle);
   ecaldqm::setElectronicsMap(elecMapHandle.product());
 
   // set up ecaldqm::electronicsMap in EcalDQMCommonUtils
   edm::ESHandle<EcalTrigTowerConstituentsMap> ttMapHandle;
   _es.get<IdealGeometryRecord>().get(ttMapHandle);
   ecaldqm::setTrigTowerMap(ttMapHandle.product());
 
   for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
     ecaldqm::DQWorkerTask* task(*wItr);
     task->reset();
     if(task->runsOn(ecaldqm::kRun)) task->beginRun(_run, _es);
   }
 
   if(verbosity_ > 0)
     std::cout << moduleName_ << ": Starting run " << _run.run() << std::endl;
 
   ievt_ = 0;
   taskTimes_.clear();
 }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 173 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorker::endLuminosityBlock(), ecaldqm::DQWorker::isInitialized(), ecaldqm::kLumiSection, ecaldqm::DQWorkerTask::runsOn(), and workers_.

 {
   for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
     ecaldqm::DQWorkerTask* task(*wItr);
     if(task->isInitialized() && task->runsOn(ecaldqm::kLumiSection)) task->endLuminosityBlock(_lumi, _es);
   }
 }

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

privatevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 142 of file EcalDQMonitorTask.cc.

References ecaldqm::DQWorker::endRun(), evaluateTime_, ecaldqm::DQWorker::getName(), ievt_, ecaldqm::kRun, EcalDQMonitor::moduleName_, ecaldqm::DQWorkerTask::runsOn(), taskTimes_, and workers_.

 {
   for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
     ecaldqm::DQWorkerTask* task(*wItr);
     if(task->runsOn(ecaldqm::kRun)) task->endRun(_run, _es);
   }
 
   if(evaluateTime_){
     std::stringstream ss;
 
     ss << "************** " << moduleName_ << " **************" << std::endl;
     ss << "      Mean time consumption of the modules" << std::endl;
     ss << "____________________________________" << std::endl;
     for(std::vector<ecaldqm::DQWorkerTask*>::iterator wItr(workers_.begin()); wItr != workers_.end(); ++wItr){
       ecaldqm::DQWorkerTask* task(*wItr);
       ss << std::setw(20) << std::setfill(' ') << task->getName() << "|   " << (taskTimes_[task] / ievt_) << std::endl;
     }
     edm::LogInfo("EcalDQM") << ss.str();
   }
 }

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

static

Definition at line 108 of file EcalDQMonitorTask.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

 {
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   _descs.addDefault(desc);
 }

void EcalDQMonitorTask::formSchedule_	(	std::vector< ecaldqm::Collections > const &	_usedCollections,
		std::multimap< ecaldqm::Collections, ecaldqm::Collections > const &	_dependencies
	)

private

Definition at line 152 of file EcalDQMonitorTask2.cc.

References edm::hlt::Exception, spr::find(), ecaldqm::kBlockSizeErrors, ecaldqm::kChIdErrors, ecaldqm::kEBBasicCluster, ecaldqm::kEBDigi, ecaldqm::kEBRecHit, ecaldqm::kEBSrFlag, ecaldqm::kEBSuperCluster, ecaldqm::kEBUncalibRecHit, ecaldqm::kEcalRawData, ecaldqm::kEEBasicCluster, ecaldqm::kEEDigi, ecaldqm::kEERecHit, ecaldqm::kEESrFlag, ecaldqm::kEESuperCluster, ecaldqm::kEEUncalibRecHit, ecaldqm::kGainErrors, ecaldqm::kGainSwitchErrors, ecaldqm::kMEMBlockSizeErrors, ecaldqm::kMEMChIdErrors, ecaldqm::kMEMGainErrors, ecaldqm::kMEMTowerIdErrors, ecaldqm::kPnDiodeDigi, ecaldqm::kSource, ecaldqm::kTowerIdErrors, ecaldqm::kTrigPrimDigi, ecaldqm::kTrigPrimEmulDigi, and schedule_.

Referenced by EcalDQMonitorTask().

 {
   typedef std::multimap<ecaldqm::Collections, ecaldqm::Collections>::const_iterator mmiter;
 
   std::vector<ecaldqm::Collections> preSchedule;
   std::vector<ecaldqm::Collections>::iterator insertPoint, findPoint;
 
   for(std::vector<ecaldqm::Collections>::const_iterator colItr(_usedCollections.begin()); colItr != _usedCollections.end(); ++colItr){
 
     bool inserted(true);
     if((insertPoint = find(preSchedule.begin(), preSchedule.end(), *colItr)) == preSchedule.end()) inserted = false;
 
     std::pair<mmiter, mmiter> range(_dependencies.equal_range(*colItr));
 
     for(mmiter depItr(range.first); depItr != range.second; ++depItr){
 
       if(depItr->second == depItr->first)
     throw cms::Exception("Fatal") << "Collection " << depItr->second << " depends on itself";
       if(find(_usedCollections.begin(), _usedCollections.end(), depItr->second) == _usedCollections.end())
     throw cms::Exception("Fatal") << "Collection " << depItr->first << " depends on Collection " << depItr->second;
 
       if((findPoint = find(preSchedule.begin(), preSchedule.end(), depItr->second)) == preSchedule.end())
     preSchedule.insert(insertPoint, depItr->second);
       else if(findPoint > insertPoint)
     throw cms::Exception("InvalidConfiguration") << "Circular dependencies in Collections";
 
     }
 
     if(!inserted) preSchedule.push_back(*colItr);
 
   }
 
   for(std::vector<ecaldqm::Collections>::const_iterator colItr(preSchedule.begin()); colItr != preSchedule.end(); ++colItr){
     std::pair<Processor, ecaldqm::Collections> sch;
 
     switch(*colItr){
     case ecaldqm::kSource:
       sch.first = &EcalDQMonitorTask::runOnCollection<FEDRawDataCollection>; break;
     case ecaldqm::kEcalRawData:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalRawDataCollection>; break;
     case ecaldqm::kGainErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<DetIdCollection>; break;
     case ecaldqm::kChIdErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<DetIdCollection>; break;
     case ecaldqm::kGainSwitchErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<DetIdCollection>; break;
     case ecaldqm::kTowerIdErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>; break;
     case ecaldqm::kBlockSizeErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>; break;
     case ecaldqm::kMEMTowerIdErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>; break;
     case ecaldqm::kMEMBlockSizeErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>; break;
     case ecaldqm::kMEMChIdErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>; break;
     case ecaldqm::kMEMGainErrors:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalElectronicsIdCollection>; break;
     case ecaldqm::kEBSrFlag:
       sch.first = &EcalDQMonitorTask::runOnCollection<EBSrFlagCollection>; break;
     case ecaldqm::kEESrFlag:
       sch.first = &EcalDQMonitorTask::runOnCollection<EESrFlagCollection>; break;
     case ecaldqm::kEBDigi:
       sch.first = &EcalDQMonitorTask::runOnCollection<EBDigiCollection>; break;
     case ecaldqm::kEEDigi:
       sch.first = &EcalDQMonitorTask::runOnCollection<EEDigiCollection>; break;
     case ecaldqm::kPnDiodeDigi:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalPnDiodeDigiCollection>; break;
     case ecaldqm::kTrigPrimDigi:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalTrigPrimDigiCollection>; break;
     case ecaldqm::kTrigPrimEmulDigi:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalTrigPrimDigiCollection>; break;
     case ecaldqm::kEBUncalibRecHit:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalUncalibratedRecHitCollection>; break;
     case ecaldqm::kEEUncalibRecHit:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalUncalibratedRecHitCollection>; break;
     case ecaldqm::kEBRecHit:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalRecHitCollection>; break;
     case ecaldqm::kEERecHit:
       sch.first = &EcalDQMonitorTask::runOnCollection<EcalRecHitCollection>; break;
     case ecaldqm::kEBBasicCluster:
       sch.first = &EcalDQMonitorTask::runOnCollection<reco::BasicClusterCollection>; break;
     case ecaldqm::kEEBasicCluster:
       sch.first = &EcalDQMonitorTask::runOnCollection<reco::BasicClusterCollection>; break;
     case ecaldqm::kEBSuperCluster:
       sch.first = &EcalDQMonitorTask::runOnCollection<reco::SuperClusterCollection>; break;
     case ecaldqm::kEESuperCluster:
       sch.first = &EcalDQMonitorTask::runOnCollection<reco::SuperClusterCollection>; break;
     default:
       throw cms::Exception("InvalidConfiguration") << "Undefined collection " << *colItr;
     }
 
     sch.second = *colItr;
 
     schedule_.push_back(sch);
   }
 
 }

void EcalDQMonitorTask::registerCollection	(	ecaldqm::Collections	_collection,
		edm::InputTag const &	_inputTag
	)

private

Definition at line 20 of file EcalDQMonitorTask2.cc.

References collectionTokens_, edm::hlt::Exception, ecaldqm::kBlockSizeErrors, ecaldqm::kChIdErrors, ecaldqm::kEBBasicCluster, ecaldqm::kEBDigi, ecaldqm::kEBRecHit, ecaldqm::kEBSrFlag, ecaldqm::kEBSuperCluster, ecaldqm::kEBUncalibRecHit, ecaldqm::kEcalRawData, ecaldqm::kEEBasicCluster, ecaldqm::kEEDigi, ecaldqm::kEERecHit, ecaldqm::kEESrFlag, ecaldqm::kEESuperCluster, ecaldqm::kEEUncalibRecHit, ecaldqm::kGainErrors, ecaldqm::kGainSwitchErrors, ecaldqm::kMEMBlockSizeErrors, ecaldqm::kMEMChIdErrors, ecaldqm::kMEMGainErrors, ecaldqm::kMEMTowerIdErrors, ecaldqm::kPnDiodeDigi, ecaldqm::kSource, ecaldqm::kTowerIdErrors, ecaldqm::kTrigPrimDigi, and ecaldqm::kTrigPrimEmulDigi.

Referenced by EcalDQMonitorTask().

 {
   switch(_collection){
     case ecaldqm::kSource:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<FEDRawDataCollection>(_inputTag)); break;
     case ecaldqm::kEcalRawData:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalRawDataCollection>(_inputTag)); break;
     case ecaldqm::kGainErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<DetIdCollection>(_inputTag)); break;
     case ecaldqm::kChIdErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<DetIdCollection>(_inputTag)); break;
     case ecaldqm::kGainSwitchErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<DetIdCollection>(_inputTag)); break;
     case ecaldqm::kTowerIdErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(_inputTag)); break;
     case ecaldqm::kBlockSizeErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(_inputTag)); break;
     case ecaldqm::kMEMTowerIdErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(_inputTag)); break;
     case ecaldqm::kMEMBlockSizeErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(_inputTag)); break;
     case ecaldqm::kMEMChIdErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(_inputTag)); break;
     case ecaldqm::kMEMGainErrors:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalElectronicsIdCollection>(_inputTag)); break;
     case ecaldqm::kEBSrFlag:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EBSrFlagCollection>(_inputTag)); break;
     case ecaldqm::kEESrFlag:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EESrFlagCollection>(_inputTag)); break;
     case ecaldqm::kEBDigi:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EBDigiCollection>(_inputTag)); break;
     case ecaldqm::kEEDigi:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EEDigiCollection>(_inputTag)); break;
     case ecaldqm::kPnDiodeDigi:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalPnDiodeDigiCollection>(_inputTag)); break;
     case ecaldqm::kTrigPrimDigi:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalTrigPrimDigiCollection>(_inputTag)); break;
     case ecaldqm::kTrigPrimEmulDigi:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalTrigPrimDigiCollection>(_inputTag)); break;
     case ecaldqm::kEBUncalibRecHit:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalUncalibratedRecHitCollection>(_inputTag)); break;
     case ecaldqm::kEEUncalibRecHit:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalUncalibratedRecHitCollection>(_inputTag)); break;
     case ecaldqm::kEBRecHit:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalRecHitCollection>(_inputTag)); break;
     case ecaldqm::kEERecHit:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<EcalRecHitCollection>(_inputTag)); break;
     case ecaldqm::kEBBasicCluster:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<reco::BasicClusterCollection>(_inputTag)); break;
     case ecaldqm::kEEBasicCluster:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<reco::BasicClusterCollection>(_inputTag)); break;
     case ecaldqm::kEBSuperCluster:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<reco::SuperClusterCollection>(_inputTag)); break;
     case ecaldqm::kEESuperCluster:
       collectionTokens_[_collection] = edm::EDGetToken(consumes<reco::SuperClusterCollection>(_inputTag)); break;
     default:
       throw cms::Exception("InvalidConfiguration") << "Undefined collection " << _collection;
   }
 }

template<class C >

void EcalDQMonitorTask::runOnCollection	(	edm::Event const &	_evt,
		ecaldqm::Collections	_collection
	)

private

Definition at line 82 of file EcalDQMonitorTask2.cc.

References allowMissingCollections_, ecaldqm::DQWorkerTask::analyze(), begin, ecaldqm::collectionName, collectionTokens_, enabled_, evaluateTime_, edm::hlt::Exception, edm::Event::getByToken(), edm::Handle< T >::product(), taskLists_, and taskTimes_.

 {
   edm::Handle<C> hndl;
   if(_evt.getByToken(collectionTokens_[_collection], hndl)){
 
     TStopwatch* sw(0);
     if(evaluateTime_){
       sw = new TStopwatch;
       sw->Stop();
     }
 
     ecaldqm::DQWorkerTask* task(0);
 
     for(std::vector<ecaldqm::DQWorkerTask *>::iterator wItr(taskLists_[_collection].begin()); wItr != taskLists_[_collection].end(); ++wItr){
       task = *wItr;
       if(evaluateTime_) sw->Start();
       if(enabled_[task]) task->analyze(hndl.product(), _collection);
       if(evaluateTime_){
     sw->Stop();
     taskTimes_[task] += sw->RealTime();
       }
     }
 
     delete sw;
   }
   else if(!allowMissingCollections_)
     throw cms::Exception("ObjectNotFound") << ecaldqm::collectionName[_collection] << " does not exist";
 }

template<>

void EcalDQMonitorTask::runOnCollection	(	edm::Event const &	_evt,
		ecaldqm::Collections	_collection
	)

private

Definition at line 113 of file EcalDQMonitorTask2.cc.

References ecaldqm::DQWorkerTask::analyze(), begin, ecaldqm::collectionName, edm::hlt::Exception, and edm::EDCollection< T >::push_back().

 {
   edm::Handle<EBDetIdCollection> ebHndl;
   edm::Handle<EEDetIdCollection> eeHndl;
   if(_evt.getByToken(collectionTokens_[_collection], ebHndl) && _evt.getByToken(collectionTokens_[_collection], eeHndl)){
     unsigned nEB(ebHndl->size());
     unsigned nEE(eeHndl->size());
 
     if(nEB == 0 && nEE == 0) return;
 
     DetIdCollection ids;
     for(unsigned iId(0); iId < nEB; iId++) ids.push_back(DetId(ebHndl->at(iId)));
     for(unsigned iId(0); iId < nEE; iId++) ids.push_back(DetId(eeHndl->at(iId)));
 
     TStopwatch* sw(0);
     if(evaluateTime_){
       sw = new TStopwatch;
       sw->Stop();
     }
 
     ecaldqm::DQWorkerTask* task(0);
 
     for(std::vector<ecaldqm::DQWorkerTask *>::iterator wItr(taskLists_[_collection].begin()); wItr != taskLists_[_collection].end(); ++wItr){
       task = *wItr;
       if(evaluateTime_) sw->Start();
       if(enabled_[task]) task->analyze(const_cast<const DetIdCollection*>(&ids), _collection);
       if(evaluateTime_){
     sw->Stop();
     taskTimes_[task] += sw->RealTime();
       }
     }
 
     delete sw;
   }
   else if(!allowMissingCollections_)
     throw cms::Exception("ObjectNotFound") << ecaldqm::collectionName[_collection] << " does not exist";
 }