#include <Validation/HGCalValidation/plugins/HGCalHitValidation.cc>

Inheritance diagram for HGCalHitValidation:

Public Member Functions
	HGCalHitValidation (const edm::ParameterSet &)

	~HGCalHitValidation () override

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

	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 () noexcept(false) 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)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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 Types
typedef std::tuple< float, float, float, float >	HGCHitTuple

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

template<class T1 >
void	analyzeHGCalRecHit (T1 const &theHits, std::map< unsigned int, HGCHitTuple > const &hitRefs)

void	analyzeHGCalSimHit (edm::Handle< std::vector< PCaloHit >> const &simHits, int idet, MonitorElement *hist, std::map< unsigned int, HGCHitTuple > &)

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

void	dqmBeginRun (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< HGChebRecHitCollection >	bhRecHitTokeng_

edm::EDGetTokenT< HBHERecHitCollection >	bhRecHitTokenh_

edm::InputTag	bhSimHitSource

edm::EDGetTokenT< std::vector< PCaloHit > >	bhSimHitToken_

edm::EDGetTokenT< HGCeeRecHitCollection >	eeRecHitToken_

edm::InputTag	eeSimHitSource

edm::EDGetTokenT< std::vector< PCaloHit > >	eeSimHitToken_

edm::EDGetTokenT< HGChefRecHitCollection >	fhRecHitToken_

edm::InputTag	fhSimHitSource

edm::EDGetTokenT< std::vector< PCaloHit > >	fhSimHitToken_

std::vector< std::string >	geometrySource_

const HcalDDDRecConstants *	hcConr_

const HcalDDDSimConstants *	hcCons_

const CaloSubdetectorGeometry *	hcGeometry_

MonitorElement *	hebdEtaVsEta

MonitorElement *	hebdPhiVsPhi

MonitorElement *	hebdzVsZ

MonitorElement *	hebEnRec

MonitorElement *	hebEnSim

MonitorElement *	hebEnSimRec

MonitorElement *	hebRecVsSimX

MonitorElement *	hebRecVsSimY

MonitorElement *	hebRecVsSimZ

MonitorElement *	heedxVsX

MonitorElement *	heedyVsY

MonitorElement *	heedzVsZ

MonitorElement *	heeEnRec

MonitorElement *	heeEnSim

MonitorElement *	heeEnSimRec

MonitorElement *	heeRecVsSimX

MonitorElement *	heeRecVsSimY

MonitorElement *	heeRecVsSimZ

MonitorElement *	hefdxVsX

MonitorElement *	hefdyVsY

MonitorElement *	hefdzVsZ

MonitorElement *	hefEnRec

MonitorElement *	hefEnSim

MonitorElement *	hefEnSimRec

MonitorElement *	hefRecVsSimX

MonitorElement *	hefRecVsSimY

MonitorElement *	hefRecVsSimZ

std::vector< const HGCalDDDConstants * >	hgcCons_

std::vector< const HGCalGeometry * >	hgcGeometry_

std::vector< int >	ietaExcludeBH_

bool	ifHCAL_

bool	ifHCALsim_

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

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 62 of file HGCalHitValidation.cc.

Member Typedef Documentation

typedef std::tuple<float,float,float,float> HGCalHitValidation::HGCHitTuple

protected

Definition at line 71 of file HGCalHitValidation.cc.

Constructor & Destructor Documentation

HGCalHitValidation::HGCalHitValidation ( const edm::ParameterSet & cfg )

explicit

Definition at line 121 of file HGCalHitValidation.cc.

References bhRecHitTokeng_, bhRecHitTokenh_, bhSimHitToken_, eeRecHitToken_, eeSimHitToken_, fhRecHitToken_, fhSimHitToken_, geometrySource_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), ietaExcludeBH_, ifHCAL_, ifHCALsim_, and gen::k.

                                                                  {
 
   geometrySource_ = cfg.getUntrackedParameter< std::vector<std::string> >("geometrySource");
   eeSimHitToken_  = consumes<std::vector<PCaloHit>>(cfg.getParameter<edm::InputTag>("eeSimHitSource"));
   fhSimHitToken_  = consumes<std::vector<PCaloHit>>(cfg.getParameter<edm::InputTag>("fhSimHitSource"));
   bhSimHitToken_  = consumes<std::vector<PCaloHit>>(cfg.getParameter<edm::InputTag>("bhSimHitSource"));
   eeRecHitToken_  = consumes<HGCeeRecHitCollection>(cfg.getParameter<edm::InputTag>("eeRecHitSource"));
   fhRecHitToken_  = consumes<HGChefRecHitCollection>(cfg.getParameter<edm::InputTag>("fhRecHitSource"));
   ietaExcludeBH_  = cfg.getParameter<std::vector<int> >("ietaExcludeBH");
   ifHCAL_         = cfg.getParameter<bool>("ifHCAL");
   ifHCALsim_      = cfg.getParameter<bool>("ifHCALsim");
   if (ifHCAL_) 
     bhRecHitTokenh_ = consumes<HBHERecHitCollection>(cfg.getParameter<edm::InputTag>("bhRecHitSource"));
   else
     bhRecHitTokeng_ = consumes<HGChebRecHitCollection>(cfg.getParameter<edm::InputTag>("bhRecHitSource"));
 
 #ifdef EDM_ML_DEBUG
   edm::LogInfo("HGCalValid") << "Exclude the following " 
                  << ietaExcludeBH_.size() 
                  << " ieta values from BH plots (BH "
                  << ifHCAL_ << ") ";
   for (unsigned int k=0; k<ietaExcludeBH_.size(); ++k) 
     edm::LogInfo("HGCalValid") << " [" << k << "] " << ietaExcludeBH_[k];
 #endif
 }

