ecaldqm::IntegrityWriter Class Reference

#include <DBWriterWorkers.h>

Inheritance diagram for ecaldqm::IntegrityWriter:

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

Additional Inherited Members
Public Types inherited from ecaldqm::DBWriterWorker
typedef dqm::legacy::DQMStore	DQMStore
typedef dqm::legacy::MonitorElement	MonitorElement
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 41 of file DBWriterWorkers.h.

Constructor & Destructor Documentation

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

inline

Definition at line 43 of file DBWriterWorkers.h.

: DBWriterWorker("Integrity", _ps) {}

ecaldqm::IntegrityWriter::~IntegrityWriter ( )

inlineoverride

Definition at line 44 of file DBWriterWorkers.h.

References ecaldqm::DBWriterWorker::run().

{}

Member Function Documentation

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 90 of file DBWriterWorkers.cc.

References l1GtPatternGenerator_cfi::bx, ecaldqm::ccuExists(), ewkTauDQM_cfi::channels, ecaldqm::crystalID(), data, MillePedeFileConverter_cfg::e, EcalBarrel, EcalEndcap, runTauDisplay::eid, Exception, spr::find(), PedestalClient_cfi::gain, ecaldqm::getElectronicsMap(), triggerObjects_cff::id, EcalCondDBInterface::insertDataArraySet(), ecaldqm::kBad, ecaldqm::kEBpHigh, ecaldqm::kEEmLow, ecaldqm::kEEpLow, ecaldqm::kMBad, ecaldqm::memChannelID(), ecaldqm::memDCC, ecaldqm::memTowerID(), dqmiodumpmetadata::n, ecaldqm::qualityOK(), mps_fire::result, MonMemChConsistencyDat::setProblematicEvents(), MonCrystalConsistencyDat::setProblematicEvents(), MonMemTTConsistencyDat::setProblematicEvents(), MonTTConsistencyDat::setProblematicEvents(), MonTTConsistencyDat::setProblemsBunchX(), MonCrystalConsistencyDat::setProblemsGainSwitch(), MonCrystalConsistencyDat::setProblemsGainZero(), MonMemChConsistencyDat::setProblemsGainZero(), MonMemChConsistencyDat::setProblemsID(), MonMemTTConsistencyDat::setProblemsID(), MonCrystalConsistencyDat::setProblemsID(), MonTTConsistencyDat::setProblemsID(), MonTTConsistencyDat::setProblemsLV1(), MonTTConsistencyDat::setProblemsSize(), MonMemTTConsistencyDat::setProblemsSize(), MonTTConsistencyDat::setProcessedEvents(), MonMemChConsistencyDat::setProcessedEvents(), MonCrystalConsistencyDat::setProcessedEvents(), MonMemTTConsistencyDat::setProcessedEvents(), MonCrystalConsistencyDat::setTaskStatus(), MonMemChConsistencyDat::setTaskStatus(), MonTTConsistencyDat::setTaskStatus(), MonMemTTConsistencyDat::setTaskStatus(), ecaldqm::DBWriterWorker::source_, AlCaHLTBitMon_QueryRunRegistry::string, ecaldqm::MESet::const_iterator::toNextChannel(), ecaldqm::towerID(), and ecaldqm::DBWriterWorker::verbosity_.

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

                                                                     {
    /*
    uses
    OccupancyTask.Digi (h_)
    PNDiodeTask.Occupancy (hmem_)
    IntegrityTask.Gain (h01_)
    IntegrityTask.ChId (h02_)
    IntegrityTask.GainSwitch (h03_)
    IntegrityTask.TowerId (h04_)
    IntegrityTask.BlockSize (h05_)
    RawDataTask.L1AFE
    RawDataTask.BXFE
    PNDiodeTask.MemChId (h06_)
    PNDiodeTask.MemGain (h07_)
    PNDiodeTask.MemTowerId (h08_)
    PNDiodeTask.MomBlockSize (h09_)
    IntegrityClient.Quality
    PNIntegrityClient.QualitySummary
  */

    bool result(true);

    std::map<EcalLogicID, MonCrystalConsistencyDat> crystalConsistencies;
    std::map<EcalLogicID, MonTTConsistencyDat> towerConsistencies;
    std::map<EcalLogicID, MonMemChConsistencyDat> memChannelConsistencies;
    std::map<EcalLogicID, MonMemTTConsistencyDat> memTowerConsistencies;

    MESet const &digiME(source_.at("Digi"));
    MESet const &gainME(source_.at("Gain"));
    MESet const &chidME(source_.at("ChId"));
    MESet const &gainswitchME(source_.at("GainSwitch"));
    MESet const &qualityME(source_.at("Quality"));

    MESet const &toweridME(source_.at("TowerId"));
    MESet const &blocksizeME(source_.at("BlockSize"));
    MESet const &l1aME(source_.at("L1AFE"));
    MESet const &bxME(source_.at("BXFE"));

    MESet const &memdigiME(source_.at("MEMDigi"));
    MESet const &memchidME(source_.at("MEMChId"));
    MESet const &memgainME(source_.at("MEMGain"));
    MESet const &pnqualityME(source_.at("PNQuality"));

    MESet const &memtoweridME(source_.at("MEMTowerId"));
    MESet const &memblocksizeME(source_.at("MEMBlockSize"));

    if (verbosity_ > 1)
      edm::LogInfo("EcalDQM") << " Looping over crystals";

    MESet::const_iterator dEnd(digiME.end());
    MESet::const_iterator qItr(qualityME);
    for (MESet::const_iterator dItr(digiME.beginChannel()); dItr != dEnd; dItr.toNextChannel()) {
      DetId id(dItr->getId());

      int nDigis(dItr->getBinContent());
      int gain(gainME.getBinContent(id));
      int chid(chidME.getBinContent(id));
      int gainswitch(gainswitchME.getBinContent(id));
      qItr = dItr;

      if (gain > 0 || chid > 0 || gainswitch > 0) {
        MonCrystalConsistencyDat &data(crystalConsistencies[crystalID(id)]);
        data.setProcessedEvents(nDigis);
        data.setProblematicEvents(gain + chid + gainswitch);
        data.setProblemsGainZero(gain);
        data.setProblemsID(chid);
        data.setProblemsGainSwitch(gainswitch);

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

        result &= qualityOK(channelStatus);
      }
    }

    if (verbosity_ > 1)
      edm::LogInfo("EcalDQM") << " Looping over towers";

    for (unsigned iDCC(kEEmLow); iDCC <= kEBpHigh; ++iDCC) {
      for (unsigned iTower(1); iTower <= 68; ++iTower) {
        if (!ccuExists(iDCC + 1, iTower))
          continue;

        EcalElectronicsId eid(iDCC + 1, iTower, 1, 1);
        std::vector<DetId> channels(getElectronicsMap()->dccTowerConstituents(iDCC + 1, iTower));
        int nDigis(0);
        bool towerBad(false);
        for (unsigned iD(0); iD < channels.size(); ++iD) {
          int n(digiME.getBinContent(channels[iD]));
          if (n > nDigis)
            nDigis = n;
          int channelStatus(qualityME.getBinContent(channels[iD]));
          if (channelStatus == kBad || channelStatus == kMBad)
            towerBad = true;
        }

        int towerid(toweridME.getBinContent(eid));
        int blocksize(blocksizeME.getBinContent(eid));
        int l1a(l1aME.getBinContent(iDCC + 1, iTower));
        int bx(bxME.getBinContent(iDCC + 1, iTower));

        if (towerid > 0 || blocksize > 0 || l1a > 0 || bx > 0) {
          MonTTConsistencyDat &data(towerConsistencies[towerID(eid)]);
          data.setProcessedEvents(nDigis);
          data.setProblematicEvents(towerid + blocksize + l1a + bx);
          data.setProblemsID(towerid);
          data.setProblemsSize(blocksize);
          data.setProblemsLV1(l1a);
          data.setProblemsBunchX(bx);
          data.setTaskStatus(towerBad);

          result &= !towerBad;
        }
      }
    }

    if (verbosity_ > 1)
      edm::LogInfo("EcalDQM") << " Looping over MEM channels and towers";

    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);

        int nDigis(memdigiME.getBinContent(pnid));
        int memchid(memchidME.getBinContent(pnid));
        int memgain(memgainME.getBinContent(pnid));

        if (memchid > 0 || memgain > 0) {
          MonMemChConsistencyDat &data(memChannelConsistencies[memChannelID(pnid)]);

          data.setProcessedEvents(nDigis);
          data.setProblematicEvents(memchid + memgain);
          data.setProblemsID(memchid);
          data.setProblemsGainZero(memgain);

          int channelStatus(pnqualityME.getBinContent(pnid));
          bool channelBad(channelStatus == kBad || channelStatus == kMBad);
          data.setTaskStatus(channelBad);

          result &= qualityOK(channelStatus);
        }
      }

      for (unsigned iTower(69); iTower <= 70; ++iTower) {
        EcalElectronicsId eid(iDCC + 1, iTower, 1, 1);

        int nDigis(0);
        bool towerBad(false);
        for (unsigned iPN(1); iPN <= 10; ++iPN) {
          EcalPnDiodeDetId pnid(subdet, iDCC + 1, iPN);
          int n(memdigiME.getBinContent(pnid));
          if (n > nDigis)
            nDigis = n;
          int channelStatus(pnqualityME.getBinContent(pnid));
          if (channelStatus == kBad || channelStatus == kMBad)
            towerBad = true;
        }

        int towerid(memtoweridME.getBinContent(eid));
        int blocksize(memblocksizeME.getBinContent(eid));

        if (towerid > 0 || blocksize > 0) {
          MonMemTTConsistencyDat &data(memTowerConsistencies[memTowerID(eid)]);

          data.setProcessedEvents(nDigis);
          data.setProblematicEvents(towerid + blocksize);
          data.setProblemsID(towerid);
          data.setProblemsSize(blocksize);
          data.setTaskStatus(towerBad);

          result &= !towerBad;
        }
      }
    }

    if (verbosity_ > 1)
      edm::LogInfo("EcalDQM") << " Inserting data";

    try {
      if (!crystalConsistencies.empty()) {
        if (verbosity_ > 2)
          edm::LogInfo("EcalDQM") << " crystalConsistencies";
        _db->insertDataArraySet(&crystalConsistencies, &_iov);
      }
      if (!towerConsistencies.empty()) {
        if (verbosity_ > 2)
          edm::LogInfo("EcalDQM") << " towerConsistencies";
        _db->insertDataArraySet(&towerConsistencies, &_iov);
      }
      if (!memChannelConsistencies.empty()) {
        if (verbosity_ > 2)
          edm::LogInfo("EcalDQM") << " memChannelConsistencies";
        _db->insertDataArraySet(&memChannelConsistencies, &_iov);
      }
      if (!memTowerConsistencies.empty()) {
        if (verbosity_ > 2)
          edm::LogInfo("EcalDQM") << " memTowerConsistencies";
        _db->insertDataArraySet(&memTowerConsistencies, &_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;
  }