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 ()
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 1112 of file DBWriterWorkers.cc.

References Exception, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), ecaldqm::DBWriterWorker::source_, cond::to_string(), 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 ( )

inline

Definition at line 103 of file DBWriterWorkers.h.

{}

Member Function Documentation

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 1135 of file DBWriterWorkers.cc.

References compareJSON::const, ecaldqm::crystalID(), alignCSCRings::e, Exception, spr::find(), ecaldqm::MESet::ConstBin::getBinContent(), ecaldqm::MESet::ConstBin::getBinEntries(), ecaldqm::MESet::ConstBin::getBinError(), EcalCondDBInterface::insertDataArraySet(), ecaldqm::kBad, ecaldqm::kMBad, ecaldqm::qualityOK(), query::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.size() > 0)
        _db->insertDataArraySet(&l1Amp, &_iov);
      if(l1Time.size() > 0)
        _db->insertDataArraySet(&l1Time, &_iov);
//       if(l1PN.size() > 0)
//         _db->insertDataArraySet(&l1PN, &_iov);
      if(l2Amp.size() > 0)
        _db->insertDataArraySet(&l2Amp, &_iov);
      if(l2Time.size() > 0)
        _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().