ecaldqm::PedestalWriter Class Reference

#include <DBWriterWorkers.h>

Inheritance diagram for ecaldqm::PedestalWriter:

Public Member Functions
	PedestalWriter (edm::ParameterSet const &)
bool	run (EcalCondDBInterface *, MonRunIOV &) override
	~PedestalWriter () 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 62 of file DBWriterWorkers.h.

Constructor & Destructor Documentation

PedestalWriter()

ecaldqm::PedestalWriter::PedestalWriter

(

edm::ParameterSet const &

_ps

)

Definition at line 574 of file DBWriterWorkers.cc.

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

      : DBWriterWorker("Pedestal", _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 &pedestal(static_cast<MESetMulti const &>(source_.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 &>(source_.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);
    }
  }

~PedestalWriter()

ecaldqm::PedestalWriter::~PedestalWriter ( )

inlineoverride

Definition at line 65 of file DBWriterWorkers.h.

{}

Member Function Documentation

run()

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 604 of file DBWriterWorkers.cc.

References ecaldqm::MESetCollection::at(), ecaldqm::crystalID(), data, MillePedeFileConverter_cfg::e, EcalBarrel, EcalEndcap, Exception, spr::find(), PedestalClient_cfi::gain, gainToME_, ecaldqm::DQWorker::getEcalDQMSetupObjects(), ecaldqm::DQWorker::GetElectronicsMap(), EcalCondDBInterface::insertDataArraySet(), ecaldqm::kBad, ecaldqm::kEEpLow, ecaldqm::kMBad, ecaldqm::lmPNID(), SiStripPI::mean, ecaldqm::memDCC, pnGainToME_, ecaldqm::qualityOK(), mps_fire::result, SiStripPI::rms, MonPedestalsDat::setPedMeanG1(), MonPNPedDat::setPedMeanG1(), MonPedestalsDat::setPedMeanG12(), MonPNPedDat::setPedMeanG16(), MonPedestalsDat::setPedMeanG6(), MonPNPedDat::setPedRMSG1(), MonPedestalsDat::setPedRMSG1(), MonPedestalsDat::setPedRMSG12(), MonPNPedDat::setPedRMSG16(), MonPedestalsDat::setPedRMSG6(), MonPNPedDat::setTaskStatus(), MonPedestalsDat::setTaskStatus(), ecaldqm::DBWriterWorker::source_, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, and ecaldqm::MESet::const_iterator::toNextChannel().

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

                                                                    {
    /*
    uses
    PedestalTask.Pedestal (h01, h02, h03)
    PedestalTask.PNPedestal (i01, i02)
    PedestalClient.Quality (meg01, meg02, meg03)
    PedestalClient.PNQualitySummary (meg04, meg05)
  */

    bool result(true);

    std::map<EcalLogicID, MonPedestalsDat> pedestals;
    std::map<EcalLogicID, MonPNPedDat> pnPedestals;

    MESet const &pedestalME(source_.at("Pedestal"));
    MESet const &qualityME(source_.at("Quality"));

    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 &>(pedestalME).use(iM);
      static_cast<MESetMulti const &>(qualityME).use(iM);

      MESet::const_iterator pEnd(pedestalME.end(GetElectronicsMap()));
      MESet::const_iterator qItr(GetElectronicsMap(), qualityME);
      for (MESet::const_iterator pItr(pedestalME.beginChannel(GetElectronicsMap())); pItr != pEnd;
           pItr.toNextChannel(GetElectronicsMap())) {
        float entries(pItr->getBinEntries());
        if (entries < 1.)
          continue;

        qItr = pItr;

        float mean(pItr->getBinContent());
        float rms(pItr->getBinError() * std::sqrt(entries));

        EcalLogicID logicID(crystalID(pItr->getId(), GetElectronicsMap()));
        if (pedestals.find(logicID) == pedestals.end()) {
          MonPedestalsDat &insertion(pedestals[logicID]);
          insertion.setPedMeanG1(-1.);
          insertion.setPedRMSG1(-1.);
          insertion.setPedMeanG6(-1.);
          insertion.setPedRMSG6(-1.);
          insertion.setPedMeanG12(-1.);
          insertion.setPedRMSG12(-1.);
          insertion.setTaskStatus(false);
        }

        MonPedestalsDat &data(pedestals[logicID]);
        switch (gain) {
          case 1:
            data.setPedMeanG1(mean);
            data.setPedRMSG1(rms);
            break;
          case 6:
            data.setPedMeanG6(mean);
            data.setPedRMSG6(rms);
            break;
          case 12:
            data.setPedMeanG12(mean);
            data.setPedRMSG12(rms);
            break;
        }

        int channelStatus(qItr->getBinContent());
        bool channelBad(channelStatus == kBad || channelStatus == kMBad);
        if (channelBad)
          data.setTaskStatus(true);

        result &= qualityOK(channelStatus);
      }
    }

    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 &>(pnPedestalME).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(pnPedestalME.getBinEntries(getEcalDQMSetupObjects(), pnid));
          if (entries < 1.)
            continue;

          float mean(pnPedestalME.getBinContent(getEcalDQMSetupObjects(), pnid));
          float rms(pnPedestalME.getBinError(getEcalDQMSetupObjects(), pnid) * std::sqrt(entries));

          EcalLogicID logicID(lmPNID(pnid));
          if (pnPedestals.find(logicID) == pnPedestals.end()) {
            MonPNPedDat &insertion(pnPedestals[logicID]);
            insertion.setPedMeanG1(-1.);
            insertion.setPedRMSG1(-1.);
            insertion.setPedMeanG16(-1.);
            insertion.setPedRMSG16(-1.);
            insertion.setTaskStatus(false);
          }

          MonPNPedDat &data(pnPedestals[lmPNID(pnid)]);
          switch (gain) {
            case 1:
              data.setPedMeanG1(mean);
              data.setPedRMSG1(rms);
              break;
            case 16:
              data.setPedMeanG16(mean);
              data.setPedRMSG16(rms);
              break;
          }

          int channelStatus(pnQualityME.getBinContent(getEcalDQMSetupObjects(), pnid));
          bool channelBad(channelStatus == kBad || channelStatus == kMBad);
          if (channelBad)
            data.setTaskStatus(true);

          result &= qualityOK(channelStatus);
        }
      }
    }

    try {
      if (!pedestals.empty())
        _db->insertDataArraySet(&pedestals, &_iov);
      if (!pnPedestals.empty())
        _db->insertDataArraySet(&pnPedestals, &_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::PedestalWriter::gainToME_

private

Definition at line 70 of file DBWriterWorkers.h.

Referenced by PedestalWriter(), and run().

pnGainToME_

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

private

Definition at line 71 of file DBWriterWorkers.h.

Referenced by PedestalWriter(), and run().