#include <HcalDeadCellMonitor.h>

Inheritance diagram for HcalDeadCellMonitor:

Public Member Functions
void	analyze (edm::Event const &e, edm::EventSetup const &s)

void	beginRun (const edm::Run &run, const edm::EventSetup &c)

void	cleanup ()

void	endJob ()

void	endLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)

void	endRun (const edm::Run &run, const edm::EventSetup &c)

	HcalDeadCellMonitor (const edm::ParameterSet &ps)

template<class DIGI >
void	process_Digi (DIGI &digi)

template<class RECHIT >
void	process_RecHit (RECHIT &rechit)

void	processEvent (const HBHERecHitCollection &hbHits, const HORecHitCollection &hoHits, const HFRecHitCollection &hfHits, const HBHEDigiCollection &hbhedigi, const HODigiCollection &hodigi, const HFDigiCollection &hfdigi)

void	reset ()

void	setup ()

	~HcalDeadCellMonitor ()

Public Member Functions inherited from HcalBaseDQMonitor
	HcalBaseDQMonitor (const edm::ParameterSet &ps)

	HcalBaseDQMonitor ()

	~HcalBaseDQMonitor ()

Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()

std::string	workerType () const

virtual	~EDAnalyzer ()

Private Member Functions
void	fillNevents_problemCells ()

void	fillNevents_recentdigis ()

void	fillNevents_recentrechits ()

template<class T >
void	process_Digi (T &digi)

template<class T >
void	process_RecHit (T &rechit)

void	processEvent_HBHEdigi (const HBHEDataFrame digi)

void	zeroCounters (bool resetpresent=false)

Private Attributes
int	alarmer_counter_

int	alarmer_counterHO01_

int	beamMode_

int	deadevt_

bool	deadmon_makeDiagnostics_

bool	deadmon_test_digis_

bool	deadmon_test_rechits_

edm::InputTag	digiLabel_

EtaPhiHists	DigiPresentByDepth

bool	doReset_

bool	endLumiProcessed_

double	energyThreshold_

bool	excludeHO1P02_

bool	excludeHORing2_

MonitorElement *	HBDeadVsEvent

double	HBenergyThreshold_

bool	hbhedcsON

edm::InputTag	hbheRechitLabel_

MonitorElement *	HEDeadVsEvent

double	HEenergyThreshold_

bool	hfdcsON

MonitorElement *	HFDeadVsEvent

double	HFenergyThreshold_

edm::InputTag	hfRechitLabel_

bool	hodcsON

MonitorElement *	HODeadVsEvent

double	HOenergyThreshold_

edm::InputTag	hoRechitLabel_

int	is_RBX_loss_

bool	is_stable_beam

HcalLogicalMap *	logicalMap_

int	minDeadEventCount_

MonitorElement *	Nevents

unsigned int	NumBadHB

unsigned int	NumBadHE

unsigned int	NumBadHF

unsigned int	NumBadHFLUMI

unsigned int	NumBadHO

unsigned int	NumBadHO0

unsigned int	NumBadHO01

unsigned int	NumBadHO12

int	NumBadHO1P02

unsigned int	NumBadHO2

MonitorElement *	NumberOfNeverPresentDigis

MonitorElement *	NumberOfNeverPresentDigisHB

MonitorElement *	NumberOfNeverPresentDigisHE

MonitorElement *	NumberOfNeverPresentDigisHF

MonitorElement *	NumberOfNeverPresentDigisHO

MonitorElement *	NumberOfNeverPresentRecHits

MonitorElement *	NumberOfNeverPresentRecHitsHB

MonitorElement *	NumberOfNeverPresentRecHitsHE

MonitorElement *	NumberOfNeverPresentRecHitsHF

MonitorElement *	NumberOfNeverPresentRecHitsHO

MonitorElement *	NumberOfRecentMissingDigis

MonitorElement *	NumberOfRecentMissingDigisHB

MonitorElement *	NumberOfRecentMissingDigisHE

MonitorElement *	NumberOfRecentMissingDigisHF

MonitorElement *	NumberOfRecentMissingDigisHO

MonitorElement *	NumberOfRecentMissingRecHits

MonitorElement *	NumberOfRecentMissingRecHitsHB

MonitorElement *	NumberOfRecentMissingRecHitsHE

MonitorElement *	NumberOfRecentMissingRecHitsHF

MonitorElement *	NumberOfRecentMissingRecHitsHO

unsigned int	occupancy_RBX [156]

bool	present_digi [85][72][4]

bool	present_rechit [85][72][4]

MonitorElement *	ProblemsInLastNLB_HBHEHF_alarm

MonitorElement *	ProblemsInLastNLB_HO01_alarm

MonitorElement *	ProblemsVsLB

MonitorElement *	ProblemsVsLB_HB

MonitorElement *	ProblemsVsLB_HE

MonitorElement *	ProblemsVsLB_HF

MonitorElement *	ProblemsVsLB_HO

MonitorElement *	ProblemsVsLB_HO2

MonitorElement *	RBX_loss_VS_LB

int	rbxlost [156]

EtaPhiHists	RecentMissingDigisByDepth

EtaPhiHists	RecentMissingRecHitsByDepth

unsigned int	recentoccupancy_digi [85][72][4]

unsigned int	recentoccupancy_rechit [85][72][4]

EtaPhiHists	RecHitPresentByDepth

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

typedef WorkerT< EDAnalyzer >	WorkerType

Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from HcalBaseDQMonitor
virtual void	beginJob ()

virtual void	beginLuminosityBlock (const edm::LuminosityBlock &lumiSeg, const edm::EventSetup &c)

bool	IsAllowedCalibType ()

bool	LumiInOrder (int lumisec)

void	SetupEtaPhiHists (EtaPhiHists &hh, std::string Name, std::string Units)

Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

Protected Attributes inherited from HcalBaseDQMonitor
std::vector< int >	AllowedCalibTypes_

int	badChannelStatusMask_

int	currentLS

int	currenttype_

DQMStore *	dbe_

int	debug_

bool	enableCleanup_

bool	eventAllowed_

bool	HBpresent_

bool	HEpresent_

bool	HFpresent_

bool	HOpresent_

int	ievt_

std::map< unsigned int, int >	KnownBadCells_

int	levt_

bool	makeDiagnostics_

MonitorElement *	meIevt_

MonitorElement *	meLevt_

bool	mergeRuns_

MonitorElement *	meTevt_

MonitorElement *	meTevtHist_

int	NLumiBlocks_

bool	Online_

std::string	prefixME_

MonitorElement *	ProblemsCurrentLB

MonitorElement *	ProblemsVsLB

MonitorElement *	ProblemsVsLB_HB

MonitorElement *	ProblemsVsLB_HBHEHF

MonitorElement *	ProblemsVsLB_HE

MonitorElement *	ProblemsVsLB_HF

MonitorElement *	ProblemsVsLB_HO

bool	skipOutOfOrderLS_

std::string	subdir_

int	tevt_

Detailed Description

Date:: 2012/06/21 13:40:22

Revision:: 1.60

Author: J. Temple - Univ. of Maryland

Definition at line 33 of file HcalDeadCellMonitor.h.

Constructor & Destructor Documentation

HcalDeadCellMonitor::HcalDeadCellMonitor ( const edm::ParameterSet & ps )

Definition at line 4 of file HcalDeadCellMonitor.cc.

 {
   Online_                = ps.getUntrackedParameter<bool>("online",false);
   mergeRuns_             = ps.getUntrackedParameter<bool>("mergeRuns",false);
   enableCleanup_         = ps.getUntrackedParameter<bool>("enableCleanup",false);
   debug_                 = ps.getUntrackedParameter<int>("debug",0);
   makeDiagnostics_       = ps.getUntrackedParameter<bool>("makeDiagnostics",false);
   prefixME_              = ps.getUntrackedParameter<std::string>("subSystemFolder","Hcal/");
   if (prefixME_.substr(prefixME_.size()-1,prefixME_.size())!="/")
     prefixME_.append("/");
   subdir_                = ps.getUntrackedParameter<std::string>("TaskFolder","DeadCellMonitor_Hcal"); // DeadCellMonitor_Hcal
   if (subdir_.size()>0 && subdir_.substr(subdir_.size()-1,subdir_.size())!="/")
     subdir_.append("/");
   subdir_=prefixME_+subdir_;
   AllowedCalibTypes_     = ps.getUntrackedParameter<std::vector<int> > ("AllowedCalibTypes");
   skipOutOfOrderLS_      = ps.getUntrackedParameter<bool>("skipOutOfOrderLS",true);
   NLumiBlocks_           = ps.getUntrackedParameter<int>("NLumiBlocks",4000);
 
   badChannelStatusMask_   = ps.getUntrackedParameter<int>("BadChannelStatusMask",
                                                           ps.getUntrackedParameter<int>("BadChannelStatusMask",
                                             (1<<HcalChannelStatus::HcalCellDead)));  // identify channel status values to mask
   // DeadCell-specific parameters
 
   // Collection type info
   digiLabel_             =ps.getUntrackedParameter<edm::InputTag>("digiLabel");
   hbheRechitLabel_       = ps.getUntrackedParameter<edm::InputTag>("hbheRechitLabel");
   hoRechitLabel_         = ps.getUntrackedParameter<edm::InputTag>("hoRechitLabel");
   hfRechitLabel_         = ps.getUntrackedParameter<edm::InputTag>("hfRechitLabel");
 
   // minimum number of events required for lumi section-based dead cell checks
   minDeadEventCount_    = ps.getUntrackedParameter<int>("minDeadEventCount",1000);
   excludeHORing2_       = ps.getUntrackedParameter<bool>("excludeHORing2",false);
   excludeHO1P02_        = ps.getUntrackedParameter<bool>("excludeHO1P02",false);
   endLumiProcessed_     = false;
 
   // Set which dead cell checks will be performed
   /* Dead cells can be defined in the following ways:
      1)  never present digi -- digi is never present in run
      2)  digis -- digi is absent for one or more lumi section 
      3)  never present rechit -- rechit > threshold energy never present (NOT redundant, since it requires not just that a rechit be present, but that it be above threshold as well.  )
      4)  rechits -- rechit is present, but rechit energy below threshold for one or more lumi sections
 
      Of these tests, never-present digis are always checked.
      Occasional digis are checked only if deadmon_test_digis_ is true,
      and both rechit tests are made only if deadmon_test_rechits_ is true
   */
   
   deadmon_test_digis_              = ps.getUntrackedParameter<bool>("test_digis",true);
   deadmon_test_rechits_            = ps.getUntrackedParameter<bool>("test_rechits",false);
 
   // rechit energy test -- cell must be below threshold value for a number of consecutive events to be considered dead
   energyThreshold_       = ps.getUntrackedParameter<double>("MissingRechitEnergyThreshold",0);
   HBenergyThreshold_     = ps.getUntrackedParameter<double>("HB_energyThreshold",energyThreshold_);
   HEenergyThreshold_     = ps.getUntrackedParameter<double>("HE_energyThreshold",energyThreshold_);
   HOenergyThreshold_     = ps.getUntrackedParameter<double>("HO_energyThreshold",energyThreshold_);
   HFenergyThreshold_     = ps.getUntrackedParameter<double>("HF_energyThreshold",energyThreshold_);
 
   HcalLogicalMapGenerator gen;
   logicalMap_=new HcalLogicalMap(gen.createMap());
 } //constructor

HcalDeadCellMonitor::~HcalDeadCellMonitor ( )

Definition at line 65 of file HcalDeadCellMonitor.cc.

References logicalMap_.

 {
   if (logicalMap_ == 0) delete logicalMap_;
 } //destructor

Member Function Documentation

void HcalDeadCellMonitor::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	s
	)

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 611 of file HcalDeadCellMonitor.cc.

