#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 &)

const std::string &	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_

const std::string	name_

std::set< std::string >	runTypes_

MESetCollection	source_

int	verbosity_

Detailed Description

Definition at line 41 of file DBWriterWorkers.h.

Constructor & Destructor Documentation

◆ IntegrityWriter()

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

inline

Definition at line 43 of file DBWriterWorkers.h.

43 : DBWriterWorker("Integrity", _ps) {}

◆ ~IntegrityWriter()

ecaldqm::IntegrityWriter::~IntegrityWriter ( )

inlineoverride

Definition at line 44 of file DBWriterWorkers.h.

44 {}

Member Function Documentation

◆ run()

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

overridevirtual

Implements ecaldqm::DBWriterWorker.

Definition at line 90 of file DBWriterWorkers.cc.

                                                                      {
     /*
     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;
   }

References simKBmtfDigis_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, 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().