#include <DBWriterWorkers.h>

Inheritance diagram for ecaldqm::TestPulseWriter:

Public Member Functions
bool	run (EcalCondDBInterface *, MonRunIOV &) override

	TestPulseWriter (edm::ParameterSet const &)

	~TestPulseWriter () override

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

std::string const &	getName () const

bool	isActive () const

void	retrieveSource (DQMStore::IGetter &)

bool	runsOn (std::string const &_runType) const

void	setVerbosity (int _v)

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

virtual void	bookMEs (DQMStore::IBooker &)

bool	checkElectronicsMap (bool=true)

bool	checkGeometry (bool=true)

bool	checkTopology (bool=true)

bool	checkTrigTowerMap (bool=true)

	DQWorker ()

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

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

virtual void	releaseMEs ()

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 Attributes
std::map< int, unsigned >	gainToME_

std::map< int, unsigned >	pnGainToME_

Additional Inherited Members
Public Types inherited from ecaldqm::DBWriterWorker
typedef dqm::legacy::DQMStore	DQMStore

typedef dqm::legacy::MonitorElement	MonitorElement

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::DQWorker
void	initialize (std::string const &_name, edm::ParameterSet const &)

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

virtual void	setME (edm::ParameterSet const &)

virtual void	setParams (edm::ParameterSet const &)

virtual void	setSource (edm::ParameterSet const &)

void	setVerbosity (int _verbosity)

Protected Attributes inherited from ecaldqm::DBWriterWorker
bool	active_

std::string const	name_

std::set< std::string >	runTypes_

MESetCollection	source_

int	verbosity_

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

Constructor & Destructor Documentation

◆ TestPulseWriter()

ecaldqm::TestPulseWriter::TestPulseWriter ( edm::ParameterSet const & _ps )

Definition at line 801 of file DBWriterWorkers.cc.

References CustomPhysics_cfi::amplitude, ecaldqm::MESetCollection::at(), Exception, Hcal_Conditions_forGlobalTag_cff::gain, gainToME_, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), PedestalClient_cfi::MGPAGains, PedestalClient_cfi::MGPAGainsPN, pnGainToME_, ecaldqm::DBWriterWorker::source_, and to_string().

       : DBWriterWorker("TestPulse", _ps), gainToME_(), pnGainToME_() {
     std::vector<int> MGPAGains(_ps.getUntrackedParameter<std::vector<int>>("MGPAGains"));
     std::vector<int> MGPAGainsPN(_ps.getUntrackedParameter<std::vector<int>>("MGPAGainsPN"));
 
     MESet::PathReplacements repl;
 
     MESetMulti const &amplitude(static_cast<MESetMulti const &>(source_.at("Amplitude")));
     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] = amplitude.getIndex(repl);
     }
 
     repl.clear();
 
     MESetMulti const &pnAmplitude(static_cast<MESetMulti const &>(source_.at("PNAmplitude")));
     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] = pnAmplitude.getIndex(repl);
     }
   }

◆ ~TestPulseWriter()

ecaldqm::TestPulseWriter::~TestPulseWriter ( )

inlineoverride

Definition at line 85 of file DBWriterWorkers.h.

85 {}

Member Function Documentation

◆ run()

bool ecaldqm::TestPulseWriter::run	(	EcalCondDBInterface *	_db,
		MonRunIOV &	_iov
	)

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 831 of file DBWriterWorkers.cc.

References CustomPhysics_cfi::amplitude, ecaldqm::MESetCollection::at(), ecaldqm::crystalID(), data, MillePedeFileConverter_cfg::e, EcalBarrel, EcalEndcap, Exception, spr::find(), Hcal_Conditions_forGlobalTag_cff::gain, gainToME_, ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::DQWorker::GetElectronicsMap(), mps_fire::i, EcalPhiSymFlatTableProducers_cfi::id, EcalCondDBInterface::insertDataArraySet(), EcalCondDBInterface::insertDataSet(), ecaldqm::kBad, ecaldqm::kEEpLow, ecaldqm::kMBad, ecaldqm::lmPNID(), SiStripPI::mean, ecaldqm::memDCC, ecaldqm::nChannels, pnGainToME_, ecaldqm::qualityOK(), mps_fire::result, SiStripPI::rms, EgammaValidation_cff::samples, MonPNMGPADat::setADCMeanG1(), MonTestPulseDat::setADCMeanG1(), MonTestPulseDat::setADCMeanG12(), MonPNMGPADat::setADCMeanG16(), MonTestPulseDat::setADCMeanG6(), MonPNMGPADat::setADCRMSG1(), MonTestPulseDat::setADCRMSG1(), MonTestPulseDat::setADCRMSG12(), MonPNMGPADat::setADCRMSG16(), MonTestPulseDat::setADCRMSG6(), MonPNMGPADat::setPedMeanG1(), MonPNMGPADat::setPedMeanG16(), MonPNMGPADat::setPedRMSG1(), MonPNMGPADat::setPedRMSG16(), MonPulseShapeDat::setSamples(), MonTestPulseDat::setTaskStatus(), MonPNMGPADat::setTaskStatus(), l1trig_cff::shape, ecaldqm::DBWriterWorker::source_, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, and ecaldqm::MESet::const_iterator::toNextChannel().

