popcon::EcalChannelStatusHandler Class Reference

#include <EcalChannelStatusHandler.h>

Inheritance diagram for popcon::EcalChannelStatusHandler:

Public Member Functions
float	checkPedestalRMSGain1 (EcalPedestals::Item *item)
float	checkPedestalRMSGain12 (EcalPedestals::Item *item)
float	checkPedestalRMSGain6 (EcalPedestals::Item *item)
float	checkPedestalValueGain1 (EcalPedestals::Item *item)
float	checkPedestalValueGain12 (EcalPedestals::Item *item)
float	checkPedestalValueGain6 (EcalPedestals::Item *item)
void	cosmicsAnalysis (std::map< EcalLogicID, MonPedestalsOnlineDat > pedestalO_mon, std::map< EcalLogicID, MonCrystalConsistencyDat > wrongGain_mon, std::map< EcalLogicID, MonLaserBlueDat > laser_mon, std::map< EcalLogicID, MonOccupancyDat > occupancy_mon)
void	daqOut (const RunIOV &myRun)
	EcalChannelStatusHandler (edm::ParameterSet const &)
void	getNewObjects () override
std::string	id () const override
void	laserAnalysis (std::map< EcalLogicID, MonLaserBlueDat > dataset_mon)
void	laserMasking ()
void	nBadLaserModules (std::map< EcalLogicID, MonLaserBlueDat > dataset_mon)
void	pedAnalysis (std::map< EcalLogicID, MonPedestalsDat > dataset_mon, std::map< EcalLogicID, MonCrystalConsistencyDat > wrongGain_mon)
void	pedMasking ()
void	pedOnlineMasking ()
void	physicsMasking ()
void	setElectronicsMap (const EcalElectronicsMapping *)
	~EcalChannelStatusHandler () override
Public Member Functions inherited from popcon::PopConSourceHandler< EcalChannelStatus >
void	initialize (const cond::persistency::Session &dbSession, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry)
Ref	lastPayload () const
cond::LogDBEntry_t const &	logDBEntry () const
std::pair< Container const *, std::string const >	operator() (const cond::persistency::Session &session, cond::TagInfo_t const &tagInfo, cond::LogDBEntry_t const &logDBEntry) const
	PopConSourceHandler ()
Container const &	returnData ()
cond::TagInfo_t const &	tagInfo () const
std::string const &	userTextLog () const
virtual	~PopConSourceHandler ()

Public Attributes
EcalCondDBInterface *	econn

Private Attributes
std::ofstream *	daqFile
std::ofstream *	daqFile2
EcalElectronicsMapping	ecalElectronicsMap_
EcalErrorMask	ecalErrorMask_
bool	isEBRef1 [36][2]
bool	isEBRef2 [36][2]
bool	isEERef1 [18][2]
bool	isEERef2 [18][2]
bool	isGoodLaserEBSm [36][2]
bool	isGoodLaserEESm [18][2]
unsigned int	m_firstRun
std::string	m_gentag
unsigned int	m_lastRun
std::string	m_location
std::string	m_locationsource
std::string	m_name
std::string	m_pass
std::string	m_runtype
std::string	m_sid
std::string	m_user
std::map< DetId, float >	maskedLaserEB
std::map< DetId, float >	maskedLaserEE
std::map< DetId, float >	maskedOnlinePedEB
std::map< DetId, float >	maskedOnlinePedEE
std::map< DetId, float >	maskedPedEB
std::map< DetId, float >	maskedPedEE
std::map< DetId, float >	maskedPhysicsEB
std::map< DetId, float >	maskedPhysicsEE
TProfile2D *	newBadEB_
TProfile2D *	newBadEEM_
TProfile2D *	newBadEEP_
std::ofstream *	ResFileEB
std::ofstream *	ResFileEE
std::ofstream *	ResFileNewEB
std::ofstream *	ResFileNewEE

Additional Inherited Members
Public Types inherited from popcon::PopConSourceHandler< EcalChannelStatus >
typedef std::map< Time_t, std::shared_ptr< EcalChannelStatus > >	Container
typedef std::unique_ptr< EcalChannelStatus >	Ref
typedef PopConSourceHandler< EcalChannelStatus >	self
typedef cond::Time_t	Time_t
typedef EcalChannelStatus	value_type
Protected Member Functions inherited from popcon::PopConSourceHandler< EcalChannelStatus >
cond::persistency::Session &	dbSession () const
Protected Attributes inherited from popcon::PopConSourceHandler< EcalChannelStatus >
Container	m_iovs
std::vector< std::pair< EcalChannelStatus *, Time_t > >	m_to_transfer
std::string	m_userTextLog

Detailed Description

Definition at line 68 of file EcalChannelStatusHandler.h.

Constructor & Destructor Documentation

EcalChannelStatusHandler()

popcon::EcalChannelStatusHandler::EcalChannelStatusHandler

(

edm::ParameterSet const &

ps

)

Definition at line 47 of file EcalChannelStatusHandler.cc.

References gather_cfg::cout, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), m_firstRun, m_gentag, m_lastRun, m_location, m_locationsource, m_name, m_pass, m_runtype, m_sid, m_user, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                  {
  std::cout << "EcalChannelStatus Source handler constructor\n" << std::endl;

  m_firstRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("firstRun").c_str()));
  m_lastRun = static_cast<unsigned int>(atoi(ps.getParameter<std::string>("lastRun").c_str()));
  m_sid = ps.getParameter<std::string>("OnlineDBSID");
  m_user = ps.getParameter<std::string>("OnlineDBUser");
  m_pass = ps.getParameter<std::string>("OnlineDBPassword");
  m_locationsource = ps.getParameter<std::string>("LocationSource");
  m_location = ps.getParameter<std::string>("Location");
  m_gentag = ps.getParameter<std::string>("GenTag");
  m_runtype = ps.getParameter<std::string>("RunType");
  m_name = ps.getUntrackedParameter<std::string>("name", "EcalChannelStatusHandler");

  std::cout << m_sid << "/" << m_user << "/" << m_pass << "/" << m_location << "/" << m_gentag << std::endl;
}

~EcalChannelStatusHandler()

popcon::EcalChannelStatusHandler::~EcalChannelStatusHandler ( )

override

Definition at line 64 of file EcalChannelStatusHandler.cc.

{}

Member Function Documentation

checkPedestalRMSGain1()

float popcon::EcalChannelStatusHandler::checkPedestalRMSGain1

(

EcalPedestals::Item *

item

)

Definition at line 100 of file EcalChannelStatusHandler.cc.

References B2GTnPMonitor_cfi::item, and mps_fire::result.

                                                                                   {
  float result = item->rms_x1;
  return result;
}

checkPedestalRMSGain12()

float popcon::EcalChannelStatusHandler::checkPedestalRMSGain12

(

EcalPedestals::Item *

item

)

Definition at line 88 of file EcalChannelStatusHandler.cc.

References B2GTnPMonitor_cfi::item, and mps_fire::result.

                                                                                    {
  float result = item->rms_x12;
  return result;
}

checkPedestalRMSGain6()

float popcon::EcalChannelStatusHandler::checkPedestalRMSGain6

(

EcalPedestals::Item *

item

)

Definition at line 94 of file EcalChannelStatusHandler.cc.

References B2GTnPMonitor_cfi::item, and mps_fire::result.

                                                                                   {
  float result = item->rms_x6;
  return result;
}

checkPedestalValueGain1()

float popcon::EcalChannelStatusHandler::checkPedestalValueGain1

(

EcalPedestals::Item *

item

)

Definition at line 82 of file EcalChannelStatusHandler.cc.

References B2GTnPMonitor_cfi::item, and mps_fire::result.

                                                                                     {
  float result = item->mean_x1;
  return result;
}

checkPedestalValueGain12()

float popcon::EcalChannelStatusHandler::checkPedestalValueGain12

(

EcalPedestals::Item *

item

)

Definition at line 70 of file EcalChannelStatusHandler.cc.

References B2GTnPMonitor_cfi::item, and mps_fire::result.

                                                                                      {
  float result = item->mean_x12;
  return result;
}

checkPedestalValueGain6()

float popcon::EcalChannelStatusHandler::checkPedestalValueGain6

(

EcalPedestals::Item *

item

)

Definition at line 76 of file EcalChannelStatusHandler.cc.

References B2GTnPMonitor_cfi::item, and mps_fire::result.

                                                                                     {
  float result = item->mean_x6;
  return result;
}

cosmicsAnalysis()

void popcon::EcalChannelStatusHandler::cosmicsAnalysis	(	std::map< EcalLogicID, MonPedestalsOnlineDat >	pedestalO_mon,
		std::map< EcalLogicID, MonCrystalConsistencyDat >	wrongGain_mon,
		std::map< EcalLogicID, MonLaserBlueDat >	laser_mon,
		std::map< EcalLogicID, MonOccupancyDat >	occupancy_mon
	)

Definition at line 819 of file EcalChannelStatusHandler.cc.

