#include <EcalBarrelRecHitsValidation.h>

Inheritance diagram for EcalBarrelRecHitsValidation:

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

	~EcalBarrelRecHitsValidation () override
	Destructor. More...

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

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

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

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

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

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

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Private Attributes
edm::EDGetTokenT< EBDigiCollection >	EBdigiCollection_token_

edm::EDGetTokenT< EBUncalibratedRecHitCollection >	EBuncalibrechitCollection_token_

edm::ESGetToken< EcalPedestals, EcalPedestalsRcd >	ecalPeds

MonitorElement *	meEBUncalibRecHitAmplMap_ [36]

MonitorElement *	meEBUncalibRecHitMaxSampleRatio_

MonitorElement *	meEBUncalibRecHitMaxSampleRatioGt100adc_

MonitorElement *	meEBUncalibRecHitPedMap_ [36]

MonitorElement *	meEBUncalibRecHitsAmpFullMap_

MonitorElement *	meEBUncalibRecHitsAmplitude_

MonitorElement *	meEBUncalibRecHitsAmplitudeGt100adc_

MonitorElement *	meEBUncalibRecHitsChi2_

MonitorElement *	meEBUncalibRecHitsChi2Gt100adc_

MonitorElement *	meEBUncalibRecHitsJitter_

MonitorElement *	meEBUncalibRecHitsJitterGt100adc_

MonitorElement *	meEBUncalibRecHitsOccupancy_

MonitorElement *	meEBUncalibRecHitsOccupancyGt100adc_

MonitorElement *	meEBUncalibRecHitsPedestal_

MonitorElement *	meEBUncalibRecHitsPedestalGt100adc_

MonitorElement *	meEBUncalibRecHitsPedFullMap_

bool	verbose_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 36 of file EcalBarrelRecHitsValidation.h.

Constructor & Destructor Documentation

◆ EcalBarrelRecHitsValidation()

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

Constructor.

Definition at line 16 of file EcalBarrelRecHitsValidation.cc.

                                                                                : ecalPeds(esConsumes()) {
   // ----------------------
   EBdigiCollection_token_ = consumes<EBDigiCollection>(ps.getParameter<edm::InputTag>("EBdigiCollection"));
   EBuncalibrechitCollection_token_ =
       consumes<EBUncalibratedRecHitCollection>(ps.getParameter<edm::InputTag>("EBuncalibrechitCollection"));
 
   // ----------------------
   // verbosity switch
   verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
 
   // ----------------------
   meEBUncalibRecHitsOccupancy_ = nullptr;
   meEBUncalibRecHitsAmplitude_ = nullptr;
   meEBUncalibRecHitsPedestal_ = nullptr;
   meEBUncalibRecHitsJitter_ = nullptr;
   meEBUncalibRecHitsChi2_ = nullptr;
   meEBUncalibRecHitMaxSampleRatio_ = nullptr;
   meEBUncalibRecHitsOccupancyGt100adc_ = nullptr;
   meEBUncalibRecHitsAmplitudeGt100adc_ = nullptr;
   meEBUncalibRecHitsPedestalGt100adc_ = nullptr;
   meEBUncalibRecHitsJitterGt100adc_ = nullptr;
   meEBUncalibRecHitsChi2Gt100adc_ = nullptr;
   meEBUncalibRecHitMaxSampleRatioGt100adc_ = nullptr;
   meEBUncalibRecHitsAmpFullMap_ = nullptr;
   meEBUncalibRecHitsPedFullMap_ = nullptr;
   for (int i = 0; i < 36; i++) {
     meEBUncalibRecHitAmplMap_[i] = nullptr;
     meEBUncalibRecHitPedMap_[i] = nullptr;
   }
 }

◆ ~EcalBarrelRecHitsValidation()

EcalBarrelRecHitsValidation::~EcalBarrelRecHitsValidation ( )

override

Destructor.

Definition at line 47 of file EcalBarrelRecHitsValidation.cc.

47 {}

Member Function Documentation