HGCalHitValidation::~HGCalHitValidation ( )

override

Definition at line 147 of file HGCalHitValidation.cc.

147 { }

Member Function Documentation

void HGCalHitValidation::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprotected

Definition at line 252 of file HGCalHitValidation.cc.

References analyzeHGCalRecHit(), analyzeHGCalSimHit(), edm::SortedCollection< T, SORT >::begin(), bhRecHitTokeng_, bhRecHitTokenh_, bhSimHitToken_, HcalDDDSimConstants::cell(), TauDecayModes::dec, egammaForCoreTracking_cff::depth, HcalDDDRecConstants::HcalID::depth, SoftLeptonByDistance_cfi::distance, eeRecHitToken_, eeSimHitToken_, edm::SortedCollection< T, SORT >::end(), CastorDataFrameFilter_impl::energySum(), HcalCellType::HcalCell::eta, HcalDDDRecConstants::HcalID::eta, PVValHelper::eta, fhRecHitToken_, fhSimHitToken_, MonitorElement::Fill(), spr::find(), edm::Event::getByToken(), HcalDDDRecConstants::getHCID(), HcalEndcap, hcConr_, hcCons_, hebEnSim, heedxVsX, heedyVsY, heedzVsZ, heeEnRec, heeEnSim, heeEnSimRec, heeRecVsSimX, heeRecVsSimY, heeRecVsSimZ, hefdxVsX, hefdyVsY, hefdzVsZ, hefEnRec, hefEnSim, hefEnSimRec, hefRecVsSimX, hefRecVsSimY, hefRecVsSimZ, hgcGeometry_, training_settings::idx, ietaExcludeBH_, ifHCAL_, ifHCALsim_, edm::HandleBase::isValid(), phi, HcalCellType::HcalCell::phi, HcalDDDRecConstants::HcalID::phi, edm::Handle< T >::product(), HcalCellType::HcalCell::rz, Validation_hcalonly_cfi::sign, rpcPointValidation_cfi::simHit, HcalTestNumbering::unpackHcalIndex(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), z, and PV3DBase< T, PVType, FrameType >::z().

                                                                                      {
   std::map<unsigned int, HGCHitTuple> eeHitRefs, fhHitRefs, bhHitRefs;
 
   //Accesing ee simhits
   edm::Handle<std::vector<PCaloHit>> eeSimHits;
   iEvent.getByToken(eeSimHitToken_, eeSimHits);
 
   if (eeSimHits.isValid()) {
     analyzeHGCalSimHit(eeSimHits, 0, heeEnSim, eeHitRefs);
 #ifdef EDM_ML_DEBUG
     for (std::map<unsigned int,HGCHitTuple>::iterator itr=eeHitRefs.begin();
      itr != eeHitRefs.end(); ++itr) {
       int idx = std::distance(eeHitRefs.begin(),itr);
       edm::LogInfo("HGCalValid") << "EEHit[" << idx << "] " << std::hex 
                  << itr->first << std::dec << "; Energy " 
                  << std::get<0>(itr->second) 
                  << "; Position (" << std::get<1>(itr->second) 
                  << ", " << std::get<2>(itr->second) <<", " 
                  << std::get<3>(itr->second) << ")";
     }
 #endif
   } else {   
     edm::LogVerbatim("HGCalValid") << "No EE SimHit Found ";
   }
 
   //Accesing fh simhits
   edm::Handle<std::vector<PCaloHit>> fhSimHits;
   iEvent.getByToken(fhSimHitToken_, fhSimHits);
   if (fhSimHits.isValid()) {
     analyzeHGCalSimHit(fhSimHits, 1, hefEnSim, fhHitRefs);
 #ifdef EDM_ML_DEBUG
     for (std::map<unsigned int,HGCHitTuple>::iterator itr=fhHitRefs.begin();
      itr != fhHitRefs.end(); ++itr) {
       int idx = std::distance(fhHitRefs.begin(),itr);
       edm::LogInfo("HGCalValid") << "FHHit[" << idx << "] " << std::hex 
                  << itr->first << std::dec << "; Energy "
                  << std::get<0>(itr->second) << "; Position (" 
                  << std::get<1>(itr->second) << ", "
                  << std::get<2>(itr->second) <<", " 
                  << std::get<3>(itr->second) << ")";
     }
 #endif
   } else {
     edm::LogVerbatim("HGCalValid") << "No FH SimHit Found ";
   }
     
   //Accessing bh simhits
   edm::Handle<std::vector<PCaloHit>> bhSimHits;
   iEvent.getByToken(bhSimHitToken_, bhSimHits);
   if (bhSimHits.isValid()) {
    if(ifHCALsim_){
     for (std::vector<PCaloHit>::const_iterator simHit = bhSimHits->begin();
      simHit != bhSimHits->end(); ++simHit) {
       int subdet, z, depth, eta, phi, lay;
       HcalTestNumbering::unpackHcalIndex(simHit->id(), subdet, z, depth, eta, phi, lay);
 
       if (subdet == static_cast<int>(HcalEndcap)) {
     HcalCellType::HcalCell cell = hcCons_->cell(subdet, z, lay, eta, phi);
     double zp  = cell.rz/10; 
 
     HcalDDDRecConstants::HcalID idx = hcConr_->getHCID(subdet,eta,phi,lay,depth);
     int sign = (z==0)?(-1):(1);
     zp      *= sign;
     HcalDetId id = HcalDetId(HcalEndcap,sign*idx.eta,idx.phi,idx.depth);  
 
     float energy = simHit->energy();
     float energySum(energy);
     if (bhHitRefs.count(id.rawId()) != 0) energySum += std::get<0>(bhHitRefs[id.rawId()]);
     hebEnSim->Fill(energy);
     if (std::find(ietaExcludeBH_.begin(),ietaExcludeBH_.end(),idx.eta) ==
         ietaExcludeBH_.end()) {
       bhHitRefs[id.rawId()] = std::make_tuple(energySum,cell.eta,cell.phi,zp);
 #ifdef EDM_ML_DEBUG
       edm::LogInfo("HGCalValid") << "Accept " << id << std::endl;
     } else {
       edm::LogInfo("HGCalValid") << "Reject " << id << std::endl;
 #endif
     }
       }
     }
    }
    else {
     analyzeHGCalSimHit(bhSimHits, 2, hebEnSim, bhHitRefs);
    }
 #ifdef EDM_ML_DEBUG
     for (std::map<unsigned int,HGCHitTuple>::iterator itr=bhHitRefs.begin();
      itr != bhHitRefs.end(); ++itr) {
       int idx = std::distance(bhHitRefs.begin(),itr);
       edm::LogInfo("HGCalValid") << "BHHit[" << idx << "] " << std::hex 
                  << itr->first << std::dec << "; Energy " 
                  << std::get<0>(itr->second) << "; Position (" 
                  << std::get<1>(itr->second) << ", "
                  << std::get<2>(itr->second) <<", " 
                  << std::get<3>(itr->second) << ")";
     }
 #endif
   } else {
     edm::LogVerbatim("HGCalValid") << "No BH SimHit Found ";
   }
 
   //accessing EE Rechit information
   edm::Handle<HGCeeRecHitCollection> eeRecHit;  
   iEvent.getByToken(eeRecHitToken_, eeRecHit);
   if (eeRecHit.isValid()) {
     const HGCeeRecHitCollection* theHits = (eeRecHit.product());
     for (auto it = theHits->begin(); it != theHits->end(); ++it) {
       double energy = it->energy(); 
       heeEnRec->Fill(energy);
       std::map<unsigned int, HGCHitTuple>::const_iterator itr = eeHitRefs.find(it->id().rawId());
       if (itr != eeHitRefs.end()) {
     GlobalPoint xyz = hgcGeometry_[0]->getPosition(it->id());
     heeRecVsSimX->Fill(std::get<1>(itr->second),xyz.x());
     heeRecVsSimY->Fill(std::get<2>(itr->second),xyz.y());
     heeRecVsSimZ->Fill(std::get<3>(itr->second),xyz.z());
     heedxVsX->Fill(std::get<1>(itr->second),(xyz.x()-std::get<1>(itr->second)));
     heedyVsY->Fill(std::get<2>(itr->second),(xyz.y()-std::get<2>(itr->second)));
     heedzVsZ->Fill(std::get<3>(itr->second),(xyz.z()-std::get<3>(itr->second)));
     heeEnSimRec->Fill(std::get<0>(itr->second),energy);
 #ifdef EDM_ML_DEBUG
     edm::LogInfo("HGCalValid") << "EEHit: " << std::hex << it->id().rawId() 
                    << std::dec << " Sim (" 
                    << std::get<0>(itr->second) << ", "
                    << std::get<1>(itr->second) << ", " 
                    << std::get<2>(itr->second) << ", " 
                    << std::get<3>(itr->second) << ") Rec (" 
                    << energy << ", "  << xyz.x() << ", " 
                    << xyz.y() << ", " << xyz.z() << ")";
 #endif
       }
     }
   } else {
     edm::LogVerbatim("HGCalValid") << "No EE RecHit Found ";
   }
 
   //accessing FH Rechit information
   edm::Handle<HGChefRecHitCollection> fhRecHit;
   iEvent.getByToken(fhRecHitToken_, fhRecHit);
   if (fhRecHit.isValid()) {
     const HGChefRecHitCollection* theHits = (fhRecHit.product());           
     for (auto it = theHits->begin(); it!=theHits->end(); ++it) {
       double energy = it->energy(); 
       hefEnRec->Fill(energy);
       std::map<unsigned int, HGCHitTuple>::const_iterator itr = fhHitRefs.find(it->id().rawId());
       if (itr != fhHitRefs.end()) {
     GlobalPoint xyz = hgcGeometry_[1]->getPosition(it->id());
 
     hefRecVsSimX->Fill(std::get<1>(itr->second),xyz.x());
         hefRecVsSimY->Fill(std::get<2>(itr->second),xyz.y());
         hefRecVsSimZ->Fill(std::get<3>(itr->second),xyz.z());
         hefdxVsX->Fill(std::get<1>(itr->second),(xyz.x()-std::get<1>(itr->second)));
         hefdyVsY->Fill(std::get<2>(itr->second),(xyz.y()-std::get<2>(itr->second)));
         hefdzVsZ->Fill(std::get<3>(itr->second),(xyz.z()-std::get<3>(itr->second)));
     hefEnSimRec->Fill(std::get<0>(itr->second),energy);
 #ifdef EDM_ML_DEBUG
     edm::LogInfo("HGCalValid") << "FHHit: " << std::hex << it->id().rawId()
                    << std::dec << " Sim (" 
                    << std::get<0>(itr->second) << ", "
                    << std::get<1>(itr->second) << ", " 
                    << std::get<2>(itr->second) << ", " 
                    << std::get<3>(itr->second) << ") Rec (" 
                    << energy << "," << xyz.x() << ", " 
                    << xyz.y() << ", " << xyz.z() << ")";
 #endif
       }
     }
   } else {
     edm::LogVerbatim("HGCalValid") << "No FH RecHit Found ";
   }
 
 
   //accessing BH Rechit information
   if (ifHCAL_) {
     edm::Handle<HBHERecHitCollection> bhRecHit;
     iEvent.getByToken(bhRecHitTokenh_, bhRecHit);
     if (bhRecHit.isValid()) {
       const HBHERecHitCollection* theHits = (bhRecHit.product());
       analyzeHGCalRecHit(theHits, bhHitRefs);
     } else {
       edm::LogVerbatim("HGCalValid") << "No BH RecHit Found ";
     }
   } else {
     edm::Handle<HGChebRecHitCollection> bhRecHit;
     iEvent.getByToken(bhRecHitTokeng_, bhRecHit);
     if (bhRecHit.isValid()) {
       const HGChebRecHitCollection* theHits = (bhRecHit.product());
       analyzeHGCalRecHit(theHits, bhHitRefs);
     } else {
       edm::LogVerbatim("HGCalValid") << "No BH RecHit Found ";
     }
   }
 }