References EcalElectronicsId::dccId(), nano_mu_digi_cff::float, MonPedestalsOnlineDat::getADCMeanG12(), MonPedestalsOnlineDat::getADCRMSG12(), MonLaserBlueDat::getAPDMean(), MonOccupancyDat::getEventsOverHighThreshold(), EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalLogicID::getName(), MonCrystalConsistencyDat::getProblemsGainZero(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EBDetId::ic(), EBDetId::ieta(), ALPAKA_ACCELERATOR_NAMESPACE::caPixelDoublets::if(), EBDetId::iphi(), EEDetId::ix(), EEDetId::iy(), AlCaHLTBitMon_ParallelJobs::p, EBDetId::SMCRYSTALMODE, EcalElectronicsId::towerId(), EEDetId::validDetId(), and EEDetId::zside().

                                                                                                           {
  // to take the list of masked crystals for the diffrent analyses
  pedOnlineMasking();
  laserMasking();
  physicsMasking();

  std::map<DetId, float>::const_iterator theIter;
  std::map<DetId, float> badPedOnEB, badPedOnEE;
  std::map<DetId, float> badPedOnRmsEB, badPedOnRmsEE;
  std::map<DetId, float> badGainEB, badGainEE;
  std::map<DetId, float> badLaserEB, badLaserEE;
  std::map<DetId, float> badOccHighEB, badOccHighEE;

  typedef std::map<EcalLogicID, MonPedestalsOnlineDat>::const_iterator CImonPedO;
  typedef std::map<EcalLogicID, MonCrystalConsistencyDat>::const_iterator CImonCons;
  typedef std::map<EcalLogicID, MonOccupancyDat>::const_iterator CImonOcc;
  typedef std::map<EcalLogicID, MonLaserBlueDat>::const_iterator CImonLaser;
  MonPedestalsOnlineDat rd_ped0;
  MonCrystalConsistencyDat rd_wgain;
  MonOccupancyDat rd_occ;
  MonLaserBlueDat rd_blue;

  // logic id
  EcalLogicID ecid_xt;

  // to be used after: total number of entries above high threshold
  float totEntriesAboveHighThrEB = 0.;
  float totEntriesAboveHighThrEE = 0.;
  for (CImonOcc p = occupancy_mon.begin(); p != occupancy_mon.end(); p++) {
    ecid_xt = p->first;
    rd_occ = p->second;
    float highOcc = rd_occ.getEventsOverHighThreshold();
    if (ecid_xt.getName() == "EB_crystal_number" && highOcc > -1)
      totEntriesAboveHighThrEB = totEntriesAboveHighThrEB + highOcc;
    if (ecid_xt.getName() == "EE_crystal_number" && highOcc > -1)
      totEntriesAboveHighThrEE = totEntriesAboveHighThrEE + highOcc;
  }

  // A) creating the list of all bad channels: searching for problems based on pedestal online except gain zero
  for (CImonPedO p = pedestalO_mon.begin(); p != pedestalO_mon.end(); p++) {
    bool isWrong = false;
    ecid_xt = p->first;
    rd_ped0 = p->second;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    EcalPedestals::Item ped_item;
    ped_item.mean_x12 = rd_ped0.getADCMeanG12();
    ped_item.rms_x12 = rd_ped0.getADCRMSG12();

    float lowerCut = 999.;
    if (ecid_xt.getName() == "EB_crystal_number") {
      lowerCut = 2.0;
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      lowerCut = 2.5;
    }
    if (checkPedestalRMSGain12(&ped_item) > lowerCut)
      isWrong = true;
    if (checkPedestalValueGain12(&ped_item) > 300)
      isWrong = true;
    if (checkPedestalValueGain12(&ped_item) < 100)
      isWrong = true;
    if (checkPedestalRMSGain12(&ped_item) == 0)
      isWrong = true;

    // is this channel already in the list?
    if (isWrong) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        theIter = badPedOnEB.find(ebdetid);
        if (theIter == badPedOnEB.end()) {
          badPedOnEB.insert(std::pair<DetId, float>(ebdetid, rd_ped0.getADCMeanG12()));
          badPedOnRmsEB.insert(std::pair<DetId, float>(ebdetid, rd_ped0.getADCRMSG12()));
        }
      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          theIter = badPedOnEE.find(eedetid);
          if (theIter == badPedOnEE.end()) {
            badPedOnEE.insert(std::pair<DetId, float>(eedetid, rd_ped0.getADCMeanG12()));
            badPedOnRmsEE.insert(std::pair<DetId, float>(eedetid, rd_ped0.getADCRMSG12()));
          }
        }
      }
    }
  }

  // B) creating the list of all bad channels: searching for channels at gain zero at least in 100 events
  for (CImonCons p = wrongGain_mon.begin(); p != wrongGain_mon.end(); p++) {
    bool isWrong = false;
    ecid_xt = p->first;
    rd_wgain = p->second;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    if (rd_wgain.getProblemsGainZero() > 1000) {
      isWrong = true;
    }

    if (isWrong) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        theIter = badGainEB.find(ebdetid);
        if (theIter == badGainEB.end())
          badGainEB.insert(std::pair<DetId, float>(ebdetid, 999.));
      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          theIter = badGainEE.find(eedetid);
          if (theIter == badGainEE.end())
            badGainEE.insert(std::pair<DetId, float>(eedetid, 999.));
        }
      }
    }
  }

  // C) creating the list of all bad channels: searching for channels with bad occupancy [ too high ]
  for (CImonOcc p = occupancy_mon.begin(); p != occupancy_mon.end(); p++) {
    // logic id
    ecid_xt = p->first;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    // occupancy
    rd_occ = p->second;

    bool isWrong = false;
    float occAvg = -999.;
    if (ecid_xt.getName() == "EB_crystal_number") {
      occAvg = rd_occ.getEventsOverHighThreshold() / totEntriesAboveHighThrEB;
      if (occAvg > 0.001)
        isWrong = true;
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      occAvg = rd_occ.getEventsOverHighThreshold() / totEntriesAboveHighThrEE;
      if (occAvg > 0.001)
        isWrong = true;
    }

    if (isWrong) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        theIter = badOccHighEB.find(ebdetid);
        if (theIter == badOccHighEB.end())
          badOccHighEB.insert(std::pair<DetId, float>(ebdetid, occAvg));
      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          theIter = badOccHighEE.find(eedetid);
          if (theIter == badOccHighEE.end())
            badOccHighEE.insert(std::pair<DetId, float>(eedetid, occAvg));
        }
      }
    }
  }

  // D) creating the list of all bad channels: searching for channels with bad laser amplitude [among those covered by the calibration sequence]
  for (CImonLaser p = laser_mon.begin(); p != laser_mon.end(); p++) {
    // logic id
    ecid_xt = p->first;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    // in which Fed/triggerTower/sectorSide I am
    int theFed = -100;
    int theTT = -100;
    int theIx = -100;
    if (ecid_xt.getName() == "EB_crystal_number") {
      EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
      EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
      theFed = 600 + elecId.dccId();
      theTT = elecId.towerId();
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
        EEDetId eedetid(xt_num, yt_num, sm_num);
        EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
        theFed = 600 + elecId.dccId();
        theIx = eedetid.ix();
      }
    }

    // to have numbers from 0 to 17 for the EE feds and 0-36 for EB
    int thisFed = -100;
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (theFed > 600 && theFed < 610)
        thisFed = theFed - 601;
      if (theFed > 645 && theFed < 655)
        thisFed = theFed - 646 + 9;
    }
    if (ecid_xt.getName() == "EB_crystal_number") {
      thisFed = theFed - 610;
    }

    // in which light module I am
    int theTTieta = -100;
    int theTTiphi = -100;
    int theLM = -100;
    if (ecid_xt.getName() == "EB_crystal_number") {
      theTTieta = (theTT - 1) / 4 + 1;
      theTTiphi = (theTT - 1) % 4 + 1;
      if (theTTieta == 1 || theTTiphi == 3 || theTTiphi == 4)
        theLM = 0;  // L-shaped
      if (theTTieta > 1 && (theTTiphi == 1 || theTTiphi == 2))
        theLM = 1;  // not L-shaped
    }
    if ((ecid_xt.getName() == "EE_crystal_number") && (thisFed == 7 || thisFed == 16)) {
      if (theIx <= 50)
        theLM = 0;
      if (theIx > 50)
        theLM = 1;
    }

    // APD mean value
    rd_blue = p->second;
    float myApdMean = rd_blue.getAPDMean();

    bool isWrong = false;
    if (ecid_xt.getName() == "EB_crystal_number") {
      if ((myApdMean < 400) && isGoodLaserEBSm[thisFed][theLM])
        isWrong = true;
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (myApdMean < 100) {
        if (thisFed != 7 && thisFed != 16 && isGoodLaserEESm[thisFed][0])
          isWrong = true;
        if ((thisFed == 7 || thisFed == 16) && isGoodLaserEESm[thisFed][theLM])
          isWrong = true;
      }
    }

    if (isWrong) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        theIter = badLaserEB.find(ebdetid);
        if (theIter == badLaserEB.end())
          badLaserEB.insert(std::pair<DetId, float>(ebdetid, myApdMean));
      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          theIter = badLaserEE.find(eedetid);
          if (theIter == badLaserEE.end())
            badLaserEE.insert(std::pair<DetId, float>(eedetid, myApdMean));
        }
      }
    }
  }

  // check if the crystal is in the vector and fill the summary file
  std::map<DetId, float>::const_iterator theIterPedOn;
  std::map<DetId, float>::const_iterator theIterPedOnRms;
  std::map<DetId, float>::const_iterator theIterGain;
  std::map<DetId, float>::const_iterator theIterLaser;
  std::map<DetId, float>::const_iterator theIterOccHigh;

  // EB, first check - loop over pedestal online
  for (theIterPedOn = badPedOnEB.begin(); theIterPedOn != badPedOnEB.end(); ++theIterPedOn) {
    float thePedOn = (*theIterPedOn).second;
    float thePedOnRms = 9999.;
    float theGain = 9999.;
    float theLaser = 9999.;
    float theOccHigh = 9999.;

    theIterPedOnRms = badPedOnRmsEB.find((*theIterPedOn).first);
    theIterGain = badGainEB.find((*theIterPedOn).first);
    theIterLaser = badLaserEB.find((*theIterPedOn).first);
    theIterOccHigh = badOccHighEB.find((*theIterPedOn).first);

    if (theIterPedOnRms != badPedOnRmsEB.end())
      thePedOnRms = (*theIterPedOnRms).second;
    if (theIterLaser != badLaserEB.end())
      theLaser = (*theIterLaser).second;
    if (theIterOccHigh != badOccHighEB.end())
      theOccHigh = (*theIterOccHigh).second;

    int thisFed = -100;
    EBDetId ebdetid((*theIterPedOn).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    bool isNewLaser = true;
    bool isNewPhysics = true;
    for (theIter = maskedOnlinePedEB.begin(); theIter != maskedOnlinePedEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPed = false;
    }

    for (theIter = maskedLaserEB.begin(); theIter != maskedLaserEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewLaser = false;
    }

    for (theIter = maskedPhysicsEB.begin(); theIter != maskedPhysicsEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPhysics = false;
    }

    if (isNewPed || (theLaser != 9999 && isNewLaser) || (theOccHigh != 9999 && isNewPhysics))
      isNew = true;

    if (theIterGain != badGainEB.end()) {
      *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
                 << thePedOnRms << "\t\t"
                 << "gainZero"
                 << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                      << "\t\t" << thePedOnRms << "\t\t"
                      << "gainZero"
                      << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        float thisEtaFill = float(0);
        if (ebdetid.ieta() > 0)
          thisEtaFill = ebdetid.ieta() - 0.5;
        if (ebdetid.ieta() < 0)
          thisEtaFill = ebdetid.ieta();
        newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
      }
    } else {
      *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
                 << thePedOnRms << "\t\t" << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                      << "\t\t" << thePedOnRms << "\t\t" << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh
                      << std::endl;

        float thisEtaFill = float(0);
        if (ebdetid.ieta() > 0)
          thisEtaFill = ebdetid.ieta() - 0.5;
        if (ebdetid.ieta() < 0)
          thisEtaFill = ebdetid.ieta();
        newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
      }
    }
  }

  // EB, second check - loop over laser
  for (theIterLaser = badLaserEB.begin(); theIterLaser != badLaserEB.end(); ++theIterLaser) {
    // remove already included channels
    theIterPedOnRms = badPedOnRmsEB.find((*theIterLaser).first);
    if (theIterPedOnRms != badPedOnRmsEB.end())
      continue;

    float thePedOn = 9999.;
    float thePedOnRms = 9999.;
    float theGain = 9999.;
    float theLaser = (*theIterLaser).second;
    float theOccHigh = 9999.;

    theIterGain = badGainEB.find((*theIterLaser).first);
    theIterOccHigh = badOccHighEB.find((*theIterLaser).first);
    if (theIterOccHigh != badOccHighEB.end())
      theOccHigh = (*theIterOccHigh).second;

    int thisFed = -100;
    EBDetId ebdetid((*theIterLaser).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    bool isNewLaser = true;
    bool isNewPhysics = true;
    for (theIter = maskedOnlinePedEB.begin(); theIter != maskedOnlinePedEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPed = false;
    }

    for (theIter = maskedLaserEB.begin(); theIter != maskedLaserEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewLaser = false;
    }

    for (theIter = maskedPhysicsEB.begin(); theIter != maskedPhysicsEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPhysics = false;
    }

    if ((isNewPed && theIterGain != badGainEB.end()) || (isNewLaser) || (theOccHigh != 9999 && isNewPhysics))
      isNew = true;

    if (theIterGain != badGainEB.end()) {
      *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
                 << thePedOnRms << "\t\t"
                 << "gainZero"
                 << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                      << "\t\t" << thePedOnRms << "\t\t"
                      << "gainZero"
                      << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        float thisEtaFill = float(0);
        if (ebdetid.ieta() > 0)
          thisEtaFill = ebdetid.ieta() - 0.5;
        if (ebdetid.ieta() < 0)
          thisEtaFill = ebdetid.ieta();
        newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
      }
    } else {
      *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
                 << thePedOnRms << "\t\t" << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                      << "\t\t" << thePedOnRms << "\t\t" << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh
                      << std::endl;

        float thisEtaFill = float(0);
        if (ebdetid.ieta() > 0)
          thisEtaFill = ebdetid.ieta() - 0.5;
        if (ebdetid.ieta() < 0)
          thisEtaFill = ebdetid.ieta();
        newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
      }
    }
  }

  // EB, third check: loop over occupancy
  for (theIterOccHigh = badOccHighEB.begin(); theIterOccHigh != badOccHighEB.end(); ++theIterOccHigh) {
    // remove already included  channels
    theIterPedOnRms = badPedOnRmsEB.find((*theIterOccHigh).first);
    theIterLaser = badLaserEB.find((*theIterOccHigh).first);
    if (theIterPedOnRms != badPedOnRmsEB.end())
      continue;
    if (theIterLaser != badLaserEB.end())
      continue;

    float thePedOn = 9999.;
    float thePedOnRms = 9999.;
    float theGain = 9999.;
    float theLaser = 9999.;
    float theOccHigh = (*theIterOccHigh).second;
    theIterGain = badGainEB.find((*theIterOccHigh).first);

    int thisFed = -100;
    EBDetId ebdetid((*theIterOccHigh).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    bool isNewPhysics = true;
    for (theIter = maskedOnlinePedEB.begin(); theIter != maskedOnlinePedEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPed = false;
    }

    for (theIter = maskedPhysicsEB.begin(); theIter != maskedPhysicsEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPhysics = false;
    }

    if ((isNewPed && theIterGain != badGainEB.end()) || (isNewPhysics))
      isNew = true;

    if (theIterGain != badGainEB.end()) {
      *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
                 << thePedOnRms << "\t\t"
                 << "gainZero"
                 << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                      << "\t\t" << thePedOnRms << "\t\t"
                      << "gainZero"
                      << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        float thisEtaFill = float(0);
        if (ebdetid.ieta() > 0)
          thisEtaFill = ebdetid.ieta() - 0.5;
        if (ebdetid.ieta() < 0)
          thisEtaFill = ebdetid.ieta();
        newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
      }
    } else {
      *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
                 << thePedOnRms << "\t\t" << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                      << "\t\t" << thePedOnRms << "\t\t" << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh
                      << std::endl;

        float thisEtaFill = float(0);
        if (ebdetid.ieta() > 0)
          thisEtaFill = ebdetid.ieta() - 0.5;
        if (ebdetid.ieta() < 0)
          thisEtaFill = ebdetid.ieta();
        newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
      }
    }
  }

  // EB, fourth check: loop over consistency
  for (theIterGain = badGainEB.begin(); theIterGain != badGainEB.end(); ++theIterGain) {
    // remove already included  channels
    theIterPedOnRms = badPedOnRmsEB.find((*theIterGain).first);
    theIterLaser = badLaserEB.find((*theIterGain).first);
    theIterOccHigh = badOccHighEB.find((*theIterGain).first);
    if (theIterPedOnRms != badPedOnRmsEB.end())
      continue;
    if (theIterLaser != badLaserEB.end())
      continue;
    if (theIterOccHigh != badOccHighEB.end())
      continue;

    float thePedOn = 9999.;
    float thePedOnRms = 9999.;
    float theLaser = 9999.;
    float theOccHigh = 9999.;

    int thisFed = -100;
    EBDetId ebdetid((*theIterGain).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    for (theIter = maskedOnlinePedEB.begin(); theIter != maskedOnlinePedEB.end(); ++theIter) {
      if ((*theIter).first == ebdetid)
        isNewPed = false;
    }

    if (isNewPed && theIterGain != badGainEB.end())
      isNew = true;

    *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn << "\t\t"
               << thePedOnRms << "\t\t"
               << "gainZero"
               << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

    if (isNew) {
      *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << thePedOn
                    << "\t\t" << thePedOnRms << "\t\t"
                    << "gainZero"
                    << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      float thisEtaFill = float(0);
      if (ebdetid.ieta() > 0)
        thisEtaFill = ebdetid.ieta() - 0.5;
      if (ebdetid.ieta() < 0)
        thisEtaFill = ebdetid.ieta();
      newBadEB_->Fill((ebdetid.iphi() - 0.5), thisEtaFill, 2);
    }
  }

  // EE, first check: loop over pedestal online
  for (theIterPedOn = badPedOnEE.begin(); theIterPedOn != badPedOnEE.end(); ++theIterPedOn) {
    float thePedOn = (*theIterPedOn).second;
    float thePedOnRms = 9999.;
    float theGain = 9999.;
    float theLaser = 9999.;
    float theOccHigh = 9999.;

    theIterPedOnRms = badPedOnRmsEE.find((*theIterPedOn).first);
    theIterGain = badGainEE.find((*theIterPedOn).first);
    theIterLaser = badLaserEE.find((*theIterPedOn).first);
    theIterOccHigh = badOccHighEE.find((*theIterPedOn).first);

    if (theIterPedOnRms != badPedOnRmsEE.end())
      thePedOnRms = (*theIterPedOnRms).second;
    if (theIterLaser != badLaserEE.end())
      theLaser = (*theIterLaser).second;
    if (theIterOccHigh != badOccHighEE.end())
      theOccHigh = (*theIterOccHigh).second;

    int thisFed = -100;
    EEDetId eedetid((*theIterPedOn).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    bool isNewLaser = true;
    bool isNewPhysics = true;
    for (theIter = maskedOnlinePedEE.begin(); theIter != maskedOnlinePedEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPed = false;
    }

    for (theIter = maskedLaserEE.begin(); theIter != maskedLaserEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewLaser = false;
    }

    for (theIter = maskedPhysicsEE.begin(); theIter != maskedPhysicsEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPhysics = false;
    }

    if (isNewPed || (theLaser != 9999 && isNewLaser) || (theOccHigh != 9999 && isNewPhysics))
      isNew = true;

    if (theIterGain != badGainEE.end()) {
      *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
                 << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                 << "gainZero"
                 << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                      << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                      << "gainZero"
                      << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        if (eedetid.zside() > 0)
          newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
        if (eedetid.zside() < 0)
          newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      }
    } else {
      *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
                 << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t" << theGain << "\t\t"
                 << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                      << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                      << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        if (eedetid.zside() > 0)
          newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
        if (eedetid.zside() < 0)
          newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      }
    }
  }

  // EE, second check: loop over laser
  for (theIterLaser = badLaserEE.begin(); theIterLaser != badLaserEE.end(); ++theIterLaser) {
    // remove already included  channels
    theIterPedOnRms = badPedOnRmsEE.find((*theIterLaser).first);
    if (theIterPedOnRms != badPedOnRmsEE.end())
      continue;

    float thePedOn = 9999.;
    float thePedOnRms = 9999.;
    float theGain = 9999.;
    float theLaser = (*theIterLaser).second;
    float theOccHigh = 9999.;

    theIterGain = badGainEE.find((*theIterLaser).first);
    theIterOccHigh = badOccHighEE.find((*theIterLaser).first);
    if (theIterOccHigh != badOccHighEE.end())
      theOccHigh = (*theIterOccHigh).second;

    int thisFed = -100;
    EEDetId eedetid((*theIterLaser).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    bool isNewLaser = true;
    bool isNewPhysics = true;
    for (theIter = maskedOnlinePedEE.begin(); theIter != maskedOnlinePedEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPed = false;
    }

    for (theIter = maskedLaserEE.begin(); theIter != maskedLaserEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewLaser = false;
    }

    for (theIter = maskedPhysicsEE.begin(); theIter != maskedPhysicsEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPhysics = false;
    }

    if ((isNewPed && theIterGain != badGainEE.end()) || (isNewLaser) || (theOccHigh != 9999 && isNewPhysics))
      isNew = true;

    if (theIterGain != badGainEE.end()) {
      *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
                 << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                 << "gainZero"
                 << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                      << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                      << "gainZero"
                      << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        if (eedetid.zside() > 0)
          newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
        if (eedetid.zside() < 0)
          newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      }
    } else {
      *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
                 << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t" << theGain << "\t\t"
                 << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                      << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                      << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        if (eedetid.zside() > 0)
          newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
        if (eedetid.zside() < 0)
          newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      }
    }
  }

  // third check: loop over occupancy
  for (theIterOccHigh = badOccHighEE.begin(); theIterOccHigh != badOccHighEE.end(); ++theIterOccHigh) {
    // remove already included  channels
    theIterPedOnRms = badPedOnRmsEE.find((*theIterOccHigh).first);
    theIterLaser = badLaserEE.find((*theIterOccHigh).first);
    if (theIterPedOnRms != badPedOnRmsEE.end())
      continue;
    if (theIterLaser != badLaserEE.end())
      continue;

    float thePedOn = 9999.;
    float thePedOnRms = 9999.;
    float theGain = 9999.;
    float theLaser = 9999.;
    float theOccHigh = (*theIterOccHigh).second;
    theIterGain = badGainEE.find((*theIterOccHigh).first);

    int thisFed = -100;
    EEDetId eedetid((*theIterOccHigh).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    bool isNewPhysics = true;
    for (theIter = maskedOnlinePedEE.begin(); theIter != maskedOnlinePedEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPed = false;
    }

    for (theIter = maskedPhysicsEE.begin(); theIter != maskedPhysicsEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPhysics = false;
    }

    if ((isNewPed && theIterGain != badGainEE.end()) || (isNewPhysics))
      isNew = true;

    if (theIterGain != badGainEE.end()) {
      *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
                 << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                 << "gainZero"
                 << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                      << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                      << "gainZero"
                      << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        if (eedetid.zside() > 0)
          newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
        if (eedetid.zside() < 0)
          newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      }
    } else {
      *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
                 << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t" << theGain << "\t\t"
                 << theLaser << "\t\t" << theOccHigh << std::endl;

      if (isNew) {
        *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                      << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                      << theGain << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

        if (eedetid.zside() > 0)
          newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
        if (eedetid.zside() < 0)
          newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      }
    }
  }

  // EE, fourth check: loop over consistency
  for (theIterGain = badGainEE.begin(); theIterGain != badGainEE.end(); ++theIterGain) {
    // remove already included  channels
    theIterPedOnRms = badPedOnRmsEE.find((*theIterGain).first);
    theIterLaser = badLaserEE.find((*theIterGain).first);
    theIterOccHigh = badOccHighEE.find((*theIterGain).first);
    if (theIterPedOnRms != badPedOnRmsEE.end())
      continue;
    if (theIterLaser != badLaserEE.end())
      continue;
    if (theIterOccHigh != badOccHighEE.end())
      continue;
    float thePedOn = 9999.;
    float thePedOnRms = 9999.;
    float theLaser = 9999.;
    float theOccHigh = 9999.;

    int thisFed = -100;
    EEDetId eedetid((*theIterGain).first);
    EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
    thisFed = 600 + elecId.dccId();

    // new problems only
    bool isNew = false;
    bool isNewPed = true;
    for (theIter = maskedOnlinePedEE.begin(); theIter != maskedOnlinePedEE.end(); ++theIter) {
      if ((*theIter).first == eedetid)
        isNewPed = false;
    }

    if (isNewPed && theIterGain != badGainEE.end())
      isNew = true;

    *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside() << "\t\t"
               << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
               << "gainZero"
               << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

    if (isNew) {
      *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                    << "\t\t" << eedetid.hashedIndex() << "\t\t" << thePedOn << "\t\t" << thePedOnRms << "\t\t"
                    << "gainZero"
                    << "\t\t" << theLaser << "\t\t" << theOccHigh << std::endl;

      if (eedetid.zside() > 0)
        newBadEEP_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
      if (eedetid.zside() < 0)
        newBadEEM_->Fill((eedetid.ix() - 0.5), (eedetid.iy() - 0.5), 4);
    }
  }
}

