ecaldqm::LedWriter Class Reference

#include <DBWriterWorkers.h>

Inheritance diagram for ecaldqm::LedWriter:

Public Member Functions
	LedWriter (edm::ParameterSet const &)
bool	run (EcalCondDBInterface *, MonRunIOV &) override
	~LedWriter () 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)
virtual	~DBWriterWorker ()

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

Additional Inherited Members
Protected Attributes inherited from ecaldqm::DBWriterWorker
bool	active_
std::string const	name_
std::set< std::string >	runTypes_
MESetCollection	source_
int	verbosity_

Detailed Description

Definition at line 100 of file DBWriterWorkers.h.

Constructor & Destructor Documentation

ecaldqm::LedWriter::LedWriter

(

edm::ParameterSet const &

_ps

)

Definition at line 1081 of file DBWriterWorkers.cc.

References CustomPhysics_cfi::amplitude, Exception, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), ecaldqm::DBWriterWorker::source_, and wlToME_.

                                                 : DBWriterWorker("Led", _ps), wlToME_() {
    std::vector<int> ledWavelengths(_ps.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 &>(source_.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);
    }
  }

ecaldqm::LedWriter::~LedWriter ( )

inlineoverride

Definition at line 103 of file DBWriterWorkers.h.

References ecaldqm::DBWriterWorker::run().

{}

Member Function Documentation

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 1101 of file DBWriterWorkers.cc.

