#include <EcalEndcapSimHitsValidation.h>

Inheritance diagram for EcalEndcapSimHitsValidation:

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

	~EcalEndcapSimHitsValidation () override
	Destructor. More...

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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	beginJob () override

void	endJob (void) 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 Types
typedef std::map< uint32_t, float, std::less< uint32_t > >	MapType

Private Member Functions
float	eCluster2x2 (MapType &themap)

float	eCluster4x4 (float e33, MapType &themap)

virtual float	energyInMatrixEE (int nCellInX, int nCellInY, int centralX, int centralY, int centralZ, MapType &themap)

bool	fillEEMatrix (int nCellInX, int nCellInY, int CentralX, int CentralY, int CentralZ, MapType &fillmap, MapType &themap)

std::vector< uint32_t >	getIdsAroundMax (int nCellInX, int nCellInY, int centralX, int centralY, int centralZ, MapType &themap)

uint32_t	getUnitWithMaxEnergy (MapType &themap)

Private Attributes
DQMStore *	dbe_

std::string	EEHitsCollection

edm::EDGetTokenT< edm::PCaloHitContainer >	EEHitsToken

float	eRLength [26]

std::string	g4InfoLabel

MonitorElement *	meEEcrystalEnergy2_

MonitorElement *	meEEcrystalEnergy_

MonitorElement *	meEEe16_

MonitorElement *	meEEe16oe25_

MonitorElement *	meEEe1_

MonitorElement *	meEEe1oe25_

MonitorElement *	meEEe1oe4_

MonitorElement *	meEEe1oe9_

MonitorElement *	meEEe25_

MonitorElement *	meEEe4_

MonitorElement *	meEEe4oe9_

MonitorElement *	meEEe9_

MonitorElement *	meEEe9oe16_

MonitorElement *	meEEe9oe25_

MonitorElement *	meEEHitEnergy2_

MonitorElement *	meEEHitEnergy_

MonitorElement *	meEEhitLog10Energy25Norm_

MonitorElement *	meEEhitLog10Energy_

MonitorElement *	meEEhitLog10EnergyNorm_

MonitorElement *	meEELongitudinalShower_

MonitorElement *	meEEzmCrystals_

MonitorElement *	meEEzmHits_

MonitorElement *	meEEzmOccupancy_

MonitorElement *	meEEzpCrystals_

MonitorElement *	meEEzpHits_

MonitorElement *	meEEzpOccupancy_

int	myEntries

std::string	outputFile_

std::string	ValidationCollection

edm::EDGetTokenT< PEcalValidInfo >	ValidationCollectionToken

bool	verbose_

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Detailed Description

Definition at line 37 of file EcalEndcapSimHitsValidation.h.

Member Typedef Documentation

typedef std::map<uint32_t,float,std::less<uint32_t> > EcalEndcapSimHitsValidation::MapType

private

Definition at line 39 of file EcalEndcapSimHitsValidation.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 17 of file EcalEndcapSimHitsValidation.cc.