daqOut()

void popcon::EcalChannelStatusHandler::daqOut

(

const RunIOV &

myRun

)

Definition at line 399 of file EcalChannelStatusHandler.cc.

References test_db_connect::econn, ODFEDAQConfig::getBadTTId(), RunFEConfigDat::getConfigId(), EcalLogicID::getID1(), EcalLogicID::getLogicID(), EBDetId::hashedIndex(), EcalLogicID::NULLID, AlCaHLTBitMon_ParallelJobs::p, ODFEDAQConfig::setId(), ODBadTTInfo::setId(), and EBDetId::SMCRYSTALMODE.

                                                                {
  RunIOV myRun = _myRun;
  std::map<EcalLogicID, RunFEConfigDat> feconfig;
  econn->fetchDataSet(&feconfig, &myRun);

  typedef std::map<EcalLogicID, RunFEConfigDat>::const_iterator feConfIter;
  EcalLogicID ecid_xt;
  RunFEConfigDat rd_fe;

  int fe_conf_id = 0;
  for (feConfIter p = feconfig.begin(); p != feconfig.end(); p++) {
    ecid_xt = p->first;
    rd_fe = p->second;
    fe_conf_id = rd_fe.getConfigId();
  }

  // reading this configuration
  ODFEDAQConfig myconfig;
  myconfig.setId(fe_conf_id);
  econn->fetchConfigSet(&myconfig);

  // list of bad channels
  int myTT = myconfig.getBadTTId();
  ODBadTTInfo mybadTT;
  mybadTT.setId(myTT);
  econn->fetchConfigSet(&mybadTT);

  std::vector<ODBadTTDat> badTT_dat;
  econn->fetchConfigDataSet(&badTT_dat, &mybadTT);

  for (size_t iTT = 0; iTT < badTT_dat.size(); iTT++) {
    int fed_id = badTT_dat[iTT].getFedId();
    int tt_id = badTT_dat[iTT].getTTId();
    if (tt_id < 69)
      *daqFile << fed_id << " " << tt_id << std::endl;

    // taking the channel list for towers out of daq
    if ((fed_id <= 609 || fed_id >= 646) && tt_id < 69) {  // endcap

      // moving from cms fed to db fed convention
      //int db_fedId = -999;
      //if (fed_id>=604 && fed_id<=609) db_fedId = fed_id - 603 + 9;
      //if (fed_id>=601 && fed_id<=603) db_fedId = fed_id - 600 + 15;
      //if (fed_id>=649 && fed_id<=654) db_fedId = fed_id - 648;
      //if (fed_id>=646 && fed_id<=648) db_fedId = fed_id - 645 + 6;
      // db_fedId = fed_id;    // fixme: do we need 1-18 or 6XX?

      std::vector<EcalLogicID> badCrystals;
      badCrystals = econn->getEcalLogicIDSet("EE_readout_tower",
                                             fed_id,
                                             fed_id,
                                             tt_id,
                                             tt_id,
                                             EcalLogicID::NULLID,
                                             EcalLogicID::NULLID,
                                             "EE_crystal_number");

      for (size_t mycrys = 0; mycrys < badCrystals.size(); mycrys++) {
        EcalLogicID ecid_xt = badCrystals[mycrys];
        int zSide = 999;
        int log_id = ecid_xt.getLogicID();
        int yt2 = log_id % 1000;              //  EE_crystal_number:   2010100060 -> z=-1, x=100, y=60
        int xt2 = (log_id % 1000000) / 1000;  //  EE_crystal_number:   2012020085 -> z=+1, x=20,  y=85
        int zt2 = (log_id / 1000000) % 10;
        if (zt2 == 0)
          zSide = -1;
        if (zt2 == 2)
          zSide = 1;
        *daqFile2 << xt2 << " " << yt2 << " " << zSide << std::endl;
      }
    }

    if (fed_id >= 610 && fed_id <= 645 && tt_id < 69) {  // barrel

      // moving from cms fed to db fed convention
      int db_fedId = -999;
      if (fed_id >= 610 && fed_id <= 627)
        db_fedId = fed_id - 609 + 18;
      if (fed_id >= 628 && fed_id <= 645)
        db_fedId = fed_id - 627;

      std::vector<EcalLogicID> badCrystals;
      badCrystals = econn->getEcalLogicIDSet("EB_trigger_tower",
                                             db_fedId,
                                             db_fedId,
                                             tt_id,
                                             tt_id,
                                             EcalLogicID::NULLID,
                                             EcalLogicID::NULLID,
                                             "EB_crystal_number");

      for (size_t mycrys = 0; mycrys < badCrystals.size(); mycrys++) {
        EcalLogicID ecid_xt = badCrystals[mycrys];
        int sm_num = ecid_xt.getID1();
        int log_id = ecid_xt.getLogicID();
        int xt2_num = log_id % 10000;
        EBDetId ebdetid(sm_num, xt2_num, EBDetId::SMCRYSTALMODE);
        *daqFile2 << ebdetid.hashedIndex() << std::endl;
      }
    }
  }
}

