#include <PresampleClient.h>

Inheritance diagram for ecaldqm::PresampleClient:

Public Types
enum	MESets { kQuality, kMean, kMeanDCC, kRMS, kRMSMap, kRMSMapSummary, kQualitySummary, nMESets }

enum	Sources { sPedestal, nSources }

Public Types inherited from ecaldqm::DQWorkerClient
enum	Sources { nSources }

Public Types inherited from ecaldqm::DQWorker
enum	MESets { nMESets }

Public Member Functions
void	bookMEs () override

	PresampleClient (const edm::ParameterSet &, const edm::ParameterSet &)

void	producePlots () override

	~PresampleClient ()

Public Member Functions inherited from ecaldqm::DQWorkerClient
	DQWorkerClient (const edm::ParameterSet &, const edm::ParameterSet &, std::string const &)

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

virtual void	initialize ()

void	reset ()

virtual	~DQWorkerClient ()

Public Member Functions inherited from ecaldqm::DQWorker
virtual void	beginLuminosityBlock (const edm::LuminosityBlock &, const edm::EventSetup &)

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

	DQWorker (const edm::ParameterSet &, const edm::ParameterSet &, std::string const &)

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

const std::vector< MESet * > &	getMEs ()

virtual std::string const &	getName ()

virtual bool	isInitialized ()

virtual void	setInitialized (bool _init)

virtual void	setVerbosity (int _verbosity)

virtual	~DQWorker ()

Static Public Member Functions
static void	setMEData (std::vector< MEData > &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	setMEData (std::vector< MEData > &)

Protected Attributes
float	expectedMean_

float	meanThreshold_

int	minChannelEntries_

int	minTowerEntries_

float	noisyFracThreshold_

float	rmsThreshold_

float	rmsThresholdHighEta_

Protected Attributes inherited from ecaldqm::DQWorkerClient
std::vector< MESet const * >	sources_

Protected Attributes inherited from ecaldqm::DQWorker
bool	initialized_

std::vector< MESet * >	MEs_

std::string	name_

int	verbosity_

Additional Inherited Members
Static Public Attributes inherited from ecaldqm::DQWorkerClient
static EcalDQMChannelStatus const *	channelStatus

static EcalDQMTowerStatus const *	towerStatus

Static Public Attributes inherited from ecaldqm::DQWorker
static std::map< std::string, std::vector< MEData > >	meData

Protected Member Functions inherited from ecaldqm::DQWorkerClient
void	fillQuality_ (unsigned, DetId const &, uint32_t, float)

void	source_ (unsigned, std::string const &, unsigned, edm::ParameterSet const &)

Protected Member Functions inherited from ecaldqm::DQWorker
MESet *	createMESet_ (std::string const &, MEData const &, bool _readOnly=false) const

void	meSet_ (unsigned, edm::ParameterSet const &)

Detailed Description

Definition at line 8 of file PresampleClient.h.

Member Enumeration Documentation

enum ecaldqm::PresampleClient::MESets

Enumerator
kQuality
kMean
kMeanDCC
kRMS
kRMSMap
kRMSMapSummary
kQualitySummary
nMESets

Definition at line 17 of file PresampleClient.h.

                 {
       kQuality,
       kMean,
       kMeanDCC,
       kRMS,
       kRMSMap,
       kRMSMapSummary,
       kQualitySummary,
       nMESets
     };

enum ecaldqm::PresampleClient::Sources

Enumerator
sPedestal
nSources

Definition at line 30 of file PresampleClient.h.

                  {
       sPedestal,
       nSources
     };

Constructor & Destructor Documentation

ecaldqm::PresampleClient::PresampleClient	(	const edm::ParameterSet &	_params,
		const edm::ParameterSet &	_paths
	)

Definition at line 11 of file PresampleClient.cc.

References expectedMean_, edm::ParameterSet::getUntrackedParameterSet(), ecaldqm::PresampleTask::kPedestal, meanThreshold_, minChannelEntries_, minTowerEntries_, ecaldqm::DQWorker::name_, noisyFracThreshold_, rmsThreshold_, rmsThresholdHighEta_, ecaldqm::DQWorkerClient::source_(), and sPedestal.

                                                                                                 :
     DQWorkerClient(_params, _paths, "PresampleClient"),
     minChannelEntries_(0),
     minTowerEntries_(0),
     expectedMean_(0.),
     meanThreshold_(0.),
     rmsThreshold_(0.),
     rmsThresholdHighEta_(0.),
     noisyFracThreshold_(0.)
   {
     edm::ParameterSet const& taskParams(_params.getUntrackedParameterSet(name_));
     minChannelEntries_ = taskParams.getUntrackedParameter<int>("minChannelEntries");
     minTowerEntries_ = taskParams.getUntrackedParameter<int>("minTowerEntries");
     expectedMean_ = taskParams.getUntrackedParameter<double>("expectedMean");
     meanThreshold_ = taskParams.getUntrackedParameter<double>("meanThreshold");
     rmsThreshold_ = taskParams.getUntrackedParameter<double>("rmsThreshold");
     rmsThresholdHighEta_ = taskParams.getUntrackedParameter<double>("rmsThresholdHighEta");
     noisyFracThreshold_ = taskParams.getUntrackedParameter<double>("noisyFracThreshold");
 
     edm::ParameterSet const& sources(_params.getUntrackedParameterSet("sources"));
     source_(sPedestal, "PresampleTask", PresampleTask::kPedestal, sources);
   }

ecaldqm::PresampleClient::~PresampleClient ( )

inline

Definition at line 11 of file PresampleClient.h.

11 {}

Member Function Documentation

void ecaldqm::PresampleClient::bookMEs ( )

overridevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 35 of file PresampleClient.cc.

References ecaldqm::DQWorker::bookMEs(), kQuality, kQualitySummary, kRMSMap, kRMSMapSummary, and ecaldqm::DQWorker::MEs_.

   {
     DQWorker::bookMEs();
 
     MEs_[kQuality]->resetAll(-1.);
     MEs_[kRMSMap]->resetAll(-1.);
     MEs_[kRMSMapSummary]->resetAll(-1.);
     MEs_[kQualitySummary]->resetAll(-1.);
   }

void ecaldqm::PresampleClient::producePlots ( )

overridevirtual

Implements ecaldqm::DQWorkerClient.

Definition at line 46 of file PresampleClient.cc.

References funct::abs(), python.tagInventory::entries, expectedMean_, ecaldqm::DQWorkerClient::fillQuality_(), ecaldqm::getElectronicsMap(), ecaldqm::getNSuperCrystals(), ecaldqm::kEEpLow, kMean, kMeanDCC, kQuality, kQualitySummary, kRMS, kRMSMap, kRMSMapSummary, timingPdfMaker::mean, meanThreshold_, ecaldqm::DQWorker::MEs_, minChannelEntries_, minTowerEntries_, noisyFracThreshold_, EcalDQMStatusHelper::PEDESTAL_ONLINE_HIGH_GAIN_MEAN_ERROR, EcalDQMStatusHelper::PEDESTAL_ONLINE_HIGH_GAIN_RMS_ERROR, plotscripts::rms(), rmsThreshold_, rmsThresholdHighEta_, ecaldqm::DQWorkerClient::sources_, sPedestal, and mathSSE::sqrt().

   {
     MEs_[kMean]->reset();
     MEs_[kMeanDCC]->reset();
     MEs_[kRMS]->reset();
     MEs_[kRMSMap]->reset(-1.);
     MEs_[kRMSMapSummary]->reset(-1.);
 
     uint32_t mask(1 << EcalDQMStatusHelper::PEDESTAL_ONLINE_HIGH_GAIN_MEAN_ERROR |
           1 << EcalDQMStatusHelper::PEDESTAL_ONLINE_HIGH_GAIN_RMS_ERROR);
 
     for(unsigned dccid(1); dccid <= 54; dccid++){
 
       for(unsigned tower(1); tower <= getNSuperCrystals(dccid); tower++){
     std::vector<DetId> ids(getElectronicsMap()->dccTowerConstituents(dccid, tower));
 
     if(ids.size() == 0) continue;
 
     unsigned iSM(dccid - 1);
     float rmsThresh(rmsThreshold_);
     if(iSM <= kEEmHigh || iSM >= kEEpLow || tower > 48) rmsThresh = rmsThresholdHighEta_;
 
     float nNoisy(0.);
     float towerEntries(0.);
     float towerMean(0.);
     float towerRMS(0.);
 
     for(std::vector<DetId>::iterator idItr(ids.begin()); idItr != ids.end(); ++idItr){
       float entries(sources_[sPedestal]->getBinEntries(*idItr));
       float mean(sources_[sPedestal]->getBinContent(*idItr));
       float rms(sources_[sPedestal]->getBinError(*idItr) * std::sqrt(entries));
       towerEntries += entries;
       towerMean += mean * entries;
       towerRMS += (rms * rms + mean * mean) * entries;
 
       if(entries < minChannelEntries_){
         fillQuality_(kQuality, *idItr, mask, 2.);
         continue;
       }
 
       MEs_[kMean]->fill(*idItr, mean);
       MEs_[kMeanDCC]->fill(*idItr, mean);
       MEs_[kRMS]->fill(*idItr, rms);
       MEs_[kRMSMap]->fill(*idItr, rms);
 
       if(std::abs(mean - expectedMean_) > meanThreshold_ || rms > rmsThresh){
         fillQuality_(kQuality, *idItr, mask, 0.);
         nNoisy += 1.;
       }
       else
         fillQuality_(kQuality, *idItr, mask, 1.);
     }
 
     towerMean /= towerEntries;
     towerRMS = std::sqrt(towerRMS / towerEntries - towerMean * towerMean);
 
     float quality(-1.);
 
     if(towerEntries > minTowerEntries_)
       quality = nNoisy / ids.size() > noisyFracThreshold_ ? 0. : 1.;
     else
       quality = 2.;
 
     if(dccid <= 9 || dccid >= 46){
       std::vector<EcalScDetId> scs(getElectronicsMap()->getEcalScDetId(dccid, tower));
       for(std::vector<EcalScDetId>::iterator scItr(scs.begin()); scItr != scs.end(); ++scItr){
         fillQuality_(kQualitySummary, *scItr, mask, quality);
         MEs_[kRMSMapSummary]->setBinContent(*scItr, towerRMS);
       }
     }
     else{
       fillQuality_(kQualitySummary, ids[0], mask, quality);
       MEs_[kRMSMapSummary]->setBinContent(ids[0], towerRMS);
     }
       }
     }
   }

void ecaldqm::PresampleClient::setMEData ( std::vector< MEData > & _data )

static

Definition at line 126 of file PresampleClient.cc.

References MonitorElement::DQM_KIND_TH1F, MonitorElement::DQM_KIND_TH2F, MonitorElement::DQM_KIND_TPROFILE, EcalDQMBinningService::AxisSpecs::high, EcalDQMBinningService::kCrystal, EcalDQMBinningService::kDCC, EcalDQMBinningService::kEcal2P, kMean, kMeanDCC, kQuality, kQualitySummary, kRMS, kRMSMap, kRMSMapSummary, EcalDQMBinningService::kSM, EcalDQMBinningService::kSuperCrystal, EcalDQMBinningService::kUser, EcalDQMBinningService::AxisSpecs::low, and EcalDQMBinningService::AxisSpecs::nbins.

   {
     BinService::AxisSpecs axis;
 
     _data[kQuality] = MEData("Quality", BinService::kSM, BinService::kCrystal, MonitorElement::DQM_KIND_TH2F);
 
     axis.nbins = 120;
     axis.low = 170.;
     axis.high = 230.;
     _data[kMean] = MEData("Mean", BinService::kSM, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &axis);
     _data[kMeanDCC] = MEData("MeanDCC", BinService::kEcal2P, BinService::kDCC, MonitorElement::DQM_KIND_TPROFILE, 0, &axis);
 
     axis.nbins = 100;
     axis.low = 0.;
     axis.high = 10.;
     _data[kRMS] = MEData("RMS", BinService::kSM, BinService::kUser, MonitorElement::DQM_KIND_TH1F, &axis);
     _data[kRMSMap] = MEData("RMSMap", BinService::kSM, BinService::kCrystal, MonitorElement::DQM_KIND_TH2F, 0, 0, &axis);
     _data[kRMSMapSummary] = MEData("RMSMap", BinService::kEcal2P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TH2F, 0, 0, &axis);
 
     _data[kQualitySummary] = MEData("QualitySummary", BinService::kEcal2P, BinService::kSuperCrystal, MonitorElement::DQM_KIND_TH2F);
   }