#include <LedClient.h>

Inheritance diagram for ecaldqm::LedClient:

Public Member Functions
	LedClient ()

void	producePlots (ProcessType) override

	~LedClient () override

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

virtual void	resetMEs ()

void	resetPerLumi ()

bool	retrieveSource (DQMStore::IGetter &, ProcessType)

bool	runsOn (ProcessType _type) const

void	setStatusManager (StatusManager const &_manager)

virtual void	setTokens (edm::ConsumesCollector &)

	~DQWorkerClient () override

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

EcalDQMSetupObjects const	getEcalDQMSetupObjects ()

EcalElectronicsMapping const *	GetElectronicsMap ()

CaloGeometry const *	GetGeometry ()

std::string const &	getName () const

CaloTopology const *	GetTopology ()

EcalTrigTowerConstituentsMap const *	GetTrigTowerMap ()

bool	onlineMode () const

void	setEventNumber (edm::EventNumber_t _e)

void	setLumiNumber (edm::LuminosityBlockNumber_t _l)

void	setRunNumber (edm::RunNumber_t _r)

void	setSetupObjects (edm::EventSetup const &)

void	setSetupObjectsEndLumi (edm::EventSetup const &)

void	setTime (time_t _t)

void	setTokens (edm::ConsumesCollector &)

virtual	~DQWorker () noexcept(false)

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

Private Attributes
std::vector< double >	expectedAmplitude_

std::vector< double >	expectedPNAmplitude_

std::vector< double >	expectedTiming_

float	forwardFactor_

int	minChannelEntries_

std::vector< uint32_t >	SClist_

double	toleranceAmplitude_

double	toleranceAmpRMSRatio_

double	tolerancePNAmp_

double	tolerancePNRMSRatio_

double	toleranceTiming_

double	toleranceTimRMS_

std::map< int, unsigned >	wlToME_

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)

Public Attributes inherited from ecaldqm::DQWorker
edm::ESGetToken < EcalElectronicsMapping, EcalMappingRcd >	elecMapHandle

edm::ESGetToken < EcalElectronicsMapping, EcalMappingRcd >	elecMapHandleEndLumi

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomHandle

edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomHandleEndLumi

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	topoHandle

edm::ESGetToken< CaloTopology, CaloTopologyRecord >	topoHandleEndLumi

edm::ESGetToken < EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapHandle

edm::ESGetToken < EcalTrigTowerConstituentsMap, IdealGeometryRecord >	ttMapHandleEndLumi

Protected Types inherited from ecaldqm::DQWorker
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

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 7 of file LedClient.h.

Constructor & Destructor Documentation

ecaldqm::LedClient::LedClient ( )

Definition at line 15 of file LedClient.cc.

       : DQWorkerClient(),
         wlToME_(),
         minChannelEntries_(0),
         expectedAmplitude_(0),
         toleranceAmplitude_(0.),
         toleranceAmpRMSRatio_(0.),
         expectedTiming_(0),
         toleranceTiming_(0.),
         toleranceTimRMS_(0.),
         expectedPNAmplitude_(0),
         tolerancePNAmp_(0.),
         tolerancePNRMSRatio_(0.),
         forwardFactor_(0.) {}

ecaldqm::LedClient::~LedClient ( )

inlineoverride

Definition at line 10 of file LedClient.h.

10 {}

Member Function Documentation

void ecaldqm::LedClient::producePlots ( ProcessType )

overridevirtual

Implements ecaldqm::DQWorkerClient.

Definition at line 91 of file LedClient.cc.