getNewObjects()

void popcon::EcalChannelStatusHandler::getNewObjects ( )

overridevirtual

Implements popcon::PopConSourceHandler< EcalChannelStatus >.

Definition at line 1674 of file EcalChannelStatusHandler.cc.

References DummyCfis::c, gather_cfg::cout, test_db_connect::econn, Exception, MonRunList::getRuns(), test_db_connect::my_locdef, test_db_connect::my_rundef, MillePedeFileConverter_cfg::out, timingPdfMaker::outfile, RunTag::setGeneralTag(), MonRunTag::setGeneralTag(), RunTag::setLocationDef(), MonVersionDef::setMonitoringVersion(), MonRunList::setMonRunTag(), MonRunTag::setMonVersionDef(), MonRunList::setRunTag(), RunTag::setRunTypeDef(), contentValuesCheck::ss, and dumpRecoGeometry_cfg::tagInfo.

                                                   {
  std::ostringstream ss;
  ss << "ECAL ";

  // here we retrieve all the runs of a given type after the last from online DB
  unsigned int max_since = 0;
  max_since = static_cast<unsigned int>(tagInfo().lastInterval.since);
  std::cout << "max_since : " << max_since << std::endl;

  std::cout << "Retrieving run list from ONLINE DB ... " << std::endl;
  econn = new EcalCondDBInterface(m_sid, m_user, m_pass);
  std::cout << "Connection done" << std::endl;

  if (!econn) {
    std::cout << " Problem with OMDS: connection parameters " << m_sid << "/" << m_user << "/" << m_pass << std::endl;
    throw cms::Exception("OMDS not available");
  }

  // histos
  newBadEB_ = new TProfile2D("newBadEB_", "new bad channels, EB", 360, 0., 360., 170, -85., 85.);
  newBadEEP_ = new TProfile2D("newBad_EEP_", "new bad channels, EE+", 100, 0., 100., 100, 0., 100.);
  newBadEEM_ = new TProfile2D("newBad_EEM_", "new bad channels, EE-", 100, 0., 100., 100, 0., 100.);

  // these are the online conditions DB classes
  RunList my_runlist;
  RunTag my_runtag;
  LocationDef my_locdef;
  RunTypeDef my_rundef;
  my_locdef.setLocation(m_location);
  my_rundef.setRunType(m_runtype);
  my_runtag.setLocationDef(my_locdef);
  my_runtag.setRunTypeDef(my_rundef);
  my_runtag.setGeneralTag(m_gentag);

  // range of validity
  unsigned int min_run = 0;
  if (m_firstRun < max_since) {
    min_run = max_since + 1;  // we have to add 1 to the last transferred one
  } else {
    min_run = m_firstRun;
  }
  unsigned int max_run = m_lastRun;

  // here we retrieve the Monitoring run records
  MonVersionDef monverdef;
  monverdef.setMonitoringVersion("test01");
  MonRunTag mon_tag;
  // if (m_runtype=="PEDESTAL") mon_tag.setGeneralTag("CMSSW");
  // if (m_runtype=="LASER")    mon_tag.setGeneralTag("CMSSW");
  // if (m_runtype=="COSMIC" || m_runtype=="BEAM" || m_runtype=="PHYSICS" || m_runtype=="HALO" || m_runtype=="GLOBAL_COSMICS" ) mon_tag.setGeneralTag("CMSSW-online");
  if (m_runtype == "PEDESTAL")
    mon_tag.setGeneralTag("CMSSW-offline-private");
  if (m_runtype == "LASER")
    mon_tag.setGeneralTag("CMSSW-offline-private");
  if (m_runtype == "COSMIC" || m_runtype == "BEAM" || m_runtype == "PHYSICS" || m_runtype == "HALO" ||
      m_runtype == "GLOBAL_COSMICS")
    mon_tag.setGeneralTag("CMSSW-online-private");
  mon_tag.setMonVersionDef(monverdef);
  MonRunList mon_list;
  mon_list.setMonRunTag(mon_tag);
  mon_list.setRunTag(my_runtag);
  mon_list = econn->fetchMonRunList(my_runtag, mon_tag, min_run, max_run);

  // ----------------------------------------------------------------
  // preparing the output files
  char outfile[800];
  sprintf(outfile, "BadChannelsEB_run%d.txt", min_run);
  ResFileEB = new std::ofstream(outfile, std::ios::out);
  sprintf(outfile, "BadChannelsEE_run%d.txt", min_run);
  ResFileEE = new std::ofstream(outfile, std::ios::out);
  sprintf(outfile, "BadNewChannelsEB_run%d.txt", min_run);
  ResFileNewEB = new std::ofstream(outfile, std::ios::out);
  sprintf(outfile, "BadNewChannelsEE_run%d.txt", min_run);
  ResFileNewEE = new std::ofstream(outfile, std::ios::out);
  sprintf(outfile, "DaqConfig_run%d.txt", min_run);
  daqFile = new std::ofstream(outfile, std::ios::out);
  sprintf(outfile, "DaqConfig_channels_run%d.txt", min_run);
  daqFile2 = new std::ofstream(outfile, std::ios::out);

  *daqFile << "fed"
           << "\t\t"
           << "tower" << std::endl;

  if (m_runtype == "PEDESTAL") {
    *ResFileEB << "Fed"
               << "\t\t"
               << "Ic"
               << "\t\t"
               << "hIndex"
               << "\t\t"
               << "MeanG12"
               << "\t\t"
               << "RmsG12"
               << "\t\t"
               << "MeanG6"
               << "\t\t"
               << "RmsG6"
               << "\t\t"
               << "MeanG1"
               << "\t\t"
               << "RmsG1" << std::endl;

    *ResFileEE << "Fed"
               << "\t\t"
               << "Ix"
               << "\t\t"
               << "Iy"
               << "\t\t"
               << "Iz"
               << "\t\t"
               << "hIndex"
               << "\t\t"
               << "MeanG12"
               << "\t\t"
               << "RmsG12"
               << "\t\t"
               << "MeanG6"
               << "\t\t"
               << "RmsG6"
               << "\t\t"
               << "MeanG1"
               << "\t\t"
               << "RmsG1" << std::endl;

    *ResFileNewEB << "Fed"
                  << "\t\t"
                  << "Ic"
                  << "\t\t"
                  << "hIndex"
                  << "\t\t"
                  << "MeanG12"
                  << "\t\t"
                  << "RmsG12"
                  << "\t\t"
                  << "MeanG6"
                  << "\t\t"
                  << "RmsG6"
                  << "\t\t"
                  << "MeanG1"
                  << "\t\t"
                  << "RmsG1" << std::endl;

    *ResFileNewEE << "Fed"
                  << "\t\t"
                  << "Ix"
                  << "\t\t"
                  << "Iy"
                  << "\t\t"
                  << "Iz"
                  << "\t\t"
                  << "hIndex"
                  << "\t\t"
                  << "MeanG12"
                  << "\t\t"
                  << "RmsG12"
                  << "\t\t"
                  << "MeanG6"
                  << "\t\t"
                  << "RmsG6"
                  << "\t\t"
                  << "MeanG1"
                  << "\t\t"
                  << "RmsG1" << std::endl;
  }

  if (m_runtype == "LASER") {
    *ResFileEB << "Fed"
               << "\t\t"
               << "Ic"
               << "\t\t"
               << "hIndex"
               << "\t\t"
               << "apd" << std::endl;
    *ResFileEE << "Fed"
               << "\t\t"
               << "Ix"
               << "\t\t"
               << "Iy"
               << "\t\t"
               << "Iz"
               << "\t\t"
               << "hIndex"
               << "\t\t"
               << "apd" << std::endl;
    *ResFileNewEB << "Fed"
                  << "\t\t"
                  << "Ic"
                  << "\t\t"
                  << "hIndex"
                  << "\t\t"
                  << "apd" << std::endl;
    *ResFileNewEE << "Fed"
                  << "\t\t"
                  << "Ix"
                  << "\t\t"
                  << "Iy"
                  << "\t\t"
                  << "Iz"
                  << "\t\t"
                  << "hIndex"
                  << "\t\t"
                  << "apd" << std::endl;
  }

  if (m_runtype == "COSMIC" || m_runtype == "BEAM" || m_runtype == "PHYSICS" || m_runtype == "HALO" ||
      m_runtype == "GLOBAL_COSMICS") {
    *ResFileEB << "Fed"
               << "\t\t"
               << "Ic"
               << "\t\t"
               << "hIndex"
               << "\t\t"
               << "pedOnline"
               << "\t\t"
               << "pedOnlineRMS "
               << "\t\t"
               << "gain0"
               << "\t\t"
               << "apd"
               << "\t\t"
               << "highThrOcc"
               << "\t\t" << std::endl;

    *ResFileEE << "Fed"
               << "\t\t"
               << "Ix"
               << "Iy"
               << "\t\t"
               << "Iz"
               << "\t\t"
               << "hIndex"
               << "\t\t"
               << "pedOnline"
               << "\t\t"
               << "pedOnlineRMS "
               << "\t\t"
               << "gain0"
               << "\t\t"
               << "apd"
               << "\t\t"
               << "highThrOcc"
               << "\t\t" << std::endl;

    *ResFileNewEB << "Fed"
                  << "\t\t"
                  << "Ic"
                  << "\t\t"
                  << "hIndex"
                  << "\t\t"
                  << "pedOnline"
                  << "\t\t"
                  << "pedOnlineRMS "
                  << "\t\t"
                  << "gain0"
                  << "\t\t"
                  << "apd"
                  << "\t\t"
                  << "highThrOcc"
                  << "\t\t" << std::endl;

    *ResFileNewEE << "Fed"
                  << "\t\t"
                  << "Ix"
                  << "Iy"
                  << "\t\t"
                  << "Iz"
                  << "\t\t"
                  << "hIndex"
                  << "\t\t"
                  << "pedOnline"
                  << "\t\t"
                  << "pedOnlineRMS "
                  << "\t\t"
                  << "gain0"
                  << "\t\t"
                  << "apd"
                  << "\t\t"
                  << "highThrOcc"
                  << "\t\t" << std::endl;
  }

  // -------------------------------------------------------------------
  // analysis for the wanted runs
  std::vector<MonRunIOV> mon_run_vec = mon_list.getRuns();
  int mon_runs = mon_run_vec.size();
  std::cout << "number of Mon runs is " << mon_runs << std::endl;
  if (mon_runs == 0)
    std::cout << "PROBLEM! 0 runs analyzed by DQM" << std::endl;
  if (mon_runs == 0)
    ss << "PROBLEM! 0 runs analyzed by DQM" << std::endl;

  // initialize std::maps with masked channels
  maskedOnlinePedEB.clear();
  maskedOnlinePedEE.clear();
  maskedPedEB.clear();
  maskedPedEE.clear();
  maskedLaserEB.clear();
  maskedLaserEE.clear();
  maskedPhysicsEB.clear();
  maskedPhysicsEE.clear();

  // to iterate
  std::map<DetId, float>::const_iterator theIter;

  // using db info written by DQM
  if (mon_runs > 0) {
    for (int dqmRun = 0; dqmRun < mon_runs; dqmRun++) {
      unsigned long iDqmRun = (unsigned long)mon_run_vec[dqmRun].getRunIOV().getRunNumber();

      std::cout << "retrieve the DQM data for run number: " << iDqmRun
                << ", subrun number: " << mon_run_vec[dqmRun].getSubRunNumber() << std::endl;

      if (mon_run_vec[dqmRun].getSubRunNumber() ==
          mon_runs) {  // fixme: check it still works after DMQ soft reset modifications

        // retrieve daq configuration for this run
        RunIOV myRun;
        myRun = mon_run_vec[dqmRun].getRunIOV();
        daqOut(myRun);

        // retrieve the data for a given run
        RunIOV runiov_prime = mon_run_vec[dqmRun].getRunIOV();

        // here we read the list of masked channel in the DB for this run and create masked channels std::maps
        std::cout << "Fetching masked channels from DB" << std::endl;
        ecalErrorMask_.readDB(econn, &runiov_prime);

        // -----------------------------------------------------------------------------------
        // here we do all the different types of analyses

        // PEDESTAL ANALYSIS for local runs: check pedestals only
        if (m_runtype == "PEDESTAL") {
          // retrieve the pedestals from OMDS for this run
          std::map<EcalLogicID, MonPedestalsDat> dataset_mon;
          econn->fetchDataSet(&dataset_mon, &mon_run_vec[dqmRun]);
          std::cout << "running pedestal analysis" << std::endl;
          std::cout << "OMDS record for pedestals, run " << iDqmRun << " is made of " << dataset_mon.size()
                    << " entries" << std::endl;

          // retrieve the crystal consistency from OMDS for this run
          std::map<EcalLogicID, MonCrystalConsistencyDat> wrongGain_mon;
          econn->fetchDataSet(&wrongGain_mon, &mon_run_vec[dqmRun]);
          std::cout << "OMDS record for consistency, run " << iDqmRun << " is made of " << wrongGain_mon.size()
                    << " entries" << std::endl;

          // check if enough data and perform analysis
          if (!dataset_mon.empty()) {
            pedAnalysis(dataset_mon, wrongGain_mon);
          } else {
            std::cout << "Not enought data for pedestal analysis" << std::endl;
            ss << "Not enought data for pedestal analysis" << std::endl;
          }
        }

        // LASER ANALYSIS for local runs: check APD values only
        if (m_runtype == "LASER") {
          // retrieve the APD / PNs from OMDS for this run
          std::map<EcalLogicID, MonLaserBlueDat> dataset_mon;
          econn->fetchDataSet(&dataset_mon, &mon_run_vec[dqmRun]);
          std::cout << "running the laser analysis based on DQM data" << std::endl;
          std::cout << "OMDS record for run " << iDqmRun << " is made of " << dataset_mon.size() << " records"
                    << std::endl;

          // check if enough data and select good light modules / perform analysis
          if (!dataset_mon.empty()) {
            nBadLaserModules(dataset_mon);
            laserAnalysis(dataset_mon);
          } else {
            std::cout << "Not enought data for dqm-based laser analysis" << std::endl;
            ss << "Not enought data for dqm-based laser analysis" << std::endl;
          }
        }

        // global analysis for global runs
        if (m_runtype == "COSMIC" || m_runtype == "BEAM" || m_runtype == "PHYSICS" || m_runtype == "HALO" ||
            m_runtype == "GLOBAL_COSMICS") {
          // retrieve the pedestal online from OMDS for this run
          std::map<EcalLogicID, MonPedestalsOnlineDat> pedonline_mon;
          econn->fetchDataSet(&pedonline_mon, &mon_run_vec[dqmRun]);
          std::cout << "running pedestal online analysis" << std::endl;
          std::cout << "OMDS record for pedestals, run " << iDqmRun << " is made of " << pedonline_mon.size()
                    << std::endl;

          // retrieve the crystal consistency from OMDS for this run
          std::map<EcalLogicID, MonCrystalConsistencyDat> wrongGain_mon;
          econn->fetchDataSet(&wrongGain_mon, &mon_run_vec[dqmRun]);
          std::cout << "OMDS record for consistency, run " << iDqmRun << " is made of " << wrongGain_mon.size()
                    << " entries" << std::endl;

          // retrieve the occupancy info from OMDS for this run
          std::map<EcalLogicID, MonOccupancyDat> occupancy_mon;
          econn->fetchDataSet(&occupancy_mon, &mon_run_vec[dqmRun]);
          std::cout << "OMDS record for occupancy, run " << iDqmRun << " is made of " << occupancy_mon.size()
                    << std::endl;

          // retrieve the APD / PNs from OMDS for this run
          std::map<EcalLogicID, MonLaserBlueDat> laser_mon;
          econn->fetchDataSet(&laser_mon, &mon_run_vec[dqmRun]);
          std::cout << "running laser analysis" << std::endl;
          std::cout << "OMDS record for laser, run " << iDqmRun << " is made of " << laser_mon.size() << " records"
                    << std::endl;

          // check if enough data in all the categories and do the analysis
          if (pedonline_mon.empty()) {
            std::cout << "Not enought data for pedestal online analysis" << std::endl;
            ss << "Not enought data for pedestal online analysis" << std::endl;
          }
          if (occupancy_mon.empty()) {
            std::cout << "Not enought data for occupancy analysis" << std::endl;
            ss << "Not enought data for occupancy analysis" << std::endl;
          }
          if (laser_mon.empty()) {
            std::cout << "Not enought data for laser analysis" << std::endl;
            ss << "Not enought data for laser analysis" << std::endl;
          }
          if (!pedonline_mon.empty() || !occupancy_mon.empty() || !wrongGain_mon.empty() || !laser_mon.empty()) {
            nBadLaserModules(laser_mon);
            cosmicsAnalysis(pedonline_mon, wrongGain_mon, laser_mon, occupancy_mon);
          }

          // plotting histos with new bad channels
          int iLineEB = 0;
          TLine lEB;
          gStyle->SetPalette(1);
          gStyle->SetOptStat(0);
          TCanvas c("c", "c", 1);
          newBadEB_->SetMaximum(11);
          newBadEB_->Draw("colz");
          iLineEB = 0;
          lEB.DrawLine(0, 0, 360, 0);
          while (iLineEB < 18) {
            lEB.DrawLine(iLineEB * 20, -85, iLineEB * 20, 85);
            iLineEB++;
          }
          c.SaveAs("newBadEB_.png");

          TLine lEE;
          lEE.SetLineWidth(1);
          int ixSectorsEE[202] = {
              61, 61,  60,  60, 59, 59, 58, 58, 57,  57,  55, 55, 45, 45, 43, 43, 42, 42, 41, 41, 40, 40, 39,
              39, 40,  40,  41, 41, 42, 42, 43, 43,  45,  45, 55, 55, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61,
              0,  100, 100, 97, 97, 95, 95, 92, 92,  87,  87, 85, 85, 80, 80, 75, 75, 65, 65, 60, 60, 40, 40,
              35, 35,  25,  25, 20, 20, 15, 15, 13,  13,  8,  8,  5,  5,  3,  3,  0,  0,  3,  3,  5,  5,  8,
              8,  13,  13,  15, 15, 20, 20, 25, 25,  35,  35, 40, 40, 60, 60, 65, 65, 75, 75, 80, 80, 85, 85,
              87, 87,  92,  92, 95, 95, 97, 97, 100, 100, 0,  61, 65, 65, 70, 70, 80, 80, 90, 90, 92, 0,  61,
              65, 65,  90,  90, 97, 0,  57, 60, 60,  65,  65, 70, 70, 75, 75, 80, 80, 0,  50, 50, 0,  43, 40,
              40, 35,  35,  30, 30, 25, 25, 20, 20,  0,   39, 35, 35, 10, 10, 3,  0,  39, 35, 35, 30, 30, 20,
              20, 10,  10,  8,  0,  45, 45, 40, 40,  35,  35, 0,  55, 55, 60, 60, 65, 65};
          int iySectorsEE[202] = {
              50, 55,  55, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 60, 60,  59,  59, 58, 58, 57, 57, 55, 55, 45, 45, 43,
              43, 42,  42, 41, 41, 40, 40, 39, 39, 40, 40, 41, 41, 42, 42,  43,  43, 45, 45, 50, 0,  50, 60, 60, 65, 65,
              75, 75,  80, 80, 85, 85, 87, 87, 92, 92, 95, 95, 97, 97, 100, 100, 97, 97, 95, 95, 92, 92, 87, 87, 85, 85,
              80, 80,  75, 75, 65, 65, 60, 60, 40, 40, 35, 35, 25, 25, 20,  20,  15, 15, 13, 13, 8,  8,  5,  5,  3,  3,
              0,  0,   3,  3,  5,  5,  8,  8,  13, 13, 15, 15, 20, 20, 25,  25,  35, 35, 40, 40, 50, 0,  45, 45, 40, 40,
              35, 35,  30, 30, 25, 25, 0,  50, 50, 55, 55, 60, 60, 0,  60,  60,  65, 65, 70, 70, 75, 75, 85, 85, 87, 0,
              61, 100, 0,  60, 60, 65, 65, 70, 70, 75, 75, 85, 85, 87, 0,   50,  50, 55, 55, 60, 60, 0,  45, 45, 40, 40,
              35, 35,  30, 30, 25, 25, 0,  39, 30, 30, 15, 15, 5,  0,  39,  30,  30, 15, 15, 5};

          newBadEEP_->SetMaximum(11);
          newBadEEP_->Draw("colz");
          for (int iLineEEP = 0; iLineEEP < 201; iLineEEP = iLineEEP + 1) {
            if ((ixSectorsEE[iLineEEP] != 0 || iySectorsEE[iLineEEP] != 0) &&
                (ixSectorsEE[iLineEEP + 1] != 0 || iySectorsEE[iLineEEP + 1] != 0)) {
              lEE.DrawLine(
                  ixSectorsEE[iLineEEP], iySectorsEE[iLineEEP], ixSectorsEE[iLineEEP + 1], iySectorsEE[iLineEEP + 1]);
            }
          }
          c.SaveAs("newBadEEP_.png");

          newBadEEM_->SetMaximum(11);
          newBadEEM_->Draw("colz");
          for (int iLineEEP = 0; iLineEEP < 201; iLineEEP = iLineEEP + 1) {
            if ((ixSectorsEE[iLineEEP] != 0 || iySectorsEE[iLineEEP] != 0) &&
                (ixSectorsEE[iLineEEP + 1] != 0 || iySectorsEE[iLineEEP + 1] != 0)) {
              lEE.DrawLine(
                  ixSectorsEE[iLineEEP], iySectorsEE[iLineEEP], ixSectorsEE[iLineEEP + 1], iySectorsEE[iLineEEP + 1]);
            }
          }
          c.SaveAs("newBadEEM_.png");

        }  // cosmics analysis

      }  // subruns
    }    // runs loop
  }      // we have the DQM info

  delete econn;
  std::cout << "Ecal - > end of getNewObjects -----------\n";
}