References ecaldqm::crystalID(), MillePedeFileConverter_cfg::e, Exception, spr::find(), ecaldqm::MESet::ConstBin::getBinContent(), ecaldqm::MESet::ConstBin::getBinEntries(), ecaldqm::MESet::ConstBin::getBinError(), triggerObjects_cff::id, EcalCondDBInterface::insertDataArraySet(), ecaldqm::kBad, ecaldqm::kMBad, ecaldqm::qualityOK(), mps_fire::result, MonLed1Dat::setTaskStatus(), MonLed2Dat::setTaskStatus(), ITimingDat::setTaskStatus(), ITimingDat::setTimingMean(), ITimingDat::setTimingRMS(), MonLed2Dat::setVPTMean(), MonLed1Dat::setVPTMean(), MonLed2Dat::setVPTOverPNMean(), MonLed1Dat::setVPTOverPNMean(), MonLed1Dat::setVPTOverPNRMS(), MonLed2Dat::setVPTOverPNRMS(), MonLed2Dat::setVPTRMS(), MonLed1Dat::setVPTRMS(), ecaldqm::DBWriterWorker::source_, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, ecaldqm::MESet::const_iterator::toNextChannel(), and wlToME_.

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

                                                               {
    /*
    uses
    LedTask.Amplitude (h01, h03)
    LedTask.AOverP (h02, h04)
    LedTask.Timing (h09, h10)
    LedClient.Quality (meg01, meg02)
    LedTask.PNAmplitude (i09, i10)
x      LedClient.PNQualitySummary (meg09, meg10)
x      PNDiodeTask.Pedestal (i13, i14)
  */

    bool result(true);

    std::map<EcalLogicID, MonLed1Dat> l1Amp;
    std::map<EcalLogicID, MonTimingLed1CrystalDat> l1Time;
    //     std::map<EcalLogicID, MonPNLed1Dat> l1PN;
    std::map<EcalLogicID, MonLed2Dat> l2Amp;
    std::map<EcalLogicID, MonTimingLed2CrystalDat> l2Time;
    //     std::map<EcalLogicID, MonPNLed2Dat> l2PN;

    MESet const &ampME(source_.at("Amplitude"));
    MESet const &aopME(source_.at("AOverP"));
    MESet const &timeME(source_.at("Timing"));
    MESet const &qualityME(source_.at("Quality"));

    //     MESet const& pnME(source_.at("PNAmplitude"));
    //     MESet const& pnQualityME(source_.at("PNQuality"));
    //     MESet const& pnPedestalME(source_.at("PNPedestal"));

    for (std::map<int, unsigned>::iterator wlItr(wlToME_.begin()); wlItr != wlToME_.end(); ++wlItr) {
      int wl(wlItr->first);
      unsigned iM(wlItr->second);

      static_cast<MESetMulti const &>(ampME).use(iM);
      static_cast<MESetMulti const &>(aopME).use(iM);
      static_cast<MESetMulti const &>(timeME).use(iM);
      static_cast<MESetMulti const &>(qualityME).use(iM);
      //       static_cast<MESetMulti const&>(pnME).use(iM);
      //       static_cast<MESetMulti const&>(pnQualityME).use(iM);

      MESet::const_iterator aEnd(ampME.end());
      MESet::const_iterator qItr(qualityME);
      MESet::const_iterator oItr(aopME);
      MESet::const_iterator tItr(timeME);
      for (MESet::const_iterator aItr(ampME.beginChannel()); aItr != aEnd; aItr.toNextChannel()) {
        float aEntries(aItr->getBinEntries());
        if (aEntries < 1.)
          continue;

        qItr = aItr;
        oItr = aItr;
        tItr = aItr;

        DetId id(aItr->getId());

        float ampMean(aItr->getBinContent());
        float ampRms(aItr->getBinError() * std::sqrt(aEntries));

        float aopEntries(oItr->getBinEntries());
        float aopMean(oItr->getBinContent());
        float aopRms(oItr->getBinError() * std::sqrt(aopEntries));

        float timeEntries(tItr->getBinEntries());
        float timeMean(tItr->getBinContent());
        float timeRms(tItr->getBinError() * std::sqrt(timeEntries));

        int channelStatus(qItr->getBinContent());
        bool channelBad(channelStatus == kBad || channelStatus == kMBad);

        EcalLogicID logicID(crystalID(id));

        switch (wl) {
          case 1: {
            MonLed1Dat &aData(l1Amp[logicID]);
            aData.setVPTMean(ampMean);
            aData.setVPTRMS(ampRms);
            aData.setVPTOverPNMean(aopMean);
            aData.setVPTOverPNRMS(aopRms);
            aData.setTaskStatus(channelBad);

            MonTimingLed1CrystalDat &tData(l1Time[logicID]);
            tData.setTimingMean(timeMean);
            tData.setTimingRMS(timeRms);
            tData.setTaskStatus(channelBad);
          } break;
          case 2: {
            MonLed2Dat &aData(l2Amp[logicID]);
            aData.setVPTMean(ampMean);
            aData.setVPTRMS(ampRms);
            aData.setVPTOverPNMean(aopMean);
            aData.setVPTOverPNRMS(aopRms);
            aData.setTaskStatus(channelBad);

            MonTimingLed2CrystalDat &tData(l2Time[logicID]);
            tData.setTimingMean(timeMean);
            tData.setTimingRMS(timeRms);
            tData.setTaskStatus(channelBad);
          } break;
        }
        result &= qualityOK(channelStatus);
      }

      //       for(unsigned iMD(0); iMD < memDCC.size(); ++iMD){
      //         unsigned iDCC(memDCC[iMD]);

      //         if(iDCC >= kEBmLow && iDCC <= kEBpHigh) continue;

      //         for(unsigned iPN(1); iPN <= 10; ++iPN){
      //           EcalPnDiodeDetId pnid(EcalEndcap, iDCC + 1, iPN);

      //           float entries(pnME.getBinEntries(pnid));
      //           if(entries < 1.) continue;

      //           float mean(pnME.getBinContent(pnid));
      //           float rms(pnME.getBinError(pnid) * std::sqrt(entries));

      //           float pedestalEntries(pnPedestalME.getBinEntries(pnid));
      //           float pedestalMean(pnPedestalME.getBinContent(pnid));
      //           float pedestalRms(pnPedestalME.getBinError(pnid) *
      //           std::sqrt(pedestalEntries));

      //           int channelStatus(pnQualityME.getBinContent(pnid));
      //           bool channelBad(channelStatus == kBad || channelStatus ==
      //           kMBad);

      //           switch(wl){
      //           case 1:
      //             {
      //               MonPNLed1Dat& data(l1PN[lmPNID(pnid)]);
      //               data.setADCMeanG1(-1.);
      //               data.setADCRMSG1(-1.);
      //               data.setPedMeanG1(-1.);
      //               data.setPedRMSG1(-1.);
      //               data.setADCMeanG16(mean);
      //               data.setADCRMSG16(rms);
      //               data.setPedMeanG16(pedestalMean);
      //               data.setPedRMSG16(pedestalRms);
      //               data.setTaskStatus(channelBad);
      //             }
      //             break;
      //           case 2:
      //             {
      //               MonPNLed2Dat& data(l2PN[lmPNID(pnid)]);
      //               data.setADCMeanG1(-1.);
      //               data.setADCRMSG1(-1.);
      //               data.setPedMeanG1(-1.);
      //               data.setPedRMSG1(-1.);
      //               data.setADCMeanG16(mean);
      //               data.setADCRMSG16(rms);
      //               data.setPedMeanG16(pedestalMean);
      //               data.setPedRMSG16(pedestalRms);
      //               data.setTaskStatus(channelBad);
      //             }
      //             break;
      //           }

      //           result &= qualityOK(channelStatus);

      //         }
      //       }
    }

    try {
      if (!l1Amp.empty())
        _db->insertDataArraySet(&l1Amp, &_iov);
      if (!l1Time.empty())
        _db->insertDataArraySet(&l1Time, &_iov);
      //       if(l1PN.size() > 0)
      //         _db->insertDataArraySet(&l1PN, &_iov);
      if (!l2Amp.empty())
        _db->insertDataArraySet(&l2Amp, &_iov);
      if (!l2Time.empty())
        _db->insertDataArraySet(&l2Time, &_iov);
      //       if(l2PN.size() > 0)
      //         _db->insertDataArraySet(&l2PN, &_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

std::map<int, unsigned> ecaldqm::LedWriter::wlToME_

private

Definition at line 108 of file DBWriterWorkers.h.

Referenced by LedWriter(), and run().