◆ analyze()

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

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 107 of file EcalBarrelRecHitsValidation.cc.

                                                                              {
   const EBUncalibratedRecHitCollection *EBUncalibRecHit = nullptr;
   Handle<EBUncalibratedRecHitCollection> EcalUncalibRecHitEB;
   e.getByToken(EBuncalibrechitCollection_token_, EcalUncalibRecHitEB);
   if (EcalUncalibRecHitEB.isValid()) {
     EBUncalibRecHit = EcalUncalibRecHitEB.product();
   } else {
     return;
   }
 
   bool skipDigis = false;
   const EBDigiCollection *EBDigi = nullptr;
   Handle<EBDigiCollection> EcalDigiEB;
   e.getByToken(EBdigiCollection_token_, EcalDigiEB);
   if (EcalDigiEB.isValid()) {
     EBDigi = EcalDigiEB.product();
   } else {
     skipDigis = true;
   }
 
   // ----------------------
   // loop over UncalibRecHits
   for (EcalUncalibratedRecHitCollection::const_iterator uncalibRecHit = EBUncalibRecHit->begin();
        uncalibRecHit != EBUncalibRecHit->end();
        ++uncalibRecHit) {
     EBDetId EBid = EBDetId(uncalibRecHit->id());
 
     // general checks
     if (meEBUncalibRecHitsOccupancy_)
       meEBUncalibRecHitsOccupancy_->Fill(EBid.ieta(), EBid.iphi());
     if (meEBUncalibRecHitsAmplitude_)
       meEBUncalibRecHitsAmplitude_->Fill(uncalibRecHit->amplitude());
     if (meEBUncalibRecHitsPedestal_)
       meEBUncalibRecHitsPedestal_->Fill(uncalibRecHit->pedestal());
     if (meEBUncalibRecHitsJitter_)
       meEBUncalibRecHitsJitter_->Fill(uncalibRecHit->jitter());
     if (meEBUncalibRecHitsChi2_)
       meEBUncalibRecHitsChi2_->Fill(uncalibRecHit->chi2());
     if (meEBUncalibRecHitsAmpFullMap_)
       meEBUncalibRecHitsAmpFullMap_->Fill(EBid.ieta(), EBid.iphi(), uncalibRecHit->amplitude());
     if (meEBUncalibRecHitsPedFullMap_)
       meEBUncalibRecHitsPedFullMap_->Fill(EBid.ieta(), EBid.iphi(), uncalibRecHit->pedestal());
 
     // general checks, with threshold at 3.5 GeV = 100 ADC counts
     if (uncalibRecHit->amplitude() > 100) {
       if (meEBUncalibRecHitsOccupancyGt100adc_)
         meEBUncalibRecHitsOccupancyGt100adc_->Fill(EBid.ieta(), EBid.iphi());
       if (meEBUncalibRecHitsAmplitudeGt100adc_)
         meEBUncalibRecHitsAmplitudeGt100adc_->Fill(uncalibRecHit->amplitude());
       if (meEBUncalibRecHitsPedestalGt100adc_)
         meEBUncalibRecHitsPedestalGt100adc_->Fill(uncalibRecHit->pedestal());
       if (meEBUncalibRecHitsJitterGt100adc_)
         meEBUncalibRecHitsJitterGt100adc_->Fill(uncalibRecHit->jitter());
       if (meEBUncalibRecHitsChi2Gt100adc_)
         meEBUncalibRecHitsChi2Gt100adc_->Fill(uncalibRecHit->chi2());
     }
 
     // supermodule maps
     int ic = EBid.ic();
     int ie = (ic - 1) / 20 + 1;
     int ip = (ic - 1) % 20 + 1;
     int ism = EBid.ism();
     float xie = ie - 0.5;
     float xip = ip - 0.5;
     if (meEBUncalibRecHitPedMap_[ism - 1])
       meEBUncalibRecHitPedMap_[ism - 1]->Fill(xie, xip, uncalibRecHit->pedestal());
     if (meEBUncalibRecHitAmplMap_[ism - 1])
       meEBUncalibRecHitAmplMap_[ism - 1]->Fill(xie, xip, uncalibRecHit->amplitude());
 
     if (!skipDigis) {
       // find the rechit corresponding digi and the max sample
       EBDigiCollection::const_iterator myDigi = EBDigi->find(EBid);
       // int sMax = -1; // UNUSED
       double eMax = 0.;
       if (myDigi != EBDigi->end()) {
         for (unsigned int sample = 0; sample < myDigi->size(); ++sample) {
           EcalMGPASample thisSample = (*myDigi)[sample];
           double analogSample = thisSample.adc();
           if (eMax < analogSample) {
             eMax = analogSample;
             // sMax = sample; // UNUSED
           }
         }
       } else
         continue;
 
       // ratio uncalibratedRecHit amplitude + ped / max energy digi
       const EcalPedestals *myped = &c.getData(ecalPeds);
       EcalPedestalsMap::const_iterator it = myped->getMap().find(EBid);
       if (it != myped->getMap().end()) {
         if (eMax > (*it).mean_x1 + 5 * (*it).rms_x1 && eMax != 0) {  // only real signal RecHit
 
           if (meEBUncalibRecHitMaxSampleRatio_)
             meEBUncalibRecHitMaxSampleRatio_->Fill((uncalibRecHit->amplitude() + uncalibRecHit->pedestal()) / eMax);
           if (meEBUncalibRecHitMaxSampleRatioGt100adc_ && (uncalibRecHit->amplitude() > 100))
             meEBUncalibRecHitMaxSampleRatioGt100adc_->Fill((uncalibRecHit->amplitude() + uncalibRecHit->pedestal()) /
                                                            eMax);
           LogDebug("EcalRecHitsTaskInfo")
               << "barrel, eMax = " << eMax << " Amplitude = " << uncalibRecHit->amplitude() + uncalibRecHit->pedestal();
         } else
           continue;
       } else
         continue;
     }
 
   }  // loop over the UncalibratedRecHitCollection
 }

