#include <EcalSimHitsValidation.h>

Inheritance diagram for EcalSimHitsValidation:

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

	~EcalSimHitsValidation () 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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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 Attributes
DQMStore *	dbe_

edm::EDGetTokenT< edm::PCaloHitContainer >	EBHitsCollectionToken

edm::EDGetTokenT< edm::PCaloHitContainer >	EEHitsCollectionToken

edm::EDGetTokenT< edm::PCaloHitContainer >	ESHitsCollectionToken

std::string	g4InfoLabel

edm::EDGetTokenT< edm::HepMCProduct >	HepMCToken

MonitorElement *	meEBEnergyFraction_

MonitorElement *	meEEEnergyFraction_

MonitorElement *	meESEnergyFraction_

MonitorElement *	meGunEnergy_

MonitorElement *	meGunEta_

MonitorElement *	meGunPhi_

std::string	outputFile_

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 41 of file EcalSimHitsValidation.h.

Member Typedef Documentation

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

private

Definition at line 42 of file EcalSimHitsValidation.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 20 of file EcalSimHitsValidation.cc.

References dbe_, EBHitsCollectionToken, EEHitsCollectionToken, ESHitsCollectionToken, g4InfoLabel, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), trackerHits::histo, meEBEnergyFraction_, meEEEnergyFraction_, meESEnergyFraction_, meGunEnergy_, meGunEta_, meGunPhi_, Utilities::operator, outputFile_, AlCaHLTBitMon_QueryRunRegistry::string, and verbose_.

     : g4InfoLabel(ps.getParameter<std::string>("moduleLabelG4")),
       HepMCToken(consumes<edm::HepMCProduct>(ps.getParameter<std::string>("moduleLabelMC"))) {
   EBHitsCollectionToken =
       consumes<edm::PCaloHitContainer>(edm::InputTag(g4InfoLabel, ps.getParameter<std::string>("EBHitsCollection")));
   EEHitsCollectionToken =
       consumes<edm::PCaloHitContainer>(edm::InputTag(g4InfoLabel, ps.getParameter<std::string>("EEHitsCollection")));
   ESHitsCollectionToken =
       consumes<edm::PCaloHitContainer>(edm::InputTag(g4InfoLabel, ps.getParameter<std::string>("ESHitsCollection")));
 
   // DQM ROOT output
   outputFile_ = ps.getUntrackedParameter<std::string>("outputFile", "");
 
   if (!outputFile_.empty()) {
     edm::LogInfo("OutputInfo") << " Ecal SimHits Task histograms will be saved to " << outputFile_.c_str();
   } else {
     edm::LogInfo("OutputInfo") << " Ecal SimHits Task histograms will NOT be saved";
   }
 
   // verbosity switch
   verbose_ = ps.getUntrackedParameter<bool>("verbose", false);
 
   // DQMServices
   dbe_ = nullptr;
 
   // get hold of back-end interface
   dbe_ = edm::Service<DQMStore>().operator->();
   if (dbe_) {
     if (verbose_) {
       dbe_->setVerbose(1);
     } else {
       dbe_->setVerbose(0);
     }
   }
 
   if (dbe_) {
     if (verbose_)
       dbe_->showDirStructure();
   }
 
   meGunEnergy_ = nullptr;
   meGunEta_ = nullptr;
   meGunPhi_ = nullptr;
   meEBEnergyFraction_ = nullptr;
   meEEEnergyFraction_ = nullptr;
   meESEnergyFraction_ = nullptr;
 
   Char_t histo[200];
 
   if (dbe_) {
     dbe_->setCurrentFolder("EcalHitsV/EcalSimHitsValidation");
 
     sprintf(histo, "EcalSimHitsValidation Gun Momentum");
     meGunEnergy_ = dbe_->book1D(histo, histo, 100, 0., 1000.);
 
     sprintf(histo, "EcalSimHitsValidation Gun Eta");
     meGunEta_ = dbe_->book1D(histo, histo, 700, -3.5, 3.5);
 
     sprintf(histo, "EcalSimHitsValidation Gun Phi");
     meGunPhi_ = dbe_->book1D(histo, histo, 360, 0., 360.);
 
     sprintf(histo, "EcalSimHitsValidation Barrel fraction of energy");
     meEBEnergyFraction_ = dbe_->book1D(histo, histo, 100, 0., 1.1);
 
     sprintf(histo, "EcalSimHitsValidation Endcap fraction of energy");
     meEEEnergyFraction_ = dbe_->book1D(histo, histo, 100, 0., 1.1);
 
     sprintf(histo, "EcalSimHitsValidation Preshower fraction of energy");
     meESEnergyFraction_ = dbe_->book1D(histo, histo, 60, 0., 0.001);
   }
 }

EcalSimHitsValidation::~EcalSimHitsValidation ( )

