#include <EcalPreshowerRecHitsValidation.h>

Inheritance diagram for EcalPreshowerRecHitsValidation:

Public Member Functions
	EcalPreshowerRecHitsValidation (const edm::ParameterSet &ps)
	Constructor. More...

	~EcalPreshowerRecHitsValidation () override
	Destructor. More...

Public Member Functions inherited from one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c) override
	Analyze. More...

void	bookHistograms (DQMStore::IBooker &i, edm::Run const &, edm::EventSetup const &) override

Private Attributes
edm::EDGetTokenT< EERecHitCollection >	EErechitCollection_token_

edm::EDGetTokenT< EEUncalibratedRecHitCollection >	EEuncalibrechitCollection_token_

edm::EDGetTokenT< ESRecHitCollection >	ESrechitCollection_token_

MonitorElement *	meESEERecHitsEnergy_zm_

MonitorElement *	meESEERecHitsEnergy_zp_

MonitorElement *	meESRecHitsEnergy_

MonitorElement *	meESRecHitsEnergy_zm1st_

MonitorElement *	meESRecHitsEnergy_zm2nd_

MonitorElement *	meESRecHitsEnergy_zp1st_

MonitorElement *	meESRecHitsEnergy_zp2nd_

MonitorElement *	meESRecHitsMultip_

MonitorElement *	meESRecHitsMultip_zm1st_

MonitorElement *	meESRecHitsMultip_zm2nd_

MonitorElement *	meESRecHitsMultip_zp1st_

MonitorElement *	meESRecHitsMultip_zp2nd_

MonitorElement *	meESRecHitsStripOccupancy_zm1st_ [36]

MonitorElement *	meESRecHitsStripOccupancy_zm2nd_ [36]

MonitorElement *	meESRecHitsStripOccupancy_zp1st_ [36]

MonitorElement *	meESRecHitsStripOccupancy_zp2nd_ [36]

bool	verbose_

Detailed Description

Definition at line 35 of file EcalPreshowerRecHitsValidation.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 17 of file EcalPreshowerRecHitsValidation.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and GetRecoTauVFromDQM_MC_cff::kk.

                                                                                      {
   // ----------------------
   EEuncalibrechitCollection_token_ =
       consumes<EEUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EEuncalibrechitCollection"));
   EErechitCollection_token_ = consumes<EERecHitCollection>(ps.getParameter<edm::InputTag>("EErechitCollection"));
   ESrechitCollection_token_ = consumes<ESRecHitCollection>(ps.getParameter<edm::InputTag>("ESrechitCollection"));
 
   // ----------------------
   // verbosity switch
   verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
 
   // ----------------------
   meESRecHitsEnergy_ = nullptr;  // total energy
   meESRecHitsEnergy_zp1st_ = nullptr;
   meESRecHitsEnergy_zp2nd_ = nullptr;
   meESRecHitsEnergy_zm1st_ = nullptr;
   meESRecHitsEnergy_zm2nd_ = nullptr;
   meESRecHitsMultip_ = nullptr;  // total multiplicity
   meESRecHitsMultip_zp1st_ = nullptr;
   meESRecHitsMultip_zp2nd_ = nullptr;
   meESRecHitsMultip_zm1st_ = nullptr;
   meESRecHitsMultip_zm2nd_ = nullptr;
   meESEERecHitsEnergy_zp_ = nullptr;  // versus EE energy
   meESEERecHitsEnergy_zm_ = nullptr;
 
   for (int kk = 0; kk < 32; kk++) {
     meESRecHitsStripOccupancy_zp1st_[kk] = nullptr;
     meESRecHitsStripOccupancy_zm1st_[kk] = nullptr;
     meESRecHitsStripOccupancy_zp2nd_[kk] = nullptr;
     meESRecHitsStripOccupancy_zm2nd_[kk] = nullptr;
   }
 }

EcalPreshowerRecHitsValidation::~EcalPreshowerRecHitsValidation ( )

override

Destructor.

Definition at line 50 of file EcalPreshowerRecHitsValidation.cc.

50 {}

Member Function Documentation

void EcalPreshowerRecHitsValidation::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	c
	)

overrideprotected

Analyze.

Definition at line 110 of file EcalPreshowerRecHitsValidation.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), edm::SortedCollection< T, SORT >::find(), edm::Event::getByToken(), edm::HandleBase::isValid(), ESDetId::plane(), edm::Handle< T >::product(), rpcPointValidation_cfi::recHit, ESDetId::six(), ESDetId::siy(), digitizers_cfi::strip, ESDetId::strip(), ESDetId::zside(), EEDetId::zside(), and ecaldqm::zside().

                                                                                 {
   const ESRecHitCollection *ESRecHit = nullptr;
   Handle<ESRecHitCollection> EcalRecHitES;
   e.getByToken(ESrechitCollection_token_, EcalRecHitES);
   if (EcalRecHitES.isValid()) {
     ESRecHit = EcalRecHitES.product();
   } else {
     return;
   }
 
   bool skipEE = false;
   const EERecHitCollection *EERecHit = nullptr;
   Handle<EERecHitCollection> EcalRecHitEE;
   e.getByToken(EErechitCollection_token_, EcalRecHitEE);
   if (EcalRecHitEE.isValid()) {
     EERecHit = EcalRecHitEE.product();
   } else {
     skipEE = true;
   }
 
   const EEUncalibratedRecHitCollection *EEUncalibRecHit = nullptr;
   Handle<EEUncalibratedRecHitCollection> EcalUncalibRecHitEE;
   e.getByToken(EEuncalibrechitCollection_token_, EcalUncalibRecHitEE);
   if (EcalUncalibRecHitEE.isValid()) {
     EEUncalibRecHit = EcalUncalibRecHitEE.product();
   } else {
     skipEE = true;
   }
 
   // ----------------------
   // loop over RecHits
   // multiplicities
   int mult_tot = 0;
   int mult_zp1st = 0;
   int mult_zp2nd = 0;
   int mult_zm1st = 0;
   int mult_zm2nd = 0;
 
   // energies
   float ene_zp1st = 0.;
   float ene_zp2nd = 0.;
   float ene_zm1st = 0.;
   float ene_zm2nd = 0.;
 
   // ES
   for (ESRecHitCollection::const_iterator recHit = ESRecHit->begin(); recHit != ESRecHit->end(); ++recHit) {
     ESDetId ESid = ESDetId(recHit->id());
 
     int zside = ESid.zside();
     int plane = ESid.plane();
     int six = ESid.six();
     int siy = ESid.siy();
     int strip = ESid.strip();
 
     // global
     mult_tot++;
     if (meESRecHitsEnergy_)
       meESRecHitsEnergy_->Fill(recHit->energy());
 
     // side +, plane 1
     if ((zside == +1) && (plane == 1)) {
       mult_zp1st++;
       ene_zp1st += recHit->energy();
       if (meESRecHitsEnergy_zp1st_) {
         meESRecHitsEnergy_zp1st_->Fill(recHit->energy());
       }
       if (meESRecHitsStripOccupancy_zp1st_[strip - 1]) {
         meESRecHitsStripOccupancy_zp1st_[strip - 1]->Fill(six, siy);
       }
     }
 
     // side +, plane 2
     if ((zside == +1) && (plane == 2)) {
       mult_zp2nd++;
       ene_zp2nd += recHit->energy();
       if (meESRecHitsEnergy_zp2nd_) {
         meESRecHitsEnergy_zp2nd_->Fill(recHit->energy());
       }
       if (meESRecHitsStripOccupancy_zp2nd_[strip - 1]) {
         meESRecHitsStripOccupancy_zp2nd_[strip - 1]->Fill(six, siy);
       }
     }
 
     // side -, plane 1
     if ((zside == -1) && (plane == 1)) {
       mult_zm1st++;
       ene_zm1st += recHit->energy();
       if (meESRecHitsEnergy_zm1st_) {
         meESRecHitsEnergy_zm1st_->Fill(recHit->energy());
       }
       if (meESRecHitsStripOccupancy_zm1st_[strip - 1]) {
         meESRecHitsStripOccupancy_zm1st_[strip - 1]->Fill(six, siy);
       }
     }
 
     // side +, plane 2
     if ((zside == -1) && (plane == 2)) {
       mult_zm2nd++;
       ene_zm2nd += recHit->energy();
       if (meESRecHitsEnergy_zm2nd_) {
         meESRecHitsEnergy_zm2nd_->Fill(recHit->energy());
       }
       if (meESRecHitsStripOccupancy_zm2nd_[strip - 1]) {
         meESRecHitsStripOccupancy_zm2nd_[strip - 1]->Fill(six, siy);
       }
     }
 
   }  // loop over the ES RecHitCollection
 
   // EE
   double zpEE = 0.;
   double zmEE = 0.;
   if (!skipEE) {
     for (EcalUncalibratedRecHitCollection::const_iterator uncalibRecHit = EEUncalibRecHit->begin();
          uncalibRecHit != EEUncalibRecHit->end();
          ++uncalibRecHit) {
       EEDetId EEid = EEDetId(uncalibRecHit->id());
       int mySide = EEid.zside();
 
       // Find corresponding recHit
       EcalRecHitCollection::const_iterator myRecHit = EERecHit->find(EEid);
 
       if (myRecHit != EERecHit->end()) {
         if (mySide > 0) {
           zpEE = zpEE + myRecHit->energy();
         }
         if (mySide < 0) {
           zmEE = zmEE + myRecHit->energy();
         }
       }
     }
   }
 
   // filling histos
   if (meESRecHitsMultip_) {
     meESRecHitsMultip_->Fill(mult_tot);
   }
   if (meESRecHitsMultip_zp1st_) {
     meESRecHitsMultip_zp1st_->Fill(mult_zp1st);
   }
   if (meESRecHitsMultip_zp2nd_) {
     meESRecHitsMultip_zp2nd_->Fill(mult_zp2nd);
   }
   if (meESRecHitsMultip_zm1st_) {
     meESRecHitsMultip_zm1st_->Fill(mult_zm1st);
   }
   if (meESRecHitsMultip_zm2nd_) {
     meESRecHitsMultip_zm2nd_->Fill(mult_zm2nd);
   }
   if (meESEERecHitsEnergy_zp_) {
     meESEERecHitsEnergy_zp_->Fill((ene_zp1st + 0.7 * ene_zp2nd) / 0.09, zpEE);
   }
   if (meESEERecHitsEnergy_zm_) {
     meESEERecHitsEnergy_zm_->Fill((ene_zm1st + 0.7 * ene_zm2nd) / 0.09, zmEE);
   }
 }