◆ bookHistograms()

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

overrideprotectedvirtual

Analyze.

Implements DQMEDAnalyzer.

Definition at line 49 of file EcalBarrelRecHitsValidation.cc.

                                                                         {
   Char_t histo[200];
 
   ibooker.setCurrentFolder("EcalRecHitsV/EcalBarrelRecHitsTask");
 
   sprintf(histo, "EB Occupancy");
   meEBUncalibRecHitsOccupancy_ = ibooker.book2D(histo, histo, 170, -85., 85., 360, 0., 360.);
 
   sprintf(histo, "EB Amplitude");
   meEBUncalibRecHitsAmplitude_ = ibooker.book1D(histo, histo, 201, -20., 4000.);
 
   sprintf(histo, "EB Pedestal");
   meEBUncalibRecHitsPedestal_ = ibooker.book1D(histo, histo, 50, 190., 210.);
 
   sprintf(histo, "EB Jitter");
   meEBUncalibRecHitsJitter_ = ibooker.book1D(histo, histo, 100, 0., 100.);
 
   sprintf(histo, "EB Chi2");
   meEBUncalibRecHitsChi2_ = ibooker.book1D(histo, histo, 100, 18000., 22000.);
 
   sprintf(histo, "EB RecHit Max Sample Ratio");
   meEBUncalibRecHitMaxSampleRatio_ = ibooker.book1D(histo, histo, 120, 0.90, 1.05);
 
   sprintf(histo, "EB Occupancy gt 100 adc counts");
   meEBUncalibRecHitsOccupancyGt100adc_ = ibooker.book2D(histo, histo, 170, -85., 85., 360, 0., 360.);
 
   sprintf(histo, "EB Amplitude gt 100 adc counts");
   meEBUncalibRecHitsAmplitudeGt100adc_ = ibooker.book1D(histo, histo, 200, 0., 4000.);
 
   sprintf(histo, "EB Pedestal gt 100 adc counts");
   meEBUncalibRecHitsPedestalGt100adc_ = ibooker.book1D(histo, histo, 50, 190., 210.);
 
   sprintf(histo, "EB Jitter gt 100 adc counts");
   meEBUncalibRecHitsJitterGt100adc_ = ibooker.book1D(histo, histo, 100, 0., 100.);
 
   sprintf(histo, "EB Chi2 gt 100 adc counts");
   meEBUncalibRecHitsChi2Gt100adc_ = ibooker.book1D(histo, histo, 100, 18000., 22000.);
 
   sprintf(histo, "EB RecHit Max Sample Ratio gt 100 adc counts");
   meEBUncalibRecHitMaxSampleRatioGt100adc_ = ibooker.book1D(histo, histo, 120, 0.90, 1.05);
 
   sprintf(histo, "EB Amplitude Full Map");
   meEBUncalibRecHitsAmpFullMap_ = ibooker.bookProfile2D(histo, histo, 170, -85., 85., 360, 0., 360., 200, 0., 4000.);
 
   sprintf(histo, "EB Pedestal Full Map");
   meEBUncalibRecHitsPedFullMap_ = ibooker.bookProfile2D(histo, histo, 170, -85., 85., 360, 0., 360., 50, 194., 201.);
 
   for (int i = 0; i < 36; i++) {
     sprintf(histo, "EB Amp SM%02d", i + 1);
     meEBUncalibRecHitAmplMap_[i] = ibooker.bookProfile2D(histo, histo, 85, 0., 85., 20, 0., 20., 200, 0., 4000.);
 
     sprintf(histo, "EB Ped SM%02d", i + 1);
     meEBUncalibRecHitPedMap_[i] = ibooker.bookProfile2D(histo, histo, 85, 0., 85., 20, 0., 20., 50, 194., 201.);
   }
 }