#include <PresampleClient.h>

Inheritance diagram for ecaldqm::PresampleClient:

Public Member Functions
	PresampleClient ()

void	producePlots (ProcessType) override

	~PresampleClient ()

Public Member Functions inherited from ecaldqm::DQWorkerClient
void	bookMEs (DQMStore &) override

	DQWorkerClient ()

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

void	releaseMEs () override

void	releaseSource ()

void	resetMEs ()

bool	retrieveSource (DQMStore const &, ProcessType)

void	setStatusManager (StatusManager const &_manager)

virtual	~DQWorkerClient ()

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

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

virtual void	bookMEs (DQMStore::IBooker &)

	DQWorker ()

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

std::string const &	getName () const

bool	onlineMode () const

void	setEventNumber (edm::EventNumber_t _e)

void	setLumiNumber (edm::LuminosityBlockNumber_t _l)

void	setRunNumber (edm::RunNumber_t _r)

void	setTime (time_t _t)

virtual	~DQWorker ()

Private Member Functions
void	setParams (edm::ParameterSet const &) override

Private Attributes
float	expectedMean_

int	minChannelEntries_

float	toleranceMean_

float	toleranceRMS_

float	toleranceRMSFwd_

Additional Inherited Members
Public Types inherited from ecaldqm::DQWorkerClient
enum	ProcessType { kLumi, kRun, nProcessType }

enum	Quality { kBad = 0, kGood = 1, kUnknown = 2, kMBad = 3, kMGood = 4, kMUnknown = 5 }

Static Public Member Functions inherited from ecaldqm::DQWorkerClient
static void	fillDescriptions (edm::ParameterSetDescription &)

Static Public Member Functions inherited from ecaldqm::DQWorker
static void	fillDescriptions (edm::ParameterSetDescription &_desc)

Protected Member Functions inherited from ecaldqm::DQWorkerClient
void	setME (edm::ParameterSet const &_ps) final

void	setSource (edm::ParameterSet const &) override

void	towerAverage_ (MESet &, MESet const &, float)

bool	using_ (std::string const &_name, ProcessType _type=kRun) const

Protected Member Functions inherited from ecaldqm::DQWorker
void	initialize (std::string const &_name, edm::ParameterSet const &)

void	print_ (std::string const &, int=0) const

void	setVerbosity (int _verbosity)

Protected Attributes inherited from ecaldqm::DQWorkerClient
std::set< std::string >	qualitySummaries_

MESetCollection	sources_

StatusManager const *	statusManager_

Protected Attributes inherited from ecaldqm::DQWorker
MESetCollection	MEs_

std::string	name_

bool	onlineMode_

Timestamp	timestamp_

int	verbosity_

bool	willConvertToEDM_

Detailed Description

Definition at line 8 of file PresampleClient.h.

Constructor & Destructor Documentation

ecaldqm::PresampleClient::PresampleClient ( )

Definition at line 13 of file PresampleClient.cc.

References ecaldqm::DQWorkerClient::qualitySummaries_.

                                    :
     DQWorkerClient(),
     minChannelEntries_(0),
     expectedMean_(0.),
     toleranceMean_(0.),
     toleranceRMS_(0.),
     toleranceRMSFwd_(0.)
   {
     qualitySummaries_.insert("Quality");
     qualitySummaries_.insert("QualitySummary");
   }

ecaldqm::PresampleClient::~PresampleClient ( )

inline

Definition at line 11 of file PresampleClient.h.

11 {}

Member Function Documentation

void ecaldqm::PresampleClient::producePlots ( ProcessType )

overridevirtual

Implements ecaldqm::DQWorkerClient.