id()

std::string popcon::EcalChannelStatusHandler::id ( ) const

inlineoverridevirtual

Implements popcon::PopConSourceHandler< EcalChannelStatus >.

Definition at line 76 of file EcalChannelStatusHandler.h.

References m_name.

{ return m_name; }

laserAnalysis()

void popcon::EcalChannelStatusHandler::laserAnalysis

(

std::map< EcalLogicID, MonLaserBlueDat >

dataset_mon

)

Definition at line 689 of file EcalChannelStatusHandler.cc.

References EcalElectronicsId::dccId(), MonLaserBlueDat::getAPDMean(), EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalLogicID::getName(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EBDetId::ic(), EEDetId::ix(), EEDetId::iy(), AlCaHLTBitMon_ParallelJobs::p, EBDetId::SMCRYSTALMODE, EcalElectronicsId::towerId(), EEDetId::validDetId(), and EEDetId::zside().

                                                                                                   {
  // to take the list of masked crystals
  laserMasking();

  // to iterate
  std::map<DetId, float>::const_iterator theIter;

  typedef std::map<EcalLogicID, MonLaserBlueDat>::const_iterator CImon;
  EcalLogicID ecid_xt;
  MonLaserBlueDat rd_blue;

  for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
    ecid_xt = p->first;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    // in which Fed/triggerTower/sectorSide I am
    int theFed = -100;
    int theTT = -100;
    int theIx = -100;
    if (ecid_xt.getName() == "EB_crystal_number") {
      EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
      EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
      theFed = 600 + elecId.dccId();
      theTT = elecId.towerId();
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
        EEDetId eedetid(xt_num, yt_num, sm_num);
        EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
        theFed = 600 + elecId.dccId();
        theIx = eedetid.ix();
      }
    }

    // to have numbers from 0 to 17 for the EE feds and 0-36 for EB
    int thisFed = -100;
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (theFed > 600 && theFed < 610)
        thisFed = theFed - 601;
      if (theFed > 645 && theFed < 655)
        thisFed = theFed - 646 + 9;
    }
    if (ecid_xt.getName() == "EB_crystal_number") {
      thisFed = theFed - 610;
    }

    // in which light module I am
    int theTTieta = -100;
    int theTTiphi = -100;
    int theLM = -100;
    if (ecid_xt.getName() == "EB_crystal_number") {
      theTTieta = (theTT - 1) / 4 + 1;
      theTTiphi = (theTT - 1) % 4 + 1;
      if (theTTieta == 1 || theTTiphi == 3 || theTTiphi == 4)
        theLM = 0;  // L-shaped
      if (theTTieta > 1 && (theTTiphi == 1 || theTTiphi == 2))
        theLM = 1;  // not L-shaped
    }
    if ((ecid_xt.getName() == "EE_crystal_number") && (thisFed == 7 || thisFed == 16)) {
      if (theIx <= 50)
        theLM = 0;
      if (theIx > 50)
        theLM = 1;
    }

    // check if APD mean is bad
    uint16_t status_now = 0;
    rd_blue = p->second;
    float myApdMean = rd_blue.getAPDMean();

    if (ecid_xt.getName() == "EB_crystal_number") {
      if ((myApdMean < 400) && isGoodLaserEBSm[thisFed][theLM])
        status_now = 2;
    }

    if (ecid_xt.getName() == "EE_crystal_number") {
      if (myApdMean < 100) {
        if (thisFed != 7 && thisFed != 16 && isGoodLaserEESm[thisFed][0])
          status_now = 2;
        if ((thisFed == 7 || thisFed == 16) && isGoodLaserEESm[thisFed][theLM])
          status_now = 2;
      }
    }

    // output if problematic
    if (status_now > 0) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        *ResFileEB << theFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << myApdMean
                   << std::endl;

        // file with new problems only
        bool isOld = false;
        for (theIter = maskedLaserEB.begin(); theIter != maskedLaserEB.end(); ++theIter) {
          if ((*theIter).first == ebdetid)
            isOld = true;
        }
        if (!isOld) {
          *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t" << myApdMean
                        << std::endl;
        }

      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          *ResFileEE << theFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                     << "\t\t" << eedetid.hashedIndex() << "\t\t" << myApdMean << std::endl;

          // file with new problems only
          bool isOld = false;
          for (theIter = maskedLaserEE.begin(); theIter != maskedLaserEE.end(); ++theIter) {
            if ((*theIter).first == eedetid)
              isOld = true;
          }
          if (!isOld) {
            *ResFileEE << theFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                       << "\t\t" << eedetid.hashedIndex() << "\t\t" << myApdMean << std::endl;
          }
        }
      }
    }
  }
}