void EcalPreshowerRecHitsValidation::bookHistograms	(	DQMStore::IBooker &	i,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotected

Definition at line 52 of file EcalPreshowerRecHitsValidation.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), trackerHits::histo, GetRecoTauVFromDQM_MC_cff::kk, and DQMStore::IBooker::setCurrentFolder().

                                                                            {
   Char_t histo[200];
 
   ibooker.setCurrentFolder("EcalRecHitsV/EcalPreshowerRecHitsTask");
 
   sprintf(histo, "ES Energy");
   meESRecHitsEnergy_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
 
   sprintf(histo, "ES Energy Plane1 Side+");
   meESRecHitsEnergy_zp1st_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
 
   sprintf(histo, "ES Energy Plane2 Side+");
   meESRecHitsEnergy_zp2nd_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
 
   sprintf(histo, "ES Energy Plane1 Side-");
   meESRecHitsEnergy_zm1st_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
 
   sprintf(histo, "ES Energy Plane2 Side-");
   meESRecHitsEnergy_zm2nd_ = ibooker.book1D(histo, histo, 210, -0.0005, 0.01);
 
   sprintf(histo, "ES Multiplicity");
   meESRecHitsMultip_ = ibooker.book1D(histo, histo, 100, 0., 700.);
 
   sprintf(histo, "ES Multiplicity Plane1 Side+");
   meESRecHitsMultip_zp1st_ = ibooker.book1D(histo, histo, 100, 0., 700.);
 
   sprintf(histo, "ES Multiplicity Plane2 Side+");
   meESRecHitsMultip_zp2nd_ = ibooker.book1D(histo, histo, 100, 0., 700.);
 
   sprintf(histo, "ES Multiplicity Plane1 Side-");
   meESRecHitsMultip_zm1st_ = ibooker.book1D(histo, histo, 100, 0., 700.);
 
   sprintf(histo, "ES Multiplicity Plane2 Side-");
   meESRecHitsMultip_zm2nd_ = ibooker.book1D(histo, histo, 100, 0., 700.);
 
   sprintf(histo, "Preshower EE vs ES energy Side+");
   meESEERecHitsEnergy_zp_ = ibooker.book2D(histo, histo, 100, 0., 0.2, 100, 0., 150.);
 
   sprintf(histo, "Preshower EE vs ES energy Side-");
   meESEERecHitsEnergy_zm_ = ibooker.book2D(histo, histo, 100, 0., 0.2, 100, 0., 150.);
 
   for (int kk = 0; kk < 32; kk++) {
     sprintf(histo, "ES Occupancy Plane1 Side+ Strip%02d", kk + 1);
     meESRecHitsStripOccupancy_zp1st_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);
 
     sprintf(histo, "ES Occupancy Plane2 Side+ Strip%02d", kk + 1);
     meESRecHitsStripOccupancy_zp2nd_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);
 
     sprintf(histo, "ES Occupancy Plane1 Side- Strip%02d", kk + 1);
     meESRecHitsStripOccupancy_zm1st_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);
 
     sprintf(histo, "ES Occupancy Plane2 Side- Strip%02d", kk + 1);
     meESRecHitsStripOccupancy_zm2nd_[kk] = ibooker.book2D(histo, histo, 40, 0., 40., 40, 0., 40.);
   }
 }