Definition at line 36 of file PresampleClient.cc.

   {
     MESet& meQualitySummary(MEs_.at("QualitySummary"));
     MESet& meQuality(MEs_.at("Quality"));
     MESet& meErrorsSummary(MEs_.at("ErrorsSummary"));
     MESet& meMean(MEs_.at("Mean"));
     MESet& meRMS(MEs_.at("RMS"));
     MESet& meRMSMap(MEs_.at("RMSMap"));
     MESet& meRMSMapAll(MEs_.at("RMSMapAll"));
 
     MESet const& sPedestal(sources_.at("Pedestal"));
 
     uint32_t mask(1 << EcalDQMStatusHelper::PEDESTAL_ONLINE_HIGH_GAIN_MEAN_ERROR |
           1 << EcalDQMStatusHelper::PEDESTAL_ONLINE_HIGH_GAIN_RMS_ERROR);
 
     MESet::iterator qEnd(meQuality.end());
 
     MESet::const_iterator pItr(sPedestal);
     double maxEB(0.), minEB(0.), maxEE(0.), minEE(0.);
     double rmsMaxEB(0.), rmsMaxEE(0.);
     for(MESet::iterator qItr(meQuality.beginChannel()); qItr != qEnd; qItr.toNextChannel()){
 
       pItr = qItr;
 
       DetId id(qItr->getId());
 
       bool doMask(meQuality.maskMatches(id, mask, statusManager_));
 
       double rmsThresh(toleranceRMS_);
 
       if(isForward(id)) rmsThresh = toleranceRMSFwd_;
 
       double entries(pItr->getBinEntries());
 
       if(entries < minChannelEntries_){
         qItr->setBinContent(doMask ? kMUnknown : kUnknown);
         meQualitySummary.setBinContent(id, doMask ? kMUnknown : kUnknown);
         meRMSMap.setBinContent(id, -1.);
         continue;
       }
 
       double mean(pItr->getBinContent());
       double rms(pItr->getBinError() * std::sqrt(entries));
 
       int dccid(dccId(id));
 
       meMean.fill(dccid, mean);
       meRMS.fill(dccid, rms);
       meRMSMap.setBinContent(id, rms);
 
       if(std::abs(mean - expectedMean_) > toleranceMean_ || rms > rmsThresh){
         qItr->setBinContent(doMask ? kMBad : kBad);
         meQualitySummary.setBinContent(id, doMask ? kMBad : kBad);
         if(!doMask) meErrorsSummary.fill(id);
       }
       else{
         qItr->setBinContent(doMask ? kMGood : kGood);
         meQualitySummary.setBinContent(id, doMask ? kMGood : kGood);
       }
 
       if(id.subdetId() == EcalBarrel){
         if(mean > maxEB) maxEB = mean;
         if(mean < minEB) minEB = mean;
         if(rms > rmsMaxEB) rmsMaxEB = rms;
       }
       else{
         if(mean > maxEE) maxEE = mean;
         if(mean < minEE) minEE = mean;
         if(rms > rmsMaxEE) rmsMaxEE = rms;
       }
     }
 
     towerAverage_(meRMSMapAll, meRMSMap, -1.);
 
     MESet& meTrendMean(MEs_.at("TrendMean"));
     MESet& meTrendRMS(MEs_.at("TrendRMS"));
     meTrendMean.fill(EcalBarrel, double(timestamp_.iLumi), maxEB - minEB);
     meTrendMean.fill(EcalEndcap, double(timestamp_.iLumi), maxEE - minEE);
     meTrendRMS.fill(EcalBarrel, double(timestamp_.iLumi), rmsMaxEB);
     meTrendRMS.fill(EcalEndcap, double(timestamp_.iLumi), rmsMaxEE);
   }

void ecaldqm::PresampleClient::setParams ( edm::ParameterSet const & _params )

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 26 of file PresampleClient.cc.

References expectedMean_, edm::ParameterSet::getUntrackedParameter(), minChannelEntries_, toleranceMean_, toleranceRMS_, and toleranceRMSFwd_.

   {
     minChannelEntries_ = _params.getUntrackedParameter<int>("minChannelEntries");
     expectedMean_ = _params.getUntrackedParameter<double>("expectedMean");
     toleranceMean_ = _params.getUntrackedParameter<double>("toleranceMean");
     toleranceRMS_ = _params.getUntrackedParameter<double>("toleranceRMS");
     toleranceRMSFwd_ = _params.getUntrackedParameter<double>("toleranceRMSFwd");
   }