laserMasking()

void popcon::EcalChannelStatusHandler::laserMasking

(

)

Definition at line 331 of file EcalChannelStatusHandler.cc.

References EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalErrorDictionary::getMask(), EcalLogicID::getName(), visualization-live-secondInstance_cfg::m, EBDetId::SMCRYSTALMODE, and EEDetId::validDetId().

                                                  {
  uint64_t bits03 = 0;
  bits03 |= EcalErrorDictionary::getMask("LASER_MEAN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("LASER_RMS_WARNING");
  bits03 |= EcalErrorDictionary::getMask("LASER_MEAN_OVER_PN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("LASER_RMS_OVER_PN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("LASER_MEAN_TIMING_WARNING");
  bits03 |= EcalErrorDictionary::getMask("LASER_RMS_TIMING_WARNING");

  std::map<EcalLogicID, RunCrystalErrorsDat> theMask;
  ecalErrorMask_.fetchDataSet(&theMask);

  if (!theMask.empty()) {
    std::map<EcalLogicID, RunCrystalErrorsDat>::const_iterator m;
    for (m = theMask.begin(); m != theMask.end(); m++) {
      EcalLogicID ecid_xt = m->first;
      int sm_num = ecid_xt.getID1();
      int xt_num = ecid_xt.getID2();
      int yt_num = ecid_xt.getID3();

      if ((m->second).getErrorBits() & bits03) {
        if (ecid_xt.getName() == "EB_crystal_number") {
          EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
          maskedLaserEB.insert(std::pair<DetId, float>(ebdetid, 9999.));
        } else {
          if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
            EEDetId eedetid(xt_num, yt_num, sm_num);
            maskedLaserEE.insert(std::pair<DetId, float>(eedetid, 9999.));
          }
        }
      }
    }
  }
}

nBadLaserModules()

void popcon::EcalChannelStatusHandler::nBadLaserModules

(

std::map< EcalLogicID, MonLaserBlueDat >

dataset_mon

)

Definition at line 109 of file EcalChannelStatusHandler.cc.

References EcalElectronicsId::dccId(), MonLaserBlueDat::getAPDMean(), EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalLogicID::getName(), EEDetId::ix(), AlCaHLTBitMon_ParallelJobs::p, EBDetId::SMCRYSTALMODE, EcalElectronicsId::towerId(), and EEDetId::validDetId().

                                                                                                      {
  // NB: EcalLogicId, sm_num = ecid_xt.getID1() --> for barrel is 1->18 = EB+; 19->36 = EB-
  // NB: EcalLogicId, sm_num = ecid_xt.getID1() --> for endcap is 1=Z+, -1=Z- ;

  // good and bad light modules and reference crystals in EB
  // theLM=0 -> L-shaped            ( TTs: 1,2,3,4; 7-8; 11-12 ... )
  // theLM=1 -> not L-shaped        ( TTs: 5-6,9-10 ... )
  for (int theSm = 0; theSm < 36; theSm++) {
    for (int theLM = 0; theLM < 2; theLM++) {
      isEBRef1[theSm][theLM] = false;
      isEBRef2[theSm][theLM] = false;
      isGoodLaserEBSm[theSm][theLM] = false;
    }
  }

  // good and bad light modules and reference crystals in EE [NB: only in EE-5 and EE+5 we need 2 LM... redundant]
  // theLM=0 -> light module A (ix<=50)
  // theLM=1 -> light module B (ix>50)
  for (int theSector = 0; theSector < 18; theSector++) {
    for (int theLM = 0; theLM < 2; theLM++) {
      isEERef1[theSector][theLM] = false;
      isEERef2[theSector][theLM] = false;
      isGoodLaserEESm[theSector][theLM] = false;
    }
  }

  typedef std::map<EcalLogicID, MonLaserBlueDat>::const_iterator CImon;
  EcalLogicID ecid_xt;
  MonLaserBlueDat rd_blue;

  for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
    ecid_xt = p->first;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    // in which Fed/triggerTower/sectorSide I am
    int theFed = -100;
    int theTT = -100;
    int theIx = -100;
    if (ecid_xt.getName() == "EB_crystal_number") {
      EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
      EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
      theFed = 600 + elecId.dccId();
      theTT = elecId.towerId();
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
        EEDetId eedetid(xt_num, yt_num, sm_num);
        EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
        theFed = 600 + elecId.dccId();
        theIx = eedetid.ix();
      }
    }

    // to have numbers from 0 to 17 for the EE feds and 0-36 for EB
    //  0 = EE-7;  1 = EE-8;  2 = EE-9;  3 = EE-1;  4 = EE-2;  5 = EE-3;  6 = EE-4;  7 = EE-5;  8 = EE-6;
    //  9 = EE+7; 10 = EE+8; 11 = EE+9; 12 = EE+1; 13 = EE+2; 14 = EE+3; 15 = EE+4; 16 = EE+5; 17 = EE+6
    //  0 = EB-1 --> 17 = EB-18; 18 = EB+1 --> 35 = EB+18
    int thisFed = -100;
    if (ecid_xt.getName() == "EE_crystal_number") {
      if (theFed > 600 && theFed < 610)
        thisFed = theFed - 601;
      if (theFed > 645 && theFed < 655)
        thisFed = theFed - 646 + 9;
    }
    if (ecid_xt.getName() == "EB_crystal_number") {
      thisFed = theFed - 610;
    }

    // in which light module I am
    int theTTieta = -100;
    int theTTiphi = -100;
    int theLM = -100;
    if (ecid_xt.getName() == "EB_crystal_number") {
      theTTieta = (theTT - 1) / 4 + 1;
      theTTiphi = (theTT - 1) % 4 + 1;
      if (theTTieta == 1 || theTTiphi == 3 || theTTiphi == 4)
        theLM = 0;  // L-shaped
      if (theTTieta > 1 && (theTTiphi == 1 || theTTiphi == 2))
        theLM = 1;  // not L-shaped
    }
    if ((ecid_xt.getName() == "EE_crystal_number") && (thisFed == 7 || thisFed == 16)) {
      if (theIx <= 50)
        theLM = 0;
      if (theIx > 50)
        theLM = 1;
    }

    // taking laser infos
    rd_blue = p->second;
    float myApdMean = rd_blue.getAPDMean();

    // barrel: is there at least one crystal on in this LM?
    if (ecid_xt.getName() == "EB_crystal_number") {
      EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
      if (!isEBRef1[thisFed][theLM] && !isEBRef2[thisFed][theLM] && myApdMean > 100)
        isEBRef1[thisFed][theLM] = true;
      if (isEBRef1[thisFed][theLM] && !isEBRef2[thisFed][theLM] && myApdMean > 100)
        isEBRef2[thisFed][theLM] = true;
    }

    // endcap: is there at least one crystal on in this LM?
    if (ecid_xt.getName() == "EE_crystal_number") {
      EEDetId eedetid(xt_num, yt_num, sm_num);

      // just 1 LM per Fed
      if (thisFed != 7 && thisFed != 16) {
        if (!isEERef1[thisFed][0] && !isEERef2[thisFed][0] && myApdMean > 100) {
          isEERef1[thisFed][0] = true;
          isEERef1[thisFed][1] = true;
        }
        if (isEERef1[thisFed][0] && !isEERef2[thisFed][0] && myApdMean > 100) {
          isEERef2[thisFed][0] = true;
          isEERef2[thisFed][1] = true;
        }
      }

      // 2 LMs per Fed
      if (thisFed == 7 || thisFed == 16) {
        if (!isEERef1[thisFed][theLM] && !isEERef2[thisFed][theLM] && myApdMean > 100)
          isEERef1[thisFed][theLM] = true;
        if (isEERef1[thisFed][theLM] && !isEERef2[thisFed][theLM] && myApdMean > 100)
          isEERef2[thisFed][theLM] = true;
      }
    }
  }

  // check if the light module is on: at least two crystals must be on
  for (int theSm = 0; theSm < 36; theSm++) {
    for (int theLM = 0; theLM < 2; theLM++) {
      if (isEBRef1[theSm][theLM] && isEBRef2[theSm][theLM])
        isGoodLaserEBSm[theSm][theLM] = true;
      // std::cout << "Barrel: SM " << theSm << ", LM " << theLM << ": good = " << isGoodLaserEBSm[theSm][theLM] << std::endl;
    }
  }

  for (int theSector = 0; theSector < 18; theSector++) {
    for (int theLM = 0; theLM < 2; theLM++) {
      if (isEERef1[theSector][theLM] && isEERef2[theSector][theLM])
        isGoodLaserEESm[theSector][theLM] = true;
      // std::cout << "Endcap: SM " << theSector << ", LM " << theLM << ": good = " << isGoodLaserEESm[theSector][theLM] << std::endl;
    }
  }
}