Referenced by Types.EventID::cppID(), and Types.LuminosityBlockID::cppID().

                                                                      {
     /*
     uses
     TestPulseTask.Amplitude (ha01, ha02, ha03)
     TestPulseTask.Shape (me_hs01, me_hs02, me_hs03)
     TestPulseTask.PNAmplitude (i01, i02)
     PNDiodeTask.Pedestal (i03, i04)
     TestPulseClient.Quality (meg01, meg02, meg03)
     TestPulseClient.PNQualitySummary (meg04, meg05)
   */
 
     bool result(true);
 
     std::map<EcalLogicID, MonTestPulseDat> amplitude;
     std::map<EcalLogicID, MonPulseShapeDat> shape;
     std::map<EcalLogicID, MonPNMGPADat> pnAmplitude;
 
     MESet const &amplitudeME(source_.at("Amplitude"));
     MESet const &shapeME(source_.at("Shape"));
     MESet const &qualityME(source_.at("Quality"));
 
     MESet const &pnAmplitudeME(source_.at("PNAmplitude"));
     MESet const &pnPedestalME(source_.at("PNPedestal"));
     MESet const &pnQualityME(source_.at("PNQuality"));
 
     for (std::map<int, unsigned>::iterator gainItr(gainToME_.begin()); gainItr != gainToME_.end(); ++gainItr) {
       int gain(gainItr->first);
       int iM(gainItr->second);
 
       static_cast<MESetMulti const &>(amplitudeME).use(iM);
       static_cast<MESetMulti const &>(shapeME).use(iM);
       static_cast<MESetMulti const &>(qualityME).use(iM);
 
       MESet::const_iterator aEnd(amplitudeME.end(GetElectronicsMap()));
       MESet::const_iterator qItr(GetElectronicsMap(), qualityME);
       for (MESet::const_iterator aItr(amplitudeME.beginChannel(GetElectronicsMap())); aItr != aEnd;
            aItr.toNextChannel(GetElectronicsMap())) {
         float entries(aItr->getBinEntries());
         if (entries < 1.)
           continue;
 
         qItr = aItr;
 
         float mean(aItr->getBinContent());
         float rms(aItr->getBinError() * std::sqrt(entries));
 
         EcalLogicID logicID(crystalID(aItr->getId(), GetElectronicsMap()));
         if (amplitude.find(logicID) == amplitude.end()) {
           MonTestPulseDat &insertion(amplitude[logicID]);
           insertion.setADCMeanG1(-1.);
           insertion.setADCRMSG1(-1.);
           insertion.setADCMeanG6(-1.);
           insertion.setADCRMSG6(-1.);
           insertion.setADCMeanG12(-1.);
           insertion.setADCRMSG12(-1.);
           insertion.setTaskStatus(false);
         }
 
         MonTestPulseDat &data(amplitude[logicID]);
         switch (gain) {
           case 1:
             data.setADCMeanG1(mean);
             data.setADCRMSG1(rms);
             break;
           case 6:
             data.setADCMeanG6(mean);
             data.setADCRMSG6(rms);
             break;
           case 12:
             data.setADCMeanG12(mean);
             data.setADCRMSG12(rms);
             break;
         }
 
         int channelStatus(qItr->getBinContent());
         bool channelBad(channelStatus == kBad || channelStatus == kMBad);
         if (channelBad)
           data.setTaskStatus(true);
 
         result &= qualityOK(channelStatus);
       }
 
       for (unsigned iSM(0); iSM < 54; ++iSM) {
         std::vector<float> samples(10, 0.);
         std::vector<DetId> ids(GetElectronicsMap()->dccConstituents(iSM + 1));
         unsigned nId(ids.size());
         unsigned nChannels(0);
         EcalLogicID logicID;
         for (unsigned iD(0); iD < nId; ++iD) {
           DetId &id(ids[iD]);
 
           if (iD == 0)
             logicID = crystalID(id, GetElectronicsMap());
 
           if (shapeME.getBinEntries(getEcalDQMSetupObjects(), id, 1) < 1.)
             continue;
 
           ++nChannels;
 
           for (int i(0); i < 10; ++i)
             samples[i] += shapeME.getBinContent(getEcalDQMSetupObjects(), id, i + 1);
         }
 
         if (nChannels == 0)
           continue;
 
         for (int i(0); i < 10; ++i)
           samples[i] /= nChannels;
 
         if (shape.find(logicID) == shape.end()) {
           MonPulseShapeDat &insertion(shape[logicID]);
           std::vector<float> defval(10, -1.);
           insertion.setSamples(defval, 1);
           insertion.setSamples(defval, 6);
           insertion.setSamples(defval, 12);
         }
 
         MonPulseShapeDat &data(shape[logicID]);
         data.setSamples(samples, gain);
       }
     }
 
     for (std::map<int, unsigned>::iterator gainItr(pnGainToME_.begin()); gainItr != pnGainToME_.end(); ++gainItr) {
       int gain(gainItr->first);
       int iM(gainItr->second);
 
       static_cast<MESetMulti const &>(pnAmplitudeME).use(iM);
       static_cast<MESetMulti const &>(pnQualityME).use(iM);
 
       for (unsigned iMD(0); iMD < memDCC.size(); ++iMD) {
         unsigned iDCC(memDCC[iMD]);
 
         int subdet(iDCC <= kEEmHigh || iDCC >= kEEpLow ? EcalEndcap : EcalBarrel);
 
         for (unsigned iPN(1); iPN <= 10; ++iPN) {
           EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
 
           float entries(pnAmplitudeME.getBinEntries(getEcalDQMSetupObjects(), pnid));
           if (entries < 1.)
             continue;
 
           float mean(pnAmplitudeME.getBinContent(getEcalDQMSetupObjects(), pnid));
           float rms(pnAmplitudeME.getBinError(getEcalDQMSetupObjects(), pnid) * std::sqrt(entries));
           float pedestalEntries(pnPedestalME.getBinEntries(getEcalDQMSetupObjects(), pnid));
           float pedestalMean(pnPedestalME.getBinContent(getEcalDQMSetupObjects(), pnid));
           float pedestalRms(pnPedestalME.getBinError(getEcalDQMSetupObjects(), pnid) * std::sqrt(pedestalEntries));
 
           EcalLogicID logicID(lmPNID(pnid));
           if (pnAmplitude.find(logicID) == pnAmplitude.end()) {
             MonPNMGPADat &insertion(pnAmplitude[logicID]);
             insertion.setADCMeanG1(-1.);
             insertion.setADCRMSG1(-1.);
             insertion.setPedMeanG1(-1.);
             insertion.setPedRMSG1(-1.);
             insertion.setADCMeanG16(-1.);
             insertion.setADCRMSG16(-1.);
             insertion.setPedMeanG16(-1.);
             insertion.setPedRMSG16(-1.);
             insertion.setTaskStatus(false);
           }
 
           MonPNMGPADat &data(pnAmplitude[lmPNID(pnid)]);
           switch (gain) {
             case 1:
               data.setADCMeanG1(mean);
               data.setADCRMSG1(rms);
               // dynamic pedestal not measured for G1
               //             data.setPedMeanG1(pedestalMean);
               //             data.setPedRMSG1(pedestalRms);
               break;
             case 16:
               data.setADCMeanG16(mean);
               data.setADCRMSG16(rms);
               data.setPedMeanG16(pedestalMean);
               data.setPedRMSG16(pedestalRms);
               break;
           }
 
           int channelStatus(pnQualityME.getBinContent(getEcalDQMSetupObjects(), pnid));
           bool channelBad(channelStatus == kBad || channelStatus == kMBad);
           if (channelBad)
             data.setTaskStatus(true);
 
           result &= qualityOK(channelStatus);
         }
       }
     }
 
     try {
       if (!amplitude.empty())
         _db->insertDataArraySet(&amplitude, &_iov);
       if (!shape.empty())
         _db->insertDataSet(&shape, &_iov);
       if (!pnAmplitude.empty())
         _db->insertDataArraySet(&pnAmplitude, &_iov);
     } catch (std::runtime_error &e) {
       if (std::string(e.what()).find("unique constraint") != std::string::npos)
         edm::LogWarning("EcalDQM") << e.what();
       else
         throw cms::Exception("DBError") << e.what();
     }
 
     return result;
   }

Member Data Documentation

◆ gainToME_

std::map<int, unsigned> ecaldqm::TestPulseWriter::gainToME_

private

Definition at line 90 of file DBWriterWorkers.h.

Referenced by run(), and TestPulseWriter().

◆ pnGainToME_

std::map<int, unsigned> ecaldqm::TestPulseWriter::pnGainToME_