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

inline

Definition at line 44 of file DBWriterWorkers.h.

{}

Member Function Documentation

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 107 of file DBWriterWorkers.cc.

References ecaldqm::ccuExists(), ecaldqm::crystalID(), data, alignCSCRings::e, EcalBarrel, EcalEndcap, Exception, spr::find(), ecaldqm::getElectronicsMap(), EcalCondDBInterface::insertDataArraySet(), ecaldqm::kBad, ecaldqm::kEBpHigh, ecaldqm::kEEmLow, ecaldqm::kEEpLow, ecaldqm::kMBad, ecaldqm::memChannelID(), ecaldqm::memDCC, ecaldqm::memTowerID(), gen::n, ecaldqm::qualityOK(), mps_fire::result, MonMemChConsistencyDat::setProblematicEvents(), MonCrystalConsistencyDat::setProblematicEvents(), MonMemTTConsistencyDat::setProblematicEvents(), MonTTConsistencyDat::setProblematicEvents(), MonTTConsistencyDat::setProblemsBunchX(), MonCrystalConsistencyDat::setProblemsGainSwitch(), MonCrystalConsistencyDat::setProblemsGainZero(), MonMemChConsistencyDat::setProblemsGainZero(), MonCrystalConsistencyDat::setProblemsID(), MonMemTTConsistencyDat::setProblemsID(), MonTTConsistencyDat::setProblemsID(), MonMemChConsistencyDat::setProblemsID(), MonTTConsistencyDat::setProblemsLV1(), MonTTConsistencyDat::setProblemsSize(), MonMemTTConsistencyDat::setProblemsSize(), MonMemTTConsistencyDat::setProcessedEvents(), MonTTConsistencyDat::setProcessedEvents(), MonCrystalConsistencyDat::setProcessedEvents(), MonMemChConsistencyDat::setProcessedEvents(), MonCrystalConsistencyDat::setTaskStatus(), MonMemChConsistencyDat::setTaskStatus(), MonMemTTConsistencyDat::setTaskStatus(), MonTTConsistencyDat::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.size() > 0){
        if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " crystalConsistencies";
        _db->insertDataArraySet(&crystalConsistencies, &_iov);
      }
      if(towerConsistencies.size() > 0){
        if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " towerConsistencies";
        _db->insertDataArraySet(&towerConsistencies, &_iov);
      }
      if(memChannelConsistencies.size() > 0){
        if(verbosity_ > 2) edm::LogInfo("EcalDQM") << " memChannelConsistencies";
        _db->insertDataArraySet(&memChannelConsistencies, &_iov);
      }
      if(memTowerConsistencies.size() > 0){
        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;
  }