References dbe_, EEHitsCollection, EEHitsToken, eRLength, g4InfoLabel, edm::ParameterSet::getUntrackedParameter(), trackerHits::histo, meEEcrystalEnergy2_, meEEcrystalEnergy_, meEEe16_, meEEe16oe25_, meEEe1_, meEEe1oe25_, meEEe1oe4_, meEEe1oe9_, meEEe25_, meEEe4_, meEEe4oe9_, meEEe9_, meEEe9oe16_, meEEe9oe25_, meEEHitEnergy2_, meEEHitEnergy_, meEEhitLog10Energy25Norm_, meEEhitLog10Energy_, meEEhitLog10EnergyNorm_, meEELongitudinalShower_, meEEzmCrystals_, meEEzmHits_, meEEzmOccupancy_, meEEzpCrystals_, meEEzpHits_, meEEzpOccupancy_, myEntries, Utilities::operator, AlCaHLTBitMon_QueryRunRegistry::string, ValidationCollection, ValidationCollectionToken, and verbose_.

                                                                                  :
   g4InfoLabel(ps.getParameter<std::string>("moduleLabelG4")),
   EEHitsCollection(ps.getParameter<std::string>("EEHitsCollection")),
   ValidationCollection(ps.getParameter<std::string>("ValidationCollection")){   
 
   EEHitsToken               = consumes <edm::PCaloHitContainer> (edm::InputTag(std::string(g4InfoLabel),std::string(EEHitsCollection)));
   ValidationCollectionToken = consumes <PEcalValidInfo>         (edm::InputTag(std::string(g4InfoLabel),std::string(ValidationCollection)));
   // verbosity switch
   verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
  
   // get hold of back-end interface
   dbe_ = nullptr;
   dbe_ = edm::Service<DQMStore>().operator->();           
   if ( dbe_ ) {
     if ( verbose_ ) { dbe_->setVerbose(1); } 
     else            { dbe_->setVerbose(0); }
   }
                                                                                                             
   if ( dbe_ ) {
     if ( verbose_ ) dbe_->showDirStructure();
   }
  
 
   meEEzpHits_             = nullptr;
   meEEzmHits_             = nullptr;
   meEEzpCrystals_         = nullptr;
   meEEzmCrystals_         = nullptr;
   meEEzpOccupancy_        = nullptr;
   meEEzmOccupancy_        = nullptr;
   meEELongitudinalShower_ = nullptr;
   meEEHitEnergy_          = nullptr;
   meEEhitLog10Energy_       = nullptr;
   meEEhitLog10EnergyNorm_   = nullptr;
   meEEhitLog10Energy25Norm_ = nullptr;
   meEEHitEnergy2_         = nullptr;
   meEEcrystalEnergy_      = nullptr;
   meEEcrystalEnergy2_     = nullptr;
 
   meEEe1_  = nullptr;  
   meEEe4_  = nullptr;  
   meEEe9_  = nullptr;  
   meEEe16_ = nullptr; 
   meEEe25_ = nullptr; 
 
   meEEe1oe4_   = nullptr;  
   meEEe1oe9_   = nullptr;  
   meEEe4oe9_   = nullptr;  
   meEEe9oe16_  = nullptr;
   meEEe1oe25_  = nullptr;  
   meEEe9oe25_  = nullptr; 
   meEEe16oe25_ = nullptr;
 
   myEntries = 0;
   for ( int myStep = 0; myStep<26; myStep++) { eRLength[myStep] = 0.0; }
 
   Char_t histo[200];
  
   if ( dbe_ ) {
     dbe_->setCurrentFolder("EcalHitsV/EcalSimHitsValidation");
   
     sprintf (histo, "EE+ hits multiplicity" ) ;
     meEEzpHits_ = dbe_->book1D(histo, histo, 50, 0., 5000.) ; 
 
     sprintf (histo, "EE- hits multiplicity" ) ;
     meEEzmHits_ = dbe_->book1D(histo, histo, 50, 0., 5000.) ; 
 
     sprintf (histo, "EE+ crystals multiplicity" ) ;
     meEEzpCrystals_ = dbe_->book1D(histo, histo, 200, 0., 2000.) ; 
 
     sprintf (histo, "EE- crystals multiplicity" ) ;
     meEEzmCrystals_ = dbe_->book1D(histo, histo, 200, 0., 2000.) ; 
 
     sprintf (histo, "EE+ occupancy" ) ;
     meEEzpOccupancy_ = dbe_->book2D(histo, histo, 100, 0., 100., 100, 0., 100.);
   
     sprintf (histo, "EE- occupancy" ) ;
     meEEzmOccupancy_ = dbe_->book2D(histo, histo, 100, 0., 100., 100, 0., 100.);
   
     sprintf (histo, "EE longitudinal shower profile" ) ;
     meEELongitudinalShower_ = dbe_->bookProfile(histo, histo, 26,0,26, 100, 0, 20000);
 
     sprintf (histo, "EE hits energy spectrum" );
     meEEHitEnergy_ = dbe_->book1D(histo, histo, 4000, 0., 400.);
 
     sprintf (histo, "EE hits log10energy spectrum" );
     meEEhitLog10Energy_ = dbe_->book1D(histo, histo, 140, -10., 4.);
 
     sprintf (histo, "EE hits log10energy spectrum vs normalized energy" );
     meEEhitLog10EnergyNorm_ = dbe_->bookProfile(histo, histo, 140, -10., 4., 100, 0., 1.);
 
     sprintf (histo, "EE hits log10energy spectrum vs normalized energy25" );
     meEEhitLog10Energy25Norm_ = dbe_->bookProfile(histo, histo, 140, -10., 4., 100, 0., 1.);
 
     sprintf (histo, "EE hits energy spectrum 2" );
     meEEHitEnergy2_ = dbe_->book1D(histo, histo, 1000, 0., 0.001);
 
     sprintf (histo, "EE crystal energy spectrum" );
     meEEcrystalEnergy_ = dbe_->book1D(histo, histo, 5000, 0., 50.);
 
     sprintf (histo, "EE crystal energy spectrum 2" );
     meEEcrystalEnergy2_ = dbe_->book1D(histo, histo, 1000, 0., 0.001);
 
     sprintf (histo, "EE E1" ) ;
     meEEe1_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EE E4" ) ;
     meEEe4_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EE E9" ) ;
     meEEe9_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EE E16" ) ;
     meEEe16_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EE E25" ) ;
     meEEe25_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EE E1oE4" ) ;
     meEEe1oe4_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EE E1oE9" ) ;
     meEEe1oe9_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EE E4oE9" ) ;
     meEEe4oe9_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EE E9oE16" ) ;
     meEEe9oe16_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EE E1oE25" ) ;
     meEEe1oe25_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EE E9oE25" ) ;
     meEEe9oe25_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EE E16oE25" ) ;
     meEEe16oe25_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
   }
 }

EcalEndcapSimHitsValidation::~EcalEndcapSimHitsValidation ( )

override

Destructor.

Definition at line 157 of file EcalEndcapSimHitsValidation.cc.

                                                          {
 
 }

Member Function Documentation

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

overrideprotected

Analyze.

Definition at line 173 of file EcalEndcapSimHitsValidation.cc.

References eCluster2x2(), eCluster4x4(), PEcalValidInfo::ee1x1(), EEHitsToken, energyInMatrixEE(), eRLength, edm::EventID::event(), PEcalValidInfo::eX0(), MonitorElement::Fill(), fillEEMatrix(), edm::Event::getByToken(), getIdsAroundMax(), getUnitWithMaxEnergy(), mps_fire::i, edm::EventBase::id(), createfilelist::int, edm::HandleBase::isValid(), EEDetId::ix(), EEDetId::iy(), LogDebug, genParticles_cff::map, meEEcrystalEnergy2_, meEEcrystalEnergy_, meEEe16_, meEEe16oe25_, meEEe1_, meEEe1oe25_, meEEe1oe4_, meEEe1oe9_, meEEe25_, meEEe4_, meEEe4oe9_, meEEe9_, meEEe9oe16_, meEEe9oe25_, meEEHitEnergy2_, meEEHitEnergy_, meEEhitLog10Energy25Norm_, meEEhitLog10Energy_, meEEhitLog10EnergyNorm_, meEELongitudinalShower_, meEEzmCrystals_, meEEzmHits_, meEEzmOccupancy_, meEEzpCrystals_, meEEzpHits_, meEEzpOccupancy_, myEntries, MonitorElement::Reset(), edm::EventID::run(), ValidationCollectionToken, and EEDetId::zside().

                                                                                   {
 
   edm::LogInfo("EventInfo") << " Run = " << e.id().run() << " Event = " << e.id().event();
   
   edm::Handle<edm::PCaloHitContainer> EcalHitsEE;
   e.getByToken(EEHitsToken,EcalHitsEE);
 
   // Do nothing if no EndCap data available
   if( ! EcalHitsEE.isValid() ) return;
 
   edm::Handle<PEcalValidInfo> MyPEcalValidInfo;
   e.getByToken(ValidationCollectionToken,MyPEcalValidInfo);
 
   std::vector<PCaloHit> theEECaloHits;
   theEECaloHits.insert(theEECaloHits.end(), EcalHitsEE->begin(), EcalHitsEE->end());
   
   myEntries++;
 
   std::map<unsigned int, std::vector<PCaloHit*>,std::less<unsigned int> > CaloHitMap;
   
   double EEetzp_ = 0.;
   double EEetzm_ = 0.;
   
   double ee1  = 0.0;
   double ee4  = 0.0;
   double ee9  = 0.0;
   double ee16 = 0.0;
   double ee25 = 0.0;
   std::vector<double> econtr(140, 0. );
   std::vector<double> econtr25(140, 0. );
   
   MapType eemap;
   MapType eemapzp;
   MapType eemapzm;
   uint32_t nEEzpHits = 0;
   uint32_t nEEzmHits = 0;
   
   for (std::vector<PCaloHit>::iterator isim = theEECaloHits.begin();
        isim != theEECaloHits.end(); ++isim){
 
     if ( isim->time() > 500. ) { continue; }
 
     CaloHitMap[ isim->id()].push_back(&(*isim));
     
     EEDetId eeid (isim->id()) ;
     
     LogDebug("HitInfo") 
       << " CaloHit " << isim->getName() << "\n" 
       << " DetID = "<<isim->id()<< " EEDetId = " << eeid.ix() << " " << eeid.iy() << "\n"   
       << " Time = " << isim->time() << "\n"
       << " Track Id = " << isim->geantTrackId() << "\n"
       << " Energy = " << isim->energy();
     
     uint32_t crystid = eeid.rawId();
      
     if (eeid.zside() > 0 ) {
       nEEzpHits++;
       EEetzp_ += isim->energy();
       eemapzp[crystid] += isim->energy();
       if (meEEzpOccupancy_) meEEzpOccupancy_->Fill(eeid.ix(), eeid.iy());
     }
     else if (eeid.zside() < 0 ) {
       nEEzmHits++;
       EEetzm_ += isim->energy();
       eemapzm[crystid] += isim->energy();
       if (meEEzmOccupancy_) meEEzmOccupancy_->Fill(eeid.ix(), eeid.iy());
     }
 
     if (meEEHitEnergy_) meEEHitEnergy_->Fill(isim->energy());
     if( isim->energy() > 0 ) {
       if( meEEhitLog10Energy_ ) meEEhitLog10Energy_->Fill(log10(isim->energy()));
       int log10i = int( ( log10(isim->energy()) + 10. ) * 10. );
       if( log10i >=0 && log10i < 140 ) econtr[log10i] += isim->energy();
     }
     if (meEEHitEnergy2_) meEEHitEnergy2_->Fill(isim->energy());
     eemap[crystid] += isim->energy();
 
 
   }
   
   if (meEEzpCrystals_) meEEzpCrystals_->Fill(eemapzp.size());
   if (meEEzmCrystals_) meEEzmCrystals_->Fill(eemapzm.size());
   
   if (meEEcrystalEnergy_) {
     for (std::map<uint32_t,float,std::less<uint32_t> >::iterator it = eemap.begin(); it != eemap.end(); ++it ) meEEcrystalEnergy_->Fill((*it).second);
   }
   if (meEEcrystalEnergy2_) {
     for (std::map<uint32_t,float,std::less<uint32_t> >::iterator it = eemap.begin(); it != eemap.end(); ++it ) meEEcrystalEnergy2_->Fill((*it).second);
   }
     
   if (meEEzpHits_)    meEEzpHits_->Fill(nEEzpHits);
   if (meEEzmHits_)    meEEzmHits_->Fill(nEEzmHits);
     
   
   int nEEHits = nEEzmHits + nEEzpHits;
   if (nEEHits > 0) {
     
     uint32_t  eecenterid = getUnitWithMaxEnergy(eemap);
     EEDetId myEEid(eecenterid);
     int bx = myEEid.ix();
     int by = myEEid.iy();
     int bz = myEEid.zside();
     ee1 =  energyInMatrixEE(1,1,bx,by,bz,eemap);
     if (meEEe1_) meEEe1_->Fill(ee1);
     ee9 =  energyInMatrixEE(3,3,bx,by,bz,eemap);
     if (meEEe9_) meEEe9_->Fill(ee9);
     ee25=  energyInMatrixEE(5,5,bx,by,bz,eemap);
     if (meEEe25_) meEEe25_->Fill(ee25);
     
     std::vector<uint32_t> ids25; ids25 = getIdsAroundMax(5,5,bx,by,bz,eemap);
 
     for( unsigned i=0; i<25; i++ ) {
       for( unsigned int j=0; j<CaloHitMap[ids25[i]].size(); j++ ) {
     if( CaloHitMap[ids25[i]][j]->energy() > 0 ) {
       int log10i = int( ( log10( CaloHitMap[ids25[i]][j]->energy()) + 10. ) * 10. );
       if( log10i >=0 && log10i < 140 ) econtr25[log10i] += CaloHitMap[ids25[i]][j]->energy();
     }
       }
     }
 
     MapType  neweemap;
     if( fillEEMatrix(3,3,bx,by,bz,neweemap, eemap)){
       ee4 = eCluster2x2(neweemap);
       if (meEEe4_) meEEe4_->Fill(ee4);
     }
     if( fillEEMatrix(5,5,bx,by,bz,neweemap, eemap)){
       ee16 = eCluster4x4(ee9,neweemap); 
       if (meEEe16_) meEEe16_->Fill(ee16);
     }
     
     if (meEEe1oe4_   && ee4  > 0.1 ) meEEe1oe4_  ->Fill(ee1/ee4);
     if (meEEe1oe9_   && ee9  > 0.1 ) meEEe1oe9_  ->Fill(ee1/ee9);
     if (meEEe4oe9_   && ee9  > 0.1 ) meEEe4oe9_  ->Fill(ee4/ee9);
     if (meEEe9oe16_  && ee16 > 0.1 ) meEEe9oe16_ ->Fill(ee9/ee16);
     if (meEEe16oe25_ && ee25 > 0.1 ) meEEe16oe25_->Fill(ee16/ee25);
     if (meEEe1oe25_  && ee25 > 0.1 ) meEEe1oe25_ ->Fill(ee1/ee25);
     if (meEEe9oe25_  && ee25 > 0.1 ) meEEe9oe25_ ->Fill(ee9/ee25);
 
     if( meEEhitLog10EnergyNorm_ && (EEetzp_+EEetzm_) != 0 ) {
       for( int i=0; i<140; i++ ) {
     meEEhitLog10EnergyNorm_->Fill( -10.+(float(i)+0.5)/10., econtr[i]/(EEetzp_+EEetzm_) );
       }
     }
 
     if( meEEhitLog10Energy25Norm_ && ee25 != 0 ) {
       for( int i=0; i<140; i++ ) {
     meEEhitLog10Energy25Norm_->Fill( -10.+(float(i)+0.5)/10., econtr25[i]/ee25 );
       }
     }
     
   }
     
   if( MyPEcalValidInfo.isValid() ) {
     if ( MyPEcalValidInfo->ee1x1() > 0. ) {
       std::vector<float>  EX0 = MyPEcalValidInfo->eX0();
       if (meEELongitudinalShower_) meEELongitudinalShower_->Reset();
       for (int myStep=0; myStep< 26; myStep++ ) { 
     eRLength[myStep] += EX0[myStep]; 
     if (meEELongitudinalShower_) meEELongitudinalShower_->Fill(float(myStep), eRLength[myStep]/myEntries);
       }
     }
   }
 }

void EcalEndcapSimHitsValidation::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 161 of file EcalEndcapSimHitsValidation.cc.

                                           {
 
 }

float EcalEndcapSimHitsValidation::eCluster2x2 ( MapType & themap )

private

Definition at line 431 of file EcalEndcapSimHitsValidation.cc.

Referenced by analyze().

                                                               {
   float  E22=0.;
   float e012  = themap[0]+themap[1]+themap[2];
   float e036  = themap[0]+themap[3]+themap[6];
   float e678  = themap[6]+themap[7]+themap[8];
   float e258  = themap[2]+themap[5]+themap[8];
 
   if ( (e012>e678 || e012==e678) && (e036>e258  || e036==e258))
     return     E22=themap[0]+themap[1]+themap[3]+themap[4];
   else if ( (e012>e678 || e012==e678)  && (e036<e258 || e036==e258) )
     return    E22=themap[1]+themap[2]+themap[4]+themap[5];
   else if ( (e012<e678 || e012==e678) && (e036>e258 || e036==e258))
     return     E22=themap[3]+themap[4]+themap[6]+themap[7];
   else if ( (e012<e678|| e012==e678)  && (e036<e258|| e036==e258) )
     return    E22=themap[4]+themap[5]+themap[7]+themap[8];
   else {
     return E22;
   }
 }

float EcalEndcapSimHitsValidation::eCluster4x4	(	float	e33,
		MapType &	themap
	)

private

Definition at line 451 of file EcalEndcapSimHitsValidation.cc.

Referenced by analyze().

                                                                           {
   float E44=0.;
   float e0_4   = themap[0]+themap[1]+themap[2]+themap[3]+themap[4];
   float e0_20  = themap[0]+themap[5]+themap[10]+themap[15]+themap[20];
   float e4_24  = themap[4]+themap[9]+themap[14]+themap[19]+themap[24];
   float e0_24  = themap[20]+themap[21]+themap[22]+themap[23]+themap[24];
   
   if ((e0_4>e0_24 || e0_4==e0_24) && (e0_20>e4_24|| e0_20==e4_24))
     return E44=e33+themap[0]+themap[1]+themap[2]+themap[3]+themap[5]+themap[10]+themap[15];
   else if ((e0_4>e0_24 || e0_4==e0_24)  && (e0_20<e4_24 || e0_20==e4_24))
     return E44=e33+themap[1]+themap[2]+themap[3]+themap[4]+themap[9]+themap[14]+themap[19];
   else if ((e0_4<e0_24|| e0_4==e0_24) && (e0_20>e4_24 || e0_20==e4_24))
     return E44=e33+themap[5]+themap[10]+themap[15]+themap[20]+themap[21]+themap[22]+themap[23];
   else if ((e0_4<e0_24|| e0_4==e0_24) && (e0_20<e4_24 || e0_20==e4_24))
     return E44=e33+themap[21]+themap[22]+themap[23]+themap[24]+themap[9]+themap[14]+themap[19];
   else{
     return E44;
   }
 }

void EcalEndcapSimHitsValidation::endJob ( void )

overrideprotectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 165 of file EcalEndcapSimHitsValidation.cc.

                                         {
 
   //for ( int myStep = 0; myStep<26; myStep++){
   //  if (meEELongitudinalShower_) meEELongitudinalShower_->Fill(float(myStep), eRLength[myStep]/myEntries);
   //}
 
 }

float EcalEndcapSimHitsValidation::energyInMatrixEE	(	int	nCellInX,
		int	nCellInY,
		int	centralX,
		int	centralY,
		int	centralZ,
		MapType &	themap
	)

privatevirtual

Definition at line 337 of file EcalEndcapSimHitsValidation.cc.

References LogDebug, DetId::rawId(), and EEDetId::validDetId().

Referenced by analyze().

                                                                       {
   
   int   ncristals   = 0;
   float totalEnergy = 0.;
         
   int goBackInX = nCellInX/2;
   int goBackInY = nCellInY/2;
   int startX    = centralX-goBackInX;
   int startY    = centralY-goBackInY;
   
   for (int ix=startX; ix<startX+nCellInX; ix++) {
     for (int iy=startY; iy<startY+nCellInY; iy++) {
       uint32_t index ;
       
       if(EEDetId::validDetId(ix,iy,centralZ)) {
         index = EEDetId(ix,iy,centralZ).rawId();
       }
       else { continue; }
 
       totalEnergy   += themap[index];
       ncristals     += 1;
     }
   }
   
   LogDebug("GeomInfo")
     << nCellInX << " x " << nCellInY 
     << " EE matrix energy = " << totalEnergy
     << " for " << ncristals << " crystals";
   return totalEnergy;
   
 }

bool EcalEndcapSimHitsValidation::fillEEMatrix	(	int	nCellInX,
		int	nCellInY,
		int	CentralX,
		int	CentralY,
		int	CentralZ,
		MapType &	fillmap,
		MapType &	themap
	)

private

Definition at line 398 of file EcalEndcapSimHitsValidation.cc.

References getUnitWithMaxEnergy(), mps_fire::i, DetId::rawId(), and EEDetId::validDetId().

Referenced by analyze().

 {
    int goBackInX = nCellInX/2;
    int goBackInY = nCellInY/2;
 
    int startX  =  CentralX - goBackInX;
    int startY  =  CentralY - goBackInY;
 
    int i = 0 ;
    for ( int ix = startX; ix < startX+nCellInX; ix ++ ) {
 
       for( int iy = startY; iy < startY + nCellInY; iy++ ) {
 
         uint32_t index ;
 
     if(EEDetId::validDetId(ix,iy,CentralZ)) {
           index = EEDetId(ix,iy,CentralZ).rawId();
     }
     else { continue; }
         fillmap[i++] = themap[index];
       }
    }
    uint32_t  centerid = getUnitWithMaxEnergy(themap);
 
    if ( fillmap[i/2] == themap[centerid] ) 
         return true;
    else
         return false;
 }

std::vector< uint32_t > EcalEndcapSimHitsValidation::getIdsAroundMax	(	int	nCellInX,
		int	nCellInY,
		int	centralX,
		int	centralY,
		int	centralZ,
		MapType &	themap
	)

private

Definition at line 371 of file EcalEndcapSimHitsValidation.cc.

References photons_cff::ids, DetId::rawId(), and EEDetId::validDetId().

Referenced by analyze().

                                                                                                                                                       {
   
   int   ncristals   = 0;
   std::vector<uint32_t> ids( nCellInX*nCellInY );
         
   int goBackInX = nCellInX/2;
   int goBackInY = nCellInY/2;
   int startX    = centralX-goBackInX;
   int startY    = centralY-goBackInY;
   
   for (int ix=startX; ix<startX+nCellInX; ix++) {
     for (int iy=startY; iy<startY+nCellInY; iy++) {
       uint32_t index ;
       
       if(EEDetId::validDetId(ix,iy,centralZ)) {
         index = EEDetId(ix,iy,centralZ).rawId();
       }
       else { continue; }
 
       ids[ncristals] = index;
       ncristals     += 1;
     }
   }
   
   return ids;
 }

uint32_t EcalEndcapSimHitsValidation::getUnitWithMaxEnergy ( MapType & themap )

private

Definition at line 471 of file EcalEndcapSimHitsValidation.cc.

References LogDebug, and particleFlowClusterECALTimeSelected_cfi::maxEnergy.

Referenced by analyze(), and fillEEMatrix().

                                                                           {
   
   //look for max
   uint32_t unitWithMaxEnergy = 0;
   float    maxEnergy = 0.;
   
   MapType::iterator iter;
   for (iter = themap.begin(); iter != themap.end(); iter++) {
     
     if (maxEnergy < (*iter).second) {
       maxEnergy = (*iter).second;       
       unitWithMaxEnergy = (*iter).first;
     }                           
   }
   
   LogDebug("GeomInfo")
     << " max energy of " << maxEnergy 
     << " GeV in Unit id " << unitWithMaxEnergy;
   return unitWithMaxEnergy;
 }