template<class T1 >

void HGCalHitValidation::analyzeHGCalRecHit	(	T1 const &	theHits,
		std::map< unsigned int, HGCHitTuple > const &	hitRefs
	)

protected

Definition at line 479 of file HGCalHitValidation.cc.

References funct::cos(), TauDecayModes::dec, DEFINE_FWK_MODULE, PV3DBase< T, PVType, FrameType >::eta(), MonitorElement::Fill(), CaloSubdetectorGeometry::getGeometry(), DetId::Hcal, HcalEndcap, hcGeometry_, hebdEtaVsEta, hebdPhiVsPhi, hebdzVsZ, hebEnRec, hebEnSimRec, hebRecVsSimX, hebRecVsSimY, hebRecVsSimZ, PV3DBase< T, PVType, FrameType >::phi(), PVValHelper::pT, funct::sin(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

                                                                           {
   for (auto it = theHits->begin(); it!=theHits->end(); ++it) {
     DetId id = it->id();
     if (id.det() == DetId::Hcal and id.subdetId() == (int)(HcalEndcap)) {
       double energy = it->energy();
       hebEnRec->Fill(energy);
       GlobalPoint xyz = hcGeometry_->getGeometry(id)->getPosition();
 
       std::map<unsigned int, HGCHitTuple>::const_iterator itr = hitRefs.find(id.rawId());
       if (itr != hitRefs.end()) {
     float ang3 = xyz.phi().value(); // returns the phi in radians
     double fac = sinh(std::get<1>(itr->second));
     double pT  = std::get<3>(itr->second) / fac;
     double xp = pT * cos(std::get<2>(itr->second));
     double yp = pT * sin(std::get<2>(itr->second));
     hebRecVsSimX->Fill(xp,xyz.x());
     hebRecVsSimY->Fill(yp,xyz.y());
     hebRecVsSimZ->Fill(std::get<3>(itr->second),xyz.z());
     hebdEtaVsEta->Fill(std::get<1>(itr->second),(xyz.eta()-std::get<1>(itr->second)));
     hebdPhiVsPhi->Fill(std::get<2>(itr->second),(ang3-std::get<2>(itr->second)));
     hebdzVsZ->Fill(std::get<3>(itr->second),(xyz.z()-std::get<3>(itr->second)));
     hebEnSimRec->Fill(std::get<0>(itr->second),energy);
 
 #ifdef EDM_ML_DEBUG
     edm::LogInfo("HGCalValid") << "BHHit: " << std::hex << id.rawId()
                    << std::dec << " Sim (" 
                    << std::get<0>(itr->second) << ", "
                    << std::get<1>(itr->second) << ", " 
                    << std::get<2>(itr->second) << ", " 
                    << std::get<3>(itr->second) << ") Rec ("
                    << energy << ", "  << xyz.x() << ", " 
                    << xyz.y() << ", " << xyz.z() << ")\n";
 #endif
       }
     }
   }
 }

void HGCalHitValidation::analyzeHGCalSimHit	(	edm::Handle< std::vector< PCaloHit >> const &	simHits,
		int	idet,
		MonitorElement *	hist,
		std::map< unsigned int, HGCHitTuple > &	hitRefs
	)

protected

Definition at line 444 of file HGCalHitValidation.cc.

References HGCalTopology::detectorType(), CastorDataFrameFilter_impl::energySum(), MonitorElement::Fill(), hgcCons_, hgcGeometry_, rpcPointValidation_cfi::simHit, trackerHits::simHits, HGCalTestNumbering::unpackHexagonIndex(), geometryCSVtoXML::xy, and ecaldqm::zside().

Referenced by analyze().

                                                                     {
 
   const HGCalTopology &hTopo=hgcGeometry_[idet]->topology();
   for (std::vector<PCaloHit>::const_iterator simHit = simHits->begin(); simHit != simHits->end(); ++simHit) {
     int subdet, zside, layer, wafer, celltype, cell;
     HGCalTestNumbering::unpackHexagonIndex(simHit->id(), subdet, zside, layer, wafer, celltype, cell);
     std::pair<float, float> xy = hgcCons_[idet]->locateCell(cell,layer,wafer,false);
     float zp = hgcCons_[idet]->waferZ(layer,false);
     if (zside < 0) zp = -zp;
     float xp = (zp<0) ? -xy.first/10 : xy.first/10;
     float yp = xy.second/10.0;
 
     //skip this hit if after ganging it is not valid
     std::pair<int,int> recoLayerCell=hgcCons_[idet]->simToReco(cell,layer,wafer,hTopo.detectorType());
     cell  = recoLayerCell.first;
     layer = recoLayerCell.second;
 
     //skip this hit if after ganging it is not valid
     if (layer<0 || cell<0) {
     } else {
       //assign the RECO DetId
       HGCalDetId id = HGCalDetId((ForwardSubdetector)(subdet),zside,layer,celltype,wafer,cell);
       float energy = simHit->energy();
 
       float energySum(energy);
       if (hitRefs.count(id.rawId()) != 0) energySum += std::get<0>(hitRefs[id.rawId()]);
       hitRefs[id.rawId()] = std::make_tuple(energySum,xp,yp,zp);
       hist->Fill(energy);
     }
   }
 }

void HGCalHitValidation::bookHistograms	(	DQMStore::IBooker &	iB,
		edm::Run const &	,
		edm::EventSetup const &
	)

overrideprotectedvirtual

Implements DQMEDAnalyzer.

Definition at line 157 of file HGCalHitValidation.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), hebdEtaVsEta, hebdPhiVsPhi, hebdzVsZ, hebEnRec, hebEnSim, hebEnSimRec, hebRecVsSimX, hebRecVsSimY, hebRecVsSimZ, heedxVsX, heedyVsY, heedzVsZ, heeEnRec, heeEnSim, heeEnSimRec, heeRecVsSimX, heeRecVsSimY, heeRecVsSimZ, hefdxVsX, hefdyVsY, hefdzVsZ, hefEnRec, hefEnSim, hefEnSimRec, hefRecVsSimX, hefRecVsSimY, hefRecVsSimZ, M_PI, and DQMStore::IBooker::setCurrentFolder().

                                           {
 
   iB.setCurrentFolder("HGCAL/HGCalSimHitsV/HitValidation");
 
   //initiating histograms
   heedzVsZ     = iB.book2D("heedzVsZ","",7200,-360,360,100,-0.1,0.1);
   heedyVsY     = iB.book2D("heedyVsY","",400,-200,200,100,-0.02,0.02);
   heedxVsX     = iB.book2D("heedxVsX","",400,-200,200,100,-0.02,0.02);
   heeRecVsSimZ = iB.book2D("heeRecVsSimZ","",7200,-360,360,7200,-360,360);
   heeRecVsSimY = iB.book2D("heeRecVsSimY","",400,-200,200,400,-200,200);
   heeRecVsSimX = iB.book2D("heeRecVsSimX","",400,-200,200,400,-200,200);
 
   hefdzVsZ     = iB.book2D("hefdzVsZ","",8200,-410,410,100,-0.1,0.1);
   hefdyVsY     = iB.book2D("hefdyVsY","",400,-200,200,100,-0.02,0.02);
   hefdxVsX     = iB.book2D("hefdxVsX","",400,-200,200,100,-0.02,0.02);
   hefRecVsSimZ = iB.book2D("hefRecVsSimZ","",8200,-410,410,8200,-410,410);
   hefRecVsSimY = iB.book2D("hefRecVsSimY","",400,-200,200,400,-200,200);
   hefRecVsSimX = iB.book2D("hefRecVsSimX","",400,-200,200,400,-200,200);
 
   hebdzVsZ     = iB.book2D("hebdzVsZ","",1080,-540,540,100,-1.0,1.0);
   hebdPhiVsPhi = iB.book2D("hebdPhiVsPhi","",M_PI*100,-0.5,M_PI+0.5,200,-0.2,0.2);
   hebdEtaVsEta = iB.book2D("hebdEtaVsEta","",1000,-5,5,200,-0.1,0.1);
   hebRecVsSimZ = iB.book2D("hebRecVsSimZ","",1080,-540,540,1080,-540,540);
   hebRecVsSimY = iB.book2D("hebRecVsSimY","",400,-200,200,400,-200,200);
   hebRecVsSimX = iB.book2D("hebRecVsSimX","",400,-200,200,400,-200,200);
 
   heeEnRec     = iB.book1D("heeEnRec","",1000,0,10);
   heeEnSim     = iB.book1D("heeEnSim","",1000,0,0.01);
   heeEnSimRec  = iB.book2D("heeEnSimRec","",200,0,0.002,200,0,0.2);
 
   hefEnRec     = iB.book1D("hefEnRec","",1000,0,10);
   hefEnSim     = iB.book1D("hefEnSim","",1000,0,0.01);
   hefEnSimRec  = iB.book2D("hefEnSimRec","",200,0,0.001,200,0,0.5);
 
   hebEnRec     = iB.book1D("hebEnRec","",1000,0,15);
   hebEnSim     = iB.book1D("hebEnSim","",1000,0,0.01);
   hebEnSimRec  = iB.book2D("hebEnSimRec","",200,0,0.02,200,0,4);
 
 }

