#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 DQMEDAnalyzer
void	accumulate (edm::Event const &ev, edm::EventSetup const &es) final

virtual void	analyze (edm::Event const &, edm::EventSetup const &)

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

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

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

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override

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

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

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) override

	~DQMEDAnalyzer () override=default

Public Member Functions inherited from edm::one::EDProducer< edm::Accumulator, edm::EndLuminosityBlockProducer, edm::EndRunProducer, edm::one::WatchLuminosityBlocks, edm::one::WatchRuns >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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_

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 35 of file EcalPreshowerRecHitsValidation.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 18 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 54 of file EcalPreshowerRecHitsValidation.cc.

                                                                {   
 
 }

Member Function Documentation

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

overrideprotected

Analyze.

Definition at line 116 of file EcalPreshowerRecHitsValidation.cc.

References edm::SortedCollection< T, SORT >::begin(), edm::SortedCollection< T, SORT >::end(), HcalObjRepresent::Fill(), 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 &
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 58 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.);
     }
 }