pedAnalysis()

void popcon::EcalChannelStatusHandler::pedAnalysis	(	std::map< EcalLogicID, MonPedestalsDat >	dataset_mon,
		std::map< EcalLogicID, MonCrystalConsistencyDat >	wrongGain_mon
	)

Definition at line 511 of file EcalChannelStatusHandler.cc.

References EcalElectronicsId::dccId(), EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalLogicID::getName(), MonPedestalsDat::getPedMeanG1(), MonPedestalsDat::getPedMeanG12(), MonPedestalsDat::getPedMeanG6(), MonPedestalsDat::getPedRMSG1(), MonPedestalsDat::getPedRMSG12(), MonPedestalsDat::getPedRMSG6(), MonCrystalConsistencyDat::getProblemsGainZero(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EBDetId::ic(), EEDetId::ix(), EEDetId::iy(), AlCaHLTBitMon_ParallelJobs::p, EBDetId::SMCRYSTALMODE, EEDetId::validDetId(), and EEDetId::zside().

                                                                                                                {
  // to take the list of masked crystals
  pedMasking();

  // to iterate
  std::map<DetId, float>::const_iterator theIter;

  // logic id
  EcalLogicID ecid_xt;

  // to check all problems except gain zero
  typedef std::map<EcalLogicID, MonPedestalsDat>::const_iterator CImon;
  MonPedestalsDat rd_ped;

  for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
    uint16_t status_now = 0;
    ecid_xt = p->first;
    rd_ped = p->second;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    EcalPedestals::Item ped_item;
    ped_item.mean_x1 = rd_ped.getPedMeanG1();
    ped_item.mean_x6 = rd_ped.getPedMeanG6();
    ped_item.mean_x12 = rd_ped.getPedMeanG12();
    ped_item.rms_x1 = rd_ped.getPedRMSG1();
    ped_item.rms_x6 = rd_ped.getPedRMSG6();
    ped_item.rms_x12 = rd_ped.getPedRMSG12();

    // check if pedestal RMS is bad at least at 1 gain -> noisy or very noisy channel
    float lowerCut = 999.;
    if (ecid_xt.getName() == "EB_crystal_number") {
      lowerCut = 2.0;
    }
    if (ecid_xt.getName() == "EE_crystal_number") {
      lowerCut = 2.5;
    }
    if ((checkPedestalRMSGain12(&ped_item) > lowerCut) || (checkPedestalRMSGain6(&ped_item) > lowerCut) ||
        (checkPedestalRMSGain1(&ped_item) > lowerCut))
      status_now = 3;

    // check if pedestal value is bad at least at 1 gain -> problem in dac settings
    if ((checkPedestalValueGain12(&ped_item) > 300 || checkPedestalValueGain12(&ped_item) < 100) ||
        (checkPedestalValueGain6(&ped_item) > 300 || checkPedestalValueGain6(&ped_item) < 100) ||
        (checkPedestalValueGain1(&ped_item) > 300 || checkPedestalValueGain1(&ped_item) < 100))
      status_now = 1;

    // check if pedestal rms is zero at least at 1 gain -> dead at that channel
    if (checkPedestalRMSGain12(&ped_item) == 0 || checkPedestalRMSGain6(&ped_item) == 0 ||
        checkPedestalRMSGain1(&ped_item) == 0)
      status_now = 11;

    // check if the channel is fixed at G1
    if (checkPedestalValueGain12(&ped_item) < 0 && checkPedestalValueGain6(&ped_item) < 0 &&
        checkPedestalValueGain1(&ped_item) > 0)
      status_now = 9;

    // check if the channel is fixed at G6
    if (checkPedestalValueGain12(&ped_item) < 0 && checkPedestalValueGain6(&ped_item) > 0 &&
        checkPedestalValueGain1(&ped_item) < 0)
      status_now = 8;

    // check if the channel is not working at G12
    if (checkPedestalValueGain12(&ped_item) < 0 && checkPedestalValueGain6(&ped_item) > 0 &&
        checkPedestalValueGain1(&ped_item) > 0)
      status_now = 8;

    // output in case of problems:
    if (status_now > 0) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
        int thisFed = 600 + elecId.dccId();

        *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t"
                   << ped_item.mean_x12 << "\t\t" << ped_item.rms_x12 << "\t\t" << ped_item.mean_x6 << "\t\t"
                   << ped_item.rms_x6 << "\t\t" << ped_item.mean_x1 << "\t\t" << ped_item.rms_x1 << std::endl;

        // file with new problems only
        bool isOld = false;
        for (theIter = maskedPedEB.begin(); theIter != maskedPedEB.end(); ++theIter) {
          if ((*theIter).first == ebdetid)
            isOld = true;
        }
        if (!isOld) {
          *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t"
                        << ped_item.mean_x12 << "\t\t" << ped_item.rms_x12 << "\t\t" << ped_item.mean_x6 << "\t\t"
                        << ped_item.rms_x6 << "\t\t" << ped_item.mean_x1 << "\t\t" << ped_item.rms_x1 << std::endl;
        }

      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
          int thisFed = 600 + elecId.dccId();
          *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                     << "\t\t" << eedetid.hashedIndex() << "\t\t" << ped_item.mean_x12 << "\t\t" << ped_item.rms_x12
                     << "\t\t" << ped_item.mean_x6 << "\t\t" << ped_item.rms_x6 << "\t\t" << ped_item.mean_x1 << "\t\t"
                     << ped_item.rms_x1 << std::endl;

          bool isOld = false;
          for (theIter = maskedPedEE.begin(); theIter != maskedPedEE.end(); ++theIter) {
            if ((*theIter).first == eedetid)
              isOld = true;
          }
          if (!isOld) {
            *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                          << "\t\t" << eedetid.hashedIndex() << "\t\t" << ped_item.mean_x12 << "\t\t"
                          << ped_item.rms_x12 << "\t\t" << ped_item.mean_x6 << "\t\t" << ped_item.rms_x6 << "\t\t"
                          << ped_item.mean_x1 << "\t\t" << ped_item.rms_x1 << std::endl;
          }
        }
      }
    }
  }

  // to check if a crystal is at gain zero in at least 1000 events (which is not the best! fixme)
  typedef std::map<EcalLogicID, MonCrystalConsistencyDat>::const_iterator WGmonIter;
  MonCrystalConsistencyDat rd_wgain;

  for (WGmonIter p = wrongGain_mon.begin(); p != wrongGain_mon.end(); p++) {
    ecid_xt = p->first;
    rd_wgain = p->second;
    int sm_num = ecid_xt.getID1();
    int xt_num = ecid_xt.getID2();
    int yt_num = ecid_xt.getID3();

    // output if problematic
    if (rd_wgain.getProblemsGainZero() > 1000) {
      if (ecid_xt.getName() == "EB_crystal_number") {
        EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
        EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(ebdetid);
        int thisFed = 600 + elecId.dccId();
        *ResFileEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t"
                   << "at gain zero" << std::endl;

        // file with new problems only
        bool isOld = false;
        for (theIter = maskedPedEB.begin(); theIter != maskedPedEB.end(); ++theIter) {
          if ((*theIter).first == ebdetid)
            isOld = true;
        }
        if (!isOld) {
          *ResFileNewEB << thisFed << "\t\t" << ebdetid.ic() << "\t\t" << ebdetid.hashedIndex() << "\t\t"
                        << "at gain zero" << std::endl;
        }

      } else {
        if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
          EEDetId eedetid(xt_num, yt_num, sm_num);
          EcalElectronicsId elecId = ecalElectronicsMap_.getElectronicsId(eedetid);
          int thisFed = 600 + elecId.dccId();
          *ResFileEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                     << "\t\t" << eedetid.hashedIndex() << "\t\t"
                     << "at gain zero" << std::endl;

          bool isOld = false;
          for (theIter = maskedPedEE.begin(); theIter != maskedPedEE.end(); ++theIter) {
            if ((*theIter).first == eedetid)
              isOld = true;
          }
          if (!isOld) {
            *ResFileNewEE << thisFed << "\t\t" << eedetid.ix() << "\t\t" << eedetid.iy() << "\t\t" << eedetid.zside()
                          << "\t\t" << eedetid.hashedIndex() << "\t\t"
                          << "at gain zero" << std::endl;
          }
        }
      }
    }
  }
}

