#include <CalibrationSummaryClient.h>

Inheritance diagram for ecaldqm::CalibrationSummaryClient:

Public Member Functions
	CalibrationSummaryClient ()

void	producePlots (ProcessType) override

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

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

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

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

Private Attributes
std::map< int, unsigned >	laserWlToME_

std::map< int, unsigned >	ledWlToME_

std::map< int, unsigned >	pedGainToME_

std::map< int, unsigned >	pedPNGainToME_

std::map< int, unsigned >	tpGainToME_

std::map< int, unsigned >	tpPNGainToME_

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

Constructor & Destructor Documentation

ecaldqm::CalibrationSummaryClient::CalibrationSummaryClient ( )

Definition at line 13 of file CalibrationSummaryClient.cc.

       : DQWorkerClient(),
         laserWlToME_(),
         ledWlToME_(),
         tpGainToME_(),
         tpPNGainToME_(),
         pedGainToME_(),
         pedPNGainToME_() {}

ecaldqm::CalibrationSummaryClient::~CalibrationSummaryClient ( )

inlineoverride

Definition at line 11 of file CalibrationSummaryClient.h.

References producePlots(), and setParams().

11 {}

Member Function Documentation

void ecaldqm::CalibrationSummaryClient::producePlots ( ProcessType )

overridevirtual

Implements ecaldqm::DQWorkerClient.

Definition at line 127 of file CalibrationSummaryClient.cc.

References DEFINE_ECALDQM_WORKER, EcalBarrel, EcalEndcap, ecaldqm::MESetMulti::getBinContent(), triggerObjects_cff::id, ecaldqm::DQWorkerClient::kBad, ecaldqm::kEBmLow, ecaldqm::kEBpHigh, ecaldqm::DQWorkerClient::kGood, laserWlToME_, ledWlToME_, ecaldqm::memDCCIndex(), ecaldqm::DQWorker::MEs_, ecaldqm::nDCC, pedGainToME_, pedPNGainToME_, ecaldqm::DQWorkerClient::sources_, mps_update::status, ecaldqm::MESet::iterator::toNextChannel(), tpGainToME_, tpPNGainToME_, ecaldqm::MESetMulti::use(), and ecaldqm::DQWorkerClient::using_().