void HGCalHitValidation::dqmBeginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overrideprotectedvirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 199 of file HGCalHitValidation.cc.

References spr::find(), geometrySource_, edm::EventSetup::get(), CaloGeometry::getSubdetectorGeometry(), DetId::Hcal, HcalBarrel, hcConr_, hcCons_, hcGeometry_, hgcCons_, hgcGeometry_, mps_fire::i, edm::ESHandleBase::isValid(), and edm::ESHandle< T >::product().

                                                   {
   //initiating hgc Geometry
   for (size_t i=0; i<geometrySource_.size(); i++) {
     if (geometrySource_[i].find("Hcal") != std::string::npos) {
       edm::ESHandle<HcalDDDSimConstants> pHSNDC;
       iSetup.get<HcalSimNumberingRecord>().get(pHSNDC);
       if (pHSNDC.isValid()) {
         hcCons_ = pHSNDC.product();
         hgcCons_.push_back(nullptr);
       } else {
         edm::LogWarning("HGCalValid") << "Cannot initiate HcalDDDSimConstants: "
                                       << geometrySource_[i] << std::endl;
       }
       edm::ESHandle<HcalDDDRecConstants> pHRNDC;
       iSetup.get<HcalRecNumberingRecord>().get(pHRNDC);
       if (pHRNDC.isValid()) {
         hcConr_ = pHRNDC.product();
       } else {
         edm::LogWarning("HGCalValid") << "Cannot initiate HcalDDDRecConstants: "
                                       << geometrySource_[i] << std::endl;
       }
       edm::ESHandle<CaloGeometry> caloG;
       iSetup.get<CaloGeometryRecord>().get(caloG);
       if (caloG.isValid()) {
     const CaloGeometry* geo = caloG.product();
     hcGeometry_ = geo->getSubdetectorGeometry(DetId::Hcal,HcalBarrel);
     hgcGeometry_.push_back(nullptr);
       } else {
         edm::LogWarning("HGCalValid") << "Cannot initiate HcalGeometry for "
                                       << geometrySource_[i] << std::endl;
       }
    } else {
       edm::ESHandle<HGCalDDDConstants> hgcCons;
       iSetup.get<IdealGeometryRecord>().get(geometrySource_[i],hgcCons);
       if (hgcCons.isValid()) {
         hgcCons_.push_back(hgcCons.product());
       } else {
         edm::LogWarning("HGCalValid") << "Cannot initiate HGCalDDDConstants for "
                                       << geometrySource_[i] << std::endl;
       }
       edm::ESHandle<HGCalGeometry> hgcGeom;
       iSetup.get<IdealGeometryRecord>().get(geometrySource_[i],hgcGeom);    
       if(hgcGeom.isValid()) {
     hgcGeometry_.push_back(hgcGeom.product());  
       } else {
     edm::LogWarning("HGCalValid") << "Cannot initiate HGCalGeometry for "
                       << geometrySource_[i] << std::endl;
       }
     }
   }
 }

void HGCalHitValidation::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 149 of file HGCalHitValidation.cc.

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

                                                                                     {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }