#include <EcalPreshowerRecHitsValidation.h>

Inheritance diagram for EcalPreshowerRecHitsValidation:

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

	~EcalPreshowerRecHitsValidation ()
	Destructor. More...

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c)
	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::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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_           = 0;                // total energy
   meESRecHitsEnergy_zp1st_     = 0;    
   meESRecHitsEnergy_zp2nd_     = 0;    
   meESRecHitsEnergy_zm1st_     = 0;    
   meESRecHitsEnergy_zm2nd_     = 0;    
   meESRecHitsMultip_           = 0;                // total multiplicity
   meESRecHitsMultip_zp1st_     = 0;    
   meESRecHitsMultip_zp2nd_     = 0;    
   meESRecHitsMultip_zm1st_     = 0;    
   meESRecHitsMultip_zm2nd_     = 0;    
   meESEERecHitsEnergy_zp_      = 0;                // versus EE energy 
   meESEERecHitsEnergy_zm_      = 0;      
 
   for (int kk=0; kk<32; kk++)
     { 
       meESRecHitsStripOccupancy_zp1st_[kk] = 0;   
       meESRecHitsStripOccupancy_zm1st_[kk] = 0;   
       meESRecHitsStripOccupancy_zp2nd_[kk] = 0;   
       meESRecHitsStripOccupancy_zm2nd_[kk] = 0;   
     }
 }

EcalPreshowerRecHitsValidation::~EcalPreshowerRecHitsValidation ( )

Destructor.

Definition at line 54 of file EcalPreshowerRecHitsValidation.cc.

                                                                {   
 
 }

Member Function Documentation

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

protectedvirtual

Analyze.

Implements edm::stream::EDAnalyzerBase.

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(), ESDetId::six(), ESDetId::siy(), ESDetId::strip(), ESDetId::zside(), EEDetId::zside(), and ecaldqm::zside().

                                                                                {
 
   const ESRecHitCollection *ESRecHit = 0;
   Handle<ESRecHitCollection> EcalRecHitES;
   e.getByToken( ESrechitCollection_token_, EcalRecHitES);
   if (EcalRecHitES.isValid()) {
     ESRecHit = EcalRecHitES.product ();
   } else {
     return;
   }
 
   bool skipEE = false;
   const EERecHitCollection *EERecHit = 0;
   Handle<EERecHitCollection> EcalRecHitEE;
   e.getByToken( EErechitCollection_token_, EcalRecHitEE);
   if (EcalRecHitEE.isValid()){   
     EERecHit = EcalRecHitEE.product ();  
   } else {
     skipEE = true;
   }
 
   const EEUncalibratedRecHitCollection *EEUncalibRecHit = 0;
   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(), timingPdfMaker::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.);
     }
 }