Referenced by ~CalibrationSummaryClient().

                                                          {
     using namespace std;
 
     MESet& meQualitySummary(MEs_.at("QualitySummary"));
     MESet& mePNQualitySummary(MEs_.at("PNQualitySummary"));
 
     MESetMulti const* sLaser(using_("Laser") ? static_cast<MESetMulti const*>(&sources_.at("Laser")) : nullptr);
     MESetMulti const* sLaserPN(using_("LaserPN") ? static_cast<MESetMulti const*>(&sources_.at("LaserPN")) : nullptr);
     MESetMulti const* sLed(using_("Led") ? static_cast<MESetMulti const*>(&sources_.at("Led")) : nullptr);
     MESetMulti const* sLedPN(using_("LedPN") ? static_cast<MESetMulti const*>(&sources_.at("LedPN")) : nullptr);
     MESetMulti const* sTestPulse(using_("TestPulse") ? static_cast<MESetMulti const*>(&sources_.at("TestPulse"))
                                                      : nullptr);
     MESetMulti const* sTestPulsePN(using_("TestPulsePN") ? static_cast<MESetMulti const*>(&sources_.at("TestPulsePN"))
                                                          : nullptr);
     MESetMulti const* sPedestal(using_("Pedestal") ? static_cast<MESetMulti const*>(&sources_.at("Pedestal"))
                                                    : nullptr);
     MESetMulti const* sPedestalPN(using_("PedestalPN") ? static_cast<MESetMulti const*>(&sources_.at("PedestalPN"))
                                                        : nullptr);
     MESet const& sPNIntegrity(sources_.at("PNIntegrity"));
 
     MESet::iterator qEnd(meQualitySummary.end());
     for (MESet::iterator qItr(meQualitySummary.beginChannel()); qItr != qEnd; qItr.toNextChannel()) {
       DetId id(qItr->getId());
 
       int status(kGood);
 
       if (status == kGood && sLaser) {
         for (map<int, unsigned>::iterator wlItr(laserWlToME_.begin()); wlItr != laserWlToME_.end(); ++wlItr) {
           sLaser->use(wlItr->second);
           if (sLaser->getBinContent(id) == kBad) {
             status = kBad;
             break;
           }
         }
       }
 
       if (status == kGood && sLed) {
         DetId id(qItr->getId());
         if (id.subdetId() == EcalEndcap) {
           for (map<int, unsigned>::iterator wlItr(ledWlToME_.begin()); wlItr != ledWlToME_.end(); ++wlItr) {
             sLed->use(wlItr->second);
             if (sLed->getBinContent(id) == kBad) {
               status = kBad;
               break;
             }
           }
         }
       }
 
       if (status == kGood && sTestPulse) {
         for (map<int, unsigned>::iterator gainItr(tpGainToME_.begin()); gainItr != tpGainToME_.end(); ++gainItr) {
           sTestPulse->use(gainItr->second);
           if (sTestPulse->getBinContent(id) == kBad) {
             status = kBad;
             break;
           }
         }
       }
 
       if (status == kGood && sPedestal) {
         for (map<int, unsigned>::iterator gainItr(pedGainToME_.begin()); gainItr != pedGainToME_.end(); ++gainItr) {
           sPedestal->use(gainItr->second);
           if (sPedestal->getBinContent(id) == kBad) {
             status = kBad;
             break;
           }
         }
       }
 
       qItr->setBinContent(status);
     }
 
     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);
 
         int status(kGood);
 
         if (sPNIntegrity.getBinContent(id) == kBad)
           status = kBad;
 
         if (status == kGood && sLaserPN) {
           for (map<int, unsigned>::iterator wlItr(laserWlToME_.begin()); wlItr != laserWlToME_.end(); ++wlItr) {
             sLaserPN->use(wlItr->second);
             if (sLaserPN->getBinContent(id) == kBad) {
               status = kBad;
               break;
             }
           }
         }
 
         if (status == kGood && sLedPN) {
           for (map<int, unsigned>::iterator wlItr(ledWlToME_.begin()); wlItr != ledWlToME_.end(); ++wlItr) {
             sLedPN->use(wlItr->second);
             if (sLedPN->getBinContent(id) == kBad) {
               status = kBad;
               break;
             }
           }
         }
 
         if (status == kGood && sTestPulsePN) {
           for (map<int, unsigned>::iterator gainItr(tpPNGainToME_.begin()); gainItr != tpPNGainToME_.end(); ++gainItr) {
             sTestPulsePN->use(gainItr->second);
             if (sTestPulsePN->getBinContent(id) == kBad) {
               status = kBad;
               break;
             }
           }
         }
 
         if (status == kGood && sPedestalPN) {
           for (map<int, unsigned>::iterator gainItr(pedPNGainToME_.begin()); gainItr != pedPNGainToME_.end();
                ++gainItr) {
             sPedestalPN->use(gainItr->second);
             if (sPedestalPN->getBinContent(id) == kBad) {
               status = kBad;
               break;
             }
           }
         }
 
         mePNQualitySummary.setBinContent(id, status);
       }
     }
   }

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

overrideprivatevirtual

Reimplemented from ecaldqm::DQWorker.

Definition at line 22 of file CalibrationSummaryClient.cc.

References Exception, spr::find(), PedestalClient_cfi::gain, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), EcalCondDBWriter_cfi::laser, CalibrationSummaryClient_cfi::laserWavelengths, laserWlToME_, EcalCondDBWriter_cfi::led, CalibrationSummaryClient_cfi::ledWavelengths, ledWlToME_, pedGainToME_, pedPNGainToME_, ecaldqm::DQWorkerClient::qualitySummaries_, ecaldqm::DQWorkerClient::sources_, AlCaHLTBitMon_QueryRunRegistry::string, tpGainToME_, tpPNGainToME_, ecaldqm::DQWorkerClient::using_(), and LaserClient_cfi::wl.