References HcalBaseDQMonitor::analyze(), L1GtfeExtWord::beamMode(), gather_cfg::cout, deadevt_, HcalBaseDQMonitor::debug_, digiLabel_, doReset_, endLumiProcessed_, MonitorElement::Fill(), edm::Event::getByLabel(), DcsStatus::HBHEa, DcsStatus::HBHEb, DcsStatus::HBHEc, hbhedcsON, hbheRechitLabel_, DcsStatus::HF, hfdcsON, hfRechitLabel_, DcsStatus::HO, hodcsON, hoRechitLabel_, i, HcalBaseDQMonitor::ievt_, is_RBX_loss_, is_stable_beam, HcalBaseDQMonitor::IsAllowedCalibType(), edm::HandleBase::isValid(), HcalBaseDQMonitor::levt_, HcalBaseDQMonitor::LumiInOrder(), edm::EventBase::luminosityBlock(), Nevents, occupancy_RBX, processEvent(), edm::Handle< T >::product(), rbxlost, reset(), HcalBaseDQMonitor::tevt_, L1GtfeExtWord::totalIntensityBeam1(), and L1GtfeExtWord::totalIntensityBeam2().

 {
   if (!IsAllowedCalibType()) return;
   endLumiProcessed_=false;
 
   if(doReset_) 
     this->reset();
 
   Nevents->Fill(0,1); // count all events of allowed calibration type, even if their lumi block is not in the right order
   if (LumiInOrder(e.luminosityBlock())==false) return;
   // try to get rechits and digis
   edm::Handle<HBHEDigiCollection> hbhe_digi;
   edm::Handle<HODigiCollection> ho_digi;
   edm::Handle<HFDigiCollection> hf_digi;
 
   edm::Handle<HBHERecHitCollection> hbhe_rechit;
   edm::Handle<HORecHitCollection> ho_rechit;
   edm::Handle<HFRecHitCollection> hf_rechit;
 
   edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvm_handle;
  
   // check if detectors whether they were ON
   edm::Handle<DcsStatusCollection> dcsStatus;
   e.getByLabel("scalersRawToDigi", dcsStatus);
   
   if (dcsStatus.isValid() && dcsStatus->size() != 0) 
     {      
       if ((*dcsStatus)[0].ready(DcsStatus::HBHEa) &&
       (*dcsStatus)[0].ready(DcsStatus::HBHEb) &&   
       (*dcsStatus)[0].ready(DcsStatus::HBHEc))
     {   
       hbhedcsON = true;
       if (debug_) std::cout << "hbhe on" << std::endl;
     } 
       else hbhedcsON = false;
 
       if ((*dcsStatus)[0].ready(DcsStatus::HF))
     {
       hfdcsON = true;
       if (debug_) std::cout << "hf on" << std::endl;
     } 
       else hfdcsON = false;
       
       if ((*dcsStatus)[0].ready(DcsStatus::HO))
     {
       hodcsON = true;
       if (debug_) std::cout << "ho on" << std::endl;
     } 
       else hodcsON = false;     
     }
 
   if (!(e.getByLabel(digiLabel_,hbhe_digi)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< digiLabel_<<" hbhe_digi not available";
       return;
     }
   if (!(e.getByLabel(digiLabel_,ho_digi)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< digiLabel_<<" ho_digi not available";
       return;
     }
   if (!(e.getByLabel(digiLabel_,hf_digi)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< digiLabel_<<" hf_digi not available";
       return;
     }
 
   if (!(e.getByLabel(hbheRechitLabel_,hbhe_rechit)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< hbheRechitLabel_<<" hbhe_rechit not available";
       return;
     }
 
   if (!(e.getByLabel(hfRechitLabel_,hf_rechit)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< hfRechitLabel_<<" hf_rechit not available";
       return;
     }
   if (!(e.getByLabel(hoRechitLabel_,ho_rechit)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< hoRechitLabel_<<" ho_rechit not available";
       return;
     }
   if (!(e.getByLabel("gtEvmDigis", gtEvm_handle)))
     {
       edm::LogWarning("HcalDeadCellMonitor")<< "gtEvmDigis"<<" gtEvmDigis not available";
       return;
     }
   L1GtfeExtWord gtfeEvmExtWord = gtEvm_handle.product()->gtfeWord();
 
   if (debug_>1) std::cout <<"\t<HcalDeadCellMonitor::analyze>  Processing good event! event # = "<<ievt_<<std::endl;
   // Good event found; increment counter (via base class analyze method)
   // This also runs the allowed calibration /lumi in order tests again;  remove?
   HcalBaseDQMonitor::analyze(e,s);
   
   ++deadevt_; //increment local counter
   
   processEvent(*hbhe_rechit, *ho_rechit, *hf_rechit, *hbhe_digi, *ho_digi, *hf_digi);
       
   // check for presence of an RBX data loss
   if(levt_>10 && tevt_ % 10 == 0 ) //levt_ counts events perLS, but excludes 
     {                              //"wrong", calibration-type events. Compare with tevt_ instead...            
       for(int i=71; i<132; i++)
     {
       // These RBXs in HO are excluded, set to 1 to ignore
       // HO0: 96-107 (all)
       // HO1: 85-95, 109-119 (all odd)
       // HO2: 73, 75, 79, 81, 83, 121-131 (all odd)   
       if(i >= 72 && i < 95 && i%2==0)
         occupancy_RBX[i] = 1;
       if(i >=108 && i <= 131 && i%2==0)
         occupancy_RBX[i] = 1;
 
       if(i==117 || i==131) // HO SiPMs have much less hits, 10 events not enough. 
         occupancy_RBX[i] = 1;  // Also no RBX loss for SiPMs, so ignore for now.
       if(i==77)
         occupancy_RBX[i] = 1; 
     }
       
       // RBX loss detected
       for (unsigned int i=0;i<132;++i)
     if(occupancy_RBX[i] == 0) 
       {
         is_RBX_loss_ = 1;
         rbxlost[i] = 1;
       }
       
       int intensity1_ = gtfeEvmExtWord.totalIntensityBeam1();
       int intensity2_ = gtfeEvmExtWord.totalIntensityBeam2();
       
       is_stable_beam = gtfeEvmExtWord.beamMode() == 11 ? true : false; 
       
       for (unsigned int i=132;i<156;++i)
     if(occupancy_RBX[i] == 0 && gtfeEvmExtWord.beamMode() == 11) 
       if(intensity1_>100 && intensity2_>100)                     // only in stable beam mode (11) and with circulating beams, otherwise 
       {                                                          // this check is too sensitive in HF
         is_RBX_loss_ = 1;
         rbxlost[i] = 1;
       }
       
       // no RBX loss, reset the counters
       if (is_RBX_loss_ == 0)
     for (unsigned int i=0;i<156;++i)
       occupancy_RBX[i] = 0;
     }
 
   // if RBX is lost any time during the LS, don't allow the counters to increment
   if(is_RBX_loss_ == 1)
     for (unsigned int i=0;i<156;++i)
       if(rbxlost[i]==1) occupancy_RBX[i] = 0;
 
 } // void HcalDeadCellMonitor::analyze(...)

void HcalDeadCellMonitor::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 372 of file HcalDeadCellMonitor.cc.

References HcalBaseDQMonitor::badChannelStatusMask_, HcalBaseDQMonitor::beginRun(), gather_cfg::cout, HcalBaseDQMonitor::debug_, doReset_, edm::EventSetup::get(), HcalCondObjectContainer< Item >::getAllChannels(), reco::JetExtendedAssociation::getValue(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, i, HcalBaseDQMonitor::KnownBadCells_, HcalBaseDQMonitor::mergeRuns_, AlCaHLTBitMon_ParallelJobs::p, edm::ESHandle< class >::product(), reset(), setup(), ntuplemaker::status, and HcalBaseDQMonitor::tevt_.

 {
   if (debug_>1) std::cout <<"HcalDeadCellMonitor::beginRun"<<std::endl;
   HcalBaseDQMonitor::beginRun(run,c);
 
   if (tevt_==0) this->setup(); // set up histograms if they have not been created before
   if (mergeRuns_==false)
     this->reset();
 
   doReset_ = true;
 
   // Get known dead cells for this run
   KnownBadCells_.clear();
   if (badChannelStatusMask_>0)
     {
       edm::ESHandle<HcalChannelQuality> p;
       c.get<HcalChannelQualityRcd>().get(p);
       HcalChannelQuality* chanquality= new HcalChannelQuality(*p.product());
       std::vector<DetId> mydetids = chanquality->getAllChannels();
       for (std::vector<DetId>::const_iterator i = mydetids.begin();
        i!=mydetids.end();
        ++i)
     {
       if (i->det()!=DetId::Hcal) continue; // not an hcal cell
       HcalDetId id=HcalDetId(*i);
       int status=(chanquality->getValues(id))->getValue();
       if ((status & badChannelStatusMask_))
         KnownBadCells_[id.rawId()]=status;
     } 
       delete chanquality;
     } // if (badChannelStatusMask_>0)
   return;
 } //void HcalDeadCellMonitor::beginRun(...)

void HcalDeadCellMonitor::cleanup ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 484 of file HcalDeadCellMonitor.cc.

References HcalBaseDQMonitor::dbe_, HcalBaseDQMonitor::enableCleanup_, DQMStore::removeContents(), DQMStore::setCurrentFolder(), and HcalBaseDQMonitor::subdir_.

Referenced by endJob().

 {
   if (!enableCleanup_) return;
   if (dbe_)
     {
       dbe_->setCurrentFolder(subdir_);
       dbe_->removeContents();
       dbe_->setCurrentFolder(subdir_+"dead_digi_never_present");
       dbe_->removeContents();
       dbe_->setCurrentFolder(subdir_+"dead_digi_often_missing");
       dbe_->removeContents();
       dbe_->setCurrentFolder(subdir_+"dead_rechit_neverpresent");
       dbe_->removeContents();
       dbe_->setCurrentFolder(subdir_+"dead_rechit_often_missing");
       dbe_->removeContents();
       dbe_->setCurrentFolder(subdir_+"dead_cell_parameters");
       dbe_->removeContents();
       dbe_->setCurrentFolder(subdir_+"LSvalues");
       dbe_->removeContents();
     }
   return;
 } // void HcalDeadCellMonitor::cleanup()

void HcalDeadCellMonitor::endJob ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 605 of file HcalDeadCellMonitor.cc.

References cleanup(), gather_cfg::cout, HcalBaseDQMonitor::debug_, and HcalBaseDQMonitor::enableCleanup_.

 {
   if (debug_>0) std::cout <<"HcalDeadCellMonitor::endJob()"<<std::endl;
   if (enableCleanup_) cleanup(); // when do we force cleanup?
 }

void HcalDeadCellMonitor::endLuminosityBlock	(	const edm::LuminosityBlock &	lumiSeg,
		const edm::EventSetup &	c
	)

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 509 of file HcalDeadCellMonitor.cc.

References alarmer_counter_, alarmer_counterHO01_, beamMode_, deadevt_, endLumiProcessed_, fillNevents_problemCells(), fillNevents_recentdigis(), fillNevents_recentrechits(), hbhedcsON, HcalBaseDQMonitor::HBpresent_, HcalBaseDQMonitor::HEpresent_, hfdcsON, HcalBaseDQMonitor::HFpresent_, hodcsON, HcalBaseDQMonitor::HOpresent_, i, is_RBX_loss_, is_stable_beam, HcalBaseDQMonitor::levt_, HcalBaseDQMonitor::LumiInOrder(), edm::LuminosityBlockBase::luminosityBlock(), minDeadEventCount_, NumBadHB, NumBadHE, NumBadHF, NumBadHFLUMI, NumBadHO, NumBadHO0, NumBadHO12, HcalBaseDQMonitor::ProblemsCurrentLB, ProblemsInLastNLB_HBHEHF_alarm, ProblemsInLastNLB_HO01_alarm, rbxlost, MonitorElement::Reset(), MonitorElement::setBinContent(), and zeroCounters().

 {
   // skip old lumi sections
   if (this->LumiInOrder(lumiSeg.luminosityBlock())==false) return;
 
   // Reset current LS histogram
   if (ProblemsCurrentLB)
       ProblemsCurrentLB->Reset();
 
   ProblemsInLastNLB_HBHEHF_alarm->Reset();
   ProblemsInLastNLB_HO01_alarm->Reset();
 
   //increase the number of LS counting, for alarmer. Only make alarms for HBHE
   if(hbhedcsON == true && hfdcsON == true && HBpresent_ == 1 && HEpresent_ == 1 && HFpresent_ == 1)
     ++alarmer_counter_;
   else 
     alarmer_counter_ = 0;
 
   if(hodcsON==true && HOpresent_ == 1)
     ++alarmer_counterHO01_;
   else 
     alarmer_counterHO01_ = 0;
 
   if (!is_stable_beam)
     {
       alarmer_counter_ = 0;
       alarmer_counterHO01_ = 0;
     }
 
   // Here is where we determine whether or not to process an event
   // Not enough events
   // there are less than minDeadEventCount_ in this LS, but RBXloss is found
   
   if (deadevt_>=10 && deadevt_<minDeadEventCount_ && is_RBX_loss_==1)
     {
       fillNevents_problemCells();
       fillNevents_recentrechits();
       fillNevents_recentdigis();
             
       endLumiProcessed_=true;
       is_RBX_loss_=0;
 
       for (unsigned int i=0;i<156;++i)
     rbxlost[i] = 0;
 
       if (ProblemsCurrentLB)
     {
       ProblemsCurrentLB->setBinContent(0,0, levt_);  // underflow bin contains number of events
       ProblemsCurrentLB->setBinContent(1,1, NumBadHB*levt_);
       ProblemsCurrentLB->setBinContent(2,1, NumBadHE*levt_);
       ProblemsCurrentLB->setBinContent(3,1, NumBadHO*levt_);
       ProblemsCurrentLB->setBinContent(4,1, NumBadHF*levt_);
       ProblemsCurrentLB->setBinContent(5,1, NumBadHO0*levt_);
       ProblemsCurrentLB->setBinContent(6,1, NumBadHO12*levt_);
       ProblemsCurrentLB->setBinContent(7,1, NumBadHFLUMI*levt_);
     }
     }
 
   if (deadevt_<minDeadEventCount_) // perform normal tasks, since no RBX loss is detected in this lumisections
       return;
     
   endLumiProcessed_=true;
   // fillNevents_problemCells checks for never-present cells
   fillNevents_problemCells();
   fillNevents_recentdigis();
   fillNevents_recentrechits();
 
   if (ProblemsCurrentLB)
     {
       ProblemsCurrentLB->setBinContent(0,0, levt_);  // underflow bin contains number of events
       ProblemsCurrentLB->setBinContent(1,1, NumBadHB*levt_);
       ProblemsCurrentLB->setBinContent(2,1, NumBadHE*levt_);
       ProblemsCurrentLB->setBinContent(3,1, NumBadHO*levt_);
       ProblemsCurrentLB->setBinContent(4,1, NumBadHF*levt_);
       ProblemsCurrentLB->setBinContent(5,1, NumBadHO0*levt_);
       ProblemsCurrentLB->setBinContent(6,1, NumBadHO12*levt_);
       ProblemsCurrentLB->setBinContent(7,1, NumBadHFLUMI*levt_);
     }
   zeroCounters();
   deadevt_=0;
   is_RBX_loss_=0;
   beamMode_ = 0;
   return;
 } //endLuminosityBlock()

void HcalDeadCellMonitor::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	c
	)

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 595 of file HcalDeadCellMonitor.cc.

References endLumiProcessed_, and fillNevents_problemCells().

 {
   // Always carry out overall occupancy test at endRun, regardless minimum number of events?  
   // Or should we require an absolute lower bound?
   // We can always run this test; we'll use the summary client to implement a lower bound before calculating reportSummary values
   if (endLumiProcessed_==false) fillNevents_problemCells(); // always check for never-present cells
 
   return;
 }

void HcalDeadCellMonitor::fillNevents_problemCells ( )

private

Definition at line 1224 of file HcalDeadCellMonitor.cc.

Referenced by endLuminosityBlock(), and endRun().

 {
   //fillNevents_problemCells now only performs checks of never-present cells
 
   if (debug_>0)
     std::cout <<"<HcalDeadCellMonitor::fillNevents_problemCells> FILLING PROBLEM CELL PLOTS"<<std::endl;
 
   int ieta=0;
   int iphi=0;
 
   // Count problem cells in each subdetector
 
   NumBadHB=0;
   NumBadHE=0;
   NumBadHO=0;
   NumBadHF=0;
   NumBadHFLUMI=0;
   NumBadHO01=0;
   NumBadHO2=0;
   NumBadHO12=0;
   NumBadHO1P02=0;
   
   int knownBadHB=0;
   int knownBadHE=0;
   int knownBadHF=0;
   int knownBadHO=0;
   int knownBadHFLUMI=0;
   int knownBadHO01=0;
   int knownBadHO2=0;
   int knownBadHO12=0;
 
 
   unsigned int neverpresentHB=0;
   unsigned int neverpresentHE=0;
   unsigned int neverpresentHO=0;
   unsigned int neverpresentHF=0;
   
   unsigned int unoccupiedHB=0;
   unsigned int unoccupiedHE=0;
   unsigned int unoccupiedHO=0;
   unsigned int unoccupiedHF=0;
     
   unsigned int belowenergyHB=0;
   unsigned int belowenergyHE=0;
   unsigned int belowenergyHO=0;
   unsigned int belowenergyHF=0;
   
   unsigned int energyneverpresentHB=0;
   unsigned int energyneverpresentHE=0;
   unsigned int energyneverpresentHO=0;
   unsigned int energyneverpresentHF=0;
 
   if (deadevt_>=minDeadEventCount_)
     Nevents->Fill(1,deadevt_);
 
   int etabins=0;
   int phibins=0;
 
   // Store values for number of bad channels in each lumi section, for plots of ProblemsVsLS.
   // This is different than the NumBadHB, etc. values, which must included even known bad channels 
   // in order to calculate reportSummaryByLS values correctly.
 
   //Check for RBX data loss
   unsigned int RBX_loss_HB=0;
   unsigned int RBX_loss_HE=0;
   unsigned int RBX_loss_HO01=0;
   unsigned int RBX_loss_HO2=0;
   unsigned int RBX_loss_HF=0;
 
   unsigned int counter_HB = 0;
   unsigned int counter_HE = 0;
   unsigned int counter_HO01 = 0;
   unsigned int counter_HO2 = 0;
   unsigned int counter_HF = 0;
 
   for(int i=0; i<156; i++)
     {
       if(occupancy_RBX[i]==0 && is_RBX_loss_ == 1)
     {
       if(i<=35)            //HB
         { counter_HB ++ ; RBX_loss_HB = 72*(counter_HB); }
       if(i>=36 && i<=71)   //HE
         { counter_HE ++ ; RBX_loss_HE = 72*(counter_HE); }
       if(i>=85 && i<=119) // HO Rings 0, 1
         { counter_HO01 ++ ; RBX_loss_HO01 = 72*(counter_HO01); }
       if(i>=121 || i<=83) // HO Ring 2
         { counter_HO2 ++ ; RBX_loss_HO2 = 72*(counter_HO2); }
       if(i>=132 && i<=155)  //HF
         { counter_HF ++ ; RBX_loss_HF = 72*(counter_HF); }
       
       if(excludeHO1P02_==true && i==109) NumBadHO1P02 = 72; // exclude HO1P02
     }      
       if(occupancy_RBX[i]>0)
     RBX_loss_VS_LB->Fill(currentLS, i, 0);
       if(occupancy_RBX[i]==0 && is_RBX_loss_ == 1)
     RBX_loss_VS_LB->Fill(currentLS, i, 1);      
     }  
   
   if (deadevt_ >= 10 && deadevt_<minDeadEventCount_) // maybe not enough events to run the standard test
     if( is_RBX_loss_ == 1 )                          // but enough to detect RBX loss
       { 
     NumBadHB+=RBX_loss_HB;
     NumBadHE+=RBX_loss_HE;
     NumBadHO+=RBX_loss_HO01+RBX_loss_HO2;
     NumBadHO01+=RBX_loss_HO01;
     NumBadHO2+=RBX_loss_HO2;
     NumBadHF+=RBX_loss_HF;
 
     belowenergyHB+=RBX_loss_HB;
     belowenergyHE+=RBX_loss_HE;
     belowenergyHO+=RBX_loss_HO01+RBX_loss_HO2;
     belowenergyHF+=RBX_loss_HF;
 
     unoccupiedHB+=RBX_loss_HB;
     unoccupiedHE+=RBX_loss_HE;
     unoccupiedHO+=RBX_loss_HO01+RBX_loss_HO2;
     unoccupiedHF+=RBX_loss_HF;
       }
 
   for (unsigned int depth=0;depth<DigiPresentByDepth.depth.size();++depth)
     {
       DigiPresentByDepth.depth[depth]->setBinContent(0,0,ievt_); 
       etabins=DigiPresentByDepth.depth[depth]->getNbinsX();
       phibins=DigiPresentByDepth.depth[depth]->getNbinsY();
       for (int eta=0;eta<etabins;++eta)
     {
       for (int phi=0;phi<phibins;++phi)
         {
           iphi=phi+1;
           for (int subdet=1;subdet<=4;++subdet)
         {
           ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
           if (ieta==-9999) continue;
           if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
             continue;
           // Ignore subdetectors that weren't in run?
           /*
                   if ((subdet==HcalBarrel && !HBpresent_) || 
               (subdet==HcalEndcap &&!HEpresent_)  ||
               (subdet==HcalOuter &&!HOpresent_)  ||
               (subdet==HcalForward &&!HFpresent_))   continue;
           */
           
           /*
           if ((!checkHB_ && subdet==HcalBarrel) ||
               (!checkHE_ && subdet==HcalEndcap) ||
               (!checkHO_ && subdet==HcalOuter) ||
               (!checkHF_ && subdet==HcalForward))  continue;
           */
 
           // now check which dead cell tests failed; increment counter if any failed
           if ((present_digi[eta][phi][depth]==0) ||
               (deadmon_test_digis_ && recentoccupancy_digi[eta][phi][depth]==0 && (deadevt_>=minDeadEventCount_)) ||
               (deadmon_test_rechits_ && recentoccupancy_rechit[eta][phi][depth]==0  && (deadevt_>=minDeadEventCount_))
               )
             {
               HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
               if (subdet==HcalBarrel)      
             { 
               ++NumBadHB;
               if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
                 ++knownBadHB;
             }
               else if (subdet==HcalEndcap) 
             {
               ++NumBadHE;
               if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
                 ++knownBadHE;
             }
 
               else if (subdet==HcalOuter)  
             {
               ++NumBadHO;
               if (abs(ieta)<=10) ++NumBadHO01;
               else ++NumBadHO2;
               // Don't include HORing2 if boolean set; subtract away those counters
               if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
                 {
                   --NumBadHO;
                   --NumBadHO2;
                   --NumBadHO12;
                 }             
               // Don't include HO1P02 if boolean set, RBX does not repsond well to resets,; subtract away those counters
               if (excludeHO1P02_==true && ( (ieta>4 && ieta<10) && (iphi<=10 || iphi>70) ) )
                 ++NumBadHO1P02;
 
               if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
                 {
                   ++knownBadHO;
                   if (abs(ieta)<=10) ++knownBadHO01;
                   else ++knownBadHO2;
                   // Don't include HORing2 if boolean set; subtract away those counters
                   if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
                 {
                   --knownBadHO;
                   --knownBadHO12;
                 }
                 }
             }
               else if (subdet==HcalForward)
             {
               ++NumBadHF;
               if (depth==1 && (abs(ieta)==33 || abs(ieta)==34))
                 ++NumBadHFLUMI;
               else if (depth==2 && (abs(ieta)==35 || abs(ieta)==36))
                 ++NumBadHFLUMI;
               if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end())
                 {
                   ++knownBadHF;
                   if (depth==1 && (abs(ieta)==33 || abs(ieta)==34))
                 ++knownBadHFLUMI;
                   else if (depth==2 && (abs(ieta)==35 || abs(ieta)==36))
                 ++knownBadHFLUMI;
                 }
             }
             }
           if (present_digi[eta][phi][depth]==0 )
             {
               if (subdet==HcalBarrel) ++neverpresentHB;
               else if (subdet==HcalEndcap) ++neverpresentHE;
               else if (subdet==HcalOuter) 
             {
               ++neverpresentHO;
               if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
                 --neverpresentHO;
             }
               else if (subdet==HcalForward) ++neverpresentHF;
             }
           // Count recent unoccupied digis if the total events in this lumi section is > minEvents_
           if (deadmon_test_digis_ && recentoccupancy_digi[eta][phi][depth]==0 && deadevt_>=minDeadEventCount_)
             {
               HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
               if (subdet==HcalBarrel) ++unoccupiedHB;
               else if (subdet==HcalEndcap) ++unoccupiedHE;
               else if (subdet==HcalOuter) 
             {
               ++unoccupiedHO;
               if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
                 --unoccupiedHO;
               if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end() && abs(ieta)<=10)
                 --unoccupiedHO;
             }
               else if (subdet==HcalForward) ++unoccupiedHF;
             }
           // Look at rechit checks
           if (deadmon_test_rechits_)
             {
               if (present_rechit[eta][phi][depth]==0)
             {
               if (subdet==HcalBarrel) ++energyneverpresentHB;
               else if (subdet==HcalEndcap) ++energyneverpresentHE;
               else if (subdet==HcalOuter) 
                 {
                   ++energyneverpresentHO;
                   if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
                 --energyneverpresentHO; 
                 }
               else if (subdet==HcalForward) ++energyneverpresentHF;
             }
               if (recentoccupancy_rechit[eta][phi][depth]==0 && deadevt_>=minDeadEventCount_)
             {
               HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
               if (subdet==HcalBarrel) ++belowenergyHB;
               else if (subdet==HcalEndcap) ++belowenergyHE;
               else if (subdet==HcalOuter) 
                 {
                   ++belowenergyHO;
                   if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
                 --belowenergyHO;
                   if (KnownBadCells_.find(TempID.rawId())!=KnownBadCells_.end() && abs(ieta)<=10)
                     --belowenergyHO;
                 }
               else if (subdet==HcalForward) ++belowenergyHF;
             }
             }
         } // subdet loop
         } // phi loop
     } //eta loop
     } // depth loop
 
   // Fill with number of problem cells found on this pass
   NumberOfNeverPresentDigisHB->Fill(currentLS,neverpresentHB);
   NumberOfNeverPresentDigisHE->Fill(currentLS,neverpresentHE);
   NumberOfNeverPresentDigisHO->Fill(currentLS,neverpresentHO);
   NumberOfNeverPresentDigisHF->Fill(currentLS,neverpresentHF);
   NumberOfNeverPresentDigis->Fill(currentLS,neverpresentHB+neverpresentHE+neverpresentHO+neverpresentHF);
 
   if (deadevt_>=minDeadEventCount_ && is_RBX_loss_ == 1 )
     {
       if( NumBadHB<RBX_loss_HB )
     NumBadHB+=RBX_loss_HB;
       if( NumBadHE<RBX_loss_HE )
     NumBadHE+=RBX_loss_HE;
       if( NumBadHO01<RBX_loss_HO01 )
     NumBadHO01+=RBX_loss_HO01;
       if( NumBadHO2<RBX_loss_HO2 )
     NumBadHO2+=RBX_loss_HO2;
       if( NumBadHF<RBX_loss_HF )
     NumBadHF+=RBX_loss_HF;
 
       if( belowenergyHB<RBX_loss_HB )
     belowenergyHB+=RBX_loss_HB;
       if( belowenergyHE<RBX_loss_HE )
     belowenergyHE+=RBX_loss_HE;
       if( belowenergyHO<RBX_loss_HO01+RBX_loss_HO2)
     belowenergyHO+=RBX_loss_HO01+RBX_loss_HO2;
       if( belowenergyHF<RBX_loss_HF )
     belowenergyHF+=RBX_loss_HF;
 
       if( unoccupiedHB<RBX_loss_HB )
     unoccupiedHB+=RBX_loss_HB;
       if( unoccupiedHE<RBX_loss_HE )
     unoccupiedHE+=RBX_loss_HE;
       if( unoccupiedHO<RBX_loss_HO01+RBX_loss_HO2 )
     unoccupiedHO+=RBX_loss_HO01+RBX_loss_HO2;
       if( unoccupiedHF<RBX_loss_HF )
     unoccupiedHF+=RBX_loss_HF;
 
       // is_RBX_loss_ = 0;
     }
 
   ProblemsVsLB_HB->Fill(currentLS,NumBadHB-knownBadHB+0.0001); // add a small offset, so that the histograms reset when no errors follow
   ProblemsVsLB_HE->Fill(currentLS,NumBadHE-knownBadHE+0.0001); // problematic LSs
   ProblemsVsLB_HO->Fill(currentLS,NumBadHO01-knownBadHO01+0.0001);
   ProblemsVsLB_HO2->Fill(currentLS,NumBadHO2-knownBadHO2+0.0001);
   ProblemsVsLB_HF->Fill(currentLS,NumBadHF-knownBadHF+0.0001);
   ProblemsVsLB_HBHEHF->Fill(currentLS,NumBadHB+NumBadHE+NumBadHF-knownBadHB-knownBadHE-knownBadHF+0.0001);
   ProblemsVsLB->Fill(currentLS,NumBadHB+NumBadHE+NumBadHO01+NumBadHO2+NumBadHF-knownBadHB-knownBadHE-knownBadHO01-knownBadHO2-knownBadHF+0.0001);
   
   if(excludeHO1P02_==true)
     ProblemsVsLB_HO->Fill(0, NumBadHO1P02);
 
   if( NumBadHB+NumBadHE+NumBadHF-knownBadHB-knownBadHE-knownBadHF < 30 )    
     alarmer_counter_ = 0;
   if( NumBadHO01-knownBadHO01 < 30 )    
     alarmer_counterHO01_ = 0;
     
   if( alarmer_counter_ >= 10 )
     ProblemsInLastNLB_HBHEHF_alarm->Fill( std::min(int(NumBadHB+NumBadHE+NumBadHF-knownBadHB-knownBadHE-knownBadHF), 99) );
   if( alarmer_counterHO01_ >= 10 )
     ProblemsInLastNLB_HO01_alarm->Fill( std::min(int(NumBadHO01-knownBadHO01), 99) );
 
   // if (deadevt_<minDeadEventCount_)
   //   return;
     
   if (deadmon_test_digis_)
     {
       NumberOfRecentMissingDigisHB->Fill(currentLS,unoccupiedHB);
       NumberOfRecentMissingDigisHE->Fill(currentLS,unoccupiedHE);
       NumberOfRecentMissingDigisHO->Fill(currentLS,unoccupiedHO);
       NumberOfRecentMissingDigisHF->Fill(currentLS,unoccupiedHF);
       NumberOfRecentMissingDigis->Fill(currentLS,unoccupiedHB+unoccupiedHE+unoccupiedHO+unoccupiedHF);
     }
 
   if (deadmon_test_rechits_)
     {
       NumberOfNeverPresentRecHitsHB->Fill(currentLS,energyneverpresentHB);
       NumberOfNeverPresentRecHitsHE->Fill(currentLS,energyneverpresentHE);
       NumberOfNeverPresentRecHitsHO->Fill(currentLS,energyneverpresentHO);
       NumberOfNeverPresentRecHitsHF->Fill(currentLS,energyneverpresentHF);
       NumberOfNeverPresentRecHits->Fill(currentLS,energyneverpresentHB+energyneverpresentHE+energyneverpresentHO+energyneverpresentHF);
       
       NumberOfRecentMissingRecHitsHB->Fill(currentLS,belowenergyHB);
       NumberOfRecentMissingRecHitsHE->Fill(currentLS,belowenergyHE);
       NumberOfRecentMissingRecHitsHO->Fill(currentLS,belowenergyHO);
       NumberOfRecentMissingRecHitsHF->Fill(currentLS,belowenergyHF);
       NumberOfRecentMissingRecHits->Fill(currentLS,belowenergyHB+belowenergyHE+belowenergyHO+belowenergyHF);
     }
 
   return;
 } // void HcalDeadCellMonitor::fillNevents_problemCells(void)

void HcalDeadCellMonitor::fillNevents_recentdigis ( )

private

Definition at line 1007 of file HcalDeadCellMonitor.cc.

References abs, HcalObjRepresent::CalcIeta(), gather_cfg::cout, deadevt_, deadmon_test_digis_, HcalBaseDQMonitor::debug_, EtaPhiHists::depth, eta(), excludeHORing2_, HcalObjRepresent::FillUnphysicalHEHFBins(), HcalLogicalMap::getHcalFrontEndId(), HcalForward, HcalBaseDQMonitor::ievt_, getHLTprescales::index, is_RBX_loss_, isSiPM(), logicalMap_, minDeadEventCount_, occupancy_RBX, phi, present_digi, HcalFrontEndId::rbxIndex(), RecentMissingDigisByDepth, recentoccupancy_digi, and validDetId().

Referenced by endLuminosityBlock().

 {
   // Fill Histograms showing digi cells with no occupancy for the past few lumiblocks
   if (!deadmon_test_digis_) return; // extra protection here against calling histograms than don't exist
 
   if (debug_>0)
     std::cout <<"<HcalDeadCellMonitor::fillNevents_recentdigis> CHECKING FOR RECENT MISSING DIGIS   evtcount = "<<deadevt_<<std::endl;
 
   int ieta=0;
   int iphi=0;
 
   int etabins=0;
   int phibins=0;
 
   if ((deadevt_ >= 10 && deadevt_<minDeadEventCount_) || (deadevt_ >= 10 && is_RBX_loss_==1)) // maybe not enough events to run the standard test
     // if( is_RBX_loss_ == 1 )                          // but enough to detect RBX loss
       for (unsigned int depth=0;depth<RecentMissingDigisByDepth.depth.size();++depth)
     {
       RecentMissingDigisByDepth.depth[depth]->setBinContent(0,0,ievt_);
       etabins=RecentMissingDigisByDepth.depth[depth]->getNbinsX();
       phibins=RecentMissingDigisByDepth.depth[depth]->getNbinsY();      
       for (int eta=0;eta<etabins;++eta)
         for (int phi=0;phi<phibins;++phi)
           {
         iphi=phi+1;
         for (int subdet=1;subdet<=4;++subdet)
           {
             ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
             if (ieta==-9999) continue;
             if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
               continue;
             // now check which dead cell tests failed; increment counter if any failed
             HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
             
             int index = logicalMap_->getHcalFrontEndId(TempID).rbxIndex();
             // if(subdet==HcalForward) continue;
             
             if(occupancy_RBX[index]==0)
               {
             recentoccupancy_digi[eta][phi][depth] = 0;
             RecentMissingDigisByDepth.depth[depth]->Fill(ieta,iphi,deadevt_);
               }
           }
           }
     }
 
   if (deadevt_ < minDeadEventCount_) return; // not enough entries to make a determination for this LS
 
   for (unsigned int depth=0;depth<RecentMissingDigisByDepth.depth.size();++depth)
     { 
       RecentMissingDigisByDepth.depth[depth]->setBinContent(0,0,ievt_);
       etabins=RecentMissingDigisByDepth.depth[depth]->getNbinsX();
       phibins=RecentMissingDigisByDepth.depth[depth]->getNbinsY();
       for (int eta=0;eta<etabins;++eta)
     {
       for (int subdet=1;subdet<=4;++subdet)
         {
           ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
           if (ieta==-9999) continue;
           for (int phi=0;phi<phibins;++phi)
         {
           iphi=phi+1;
           
           if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
             continue;
           
           // Ignore subdetectors that weren't in run?
           /*
           if ((subdet==HcalBarrel && !HBpresent_) || 
               (subdet==HcalEndcap &&!HEpresent_)  ||
               (subdet==HcalOuter &&!HOpresent_)  || 
               (subdet==HcalForward &&!HFpresent_))   continue;
           */
           int zside=0;
           if (subdet==HcalForward) // shift HcalForward ieta
             ieta<0 ? zside=-1 : zside=+1;
           
           if (recentoccupancy_digi[eta][phi][depth]==0)
             {
               if (debug_>0)
             {
               std::cout <<"DEAD CELL; NO RECENT OCCUPANCY: subdet = "<<subdet<<", ieta = "<<ieta<<", iphi = "<<iphi<<" depth = "<<depth+1<<std::endl;
               std::cout <<"\t RAW COORDINATES:  eta = "<<eta<< " phi = "<<phi<<" depth = "<<depth<<std::endl;
               std::cout <<"\t Present? "<<present_digi[eta][phi][depth]<<std::endl;
             }
               
               // Don't fill HORing2 if boolean enabled
               if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
             continue;
 
               // no digi was found for the N events; Fill cell as bad for all N events (N = checkN);
               if (RecentMissingDigisByDepth.depth[depth]) RecentMissingDigisByDepth.depth[depth]->Fill(ieta+zside,iphi,deadevt_);
             }
         } // for (int subdet=1;subdet<=4;++subdet)
         } // for (int phi=0;...)
     } // for (int eta=0;...)
     } //for (int depth=1;...)
   FillUnphysicalHEHFBins(RecentMissingDigisByDepth);
 
   return;
 
 } // void HcalDeadCellMonitor::fillNevents_recentdigis()

void HcalDeadCellMonitor::fillNevents_recentrechits ( )

private

Definition at line 1116 of file HcalDeadCellMonitor.cc.

References abs, HcalObjRepresent::CalcIeta(), gather_cfg::cout, deadevt_, deadmon_test_rechits_, HcalBaseDQMonitor::debug_, EtaPhiHists::depth, eta(), excludeHORing2_, HcalObjRepresent::FillUnphysicalHEHFBins(), HcalLogicalMap::getHcalFrontEndId(), HcalForward, HcalBaseDQMonitor::ievt_, getHLTprescales::index, is_RBX_loss_, isSiPM(), logicalMap_, minDeadEventCount_, occupancy_RBX, phi, HcalFrontEndId::rbxIndex(), RecentMissingRecHitsByDepth, recentoccupancy_rechit, RecHitPresentByDepth, and validDetId().

Referenced by endLuminosityBlock().

 {
   // Fill Histograms showing unoccupied rechits, or rec hits with low energy
 
   // This test is a bit pointless, unless the energy threshold is greater than the ZS threshold.
   // If we require that cells are always < thresh to be flagged by this test, and if 
   // thresh < ZS, then we will never catch any cells, since they'll show up as dead in the
   // neverpresent/occupancy test plots first.
   // Only exception is if something strange is going on between ZS ADC value an RecHit energy?
 
   if (!deadmon_test_rechits_) return;
   FillUnphysicalHEHFBins(RecHitPresentByDepth);  
 
   if (debug_>0)
     std::cout <<"<HcalDeadCellMonitor::fillNevents_energy> BELOW-ENERGY-THRESHOLD PLOTS"<<std::endl;
 
   int ieta=0;
   int iphi=0;
   
   int etabins=0;
   int phibins=0;
 
   if ((deadevt_ >= 10 && deadevt_<minDeadEventCount_) || (deadevt_ >= 10 && is_RBX_loss_==1)) // maybe not enough events to run the standard test
     // if( is_RBX_loss_ == 1 )                          // but enough to detect RBX loss
       for (unsigned int depth=0;depth<RecentMissingRecHitsByDepth.depth.size();++depth)
     {
       RecentMissingRecHitsByDepth.depth[depth]->setBinContent(0,0,ievt_);
       etabins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsX();
       phibins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsY();      
       for (int eta=0;eta<etabins;++eta)
         for (int phi=0;phi<phibins;++phi)
           {
         iphi=phi+1;
         for (int subdet=1;subdet<=4;++subdet)
           {
             ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
             if (ieta==-9999) continue;
             if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
               continue;
             // now check which dead cell tests failed; increment counter if any failed
             HcalDetId TempID((HcalSubdetector)subdet, ieta, iphi, (int)depth+1);
             
             int index = logicalMap_->getHcalFrontEndId(TempID).rbxIndex();
             // if(subdet==HcalForward) continue;
             
             if(occupancy_RBX[index]==0)
               {
             recentoccupancy_rechit[eta][phi][depth] = 0;
             RecentMissingRecHitsByDepth.depth[depth]->Fill(ieta,iphi,deadevt_);
               }
           }
           }
     }
 
   if (deadevt_ < minDeadEventCount_) return; // not enough entries to make a determination for this LS
 
   for (unsigned int depth=0;depth<RecentMissingRecHitsByDepth.depth.size();++depth)
     { 
       RecentMissingRecHitsByDepth.depth[depth]->setBinContent(0,0,ievt_);
       etabins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsX();
       phibins=RecentMissingRecHitsByDepth.depth[depth]->getNbinsY();
       for (int eta=0;eta<etabins;++eta)
     {
       for (int subdet=1;subdet<=4;++subdet)
         {
           ieta=CalcIeta((HcalSubdetector)subdet,eta,depth+1);
           if (ieta==-9999) continue;
           for (int phi=0;phi<phibins;++phi)
         {
           iphi=phi+1;
           if (!validDetId((HcalSubdetector)subdet, ieta, iphi, depth+1))
             continue;
           
           if (recentoccupancy_rechit[eta][phi][depth]>0) continue; // cell exceeded energy at least once, so it's not dead
                   
           // Ignore subdetectors that weren't in run?
           /*
                   if ((subdet==HcalBarrel && !HBpresent_) || 
               (subdet==HcalEndcap &&!HEpresent_)  ||
               (subdet==HcalOuter &&!HOpresent_)  ||
               (subdet==HcalForward &&!HFpresent_))   continue;
           */
 
           int zside=0;
           if (subdet==HcalForward) // shift HcalForward ieta
             {
               ieta<0 ? zside=-1 : zside=+1;
             }
           
           if (debug_>2) 
             std::cout <<"DEAD CELL; BELOW ENERGY THRESHOLD; subdet = "<<subdet<<" ieta = "<<ieta<<", phi = "<<iphi<<" depth = "<<depth+1<<std::endl;
           if (excludeHORing2_==true && abs(ieta)>10 && isSiPM(ieta,iphi,depth+1)==false)
             continue;
       
           if (RecentMissingRecHitsByDepth.depth[depth]) RecentMissingRecHitsByDepth.depth[depth]->Fill(ieta+zside,iphi,deadevt_);
         } // loop on phi bins
         } // for (unsigned int depth=1;depth<=4;++depth)
     } // // loop on subdetectors
     } // for (int eta=0;...)
   
   FillUnphysicalHEHFBins(RecentMissingRecHitsByDepth);
 
   return;
 } // void HcalDeadCellMonitor::fillNevents_recentrechits()

template<class T >

void HcalDeadCellMonitor::process_Digi ( T & digi )

private

Referenced by processEvent(), and processEvent_HBHEdigi().

template<class DIGI >

void HcalDeadCellMonitor::process_Digi ( DIGI & digi )

Definition at line 906 of file HcalDeadCellMonitor.cc.

References CalcEtaBin(), EtaPhiHists::depth, DigiPresentByDepth, present_digi, and recentoccupancy_digi.

 {
   // Remove the validate check when we figure out how to access bad digis in digi monitor
   //if (!digi.validate()) return; // digi must be good to be counted
   int ieta=digi.id().ieta();
   int iphi=digi.id().iphi();
   int depth=digi.id().depth();
 
   // Fill occupancy counter
   ++recentoccupancy_digi[CalcEtaBin(digi.id().subdet(),ieta,depth)][iphi-1][depth-1];
 
   // If previously-missing digi found, change boolean status and fill histogram
   if (present_digi[CalcEtaBin(digi.id().subdet(),ieta,depth)][iphi-1][depth-1]==false)
     {
       if (DigiPresentByDepth.depth[depth-1])
     {
       DigiPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(digi.id().subdet(),ieta,depth)+1,iphi,1);
     }
       present_digi[CalcEtaBin(digi.id().subdet(),ieta,depth)][iphi-1][depth-1]=true;
     }
   return;
 }

template<class T >

void HcalDeadCellMonitor::process_RecHit ( T & rechit )

private

Referenced by processEvent().

template<class RECHIT >

void HcalDeadCellMonitor::process_RecHit ( RECHIT & rechit )

Definition at line 932 of file HcalDeadCellMonitor.cc.

References CalcEtaBin(), EtaPhiHists::depth, HcalLogicalMap::getHcalFrontEndId(), HBenergyThreshold_, HcalBarrel, HcalEndcap, HcalForward, HcalOuter, HEenergyThreshold_, HFenergyThreshold_, HOenergyThreshold_, errorMatrix2Lands_multiChannel::id, logicalMap_, occupancy_RBX, present_rechit, recentoccupancy_rechit, and RecHitPresentByDepth.

 {
   float en = rechit->energy();
   HcalDetId id(rechit->detid().rawId());
   int ieta = id.ieta();
   int iphi = id.iphi();
   int depth = id.depth();
   
   if (id.subdet()==HcalBarrel)
     {
       if (en>=HBenergyThreshold_)
     {
       ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
       present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
       if (RecHitPresentByDepth.depth[depth-1])
         RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
     }      
       // RBX index, HB RBX indices are 0-35
       int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
 
       occupancy_RBX[RBXindex]++;
     }
   else if (id.subdet()==HcalEndcap)
     {
       if (en>=HEenergyThreshold_)
     {
     ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
     present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
     if (RecHitPresentByDepth.depth[depth-1])
       RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
     }
       // RBX index, HE RBX indices are 36-71
       int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
       
       occupancy_RBX[RBXindex]++;
     }
   else if (id.subdet()==HcalForward)
     {
       if (en>=HFenergyThreshold_)
     {
       ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
     
       present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
       if (RecHitPresentByDepth.depth[depth-1])
         RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1);
     }
       // RBX index, HF RBX indices are 132-155
       int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
       
       occupancy_RBX[RBXindex]++;
     }
   else if (id.subdet()==HcalOuter)
     {
       if (en>=HOenergyThreshold_)
     {
       ++recentoccupancy_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1];
       present_rechit[CalcEtaBin(id.subdet(),ieta,depth)][iphi-1][depth-1]=true;
       if (RecHitPresentByDepth.depth[depth-1])
         RecHitPresentByDepth.depth[depth-1]->setBinContent(CalcEtaBin(id.subdet(),ieta,depth)+1,iphi,1); 
     }
       // RBX index, HO RBX indices are 73-95 (odd), 96-107 (all), 108-119 (odd), 120-130 (EXCL), 131
       int RBXindex = logicalMap_->getHcalFrontEndId(rechit->detid()).rbxIndex();
     
       occupancy_RBX[RBXindex]++;
     }
 }

void HcalDeadCellMonitor::processEvent	(	const HBHERecHitCollection &	hbHits,
		const HORecHitCollection &	hoHits,
		const HFRecHitCollection &	hfHits,
		const HBHEDigiCollection &	hbhedigi,
		const HODigiCollection &	hodigi,
		const HFDigiCollection &	hfdigi
	)

Definition at line 769 of file HcalDeadCellMonitor.cc.

Referenced by analyze().

 {
   if (debug_>1) std::cout <<"<HcalDeadCellMonitor::processEvent> Processing event..."<<std::endl;
 
   // Do Digi-Based dead cell searches 
   
   // Make sure histograms update
   for (unsigned int i=0;i<DigiPresentByDepth.depth.size();++i)
     DigiPresentByDepth.depth[i]->update();
 
   NumberOfNeverPresentDigis->update();;
   NumberOfNeverPresentDigisHB->update();
   NumberOfNeverPresentDigisHE->update();
   NumberOfNeverPresentDigisHO->update();
   NumberOfNeverPresentDigisHF->update();
 
   if (deadmon_test_digis_)
     {
       
       for (unsigned int i=0;i<RecentMissingDigisByDepth.depth.size();++i)
     RecentMissingDigisByDepth.depth[i]->update();
 
       NumberOfRecentMissingDigis->update();
       NumberOfRecentMissingDigisHB->update();
       NumberOfRecentMissingDigisHE->update();
       NumberOfRecentMissingDigisHO->update();
       NumberOfRecentMissingDigisHF->update();
     }
   
   for (HBHEDigiCollection::const_iterator j=hbhedigi.begin();
        j!=hbhedigi.end(); ++j)
     {
       const HBHEDataFrame digi = (const HBHEDataFrame)(*j);
       processEvent_HBHEdigi(digi);
     }
     
   for (HODigiCollection::const_iterator j=hodigi.begin();
        j!=hodigi.end(); ++j)
     {
       const HODataFrame digi = (const HODataFrame)(*j);
       process_Digi(digi);
     }
   for (HFDigiCollection::const_iterator j=hfdigi.begin();
        j!=hfdigi.end(); ++j)
     {
       const HFDataFrame digi = (const HFDataFrame)(*j);  
       process_Digi(digi);
     }
   FillUnphysicalHEHFBins(DigiPresentByDepth);
   
   // Search for "dead" cells below a certain energy
   if (deadmon_test_rechits_) 
     {
       // Normalization Fill
       for (unsigned int i=0;i<RecentMissingRecHitsByDepth.depth.size();++i)
     RecentMissingRecHitsByDepth.depth[i]->update();
 
       NumberOfRecentMissingRecHits->update();
       NumberOfRecentMissingRecHitsHB->update();
       NumberOfRecentMissingRecHitsHE->update();
       NumberOfRecentMissingRecHitsHO->update();
       NumberOfRecentMissingRecHitsHF->update();
 
       for (HBHERecHitCollection::const_iterator j=hbHits.begin();
        j!=hbHits.end(); ++j)
     process_RecHit(j);
       
       for (HORecHitCollection::const_iterator k=hoHits.begin();
        k!=hoHits.end(); ++k)
     process_RecHit(k);
       
       for (HFRecHitCollection::const_iterator j=hfHits.begin();
        j!=hfHits.end(); ++j)
     process_RecHit(j);
     
     } // if (deadmon_test_rechits)
 
   if (!makeDiagnostics_) return;
   if (tevt_>=NLumiBlocks_) return;
   // Diagnostic plots -- add number of missing channels vs event number
   int hbpresent=0;
   int hepresent=0;
   int hopresent=0;
   int hfpresent=0;
   int ieta=0;
   for (int d=0;d<4;++d)
     {
       for (int phi=0;phi<72;++phi)
     {
       for (int eta=0;eta<85;++eta)
         {
           if (!present_digi[eta][phi][d]) continue;
           if (d==3) ++hopresent;
           else if (d==2) ++hepresent;
           else if (d==1)
         {
           ieta=binmapd2[eta];
           //if (abs(ieta)>29) continue;
           if (abs(ieta)>29) ++hfpresent;
           else if (abs(ieta)<17) ++hbpresent; //depths 15&16
           else ++hepresent;
         }
           else if (d==0)
         {
           ieta=eta-42;
           if (abs(ieta)>29) ++hfpresent;
           else if (abs(ieta)<17) ++hbpresent;
           else ++hepresent;
         }
         }
     }
     } // for (int d=0;d<4;++d)
   HBDeadVsEvent->Fill(tevt_,2592-hbpresent);
   HEDeadVsEvent->Fill(tevt_,2592-hepresent);
   HODeadVsEvent->Fill(tevt_,2160-hopresent);
   HFDeadVsEvent->Fill(tevt_,1728-hfpresent);
   return;
 } // void HcalDeadCellMonitor::processEvent(...)

void HcalDeadCellMonitor::processEvent_HBHEdigi ( const HBHEDataFrame digi )

private

Definition at line 898 of file HcalDeadCellMonitor.cc.

References process_Digi().

Referenced by processEvent().

 {
   // Simply check whether a digi is present.  If so, increment occupancy counter.
   process_Digi(digi);
   return;
 } //void HcalDeadCellMonitor::processEvent_HBHEdigi(HBHEDigiCollection::const_iterator j)

void HcalDeadCellMonitor::reset ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 406 of file HcalDeadCellMonitor.cc.

Referenced by analyze(), beginRun(), and setup().

 {
   if (debug_>1) std::cout <<"HcalDeadCellMonitor::reset()"<<std::endl;
   doReset_ = false;
 
   HcalBaseDQMonitor::reset();
   zeroCounters();
   deadevt_=0;
   is_RBX_loss_ = 0;
   beamMode_ = 0 ;
   alarmer_counter_ = 0;
   alarmer_counterHO01_ = 0;
   is_stable_beam = true;
   hbhedcsON = true; hfdcsON = true; hodcsON = true;
   ProblemsVsLB->Reset(); ProblemsVsLB_HB->Reset(); ProblemsVsLB_HE->Reset(); ProblemsVsLB_HO->Reset(); ProblemsVsLB_HO2->Reset(); ProblemsVsLB_HF->Reset(); ProblemsVsLB_HBHEHF->Reset();
   RBX_loss_VS_LB->Reset();
   ProblemsInLastNLB_HBHEHF_alarm->Reset();
   ProblemsInLastNLB_HO01_alarm->Reset();
   NumberOfNeverPresentDigis->Reset(); NumberOfNeverPresentDigisHB->Reset(); NumberOfNeverPresentDigisHE->Reset(); NumberOfNeverPresentDigisHO->Reset(); NumberOfNeverPresentDigisHF->Reset();
 
   for (unsigned int depth=0;depth<DigiPresentByDepth.depth.size();++depth)
     DigiPresentByDepth.depth[depth]->Reset();
 
   // Mark HORing2 channels as present  (fill with a 2, rather than a 1, to distinguish between this setting and actual presence)
   if (excludeHORing2_==true && DigiPresentByDepth.depth.size()>3)
     {
       for (int ieta=11;ieta<=15;++ieta)
     for (int iphi=1;iphi<=72;++iphi)
       {
         // Don't fill ring2 SiPMs, since they will still be active even if the rest of HO is excluded.
         if (isSiPM(ieta,iphi,4)==false)
           DigiPresentByDepth.depth[3]->Fill(ieta,iphi,2);
         //std::cout <<" FILLING ("<<-1*ieta<<", "<<iphi<<") with '2'"<<std::endl;
         DigiPresentByDepth.depth[3]->Fill(-1*ieta,iphi,2);
       }
     }
   FillUnphysicalHEHFBins(DigiPresentByDepth);
 
 
   if (deadmon_test_digis_)
     {
       NumberOfRecentMissingDigis->Reset(); NumberOfRecentMissingDigisHB->Reset(); NumberOfRecentMissingDigisHE->Reset(); NumberOfRecentMissingDigisHO->Reset(); NumberOfRecentMissingDigisHF->Reset();
       RecentMissingDigisByDepth.Reset();
     }
   if (deadmon_test_rechits_)
     {
       NumberOfRecentMissingRecHits->Reset();
       NumberOfRecentMissingRecHitsHB->Reset();
       NumberOfRecentMissingRecHitsHE->Reset();
       NumberOfRecentMissingRecHitsHO->Reset(); 
       NumberOfRecentMissingRecHitsHF->Reset();
       NumberOfNeverPresentRecHits->Reset(); 
       NumberOfNeverPresentRecHitsHB->Reset(); 
       NumberOfNeverPresentRecHitsHE->Reset(); 
       NumberOfNeverPresentRecHitsHO->Reset(); 
       NumberOfNeverPresentRecHitsHF->Reset();
       RecentMissingRecHitsByDepth.Reset();
       RecHitPresentByDepth.Reset();
       
       // Mark HORing2 channels as present  (fill with a 2, rather than a 1, to distinguish between this setting and actual presence)
       if (excludeHORing2_==true && RecHitPresentByDepth.depth.size()>3)
     {
       for (int ieta=11;ieta<=15;++ieta)
         for (int iphi=1;iphi<=72;++iphi)
           {
         RecHitPresentByDepth.depth[3]->Fill(ieta,iphi,2);
         RecHitPresentByDepth.depth[3]->Fill(-1*ieta,iphi,2);
           }
     }
       FillUnphysicalHEHFBins(RecHitPresentByDepth);
     }
 
   Nevents->Reset();
 }  // reset function is empty for now

void HcalDeadCellMonitor::setup ( void )

virtual

Reimplemented from HcalBaseDQMonitor.

Definition at line 73 of file HcalDeadCellMonitor.cc.

Referenced by beginRun().

 {
   HcalBaseDQMonitor::setup();
   zeroCounters(1); // make sure arrays are set up
   if (debug_>0)
     std::cout <<"<HcalDeadCellMonitor::setup>  Setting up histograms"<<std::endl;
 
   if (!dbe_) return;
 
   dbe_->setCurrentFolder(subdir_);
   MonitorElement* excludeHO2=dbe_->bookInt("ExcludeHOring2");
   // Fill with 0 if ring is not to be excluded; fill with 1 if it is to be excluded
   if (excludeHO2) excludeHO2->Fill(excludeHORing2_==true ? 1 : 0);
 
   Nevents = dbe_->book1D("NumberOfDeadCellEvents","Number of Events Seen by DeadCellMonitor",2,0,2);
   Nevents->setBinLabel(1,"allEvents");
   Nevents->setBinLabel(2,"lumiCheck");
  // 1D plots count number of bad cells vs. luminosity block
   ProblemsVsLB=dbe_->bookProfile("TotalDeadCells_HCAL_vs_LS",
                   "Total Number of Dead Hcal Cells (excluding known problems) vs LS;Lumi Section;Dead Cells", 
                   NLumiBlocks_,0.5,NLumiBlocks_+0.5,
                   100,0,10000);
   ProblemsVsLB_HB=dbe_->bookProfile("TotalDeadCells_HB_vs_LS",
                      "Total Number of Dead HB Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
                      NLumiBlocks_,0.5,NLumiBlocks_+0.5,
                      100,0,10000);
   ProblemsVsLB_HE=dbe_->bookProfile("TotalDeadCells_HE_vs_LS",
                      "Total Number of Dead HE Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
                      NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
   ProblemsVsLB_HO=dbe_->bookProfile("TotalDeadCells_HO_vs_LS",
                       "Total Number of Dead HO Cells Ring 0,1 |ieta|<=10 (excluding known problems) vs LS;Lumi Section;Dead Cells",
                       NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
   ProblemsVsLB_HO2=dbe_->bookProfile("TotalDeadCells_HO2_vs_LS",
                      "Total Number of Dead HO Cells Ring 2 |ieta|>10 (excluding known problems) vs LS;Lumi Section;Dead Cells",
                      NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
   ProblemsVsLB_HF=dbe_->bookProfile("TotalDeadCells_HF_vs_LS",
                      "Total Number of Dead HF Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
                      NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
   ProblemsVsLB_HBHEHF=dbe_->bookProfile("TotalDeadCells_HBHEHF_vs_LS",
                      "Total Number of Dead HBHEHF Cells (excluding known problems) vs LS;Lumi Section;Dead Cells",
                      NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
   
   (ProblemsVsLB->getTProfile())->SetMarkerStyle(20);
   (ProblemsVsLB_HB->getTProfile())->SetMarkerStyle(20);
   (ProblemsVsLB_HE->getTProfile())->SetMarkerStyle(20);
   (ProblemsVsLB_HO->getTProfile())->SetMarkerStyle(20);
   (ProblemsVsLB_HO2->getTProfile())->SetMarkerStyle(20);
   (ProblemsVsLB_HF->getTProfile())->SetMarkerStyle(20);
   (ProblemsVsLB_HBHEHF->getTProfile())->SetMarkerStyle(20);
 
   RBX_loss_VS_LB=dbe_->book2D("RBX_loss_VS_LB",
                   "RBX loss vs LS; Lumi Section; Index of lost RBX", 
                   NLumiBlocks_,0.5,NLumiBlocks_+0.5,156,0,156);
 
   ProblemsInLastNLB_HBHEHF_alarm=dbe_->book1D("ProblemsInLastNLB_HBHEHF_alarm",
                           "Total Number of Dead HBHEHF Cells in last 10 LS. Last bin contains OverFlow",
                           100,0,100);
   ProblemsInLastNLB_HO01_alarm=dbe_->book1D("ProblemsInLastNLB_HO01_alarm",
                         "Total Number of Dead Cells Ring 0,1 (abs(ieta)<=10) in last 10 LS. Last bin contains OverFlow",
                         100,0,100);
 
 
   dbe_->setCurrentFolder(subdir_+"dead_cell_parameters");
   MonitorElement* me=dbe_->bookInt("Test_NeverPresent_Digis");
   me->Fill(1);
   me=dbe_->bookInt("Test_DigiMissing_Periodic_Lumi_Check");
   if (deadmon_test_digis_)
     me->Fill(1);
   else 
     me->Fill(0);
   me=dbe_->bookInt("Min_Events_Required_Periodic_Lumi_Check");
   me->Fill(minDeadEventCount_);
   me=dbe_->bookInt("Test_NeverPresent_RecHits");
   deadmon_test_rechits_>0 ? me->Fill(1) : me->Fill(0);
   me=dbe_->bookFloat("HBMinimumRecHitEnergy");
   me->Fill(HBenergyThreshold_);
   me=dbe_->bookFloat("HEMinimumRecHitEnergy");
   me->Fill(HEenergyThreshold_);
   me=dbe_->bookFloat("HOMinimumRecHitEnergy");
   me->Fill(HOenergyThreshold_);
   me=dbe_->bookFloat("HFMinimumRecHitEnergy");
   me->Fill(HFenergyThreshold_);
   me=dbe_->bookInt("Test_RecHitsMissing_Periodic_Lumi_Check");
   deadmon_test_rechits_>0 ? me->Fill(1) : me->Fill(0);
 
   // ProblemCells plots are in HcalDeadCellClient!
       
   // Set up plots for each failure mode of dead cells
   std::stringstream units; // We'll need to set the titles individually, rather than passing units to SetupEtaPhiHists (since this also would affect the name of the histograms)
   std::stringstream name;
 
   // Never-present test will always be called, by definition of dead cell
 
   dbe_->setCurrentFolder(subdir_+"dead_digi_never_present");
   SetupEtaPhiHists(DigiPresentByDepth,
            "Digi Present At Least Once","");
   // 1D plots count number of bad cells
   NumberOfNeverPresentDigis=dbe_->bookProfile("Problem_NeverPresentDigis_HCAL_vs_LS",
                            "Total Number of Never-Present Hcal Cells vs LS;Lumi Section;Dead Cells",
                            NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       
   NumberOfNeverPresentDigisHB=dbe_->bookProfile("Problem_NeverPresentDigis_HB_vs_LS",
                          "Total Number of Never-Present HB Cells vs LS;Lumi Section;Dead Cells",
                          NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       
   NumberOfNeverPresentDigisHE=dbe_->bookProfile("Problem_NeverPresentDigis_HE_vs_LS",
                          "Total Number of Never-Present HE Cells vs LS;Lumi Section;Dead Cells",
                          NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       
   NumberOfNeverPresentDigisHO=dbe_->bookProfile("Problem_NeverPresentDigis_HO_vs_LS",
                          "Total Number of Never-Present HO Cells vs LS;Lumi Section;Dead Cells",
                          NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       
   NumberOfNeverPresentDigisHF=dbe_->bookProfile("Problem_NeverPresentDigis_HF_vs_LS",
                          "Total Number of Never-Present HF Cells vs LS;Lumi Section;Dead Cells",
                          NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
   (NumberOfNeverPresentDigis->getTProfile())->SetMarkerStyle(20);
   (NumberOfNeverPresentDigisHB->getTProfile())->SetMarkerStyle(20);
   (NumberOfNeverPresentDigisHE->getTProfile())->SetMarkerStyle(20);
   (NumberOfNeverPresentDigisHO->getTProfile())->SetMarkerStyle(20);
   (NumberOfNeverPresentDigisHF->getTProfile())->SetMarkerStyle(20);
 
   FillUnphysicalHEHFBins(DigiPresentByDepth);
 
   if (deadmon_test_digis_)
     {
       dbe_->setCurrentFolder(subdir_+"dead_digi_often_missing");
       //units<<"("<<deadmon_checkNevents_<<" consec. events)";
       name<<"Dead Cells with No Digis";
       SetupEtaPhiHists(RecentMissingDigisByDepth,
                name.str(),
                "");
       name.str("");
       name<<"HB HE HF Depth 1 Dead Cells with No Digis for at least 1 Full Luminosity Block"; 
       RecentMissingDigisByDepth.depth[0]->setTitle(name.str().c_str());
 
       name.str("");
       name<<"HB HE HF Depth 2 Dead Cells with No Digis for at least 1 Full Luminosity Block";
       RecentMissingDigisByDepth.depth[1]->setTitle(name.str().c_str());
 
       name.str("");
       name<<"HE Depth 3 Dead Cells with No Digis for at least 1 Full Luminosity Block";
       RecentMissingDigisByDepth.depth[2]->setTitle(name.str().c_str());
 
       name.str("");
       name<<"HO Depth 4 Dead Cells with No Digis for at least 1 Full Luminosity Block";
       RecentMissingDigisByDepth.depth[3]->setTitle(name.str().c_str());
       name.str("");
 
       // 1D plots count number of bad cells
       name<<"Total Number of Hcal Digis Unoccupied for at least 1 Full Luminosity Block"; 
       NumberOfRecentMissingDigis=dbe_->bookProfile("Problem_RecentMissingDigis_HCAL_vs_LS",
                             name.str(),
                             NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HB Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
       NumberOfRecentMissingDigisHB=dbe_->bookProfile("Problem_RecentMissingDigis_HB_vs_LS",
                               name.str(),
                               NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HE Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
       NumberOfRecentMissingDigisHE=dbe_->bookProfile("Problem_RecentMissingDigis_HE_vs_LS",
                               name.str(),
                               NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HO Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
       NumberOfRecentMissingDigisHO=dbe_->bookProfile("Problem_RecentMissingDigis_HO_vs_LS",
                               name.str(),
                               NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HF Digis Unoccupied for at least 1 Full LS vs LS;Lumi Section; Dead Cells";
       NumberOfRecentMissingDigisHF=dbe_->bookProfile("Problem_RecentMissingDigis_HF_vs_LS",
                               name.str(),
                               NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       (NumberOfRecentMissingDigis->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingDigisHB->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingDigisHE->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingDigisHO->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingDigisHF->getTProfile())->SetMarkerStyle(20);
 
     }
       
   if (deadmon_test_rechits_)
     {
       // test 1:  energy never above threshold
       dbe_->setCurrentFolder(subdir_+"dead_rechit_neverpresent");
       SetupEtaPhiHists(RecHitPresentByDepth,"RecHit Above Threshold At Least Once","");
       // set more descriptive titles for threshold plots
       units.str("");
       units<<"Cells Above Energy Threshold At Least Once: Depth 1 -- HB >="<<HBenergyThreshold_<<" GeV, HE >= "<<HEenergyThreshold_<<", HF >="<<HFenergyThreshold_<<" GeV";
       RecHitPresentByDepth.depth[0]->setTitle(units.str().c_str());
       units.str("");
       units<<"Cells Above Energy Threshold At Least Once: Depth 2 -- HB >="<<HBenergyThreshold_<<" GeV, HE >= "<<HEenergyThreshold_<<", HF >="<<HFenergyThreshold_<<" GeV";
       RecHitPresentByDepth.depth[1]->setTitle(units.str().c_str());
       units.str("");
       units<<"Cells Above Energy Threshold At Least Once: Depth 3 -- HE >="<<HEenergyThreshold_<<" GeV";
       RecHitPresentByDepth.depth[2]->setTitle(units.str().c_str());
       units.str("");
       units<<"Cells Above Energy Threshold At Least Once: Depth 4 -- HO >="<<HOenergyThreshold_<<" GeV";
       RecHitPresentByDepth.depth[3]->setTitle(units.str().c_str());
       units.str("");
 
       // 1D plots count number of bad cells
       NumberOfNeverPresentRecHits=dbe_->bookProfile("Problem_RecHitsNeverPresent_HCAL_vs_LS",
                              "Total Number of Hcal Rechits with Low Energy;Lumi Section;Dead Cells",
                              NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HB RecHits with Energy Never >= "<<HBenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfNeverPresentRecHitsHB=dbe_->bookProfile("Problem_RecHitsNeverPresent_HB_vs_LS",
                                name.str(),
                                NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HE RecHits with Energy Never >= "<<HEenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfNeverPresentRecHitsHE=dbe_->bookProfile("Problem_RecHitsNeverPresent_HE_vs_LS",
                                name.str(),
                                NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HO RecHits with Energy Never >= "<<HOenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfNeverPresentRecHitsHO=dbe_->bookProfile("Problem_RecHitsNeverPresent_HO_vs_LS",
                                name.str(),
                                NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HF RecHits with Energy Never >= "<<HFenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfNeverPresentRecHitsHF=dbe_->bookProfile("Problem_RecHitsNeverPresent_HF_vs_LS",
                                name.str(),
                                NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       (NumberOfNeverPresentRecHits->getTProfile())->SetMarkerStyle(20);
       (NumberOfNeverPresentRecHitsHB->getTProfile())->SetMarkerStyle(20);
       (NumberOfNeverPresentRecHitsHE->getTProfile())->SetMarkerStyle(20);
       (NumberOfNeverPresentRecHitsHO->getTProfile())->SetMarkerStyle(20);
       (NumberOfNeverPresentRecHitsHF->getTProfile())->SetMarkerStyle(20);
  
       dbe_->setCurrentFolder(subdir_+"dead_rechit_often_missing");
       SetupEtaPhiHists(RecentMissingRecHitsByDepth,"RecHits Failing Energy Threshold Test","");
       // set more descriptive titles for threshold plots
       units.str("");
       units<<"RecHits with Consistent Low Energy Depth 1 -- HB <"<<HBenergyThreshold_<<" GeV, HE < "<<HEenergyThreshold_<<", HF <"<<HFenergyThreshold_<<" GeV";
       RecentMissingRecHitsByDepth.depth[0]->setTitle(units.str().c_str());
       units.str("");
       units<<"RecHits with Consistent Low Energy Depth 2 -- HB <"<<HBenergyThreshold_<<" GeV, HE < "<<HEenergyThreshold_<<", HF <"<<HFenergyThreshold_<<" GeV";
       RecentMissingRecHitsByDepth.depth[1]->setTitle(units.str().c_str());
       units.str("");
       units<<"RecHits with Consistent Low Energy Depth 3 -- HE <"<<HEenergyThreshold_<<" GeV";
       RecentMissingRecHitsByDepth.depth[2]->setTitle(units.str().c_str());
       units.str("");
       units<<"RecHits with Consistent Low Energy Depth 4 -- HO <"<<HOenergyThreshold_<<" GeV";
       RecentMissingRecHitsByDepth.depth[3]->setTitle(units.str().c_str());
       units.str("");
 
 
       // 1D plots count number of bad cells
       name.str("");
       name<<"Total Number of Hcal RecHits with Consistent Low Energy;Lumi Section;Dead Cells";
       NumberOfRecentMissingRecHits=dbe_->bookProfile("Problem_BelowEnergyRecHits_HCAL_vs_LS",
                               name.str(),
                               NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HB RecHits with Consistent Low Energy < "<<HBenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfRecentMissingRecHitsHB=dbe_->bookProfile("Problem_BelowEnergyRecHits_HB_vs_LS",
                             name.str(),
                             NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HE RecHits with Consistent Low Energy < "<<HEenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfRecentMissingRecHitsHE=dbe_->bookProfile("Problem_BelowEnergyRecHits_HE_vs_LS",
                             name.str(),
                             NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HO RecHits with Consistent Low Energy < "<<HOenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfRecentMissingRecHitsHO=dbe_->bookProfile("Problem_BelowEnergyRecHits_HO_vs_LS",
                             name.str(),
                             NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       name.str("");
       name<<"Total Number of HF RecHits with Consistent Low Energy < "<<HFenergyThreshold_<<" GeV;Lumi Section;Dead Cells";
       NumberOfRecentMissingRecHitsHF=dbe_->bookProfile("Problem_BelowEnergyRecHits_HF_vs_LS",
                             name.str(),
                             NLumiBlocks_,0.5,NLumiBlocks_+0.5,100,0,10000);
       (NumberOfRecentMissingRecHits->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingRecHitsHB->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingRecHitsHE->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingRecHitsHO->getTProfile())->SetMarkerStyle(20);
       (NumberOfRecentMissingRecHitsHF->getTProfile())->SetMarkerStyle(20);
 
     } // if (deadmon_test_rechits)
 
 
   if (makeDiagnostics_)
     {
       dbe_->setCurrentFolder(subdir_+"DiagnosticPlots");
       HBDeadVsEvent=dbe_->book1D("HBDeadVsEvent","HB Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
       HEDeadVsEvent=dbe_->book1D("HEDeadVsEvent","HE Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
       HODeadVsEvent=dbe_->book1D("HODeadVsEvent","HO Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
       HFDeadVsEvent=dbe_->book1D("HFDeadVsEvent","HF Total Dead Cells Vs Event", NLumiBlocks_/10,-0.5,NLumiBlocks_-0.5);
     }
 
   this->reset();
   return;
 
 } // void HcalDeadCellMonitor::setup(...)

void HcalDeadCellMonitor::zeroCounters ( bool resetpresent = false )

private

Definition at line 1599 of file HcalDeadCellMonitor.cc.

References i, j, gen::k, occupancy_RBX, present_digi, present_rechit, rbxlost, recentoccupancy_digi, and recentoccupancy_rechit.

Referenced by endLuminosityBlock(), reset(), and setup().

 {
 
   // zero all counters
 
   // 2D histogram counters
   for (unsigned int i=0;i<85;++i)
     {
       for (unsigned int j=0;j<72;++j)
     {
       for (unsigned int k=0;k<4;++k)
         {
           if (resetpresent) present_digi[i][j][k]=false; // keeps track of whether digi was ever present
           if (resetpresent) present_rechit[i][j][k]=false;
           recentoccupancy_digi[i][j][k]=0; // counts occupancy in last (checkNevents) events
           recentoccupancy_rechit[i][j][k]=0; // counts instances of cell above threshold energy in last (checkNevents)
         }
     }
     }
 
   for (unsigned int i=0;i<156;++i)
     {
       occupancy_RBX[i] = 0;
       rbxlost[i] = 0;
     }
 
   return;
 } // void HcalDeadCellMonitor::zeroCounters(bool resetpresent)

Member Data Documentation

int HcalDeadCellMonitor::alarmer_counter_

private

Definition at line 114 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), fillNevents_problemCells(), and reset().

int HcalDeadCellMonitor::alarmer_counterHO01_

private

Definition at line 115 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), fillNevents_problemCells(), and reset().

int HcalDeadCellMonitor::beamMode_

private

Definition at line 101 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and reset().

int HcalDeadCellMonitor::deadevt_

private

Definition at line 111 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), fillNevents_problemCells(), fillNevents_recentdigis(), fillNevents_recentrechits(), and reset().

bool HcalDeadCellMonitor::deadmon_makeDiagnostics_

private

Definition at line 65 of file HcalDeadCellMonitor.h.

bool HcalDeadCellMonitor::deadmon_test_digis_

private

Definition at line 71 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), fillNevents_recentdigis(), HcalDeadCellMonitor(), processEvent(), reset(), and setup().

bool HcalDeadCellMonitor::deadmon_test_rechits_

private

Definition at line 72 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), fillNevents_recentrechits(), HcalDeadCellMonitor(), processEvent(), reset(), and setup().

edm::InputTag HcalDeadCellMonitor::digiLabel_

private

Definition at line 119 of file HcalDeadCellMonitor.h.

Referenced by analyze(), and HcalDeadCellMonitor().

EtaPhiHists HcalDeadCellMonitor::DigiPresentByDepth

private

Definition at line 86 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), process_Digi(), processEvent(), reset(), and setup().

bool HcalDeadCellMonitor::doReset_

private

Definition at line 102 of file HcalDeadCellMonitor.h.

Referenced by analyze(), beginRun(), and reset().

bool HcalDeadCellMonitor::endLumiProcessed_

private

Definition at line 122 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), endRun(), and HcalDeadCellMonitor().

double HcalDeadCellMonitor::energyThreshold_

private

Definition at line 79 of file HcalDeadCellMonitor.h.

Referenced by HcalDeadCellMonitor().

bool HcalDeadCellMonitor::excludeHO1P02_

private

Definition at line 125 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), and HcalDeadCellMonitor().

bool HcalDeadCellMonitor::excludeHORing2_

private

Definition at line 124 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), fillNevents_recentdigis(), fillNevents_recentrechits(), HcalDeadCellMonitor(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::HBDeadVsEvent

private

Definition at line 104 of file HcalDeadCellMonitor.h.

Referenced by processEvent(), and setup().

double HcalDeadCellMonitor::HBenergyThreshold_

private

Definition at line 80 of file HcalDeadCellMonitor.h.

Referenced by HcalDeadCellMonitor(), process_RecHit(), and setup().

bool HcalDeadCellMonitor::hbhedcsON

private

Definition at line 117 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), and reset().

edm::InputTag HcalDeadCellMonitor::hbheRechitLabel_

private

Definition at line 120 of file HcalDeadCellMonitor.h.

Referenced by analyze(), and HcalDeadCellMonitor().

MonitorElement * HcalDeadCellMonitor::HEDeadVsEvent

private

Definition at line 104 of file HcalDeadCellMonitor.h.

Referenced by processEvent(), and setup().

double HcalDeadCellMonitor::HEenergyThreshold_

private

Definition at line 81 of file HcalDeadCellMonitor.h.

Referenced by HcalDeadCellMonitor(), process_RecHit(), and setup().

bool HcalDeadCellMonitor::hfdcsON

private

Definition at line 117 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), and reset().

MonitorElement * HcalDeadCellMonitor::HFDeadVsEvent

private

Definition at line 104 of file HcalDeadCellMonitor.h.

Referenced by processEvent(), and setup().

double HcalDeadCellMonitor::HFenergyThreshold_

private

Definition at line 83 of file HcalDeadCellMonitor.h.

Referenced by HcalDeadCellMonitor(), process_RecHit(), and setup().

edm::InputTag HcalDeadCellMonitor::hfRechitLabel_

private

Definition at line 120 of file HcalDeadCellMonitor.h.

Referenced by analyze(), and HcalDeadCellMonitor().

bool HcalDeadCellMonitor::hodcsON

private

Definition at line 117 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), and reset().

MonitorElement * HcalDeadCellMonitor::HODeadVsEvent

private

Definition at line 104 of file HcalDeadCellMonitor.h.

Referenced by processEvent(), and setup().

double HcalDeadCellMonitor::HOenergyThreshold_

private

Definition at line 82 of file HcalDeadCellMonitor.h.

Referenced by HcalDeadCellMonitor(), process_RecHit(), and setup().

edm::InputTag HcalDeadCellMonitor::hoRechitLabel_

private

Definition at line 120 of file HcalDeadCellMonitor.h.

Referenced by analyze(), and HcalDeadCellMonitor().

int HcalDeadCellMonitor::is_RBX_loss_

private

Definition at line 112 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), fillNevents_problemCells(), fillNevents_recentdigis(), fillNevents_recentrechits(), and reset().

bool HcalDeadCellMonitor::is_stable_beam

private

Definition at line 116 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), and reset().

HcalLogicalMap* HcalDeadCellMonitor::logicalMap_

private

Definition at line 68 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_recentdigis(), fillNevents_recentrechits(), HcalDeadCellMonitor(), process_RecHit(), and ~HcalDeadCellMonitor().

int HcalDeadCellMonitor::minDeadEventCount_

private

Definition at line 66 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), fillNevents_problemCells(), fillNevents_recentdigis(), fillNevents_recentrechits(), HcalDeadCellMonitor(), and setup().

MonitorElement* HcalDeadCellMonitor::Nevents

private

Definition at line 100 of file HcalDeadCellMonitor.h.

Referenced by analyze(), fillNevents_problemCells(), reset(), and setup().

unsigned int HcalDeadCellMonitor::NumBadHB

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHE

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHF

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHFLUMI

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHO

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHO0

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock().

unsigned int HcalDeadCellMonitor::NumBadHO01

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHO12

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), and fillNevents_problemCells().

int HcalDeadCellMonitor::NumBadHO1P02

private

Definition at line 126 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells().

unsigned int HcalDeadCellMonitor::NumBadHO2

private

Definition at line 118 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells().

MonitorElement* HcalDeadCellMonitor::NumberOfNeverPresentDigis

private

Definition at line 95 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentDigisHB

private

Definition at line 95 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentDigisHE

private

Definition at line 95 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentDigisHF

private

Definition at line 95 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentDigisHO

private

Definition at line 95 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::NumberOfNeverPresentRecHits

private

Definition at line 98 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHB

private

Definition at line 98 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHE

private

Definition at line 98 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHF

private

Definition at line 98 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfNeverPresentRecHitsHO

private

Definition at line 98 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::NumberOfRecentMissingDigis

private

Definition at line 96 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingDigisHB

private

Definition at line 96 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingDigisHE

private

Definition at line 96 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingDigisHF

private

Definition at line 96 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingDigisHO

private

Definition at line 96 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::NumberOfRecentMissingRecHits

private

Definition at line 97 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHB

private

Definition at line 97 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHE

private

Definition at line 97 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHF

private

Definition at line 97 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::NumberOfRecentMissingRecHitsHO

private

Definition at line 97 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), processEvent(), reset(), and setup().

unsigned int HcalDeadCellMonitor::occupancy_RBX[156]

private

Definition at line 109 of file HcalDeadCellMonitor.h.

Referenced by analyze(), fillNevents_problemCells(), fillNevents_recentdigis(), fillNevents_recentrechits(), process_RecHit(), and zeroCounters().

bool HcalDeadCellMonitor::present_digi[85][72][4]

private

Definition at line 105 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), fillNevents_recentdigis(), process_Digi(), processEvent(), and zeroCounters().

bool HcalDeadCellMonitor::present_rechit[85][72][4]

private

Definition at line 106 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), process_RecHit(), and zeroCounters().

MonitorElement* HcalDeadCellMonitor::ProblemsInLastNLB_HBHEHF_alarm

private

Definition at line 93 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), fillNevents_problemCells(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::ProblemsInLastNLB_HO01_alarm

private

Definition at line 94 of file HcalDeadCellMonitor.h.

Referenced by endLuminosityBlock(), fillNevents_problemCells(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::ProblemsVsLB

private

Definition at line 91 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::ProblemsVsLB_HB

private

Definition at line 91 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::ProblemsVsLB_HE

private

Definition at line 91 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::ProblemsVsLB_HF

private

Definition at line 91 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::ProblemsVsLB_HO

private

Definition at line 91 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement * HcalDeadCellMonitor::ProblemsVsLB_HO2

private

Definition at line 91 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

MonitorElement* HcalDeadCellMonitor::RBX_loss_VS_LB

private

Definition at line 92 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), reset(), and setup().

int HcalDeadCellMonitor::rbxlost[156]

private

Definition at line 113 of file HcalDeadCellMonitor.h.

Referenced by analyze(), endLuminosityBlock(), and zeroCounters().

EtaPhiHists HcalDeadCellMonitor::RecentMissingDigisByDepth

private

Definition at line 85 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_recentdigis(), processEvent(), reset(), and setup().

EtaPhiHists HcalDeadCellMonitor::RecentMissingRecHitsByDepth

private

Definition at line 87 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_recentrechits(), processEvent(), reset(), and setup().

unsigned int HcalDeadCellMonitor::recentoccupancy_digi[85][72][4]

private

Definition at line 107 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), fillNevents_recentdigis(), process_Digi(), and zeroCounters().

unsigned int HcalDeadCellMonitor::recentoccupancy_rechit[85][72][4]

private

Definition at line 108 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_problemCells(), fillNevents_recentrechits(), process_RecHit(), and zeroCounters().

EtaPhiHists HcalDeadCellMonitor::RecHitPresentByDepth

private

Definition at line 88 of file HcalDeadCellMonitor.h.

Referenced by fillNevents_recentrechits(), process_RecHit(), reset(), and setup().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation