#include <EcalBarrelSimHitsValidation.h>

Inheritance diagram for EcalBarrelSimHitsValidation:

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

	~EcalBarrelSimHitsValidation ()
	Destructor. More...

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

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

	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 &	itemsToGetFromEvent () 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

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)
	Analyze. More...

void	beginJob ()

void	endJob (void)

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	energyInMatrixEB (int nCellInEta, int nCellInPhi, int centralEta, int centralPhi, int centralZ, MapType &themap)

bool	fillEBMatrix (int nCellInEta, int nCellInPhi, int CentralEta, int CentralPhi, int CentralZ, MapType &fillmap, MapType &themap)

std::vector< uint32_t >	getIdsAroundMax (int nCellInEta, int nCellInPhi, int centralEta, int centralPhi, int centralZ, MapType &themap)

uint32_t	getUnitWithMaxEnergy (MapType &themap)

Private Attributes
DQMStore *	dbe_

std::string	EBHitsCollection

edm::EDGetTokenT < edm::PCaloHitContainer >	EBHitsToken

float	eRLength [26]

std::string	g4InfoLabel

MonitorElement *	meEBcrystalEnergy2_

MonitorElement *	meEBcrystalEnergy_

MonitorElement *	meEBe16_

MonitorElement *	meEBe16oe25_

MonitorElement *	meEBe1_

MonitorElement *	meEBe1oe25_

MonitorElement *	meEBe1oe4_

MonitorElement *	meEBe1oe9_

MonitorElement *	meEBe25_

MonitorElement *	meEBe4_

MonitorElement *	meEBe4oe9_

MonitorElement *	meEBe9_

MonitorElement *	meEBe9oe16_

MonitorElement *	meEBe9oe25_

MonitorElement *	meEBhitEnergy2_

MonitorElement *	meEBhitEnergy_

MonitorElement *	meEBhitLog10Energy25Norm_

MonitorElement *	meEBhitLog10Energy_

MonitorElement *	meEBhitLog10EnergyNorm_

MonitorElement *	meEBLongitudinalShower_

MonitorElement *	meEBOccupancy_

MonitorElement *	menEBCrystals_

MonitorElement *	menEBHits_

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 &)

Detailed Description

Definition at line 36 of file EcalBarrelSimHitsValidation.h.

Member Typedef Documentation

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

private

Definition at line 38 of file EcalBarrelSimHitsValidation.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 17 of file EcalBarrelSimHitsValidation.cc.

References dbe_, EBHitsCollection, EBHitsToken, eRLength, g4InfoLabel, edm::ParameterSet::getUntrackedParameter(), timingPdfMaker::histo, HLT_25ns10e33_v2_cff::InputTag, meEBcrystalEnergy2_, meEBcrystalEnergy_, meEBe16_, meEBe16oe25_, meEBe1_, meEBe1oe25_, meEBe1oe4_, meEBe1oe9_, meEBe25_, meEBe4_, meEBe4oe9_, meEBe9_, meEBe9oe16_, meEBe9oe25_, meEBhitEnergy2_, meEBhitEnergy_, meEBhitLog10Energy25Norm_, meEBhitLog10Energy_, meEBhitLog10EnergyNorm_, meEBLongitudinalShower_, meEBOccupancy_, menEBCrystals_, menEBHits_, myEntries, cppFunctionSkipper::operator, AlCaHLTBitMon_QueryRunRegistry::string, ValidationCollection, ValidationCollectionToken, and verbose_.

                                                                                  :
   g4InfoLabel(ps.getParameter<std::string>("moduleLabelG4")),
   EBHitsCollection(ps.getParameter<std::string>("EBHitsCollection")),
   ValidationCollection(ps.getParameter<std::string>("ValidationCollection")){   
 
   EBHitsToken               = consumes <edm::PCaloHitContainer> (edm::InputTag(std::string(g4InfoLabel),std::string(EBHitsCollection)));
   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_ = 0;
   dbe_ = edm::Service<DQMStore>().operator->();           
   if ( dbe_ ) {
     if ( verbose_ ) { dbe_->setVerbose(1); } 
     else            { dbe_->setVerbose(0); }
   }
                                                                                
   if ( dbe_ ) {
     if ( verbose_ ) dbe_->showDirStructure();
   }
  
   menEBHits_       = 0;
   menEBCrystals_   = 0;
   meEBOccupancy_   = 0;
   meEBLongitudinalShower_ = 0;
   meEBhitEnergy_   = 0;
   meEBhitLog10Energy_       = 0;
   meEBhitLog10EnergyNorm_   = 0;
   meEBhitLog10Energy25Norm_ = 0;
   meEBhitEnergy2_   = 0;
   meEBcrystalEnergy_   = 0;
   meEBcrystalEnergy2_   = 0;
 
   meEBe1_  = 0;  
   meEBe4_  = 0;  
   meEBe9_  = 0;  
   meEBe16_ = 0; 
   meEBe25_ = 0; 
 
   meEBe1oe4_   = 0;  
   meEBe1oe9_   = 0;  
   meEBe4oe9_   = 0;  
   meEBe9oe16_  = 0;
   meEBe1oe25_  = 0;  
   meEBe9oe25_  = 0; 
   meEBe16oe25_ = 0;
 
   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, "EB hits multiplicity" ) ;
     menEBHits_ = dbe_->book1D(histo, histo, 50, 0., 5000.) ;
  
     sprintf (histo, "EB crystals multiplicity" ) ;
     menEBCrystals_ = dbe_->book1D(histo, histo, 200, 0., 2000.) ; 
 
     sprintf (histo, "EB occupancy" ) ;
     meEBOccupancy_ = dbe_->book2D(histo, histo, 360, 0., 360., 170, -85., 85.);
   
     sprintf (histo, "EB longitudinal shower profile" ) ;
     meEBLongitudinalShower_ = dbe_->bookProfile(histo, histo, 26, 0., 26., 100, 0., 20000.);
 
     sprintf (histo, "EB hits energy spectrum" );
     meEBhitEnergy_ = dbe_->book1D(histo, histo, 4000, 0., 400.);
 
     sprintf (histo, "EB hits log10energy spectrum" );
     meEBhitLog10Energy_ = dbe_->book1D(histo, histo, 140, -10., 4.);
 
     sprintf (histo, "EB hits log10energy spectrum vs normalized energy" );
     meEBhitLog10EnergyNorm_ = dbe_->bookProfile(histo, histo, 140, -10., 4., 100, 0., 1.);
 
     sprintf (histo, "EB hits log10energy spectrum vs normalized energy25" );
     meEBhitLog10Energy25Norm_ = dbe_->bookProfile(histo, histo, 140, -10., 4., 100, 0., 1.);
 
     sprintf (histo, "EB hits energy spectrum 2" );
     meEBhitEnergy2_ = dbe_->book1D(histo, histo, 1000, 0., 0.001);
 
     sprintf (histo, "EB crystal energy spectrum" );
     meEBcrystalEnergy_ = dbe_->book1D(histo, histo, 5000, 0., 50.);
 
     sprintf (histo, "EB crystal energy spectrum 2" );
     meEBcrystalEnergy2_ = dbe_->book1D(histo, histo, 1000, 0., 0.001);
 
     sprintf (histo, "EB E1" ) ;
     meEBe1_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EB E4" ) ;
     meEBe4_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EB E9" ) ;
     meEBe9_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EB E16" ) ;
     meEBe16_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EB E25" ) ;
     meEBe25_ = dbe_->book1D(histo, histo, 400, 0., 400.);
 
     sprintf (histo, "EB E1oE4" ) ;
     meEBe1oe4_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EB E1oE9" ) ;
     meEBe1oe9_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EB E4oE9" ) ;
     meEBe4oe9_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EB E9oE16" ) ;
     meEBe9oe16_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EB E1oE25" ) ;
     meEBe1oe25_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EB E9oE25" ) ;
     meEBe9oe25_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
 
     sprintf (histo, "EB E16oE25" ) ;
     meEBe16oe25_ = dbe_->book1D(histo, histo, 100, 0.4, 1.1);
   }
 }

EcalBarrelSimHitsValidation::~EcalBarrelSimHitsValidation ( )

Destructor.

Definition at line 144 of file EcalBarrelSimHitsValidation.cc.

                                                          {
  
 }

Member Function Documentation

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

protectedvirtual

Analyze.

Implements edm::EDAnalyzer.

Definition at line 159 of file EcalBarrelSimHitsValidation.cc.

References EBHitsToken, eCluster2x2(), eCluster4x4(), relval_parameters_module::energy, energyInMatrixEB(), eRLength, edm::EventID::event(), MonitorElement::Fill(), HcalObjRepresent::Fill(), fillEBMatrix(), edm::Event::getByToken(), getIdsAroundMax(), getUnitWithMaxEnergy(), i, edm::EventBase::id(), EBDetId::ietaAbs(), EBDetId::iphi(), edm::HandleBase::isValid(), j, LogDebug, meEBcrystalEnergy2_, meEBcrystalEnergy_, meEBe16_, meEBe16oe25_, meEBe1_, meEBe1oe25_, meEBe1oe4_, meEBe1oe9_, meEBe25_, meEBe4_, meEBe4oe9_, meEBe9_, meEBe9oe16_, meEBe9oe25_, meEBhitEnergy2_, meEBhitEnergy_, meEBhitLog10Energy25Norm_, meEBhitLog10Energy_, meEBhitLog10EnergyNorm_, meEBLongitudinalShower_, meEBOccupancy_, menEBCrystals_, menEBHits_, myEntries, MonitorElement::Reset(), edm::EventID::run(), ValidationCollectionToken, and EBDetId::zside().

                                                                                   {
 
   edm::LogInfo("EventInfo") << " Run = " << e.id().run() << " Event = " << e.id().event();
   
   edm::Handle<edm::PCaloHitContainer> EcalHitsEB;
   e.getByToken(EBHitsToken,EcalHitsEB);
 
   // Do nothing if no Barrel data available
   if( ! EcalHitsEB.isValid() ) return;
 
   edm::Handle<PEcalValidInfo> MyPEcalValidInfo;
   e.getByToken(ValidationCollectionToken,MyPEcalValidInfo);
 
   std::vector<PCaloHit> theEBCaloHits;
   theEBCaloHits.insert(theEBCaloHits.end(), EcalHitsEB->begin(), EcalHitsEB->end());
 
   myEntries++;
 
   double EBEnergy_ = 0.;
   std::map<unsigned int, std::vector<PCaloHit*>,std::less<unsigned int> > CaloHitMap;
   
   double eb1  = 0.0;
   double eb4  = 0.0;
   double eb9  = 0.0;
   double eb16 = 0.0;
   double eb25 = 0.0;
   std::vector<double> econtr(140, 0. );
   std::vector<double> econtr25(140, 0. );
   
   MapType ebmap;
   uint32_t nEBHits = 0;
   
   for (std::vector<PCaloHit>::iterator isim = theEBCaloHits.begin();
        isim != theEBCaloHits.end(); ++isim){
 
     if ( isim->time() > 500. ) { continue; }
 
     CaloHitMap[ isim->id()].push_back( &(*isim) );
     
     EBDetId ebid (isim->id()) ;
     
     LogDebug("HitInfo") 
       << " CaloHit "    << isim->getName() << "\n" 
       << " DetID = "    << isim->id()   << " EBDetId = " << ebid.ieta() << " " << ebid.iphi() << "\n" 
       << " Time = "     << isim->time()    << "\n"
       << " Track Id = " << isim->geantTrackId() << "\n"
       << " Energy = "   << isim->energy();
     
     if (meEBOccupancy_) meEBOccupancy_->Fill( ebid.iphi(), ebid.ieta() );
     
     uint32_t crystid = ebid.rawId();
     ebmap[crystid] += isim->energy();
     
     EBEnergy_ += isim->energy();
     nEBHits++;
     meEBhitEnergy_->Fill(isim->energy());
     if( isim->energy() > 0 ) {
       meEBhitLog10Energy_->Fill(log10(isim->energy()));
       int log10i = int( ( log10(isim->energy()) + 10. ) * 10. );
       if( log10i >=0 && log10i < 140 ) econtr[log10i] += isim->energy();
     }
     meEBhitEnergy2_->Fill(isim->energy());
     
   }
 
   if (menEBCrystals_) menEBCrystals_->Fill(ebmap.size());
   if (meEBcrystalEnergy_) {
     for (std::map<uint32_t,float,std::less<uint32_t> >::iterator it = ebmap.begin(); it != ebmap.end(); ++it ) meEBcrystalEnergy_->Fill((*it).second);
   }
   if (meEBcrystalEnergy2_) {
     for (std::map<uint32_t,float,std::less<uint32_t> >::iterator it = ebmap.begin(); it != ebmap.end(); ++it ) meEBcrystalEnergy2_->Fill((*it).second);
   }
   
   if (menEBHits_) menEBHits_->Fill(nEBHits);
   
   if (nEBHits > 0 ) {
     
     uint32_t  ebcenterid = getUnitWithMaxEnergy(ebmap);
     EBDetId myEBid(ebcenterid);
     int bx = myEBid.ietaAbs();
     int by = myEBid.iphi();
     int bz = myEBid.zside();
     eb1 =  energyInMatrixEB(1,1,bx,by,bz,ebmap);
     if (meEBe1_) meEBe1_->Fill(eb1);
     eb9 =  energyInMatrixEB(3,3,bx,by,bz,ebmap);
     if (meEBe9_) meEBe9_->Fill(eb9);
     eb25=  energyInMatrixEB(5,5,bx,by,bz,ebmap);
     if (meEBe25_) meEBe25_->Fill(eb25);
     
     std::vector<uint32_t> ids25; ids25 = getIdsAroundMax(5,5,bx,by,bz,ebmap);
 
     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  newebmap;
     if( fillEBMatrix(3,3,bx,by,bz,newebmap, ebmap)){
       eb4 = eCluster2x2(newebmap);
       if (meEBe4_) meEBe4_->Fill(eb4);
     }
     if( fillEBMatrix(5,5,bx,by,bz,newebmap, ebmap)){
       eb16 = eCluster4x4(eb9,newebmap); 
       if (meEBe16_) meEBe16_->Fill(eb16);
     }
     
     if (meEBe1oe4_   && eb4  > 0.1 ) meEBe1oe4_  -> Fill(eb1/eb4);
     if (meEBe1oe9_   && eb9  > 0.1 ) meEBe1oe9_  -> Fill(eb1/eb9);
     if (meEBe4oe9_   && eb9  > 0.1 ) meEBe4oe9_  -> Fill(eb4/eb9);
     if (meEBe9oe16_  && eb16 > 0.1 ) meEBe9oe16_ -> Fill(eb9/eb16);
     if (meEBe1oe25_  && eb25 > 0.1 ) meEBe1oe25_ -> Fill(eb1/eb25);
     if (meEBe9oe25_  && eb25 > 0.1 ) meEBe9oe25_ -> Fill(eb9/eb25);
     if (meEBe16oe25_ && eb25 > 0.1 ) meEBe16oe25_-> Fill(eb16/eb25);
 
     if( meEBhitLog10EnergyNorm_ && EBEnergy_ != 0 ) {
       for( int i=0; i<140; i++ ) {
     meEBhitLog10EnergyNorm_->Fill( -10.+(float(i)+0.5)/10., econtr[i]/EBEnergy_ );
       }
     }
 
     if( meEBhitLog10Energy25Norm_ && eb25 != 0 ) {
       for( int i=0; i<140; i++ ) {
     meEBhitLog10Energy25Norm_->Fill( -10.+(float(i)+0.5)/10., econtr25[i]/eb25 );
       }
     }
 
 
   }
   
 
   if( MyPEcalValidInfo.isValid() ) {
     if ( MyPEcalValidInfo->eb1x1() > 0. ) {
       std::vector<float>  BX0 = MyPEcalValidInfo->bX0();
       if (meEBLongitudinalShower_) meEBLongitudinalShower_->Reset();
       for (int myStep=0; myStep< 26; myStep++ ) { 
     eRLength[myStep] += BX0[myStep]; 
     if (meEBLongitudinalShower_) meEBLongitudinalShower_->Fill(float(myStep), eRLength[myStep]/myEntries);
       }
     }
   }
 }

void EcalBarrelSimHitsValidation::beginJob ( void )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 148 of file EcalBarrelSimHitsValidation.cc.

                                           {
 
 }

float EcalBarrelSimHitsValidation::eCluster2x2 ( MapType & themap )

private

Definition at line 396 of file EcalBarrelSimHitsValidation.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 EcalBarrelSimHitsValidation::eCluster4x4	(	float	e33,
		MapType &	themap
	)

private

Definition at line 416 of file EcalBarrelSimHitsValidation.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 EcalBarrelSimHitsValidation::endJob ( void )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 152 of file EcalBarrelSimHitsValidation.cc.

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

float EcalBarrelSimHitsValidation::energyInMatrixEB	(	int	nCellInEta,
		int	nCellInPhi,
		int	centralEta,
		int	centralPhi,
		int	centralZ,
		MapType &	themap
	)

privatevirtual

Definition at line 305 of file EcalBarrelSimHitsValidation.cc.

References funct::abs(), cmsHarvester::index, LogDebug, and DetId::rawId().

Referenced by analyze().

                                                         {
 
   int   ncristals   = 0;
   float totalEnergy = 0.;
   
   int goBackInEta = nCellInEta/2;
   int goBackInPhi = nCellInPhi/2;
   int startEta    = centralZ*centralEta-goBackInEta;
   int startPhi    = centralPhi-goBackInPhi;
   
   for (int ieta=startEta; ieta<startEta+nCellInEta; ieta++) {
     for (int iphi=startPhi; iphi<startPhi+nCellInPhi; iphi++) {
       
       uint32_t index ;
       if (abs(ieta) > 85 || abs(ieta)<1 ) { continue; }
       if (iphi< 1)      { index = EBDetId(ieta,iphi+360).rawId(); }
       else if(iphi>360) { index = EBDetId(ieta,iphi-360).rawId(); }
       else              { index = EBDetId(ieta,iphi).rawId();     }
 
       totalEnergy   += themap[index];
       ncristals     += 1;
     }
   }
   
   LogDebug("GeomInfo")
     << nCellInEta << " x " << nCellInPhi 
     << " EB matrix energy = " << totalEnergy
     << " for " << ncristals << " crystals" ;
   return totalEnergy;
   
 }   

bool EcalBarrelSimHitsValidation::fillEBMatrix	(	int	nCellInEta,
		int	nCellInPhi,
		int	CentralEta,
		int	CentralPhi,
		int	CentralZ,
		MapType &	fillmap,
		MapType &	themap
	)

private

Definition at line 366 of file EcalBarrelSimHitsValidation.cc.

References funct::abs(), getUnitWithMaxEnergy(), i, cmsHarvester::index, and DetId::rawId().

Referenced by analyze().

 {
   int goBackInEta = nCellInEta/2;
   int goBackInPhi = nCellInPhi/2;
   
   int startEta  =  CentralZ*CentralEta - goBackInEta;
   int startPhi  =  CentralPhi - goBackInPhi;
   
   int i = 0 ;
   for ( int ieta = startEta; ieta < startEta+nCellInEta; ieta ++ ) {
     for( int iphi = startPhi; iphi < startPhi + nCellInPhi; iphi++ ) {
       uint32_t  index;
       if (abs(ieta) > 85 || abs(ieta)<1 ) { continue; }
       if (iphi< 1)      { index = EBDetId(ieta,iphi+360).rawId(); }
       else if(iphi>360) { index = EBDetId(ieta,iphi-360).rawId(); }
       else              { index = EBDetId(ieta,iphi).rawId();     }
       fillmap[i++] = themap[index];
     }
   }
   
   uint32_t  ebcenterid = getUnitWithMaxEnergy(themap);
   
   if ( fillmap[i/2] == themap[ebcenterid] ) 
     return true;
   else 
     return false;
 } 

std::vector< uint32_t > EcalBarrelSimHitsValidation::getIdsAroundMax	(	int	nCellInEta,
		int	nCellInPhi,
		int	centralEta,
		int	centralPhi,
		int	centralZ,
		MapType &	themap
	)

private

Definition at line 339 of file EcalBarrelSimHitsValidation.cc.

References funct::abs(), cmsHarvester::index, and DetId::rawId().

Referenced by analyze().

                                                                                                                                                               {
 
   int   ncristals   = 0;
   std::vector<uint32_t> ids( nCellInEta*nCellInPhi );
   
   int goBackInEta = nCellInEta/2;
   int goBackInPhi = nCellInPhi/2;
   int startEta    = centralZ*centralEta-goBackInEta;
   int startPhi    = centralPhi-goBackInPhi;
   
   for (int ieta=startEta; ieta<startEta+nCellInEta; ieta++) {
     for (int iphi=startPhi; iphi<startPhi+nCellInPhi; iphi++) {
       
       uint32_t index ;
       if (abs(ieta) > 85 || abs(ieta)<1 ) { continue; }
       if (iphi< 1)      { index = EBDetId(ieta,iphi+360).rawId(); }
       else if(iphi>360) { index = EBDetId(ieta,iphi-360).rawId(); }
       else              { index = EBDetId(ieta,iphi).rawId();     }
       ids[ncristals] = index;
       ncristals     += 1;
     }
   }
   
   return ids;
   
 }   

uint32_t EcalBarrelSimHitsValidation::getUnitWithMaxEnergy ( MapType & themap )

private

Definition at line 436 of file EcalBarrelSimHitsValidation.cc.

References LogDebug.

Referenced by analyze(), and fillEBMatrix().

                                                                           {
   
   //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;
 }