Referenced by ~CalibrationSummaryClient().

                                                                          {
     std::vector<std::string> sourceList(_params.getUntrackedParameter<std::vector<std::string> >("activeSources"));
     if (std::find(sourceList.begin(), sourceList.end(), "Laser") == sourceList.end()) {
       sources_.erase(std::string("Laser"));
       sources_.erase(std::string("LaserPN"));
     }
     if (std::find(sourceList.begin(), sourceList.end(), "Led") == sourceList.end()) {
       sources_.erase(std::string("Led"));
       sources_.erase(std::string("LedPN"));
     }
     if (std::find(sourceList.begin(), sourceList.end(), "TestPulse") == sourceList.end()) {
       sources_.erase(std::string("TestPulse"));
       sources_.erase(std::string("TestPulsePN"));
     }
     if (std::find(sourceList.begin(), sourceList.end(), "Pedestal") == sourceList.end()) {
       sources_.erase(std::string("Pedestal"));
       sources_.erase(std::string("PedestalPN"));
     }
 
     MESet::PathReplacements repl;
 
     if (using_("Laser")) {
       repl.clear();
       std::vector<int> laserWavelengths(_params.getUntrackedParameter<std::vector<int> >("laserWavelengths"));
       MESetMulti const& laser(static_cast<MESetMulti const&>(sources_.at("Laser")));
       unsigned nWL(laserWavelengths.size());
       for (unsigned iWL(0); iWL != nWL; ++iWL) {
         int wl(laserWavelengths[iWL]);
         if (wl <= 0 || wl >= 5)
           throw cms::Exception("InvalidConfiguration") << "Laser Wavelength";
         repl["wl"] = std::to_string(wl);
         laserWlToME_[wl] = laser.getIndex(repl);
       }
     }
 
     if (using_("Led")) {
       repl.clear();
       std::vector<int> ledWavelengths(_params.getUntrackedParameter<std::vector<int> >("ledWavelengths"));
       MESetMulti const& led(static_cast<MESetMulti const&>(sources_.at("Led")));
       unsigned nWL(ledWavelengths.size());
       for (unsigned iWL(0); iWL != nWL; ++iWL) {
         int wl(ledWavelengths[iWL]);
         if (wl <= 0 || wl >= 5)
           throw cms::Exception("InvalidConfiguration") << "Led Wavelength";
         repl["wl"] = std::to_string(wl);
         ledWlToME_[wl] = led.getIndex(repl);
       }
     }
 
     if (using_("TestPulse")) {
       repl.clear();
       std::vector<int> tpMGPAGains(_params.getUntrackedParameter<std::vector<int> >("testPulseMGPAGains"));
       MESetMulti const& tp(static_cast<MESetMulti const&>(sources_.at("TestPulse")));
       unsigned nG(tpMGPAGains.size());
       for (unsigned iG(0); iG != nG; ++iG) {
         int gain(tpMGPAGains[iG]);
         if (gain != 1 && gain != 6 && gain != 12)
           throw cms::Exception("InvalidConfiguration") << "MGPA gain";
         repl["gain"] = std::to_string(gain);
         tpGainToME_[gain] = tp.getIndex(repl);
       }
 
       repl.clear();
       std::vector<int> tpMGPAGainsPN(_params.getUntrackedParameter<std::vector<int> >("testPulseMGPAGainsPN"));
       MESetMulti const& tppn(static_cast<MESetMulti const&>(sources_.at("TestPulsePN")));
       unsigned nGPN(tpMGPAGainsPN.size());
       for (unsigned iG(0); iG != nGPN; ++iG) {
         int gain(tpMGPAGainsPN[iG]);
         if (gain != 1 && gain != 16)
           throw cms::Exception("InvalidConfiguration") << "PN MGPA gain";
         repl["pngain"] = std::to_string(gain);
         tpPNGainToME_[gain] = tppn.getIndex(repl);
       }
     }
 
     if (using_("Pedestal")) {
       repl.clear();
       std::vector<int> pedMGPAGains(_params.getUntrackedParameter<std::vector<int> >("pedestalMGPAGains"));
       MESetMulti const& ped(static_cast<MESetMulti const&>(sources_.at("Pedestal")));
       unsigned nG(pedMGPAGains.size());
       for (unsigned iG(0); iG != nG; ++iG) {
         int gain(pedMGPAGains[iG]);
         if (gain != 1 && gain != 6 && gain != 12)
           throw cms::Exception("InvalidConfiguration") << "MGPA gain";
         repl["gain"] = std::to_string(gain);
         pedGainToME_[gain] = ped.getIndex(repl);
       }
 
       repl.clear();
       std::vector<int> pedMGPAGainsPN(_params.getUntrackedParameter<std::vector<int> >("pedestalMGPAGainsPN"));
       MESetMulti const& pedpn(static_cast<MESetMulti const&>(sources_.at("PedestalPN")));
       unsigned nGPN(pedMGPAGainsPN.size());
       for (unsigned iG(0); iG != nGPN; ++iG) {
         int gain(pedMGPAGainsPN[iG]);
         if (gain != 1 && gain != 16)
           throw cms::Exception("InvalidConfiguration") << "PN MGPA gain";
         repl["pngain"] = std::to_string(gain);
         pedPNGainToME_[gain] = pedpn.getIndex(repl);
       }
     }
 
     qualitySummaries_.insert("QualitySummary");
     qualitySummaries_.insert("PNQualitySummary");
   }