ecaldqm::TestPulseWriter Class Reference

#include <DBWriterWorkers.h>

Inheritance diagram for ecaldqm::TestPulseWriter:

Public Member Functions
bool	run (EcalCondDBInterface *, MonRunIOV &) override
	TestPulseWriter (edm::ParameterSet const &)
	~TestPulseWriter ()
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 >	gainToME_
std::map< int, unsigned >	pnGainToME_

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

Constructor & Destructor Documentation

ecaldqm::TestPulseWriter::TestPulseWriter

(

edm::ParameterSet const &

_ps

)

Definition at line 827 of file DBWriterWorkers.cc.

References Exception, gainToME_, ecaldqm::MESetMulti::getIndex(), edm::ParameterSet::getUntrackedParameter(), pnGainToME_, ecaldqm::DBWriterWorker::source_, and cond::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);
    }
  }

ecaldqm::TestPulseWriter::~TestPulseWriter ( )

inline

Definition at line 83 of file DBWriterWorkers.h.

{}

Member Function Documentation

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 859 of file DBWriterWorkers.cc.

References compareJSON::const, ecaldqm::crystalID(), AlCaHLTBitMon_QueryRunRegistry::data, alignCSCRings::e, EcalBarrel, EcalEndcap, python.tagInventory::entries, Exception, spr::find(), gainToME_, ecaldqm::getElectronicsMap(), i, EcalCondDBInterface::insertDataArraySet(), EcalCondDBInterface::insertDataSet(), ecaldqm::kBad, ecaldqm::kEEpLow, ecaldqm::kMBad, ecaldqm::lmPNID(), timingPdfMaker::mean, ecaldqm::memDCC, ecaldqm::nChannels, pnGainToME_, ecaldqm::qualityOK(), query::result, plotscripts::rms(), 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(), 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());
      MESet::const_iterator qItr(qualityME);
      for(MESet::const_iterator aItr(amplitudeME.beginChannel()); aItr != aEnd; aItr.toNextChannel()){
        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()));
        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);

          if(shapeME.getBinEntries(id, 1) < 1.) continue;

          ++nChannels;

          for(int i(0); i < 10; ++i)
            samples[i] += shapeME.getBinContent(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(pnid));
          if(entries < 1.) continue;

          float mean(pnAmplitudeME.getBinContent(pnid));
          float rms(pnAmplitudeME.getBinError(pnid) * std::sqrt(entries));
          float pedestalEntries(pnPedestalME.getBinEntries(pnid));
          float pedestalMean(pnPedestalME.getBinContent(pnid));
          float pedestalRms(pnPedestalME.getBinError(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(pnid));
          bool channelBad(channelStatus == kBad || channelStatus == kMBad);
          if(channelBad)
            data.setTaskStatus(true);

          result &= qualityOK(channelStatus);
        }
      }
    }

    try{
      if(amplitude.size() > 0)
        _db->insertDataArraySet(&amplitude, &_iov);
      if(shape.size() > 0)
        _db->insertDataSet(&shape, &_iov);
      if(pnAmplitude.size() > 0)
        _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

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

private

Definition at line 88 of file DBWriterWorkers.h.

Referenced by run(), and TestPulseWriter().

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

private

Definition at line 89 of file DBWriterWorkers.h.

Referenced by run(), and TestPulseWriter().