#include <PedestalClient.h>

Inheritance diagram for ecaldqm::PedestalClient:

Public Member Functions
	PedestalClient ()

void	producePlots (ProcessType) override

	~PedestalClient ()

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

	DQWorkerClient ()

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

void	releaseMEs () override

void	releaseSource ()

void	resetMEs ()

bool	retrieveSource (DQMStore::IGetter &, ProcessType)

bool	runsOn (ProcessType _type) const

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 &)

	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_

float	expectedPNMean_

std::map< int, unsigned >	gainToME_

int	minChannelEntries_

std::map< int, unsigned >	pnGainToME_

float	toleranceMean_

float	tolerancePNMean_

std::vector< float >	tolerancePNRMS_

std::vector< float >	toleranceRMS_

Additional Inherited Members
Public Types inherited from ecaldqm::DQWorkerClient
enum	ProcessType { kLumi, kJob, 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=kJob) 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
bool	hasLumiPlots_

std::set< std::string >	qualitySummaries_

MESetCollection	sources_

StatusManager const *	statusManager_

Protected Attributes inherited from ecaldqm::DQWorker
bool	booked_

MESetCollection	MEs_

std::string	name_

bool	onlineMode_

Timestamp	timestamp_

int	verbosity_

bool	willConvertToEDM_

Detailed Description

Definition at line 8 of file PedestalClient.h.

Constructor & Destructor Documentation

ecaldqm::PedestalClient::PedestalClient ( )

Definition at line 16 of file PedestalClient.cc.

                                  :
     DQWorkerClient(),
     gainToME_(),
     pnGainToME_(),
     minChannelEntries_(0),
     expectedMean_(0.),
     toleranceMean_(0.),
     toleranceRMS_(0),
     expectedPNMean_(0.),
     tolerancePNMean_(0.),
     tolerancePNRMS_(0)
   {
   }

ecaldqm::PedestalClient::~PedestalClient ( )

inline

Definition at line 11 of file PedestalClient.h.

11 {}

Member Function Documentation

void ecaldqm::PedestalClient::producePlots ( ProcessType )

overridevirtual

Implements ecaldqm::DQWorkerClient.

Definition at line 106 of file PedestalClient.cc.

   {
     using namespace std;
 
     MESetMulti& meQuality(static_cast<MESetMulti&>(MEs_.at("Quality")));
     MESetMulti& meQualitySummary(static_cast<MESetMulti&>(MEs_.at("QualitySummary")));
     MESetMulti& meMean(static_cast<MESetMulti&>(MEs_.at("Mean")));
     MESetMulti& meRMS(static_cast<MESetMulti&>(MEs_.at("RMS")));
     MESetMulti& mePNQualitySummary(static_cast<MESetMulti&>(MEs_.at("PNQualitySummary")));
     MESetMulti& mePNRMS(static_cast<MESetMulti&>(MEs_.at("PNRMS")));
 
     MESetMulti const& sPedestal(static_cast<MESetMulti const&>(sources_.at("Pedestal")));
     MESetMulti const& sPNPedestal(static_cast<MESetMulti const&>(sources_.at("PNPedestal")));
 
     for(map<int, unsigned>::iterator gainItr(gainToME_.begin()); gainItr != gainToME_.end(); ++gainItr){
       meQuality.use(gainItr->second);
       meQualitySummary.use(gainItr->second);
       meMean.use(gainItr->second);
       meRMS.use(gainItr->second);
 
       sPedestal.use(gainItr->second);
 
       uint32_t mask(0);
       switch(gainItr->first){
       case 1:
         mask |= (1 << EcalDQMStatusHelper::PEDESTAL_LOW_GAIN_MEAN_ERROR |
                  1 << EcalDQMStatusHelper::PEDESTAL_LOW_GAIN_RMS_ERROR);
         break;
       case 6:
         mask |= (1 << EcalDQMStatusHelper::PEDESTAL_MIDDLE_GAIN_MEAN_ERROR |
                  1 << EcalDQMStatusHelper::PEDESTAL_MIDDLE_GAIN_RMS_ERROR);
         break;
       case 12:
         mask |= (1 << EcalDQMStatusHelper::PEDESTAL_HIGH_GAIN_MEAN_ERROR |
                  1 << EcalDQMStatusHelper::PEDESTAL_HIGH_GAIN_RMS_ERROR);
         break;
       default:
         break;
       }
 
       MESet::iterator qEnd(meQuality.end());
       MESet::const_iterator pItr(sPedestal);
       for(MESet::iterator qItr(meQuality.beginChannel()); qItr != qEnd; qItr.toNextChannel()){
 
         DetId id(qItr->getId());
 
         bool doMask(meQuality.maskMatches(id, mask, statusManager_));
 
         pItr = qItr;
 
         float entries(pItr->getBinEntries());
 
         if(entries < minChannelEntries_){
           qItr->setBinContent(doMask ? kMUnknown : kUnknown);
           continue;
         }
 
         float mean(pItr->getBinContent());
         float rms(pItr->getBinError() * sqrt(entries));
 
         meMean.fill(id, mean);
         meRMS.fill(id, rms);
 
         if(abs(mean - expectedMean_) > toleranceMean_ || rms > toleranceRMS_[gainItr->second])
           qItr->setBinContent(doMask ? kMBad : kBad);
         else
           qItr->setBinContent(doMask ? kMGood : kGood);
       }
 
       towerAverage_(meQualitySummary, meQuality, 0.2);
     }
 
     for(map<int, unsigned>::iterator gainItr(pnGainToME_.begin()); gainItr != pnGainToME_.end(); ++gainItr){
       mePNQualitySummary.use(gainItr->second);
       mePNRMS.use(gainItr->second);
 
       sPNPedestal.use(gainItr->second);
 
       uint32_t mask(0);
       switch(gainItr->first){
       case 1:
         mask |= (1 << EcalDQMStatusHelper::PEDESTAL_LOW_GAIN_MEAN_ERROR |
                  1 << EcalDQMStatusHelper::PEDESTAL_LOW_GAIN_RMS_ERROR);
         break;
       case 16:
         mask |= (1 << EcalDQMStatusHelper::PEDESTAL_HIGH_GAIN_MEAN_ERROR |
                  1 << EcalDQMStatusHelper::PEDESTAL_HIGH_GAIN_RMS_ERROR);
         break;
       default:
         break;
       }
 
       for(unsigned iDCC(0); iDCC < nDCC; ++iDCC){
 
         if(memDCCIndex(iDCC + 1) == unsigned(-1)) continue;
 
         for(unsigned iPN(0); iPN < 10; ++iPN){
           int subdet(0);
           if(iDCC >= kEBmLow && iDCC <= kEBpHigh) subdet = EcalBarrel;
           else subdet = EcalEndcap;
 
           EcalPnDiodeDetId id(subdet, iDCC + 1, iPN + 1);
 
           bool doMask(mePNQualitySummary.maskMatches(id, mask, statusManager_));
 
           float entries(sPNPedestal.getBinEntries(id));
 
           if(entries < minChannelEntries_){
             mePNQualitySummary.setBinContent(id, doMask ? kMUnknown : kUnknown);
             continue;
           }
 
           float mean(sPNPedestal.getBinContent(id));
           float rms(sPNPedestal.getBinError(id) * sqrt(entries));
 
           mePNRMS.fill(id, rms);
 
           if(abs(mean - expectedPNMean_) > tolerancePNMean_ || rms > tolerancePNRMS_[gainItr->second])
             mePNQualitySummary.setBinContent(id, doMask ? kMBad : kBad);
           else
             mePNQualitySummary.setBinContent(id, doMask ? kMGood : kGood);
         }
       }
     }
   }

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

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 31 of file PedestalClient.cc.

References edm::hlt::Exception, expectedMean_, expectedPNMean_, gainToME_, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), minChannelEntries_, EcalCondDBWriter_cfi::pedestal, pnGainToME_, ecaldqm::DQWorkerClient::qualitySummaries_, ecaldqm::DQWorkerClient::sources_, cond::to_string(), toleranceMean_, tolerancePNMean_, tolerancePNRMS_, and toleranceRMS_.

   {
     minChannelEntries_ = _params.getUntrackedParameter<int>("minChannelEntries");
     expectedMean_ = _params.getUntrackedParameter<double>("expectedMean");
     toleranceMean_ = _params.getUntrackedParameter<double>("toleranceMean");
     expectedPNMean_ = _params.getUntrackedParameter<double>("expectedPNMean");
     tolerancePNMean_ = _params.getUntrackedParameter<double>("tolerancePNMean");
 
     std::vector<int> MGPAGains(_params.getUntrackedParameter<std::vector<int> >("MGPAGains"));
     std::vector<int> MGPAGainsPN(_params.getUntrackedParameter<std::vector<int> >("MGPAGainsPN"));
 
     MESet::PathReplacements repl;
 
     MESetMulti const& pedestal(static_cast<MESetMulti const&>(sources_.at("Pedestal")));
     unsigned nG(MGPAGains.size());
     for(unsigned iG(0); iG != nG; ++iG){
       int gain(MGPAGains[iG]);
       if(gain != 1 && gain != 6 && gain != 12) throw cms::Exception("InvalidConfiguration") << "MGPA gain";
       repl["gain"] = std::to_string(gain);
       gainToME_[gain] = pedestal.getIndex(repl);
     }
 
     repl.clear();
 
     MESetMulti const& pnPedestal(static_cast<MESetMulti const&>(sources_.at("PNPedestal")));
     unsigned nGPN(MGPAGainsPN.size());
     for(unsigned iG(0); iG != nGPN; ++iG){
       int gain(MGPAGainsPN[iG]);
       if(gain != 1 && gain != 16) throw cms::Exception("InvalidConfiguration") << "PN MGPA gain";
       repl["pngain"] = std::to_string(gain);
       pnGainToME_[gain] = pnPedestal.getIndex(repl);
     }
 
     toleranceRMS_.resize(nG);
 
     std::vector<double> inToleranceRMS(_params.getUntrackedParameter<std::vector<double> >("toleranceRMS"));
 
     for(std::map<int, unsigned>::iterator gainItr(gainToME_.begin()); gainItr != gainToME_.end(); ++gainItr){
       unsigned iME(gainItr->second);
       unsigned iGain(0);
       switch(gainItr->first){
       case 1:
         iGain = 0; break;
       case 6:
         iGain = 1; break;
       case 12:
         iGain = 2; break;
       }
 
       toleranceRMS_[iME] = inToleranceRMS[iGain];
     }
 
     tolerancePNRMS_.resize(nGPN);
 
     std::vector<double> inTolerancePNRMS(_params.getUntrackedParameter<std::vector<double> >("tolerancePNRMS"));
 
     for(std::map<int, unsigned>::iterator gainItr(pnGainToME_.begin()); gainItr != pnGainToME_.end(); ++gainItr){
       unsigned iME(gainItr->second);
       unsigned iGain(0);
       switch(gainItr->first){
       case 1:
         iGain = 0; break;
       case 16:
         iGain = 1; break;
       }
 
       tolerancePNRMS_[iME] = inTolerancePNRMS[iGain];
     }
 
     qualitySummaries_.insert("Quality");
     qualitySummaries_.insert("QualitySummary");
     qualitySummaries_.insert("PNQualitySummary");
   }