References funct::abs(), ecaldqm::MESetCollection::at(), ecaldqm::MESetMulti::beginChannel(), EcalEndcap, gedGsfElectrons_cfi::enabled, ecaldqm::MESetMulti::end(), expectedAmplitude_, expectedPNAmplitude_, expectedTiming_, ecaldqm::MESetMulti::fill(), spr::find(), forwardFactor_, ecaldqm::MESet::getBinContent(), ecaldqm::MESetMulti::getBinContent(), ecaldqm::MESetMulti::getBinEntries(), ecaldqm::MESetMulti::getBinError(), ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::DQWorker::GetElectronicsMap(), ecaldqm::DQWorker::GetTrigTowerMap(), gpuClustering::id, ecaldqm::isForward(), ecaldqm::DQWorkerClient::kBad, ecaldqm::kEBmLow, ecaldqm::kEBpHigh, ecaldqm::DQWorkerClient::kGood, ecaldqm::DQWorkerClient::kMBad, ecaldqm::DQWorkerClient::kMGood, ecaldqm::DQWorkerClient::kMUnknown, ecaldqm::DQWorkerClient::kUnknown, EcalDQMStatusHelper::LED_MEAN_ERROR, EcalDQMStatusHelper::LED_RMS_ERROR, EcalDQMStatusHelper::LED_TIMING_MEAN_ERROR, EcalDQMStatusHelper::LED_TIMING_RMS_ERROR, ecaldqm::MESetMulti::maskMatches(), ecaldqm::memDCCIndex(), ecaldqm::DQWorker::MEs_, minChannelEntries_, ecaldqm::nDCC, funct::pow(), EEDetId::sc(), SClist_, ecaldqm::MESetMulti::setBinContent(), ecaldqm::DQWorkerClient::sources_, mathSSE::sqrt(), ecaldqm::DQWorkerClient::statusManager_, toleranceAmpRMSRatio_, tolerancePNRMSRatio_, toleranceTiming_, toleranceTimRMS_, ecaldqm::MESet::iterator::toNextChannel(), ecaldqm::DQWorkerClient::towerAverage_(), ecaldqm::MESetMulti::use(), and wlToME_.

                                           {
     uint32_t mask(1 << EcalDQMStatusHelper::LED_MEAN_ERROR | 1 << EcalDQMStatusHelper::LED_RMS_ERROR |
                   1 << EcalDQMStatusHelper::LED_TIMING_MEAN_ERROR | 1 << EcalDQMStatusHelper::LED_TIMING_RMS_ERROR);
 
     MESetMulti& meQuality(static_cast<MESetMulti&>(MEs_.at("Quality")));
     MESetMulti& meQualitySummary(static_cast<MESetMulti&>(MEs_.at("QualitySummary")));
     MESetMulti& meAmplitudeMean(static_cast<MESetMulti&>(MEs_.at("AmplitudeMean")));
     MESetMulti& meAmplitudeRMS(static_cast<MESetMulti&>(MEs_.at("AmplitudeRMS")));
     MESetMulti& meTimingMean(static_cast<MESetMulti&>(MEs_.at("TimingMean")));
     MESetMulti& meTimingRMSMap(static_cast<MESetMulti&>(MEs_.at("TimingRMSMap")));
     MESetMulti& mePNQualitySummary(static_cast<MESetMulti&>(MEs_.at("PNQualitySummary")));
 
     MESetMulti const& sAmplitude(static_cast<MESetMulti const&>(sources_.at("Amplitude")));
     MESetMulti const& sTiming(static_cast<MESetMulti const&>(sources_.at("Timing")));
     MESetMulti const& sPNAmplitude(static_cast<MESetMulti const&>(sources_.at("PNAmplitude")));
     MESet const& sCalibStatus(static_cast<MESet const&>(sources_.at("CalibStatus")));
 
     for (std::map<int, unsigned>::iterator wlItr(wlToME_.begin()); wlItr != wlToME_.end(); ++wlItr) {
       meQuality.use(wlItr->second);
       meQualitySummary.use(wlItr->second);
       meAmplitudeMean.use(wlItr->second);
       meAmplitudeRMS.use(wlItr->second);
       meTimingMean.use(wlItr->second);
       meTimingRMSMap.use(wlItr->second);
       mePNQualitySummary.use(wlItr->second);
 
       sAmplitude.use(wlItr->second);
       sTiming.use(wlItr->second);
       sPNAmplitude.use(wlItr->second);
 
       MESet::iterator qEnd(meQuality.end(GetElectronicsMap()));
 
       MESet::const_iterator tItr(GetElectronicsMap(), sTiming);
       MESet::const_iterator aItr(GetElectronicsMap(), sAmplitude);
 
       int wl(wlItr->first + 3);
       bool enabled(wl < 0 ? false : sCalibStatus.getBinContent(getEcalDQMSetupObjects(), wl) > 0 ? true : false);
       for (MESet::iterator qItr(meQuality.beginChannel(GetElectronicsMap())); qItr != qEnd;
            qItr.toNextChannel(GetElectronicsMap())) {
         DetId id(qItr->getId());
 
         bool doMask(meQuality.maskMatches(id, mask, statusManager_, GetTrigTowerMap()));
 
         aItr = qItr;
 
         float aEntries(aItr->getBinEntries());
 
         if (aEntries < minChannelEntries_) {
           qItr->setBinContent(enabled ? (doMask ? kMUnknown : kUnknown) : kMUnknown);
           continue;
         }
 
         float aMean(aItr->getBinContent());
         float aRms(aItr->getBinError() * sqrt(aEntries));
 
         meAmplitudeMean.fill(getEcalDQMSetupObjects(), id, aMean);
         meAmplitudeRMS.setBinContent(getEcalDQMSetupObjects(), id, aRms);
 
         tItr = qItr;
 
         float tEntries(tItr->getBinEntries());
 
         if (tEntries < minChannelEntries_)
           continue;
 
         float tMean(tItr->getBinContent());
         float tRms(tItr->getBinError() * sqrt(tEntries));
 
         meTimingMean.fill(getEcalDQMSetupObjects(), id, tMean);
         meTimingRMSMap.setBinContent(getEcalDQMSetupObjects(), id, tRms);
 
         float intensity(aMean / expectedAmplitude_[wlItr->second]);
         if (isForward(id))
           intensity /= forwardFactor_;
 
         float aRmsThr(sqrt(pow(aMean * toleranceAmpRMSRatio_, 2) + pow(3., 2)));
 
         EcalScDetId scid = EEDetId(id).sc();  //Get the Endcap SC id for the given crystal id.
 
         //For the known bad Supercrystals in the SClist, bad quality flag is only set based on the amplitude RMS
         //and everything else is ignored.
         if (std::find(SClist_.begin(), SClist_.end(), int(scid)) != SClist_.end()) {
           if (aRms > aRmsThr)
             qItr->setBinContent(doMask ? kMBad : kBad);
           else
             qItr->setBinContent(doMask ? kMGood : kGood);
         } else {
           if (intensity < toleranceAmplitude_ || aRms > aRmsThr ||
               std::abs(tMean - expectedTiming_[wlItr->second]) > toleranceTiming_ || tRms > toleranceTimRMS_)
             qItr->setBinContent(doMask ? kMBad : kBad);
           else
             qItr->setBinContent(doMask ? kMGood : kGood);
         }
       }
 
       towerAverage_(meQualitySummary, meQuality, 0.2);
 
       for (unsigned iDCC(0); iDCC < nDCC; ++iDCC) {
         if (memDCCIndex(iDCC + 1) == unsigned(-1))
           continue;
         if (iDCC >= kEBmLow && iDCC <= kEBpHigh)
           continue;
 
         for (unsigned iPN(0); iPN < 10; ++iPN) {
           EcalPnDiodeDetId id(EcalEndcap, iDCC + 1, iPN + 1);
 
           bool doMask(mePNQualitySummary.maskMatches(id, mask, statusManager_, GetTrigTowerMap()));
 
           float pEntries(sPNAmplitude.getBinEntries(getEcalDQMSetupObjects(), id));
 
           if (pEntries < minChannelEntries_) {
             mePNQualitySummary.setBinContent(getEcalDQMSetupObjects(), id, doMask ? kMUnknown : kUnknown);
             continue;
           }
 
           float pMean(sPNAmplitude.getBinContent(getEcalDQMSetupObjects(), id));
           float pRms(sPNAmplitude.getBinError(getEcalDQMSetupObjects(), id) * sqrt(pEntries));
           float intensity(pMean / expectedPNAmplitude_[wlItr->second]);
 
           if (intensity < tolerancePNAmp_ || pRms > pMean * tolerancePNRMSRatio_)
             mePNQualitySummary.setBinContent(getEcalDQMSetupObjects(), id, doMask ? kMBad : kBad);
           else
             mePNQualitySummary.setBinContent(getEcalDQMSetupObjects(), id, doMask ? kMGood : kGood);
         }
       }
     }
   }

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

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 30 of file LedClient.cc.

References ecaldqm::MESetCollection::at(), Exception, expectedAmplitude_, expectedPNAmplitude_, expectedTiming_, forwardFactor_, edm::FileInPath::fullPath(), ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), timingPdfMaker::infile, minChannelEntries_, ecaldqm::DQWorkerClient::qualitySummaries_, SClist_, ecaldqm::DQWorkerClient::sources_, AlCaHLTBitMon_QueryRunRegistry::string, toleranceAmplitude_, toleranceAmpRMSRatio_, tolerancePNAmp_, tolerancePNRMSRatio_, toleranceTiming_, toleranceTimRMS_, and wlToME_.

                                                           {
     minChannelEntries_ = _params.getUntrackedParameter<int>("minChannelEntries");
     toleranceAmplitude_ = _params.getUntrackedParameter<double>("toleranceAmplitude");
     toleranceAmpRMSRatio_ = _params.getUntrackedParameter<double>("toleranceAmpRMSRatio");
     toleranceTiming_ = _params.getUntrackedParameter<double>("toleranceTiming");
     toleranceTimRMS_ = _params.getUntrackedParameter<double>("toleranceTimRMS");
     tolerancePNAmp_ = _params.getUntrackedParameter<double>("tolerancePNAmp");
     tolerancePNRMSRatio_ = _params.getUntrackedParameter<double>("tolerancePNRMSRatio");
     forwardFactor_ = _params.getUntrackedParameter<double>("forwardFactor");
 
     std::vector<int> ledWavelengths(_params.getUntrackedParameter<std::vector<int> >("ledWavelengths"));
 
     // wavelengths are not necessarily ordered
     // create a map wl -> MESet index
     // using Amplitude here but any multi-wavelength plot is fine
 
     MESet::PathReplacements repl;
 
     MESetMulti const& amplitude(static_cast<MESetMulti const&>(sources_.at("Amplitude")));
     unsigned nWL(ledWavelengths.size());
     for (unsigned iWL(0); iWL != nWL; ++iWL) {
       int wl(ledWavelengths[iWL]);
       if (wl != 1 && wl != 2)
         throw cms::Exception("InvalidConfiguration") << "Led Wavelength";
       repl["wl"] = std::to_string(wl);
       wlToME_[wl] = amplitude.getIndex(repl);
     }
 
     expectedAmplitude_.resize(nWL);
     expectedTiming_.resize(nWL);
     expectedPNAmplitude_.resize(nWL);
 
     std::vector<double> inExpectedAmplitude(_params.getUntrackedParameter<std::vector<double> >("expectedAmplitude"));
     std::vector<double> inExpectedTiming(_params.getUntrackedParameter<std::vector<double> >("expectedTiming"));
     std::vector<double> inExpectedPNAmplitude(
         _params.getUntrackedParameter<std::vector<double> >("expectedPNAmplitude"));
 
     for (std::map<int, unsigned>::iterator wlItr(wlToME_.begin()); wlItr != wlToME_.end(); ++wlItr) {
       unsigned iME(wlItr->second);
       int iWL(wlItr->first - 1);
       expectedAmplitude_[iME] = inExpectedAmplitude[iWL];
       expectedTiming_[iME] = inExpectedTiming[iWL];
       expectedPNAmplitude_[iME] = inExpectedPNAmplitude[iWL];
     }
 
     //Get the list of known problematic Supercrystal ids and store them in the vector SClist_
     std::string SClistpath = edm::FileInPath("DQM/EcalMonitorClient/data/LedTowers/SClist.dat").fullPath();
     std::ifstream infile;
     infile.open((SClistpath).c_str());
     uint32_t detid;
     int ix, iy, iz;
     while (!infile.eof()) {
       infile >> ix >> iy >> iz >> detid;
       SClist_.push_back(detid);
     }
 
     qualitySummaries_.insert("Quality");
     qualitySummaries_.insert("QualitySummary");
     qualitySummaries_.insert("PNQualitySummary");
   }