pedMasking()

void popcon::EcalChannelStatusHandler::pedMasking

(

)

Definition at line 290 of file EcalChannelStatusHandler.cc.

References EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalErrorDictionary::getMask(), EcalLogicID::getName(), visualization-live-secondInstance_cfg::m, EBDetId::SMCRYSTALMODE, and EEDetId::validDetId().

                                                {
  uint64_t bits03 = 0;
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_LOW_GAIN_MEAN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_MIDDLE_GAIN_MEAN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_HIGH_GAIN_MEAN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_LOW_GAIN_MEAN_ERROR");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_MIDDLE_GAIN_MEAN_ERROR");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_HIGH_GAIN_MEAN_ERROR");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_LOW_GAIN_RMS_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_MIDDLE_GAIN_RMS_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_HIGH_GAIN_RMS_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_LOW_GAIN_RMS_ERROR");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_MIDDLE_GAIN_RMS_ERROR");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_HIGH_GAIN_RMS_ERROR");

  std::map<EcalLogicID, RunCrystalErrorsDat> theMask;
  ecalErrorMask_.fetchDataSet(&theMask);

  if (!theMask.empty()) {
    std::map<EcalLogicID, RunCrystalErrorsDat>::const_iterator m;
    for (m = theMask.begin(); m != theMask.end(); m++) {
      EcalLogicID ecid_xt = m->first;
      int sm_num = ecid_xt.getID1();
      int xt_num = ecid_xt.getID2();
      int yt_num = ecid_xt.getID3();

      if ((m->second).getErrorBits() & bits03) {
        if (ecid_xt.getName() == "EB_crystal_number") {
          EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
          maskedPedEB.insert(std::pair<DetId, float>(ebdetid, 9999.));
        } else {
          if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
            EEDetId eedetid(xt_num, yt_num, sm_num);
            maskedPedEE.insert(std::pair<DetId, float>(eedetid, 9999.));
          }
        }
      }
    }
  }
}

pedOnlineMasking()

void popcon::EcalChannelStatusHandler::pedOnlineMasking

(

)

Definition at line 257 of file EcalChannelStatusHandler.cc.

References EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalErrorDictionary::getMask(), EcalLogicID::getName(), visualization-live-secondInstance_cfg::m, EBDetId::SMCRYSTALMODE, and EEDetId::validDetId().

                                                      {
  uint64_t bits03 = 0;
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_ONLINE_HIGH_GAIN_MEAN_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_ONLINE_HIGH_GAIN_RMS_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_ONLINE_HIGH_GAIN_MEAN_ERROR");
  bits03 |= EcalErrorDictionary::getMask("PEDESTAL_ONLINE_HIGH_GAIN_RMS_ERROR");

  std::map<EcalLogicID, RunCrystalErrorsDat> theMask;
  ecalErrorMask_.fetchDataSet(&theMask);

  if (!theMask.empty()) {
    std::map<EcalLogicID, RunCrystalErrorsDat>::const_iterator m;
    for (m = theMask.begin(); m != theMask.end(); m++) {
      EcalLogicID ecid_xt = m->first;
      int sm_num = ecid_xt.getID1();
      int xt_num = ecid_xt.getID2();
      int yt_num = ecid_xt.getID3();

      if ((m->second).getErrorBits() & bits03) {
        if (ecid_xt.getName() == "EB_crystal_number") {
          EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
          maskedOnlinePedEB.insert(std::pair<DetId, float>(ebdetid, 9999.));
        } else {
          if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
            EEDetId eedetid(xt_num, yt_num, sm_num);
            maskedOnlinePedEE.insert(std::pair<DetId, float>(eedetid, 9999.));
          }
        }
      }
    }
  }
}

physicsMasking()

void popcon::EcalChannelStatusHandler::physicsMasking

(

)

Definition at line 366 of file EcalChannelStatusHandler.cc.

References EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalErrorDictionary::getMask(), EcalLogicID::getName(), visualization-live-secondInstance_cfg::m, EBDetId::SMCRYSTALMODE, and EEDetId::validDetId().

                                                    {
  uint64_t bits03 = 0;
  bits03 |= EcalErrorDictionary::getMask("PHYSICS_BAD_CHANNEL_WARNING");
  bits03 |= EcalErrorDictionary::getMask("PHYSICS_BAD_CHANNEL_ERROR");

  std::map<EcalLogicID, RunCrystalErrorsDat> theMask;
  ecalErrorMask_.fetchDataSet(&theMask);

  if (!theMask.empty()) {
    std::map<EcalLogicID, RunCrystalErrorsDat>::const_iterator m;
    for (m = theMask.begin(); m != theMask.end(); m++) {
      EcalLogicID ecid_xt = m->first;
      int sm_num = ecid_xt.getID1();
      int xt_num = ecid_xt.getID2();
      int yt_num = ecid_xt.getID3();

      if ((m->second).getErrorBits() & bits03) {
        if (ecid_xt.getName() == "EB_crystal_number") {
          EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
          maskedPhysicsEB.insert(std::pair<DetId, float>(ebdetid, 9999.));
        } else {
          if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
            EEDetId eedetid(xt_num, yt_num, sm_num);
            maskedPhysicsEE.insert(std::pair<DetId, float>(eedetid, 9999.));
          }
        }
      }
    }
  }
}

setElectronicsMap()

void popcon::EcalChannelStatusHandler::setElectronicsMap

(

const EcalElectronicsMapping *

theEcalElectronicsMap

)

Definition at line 2164 of file EcalChannelStatusHandler.cc.

Referenced by ExTestEcalChannelStatusAnalyzer::endJob().

                                                                                                          {
  ecalElectronicsMap_ = (*theEcalElectronicsMap);
}

Member Data Documentation

daqFile

std::ofstream* popcon::EcalChannelStatusHandler::daqFile

private

Definition at line 135 of file EcalChannelStatusHandler.h.

daqFile2

std::ofstream* popcon::EcalChannelStatusHandler::daqFile2

private

Definition at line 136 of file EcalChannelStatusHandler.h.

ecalElectronicsMap_

EcalElectronicsMapping popcon::EcalChannelStatusHandler::ecalElectronicsMap_

private

Definition at line 129 of file EcalChannelStatusHandler.h.

ecalErrorMask_

EcalErrorMask popcon::EcalChannelStatusHandler::ecalErrorMask_

private

Definition at line 128 of file EcalChannelStatusHandler.h.

econn

EcalCondDBInterface* popcon::EcalChannelStatusHandler::econn

Definition at line 77 of file EcalChannelStatusHandler.h.

isEBRef1

bool popcon::EcalChannelStatusHandler::isEBRef1[36][2]

private

Definition at line 123 of file EcalChannelStatusHandler.h.

isEBRef2

bool popcon::EcalChannelStatusHandler::isEBRef2[36][2]

private

Definition at line 124 of file EcalChannelStatusHandler.h.

isEERef1

bool popcon::EcalChannelStatusHandler::isEERef1[18][2]

private

Definition at line 125 of file EcalChannelStatusHandler.h.

isEERef2

bool popcon::EcalChannelStatusHandler::isEERef2[18][2]

private

Definition at line 126 of file EcalChannelStatusHandler.h.

isGoodLaserEBSm

bool popcon::EcalChannelStatusHandler::isGoodLaserEBSm[36][2]

private

Definition at line 121 of file EcalChannelStatusHandler.h.

isGoodLaserEESm

bool popcon::EcalChannelStatusHandler::isGoodLaserEESm[18][2]

private

Definition at line 122 of file EcalChannelStatusHandler.h.

m_firstRun

unsigned int popcon::EcalChannelStatusHandler::m_firstRun

private

Definition at line 109 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_gentag

std::string popcon::EcalChannelStatusHandler::m_gentag

private

Definition at line 113 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_lastRun

unsigned int popcon::EcalChannelStatusHandler::m_lastRun

private

Definition at line 110 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_location

std::string popcon::EcalChannelStatusHandler::m_location

private

Definition at line 112 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_locationsource

std::string popcon::EcalChannelStatusHandler::m_locationsource

private

Definition at line 118 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_name

std::string popcon::EcalChannelStatusHandler::m_name

private

Definition at line 119 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler(), and id().

m_pass

std::string popcon::EcalChannelStatusHandler::m_pass

private

Definition at line 117 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_runtype

std::string popcon::EcalChannelStatusHandler::m_runtype

private

Definition at line 114 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_sid

std::string popcon::EcalChannelStatusHandler::m_sid

private

Definition at line 115 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

m_user

std::string popcon::EcalChannelStatusHandler::m_user

private

Definition at line 116 of file EcalChannelStatusHandler.h.

Referenced by EcalChannelStatusHandler().

maskedLaserEB

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedLaserEB

private

Definition at line 140 of file EcalChannelStatusHandler.h.

maskedLaserEE

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedLaserEE

private

Definition at line 140 of file EcalChannelStatusHandler.h.

maskedOnlinePedEB

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedOnlinePedEB

private

Definition at line 138 of file EcalChannelStatusHandler.h.

maskedOnlinePedEE

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedOnlinePedEE

private

Definition at line 138 of file EcalChannelStatusHandler.h.

maskedPedEB

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedPedEB

private

Definition at line 139 of file EcalChannelStatusHandler.h.

maskedPedEE

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedPedEE

private

Definition at line 139 of file EcalChannelStatusHandler.h.

maskedPhysicsEB

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedPhysicsEB

private

Definition at line 141 of file EcalChannelStatusHandler.h.

maskedPhysicsEE

std::map<DetId, float> popcon::EcalChannelStatusHandler::maskedPhysicsEE

private

Definition at line 141 of file EcalChannelStatusHandler.h.

newBadEB_

TProfile2D* popcon::EcalChannelStatusHandler::newBadEB_

private

Definition at line 143 of file EcalChannelStatusHandler.h.

newBadEEM_

TProfile2D* popcon::EcalChannelStatusHandler::newBadEEM_

private

Definition at line 145 of file EcalChannelStatusHandler.h.

newBadEEP_

TProfile2D* popcon::EcalChannelStatusHandler::newBadEEP_

private

Definition at line 144 of file EcalChannelStatusHandler.h.

ResFileEB

std::ofstream* popcon::EcalChannelStatusHandler::ResFileEB

private

Definition at line 131 of file EcalChannelStatusHandler.h.

ResFileEE

std::ofstream* popcon::EcalChannelStatusHandler::ResFileEE

private

Definition at line 132 of file EcalChannelStatusHandler.h.

ResFileNewEB

std::ofstream* popcon::EcalChannelStatusHandler::ResFileNewEB

private

Definition at line 133 of file EcalChannelStatusHandler.h.

ResFileNewEE

std::ofstream* popcon::EcalChannelStatusHandler::ResFileNewEE

private

Definition at line 134 of file EcalChannelStatusHandler.h.