override

Destructor.

Definition at line 92 of file EcalSimHitsValidation.cc.

References dbe_, and outputFile_.

                                               {
   if (!outputFile_.empty() && dbe_)
     dbe_->save(outputFile_);
 }

Member Function Documentation

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

overrideprotected

Analyze.

Definition at line 101 of file EcalSimHitsValidation.cc.

References funct::abs(), EBHitsCollectionToken, EEHitsCollectionToken, ESHitsCollectionToken, edm::EventID::event(), MonitorElement::Fill(), edm::Event::getByToken(), edm::HepMCProduct::GetEvent(), HepMCToken, edm::EventBase::id(), edm::HandleBase::isValid(), cmsBatch::log, LogDebug, M_PI, meEBEnergyFraction_, meEEEnergyFraction_, meESEnergyFraction_, meGunEnergy_, meGunEta_, meGunPhi_, AlCaHLTBitMon_ParallelJobs::p, edm::EventID::run(), and funct::tan().

                                                                              {
   edm::LogInfo("EventInfo") << " Run = " << e.id().run() << " Event = " << e.id().event();
 
   std::vector<PCaloHit> theEBCaloHits;
   std::vector<PCaloHit> theEECaloHits;
   std::vector<PCaloHit> theESCaloHits;
 
   edm::Handle<edm::HepMCProduct> MCEvt;
   edm::Handle<edm::PCaloHitContainer> EcalHitsEB;
   edm::Handle<edm::PCaloHitContainer> EcalHitsEE;
   edm::Handle<edm::PCaloHitContainer> EcalHitsES;
 
   e.getByToken(HepMCToken, MCEvt);
   e.getByToken(EBHitsCollectionToken, EcalHitsEB);
   e.getByToken(EEHitsCollectionToken, EcalHitsEE);
   e.getByToken(ESHitsCollectionToken, EcalHitsES);
 
   for (HepMC::GenEvent::particle_const_iterator p = MCEvt->GetEvent()->particles_begin();
        p != MCEvt->GetEvent()->particles_end();
        ++p) {
     double htheta = (*p)->momentum().theta();
     double heta = -99999.;
     if (tan(htheta * 0.5) > 0) {
       heta = -log(tan(htheta * 0.5));
     }
     double hphi = (*p)->momentum().phi();
     hphi = (hphi >= 0) ? hphi : hphi + 2 * M_PI;
     hphi = hphi / M_PI * 180.;
 
     LogDebug("EventInfo") << "Particle gun type form MC = " << abs((*p)->pdg_id()) << "\n"
                           << "Energy = " << (*p)->momentum().e() << " Eta = " << heta << " Phi = " << hphi;
 
     if (meGunEnergy_)
       meGunEnergy_->Fill((*p)->momentum().e());
     if (meGunEta_)
       meGunEta_->Fill(heta);
     if (meGunPhi_)
       meGunPhi_->Fill(hphi);
   }
 
   double EBEnergy_ = 0.;
   if (EcalHitsEB.isValid()) {
     theEBCaloHits.insert(theEBCaloHits.end(), EcalHitsEB->begin(), EcalHitsEB->end());
     for (std::vector<PCaloHit>::iterator isim = theEBCaloHits.begin(); isim != theEBCaloHits.end(); ++isim) {
       EBEnergy_ += isim->energy();
     }
   }
 
   double EEEnergy_ = 0.;
   if (EcalHitsEE.isValid()) {
     theEECaloHits.insert(theEECaloHits.end(), EcalHitsEE->begin(), EcalHitsEE->end());
     for (std::vector<PCaloHit>::iterator isim = theEECaloHits.begin(); isim != theEECaloHits.end(); ++isim) {
       EEEnergy_ += isim->energy();
     }
   }
 
   double ESEnergy_ = 0.;
   if (EcalHitsES.isValid()) {
     theESCaloHits.insert(theESCaloHits.end(), EcalHitsES->begin(), EcalHitsES->end());
     for (std::vector<PCaloHit>::iterator isim = theESCaloHits.begin(); isim != theESCaloHits.end(); ++isim) {
       ESEnergy_ += isim->energy();
     }
   }
 
   double etot = EBEnergy_ + EEEnergy_ + ESEnergy_;
   double fracEB = 0.0;
   double fracEE = 0.0;
   double fracES = 0.0;
 
   if (etot > 0.0) {
     fracEB = EBEnergy_ / etot;
     fracEE = EEEnergy_ / etot;
     fracES = ESEnergy_ / etot;
   }
 
   if (meEBEnergyFraction_)
     meEBEnergyFraction_->Fill(fracEB);
 
   if (meEEEnergyFraction_)
     meEEEnergyFraction_->Fill(fracEE);
 
   if (meESEnergyFraction_)
     meESEnergyFraction_->Fill(fracES);
 }