Inheritance diagram for HGCalShowerSeparation:

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

	~HGCalShowerSeparation () override

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

virtual void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

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

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

uint32_t	streamId () const

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

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

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

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 DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

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

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

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

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

void	fillWithRecHits (std::map< DetId, const HGCRecHit * > &, DetId, unsigned int, float, int &, float &)

Private Attributes
edm::EDGetTokenT< std::vector< CaloParticle > >	caloParticles_

std::vector< MonitorElement * >	centers_

int	debug_

MonitorElement *	deltaEtaPhi_

std::vector< MonitorElement * >	distanceOnLayer_

MonitorElement *	energy1_

MonitorElement *	energy2_

MonitorElement *	energytot_

MonitorElement *	eta1_

MonitorElement *	eta2_

MonitorElement *	etaPhi_

bool	filterOnEnergyAndCaloP_

std::vector< MonitorElement * >	globalProfileOnLayer_

std::vector< MonitorElement * >	idealDeltaXY_

std::vector< MonitorElement * >	idealDistanceOnLayer_

MonitorElement *	layerDistance_

MonitorElement *	layerEnergy_

std::vector< MonitorElement * >	profileOnLayer_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsBH_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsEE_

edm::EDGetTokenT< HGCRecHitCollection >	recHitsFH_

hgcal::RecHitTools	recHitTools_

MonitorElement *	scEnergy_

MonitorElement *	showerProfile_

Static Private Attributes
static const int	layers_ = 52

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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)

Detailed Description

Definition at line 45 of file HGCalShowerSeparation.cc.

Constructor & Destructor Documentation

HGCalShowerSeparation::HGCalShowerSeparation ( const edm::ParameterSet & iConfig )

explicit

Definition at line 90 of file HGCalShowerSeparation.cc.

References caloTruthProducer_cfi::caloParticles, caloParticles_, edm::ParameterSet::getParameter(), recHitsBH_, EcalDeadCellBoundaryEnergyFilter_cfi::recHitsEE, recHitsEE_, and recHitsFH_.

   : debug_(iConfig.getParameter<int>("debug")),
     filterOnEnergyAndCaloP_(iConfig.getParameter<bool>("filterOnEnergyAndCaloP")){
   auto recHitsEE = iConfig.getParameter<edm::InputTag>("recHitsEE");
   auto recHitsFH = iConfig.getParameter<edm::InputTag>("recHitsFH");
   auto recHitsBH = iConfig.getParameter<edm::InputTag>("recHitsBH");
   auto caloParticles = iConfig.getParameter<edm::InputTag>("caloParticles");
   recHitsEE_ = consumes<HGCRecHitCollection>(recHitsEE);
   recHitsFH_ = consumes<HGCRecHitCollection>(recHitsFH);
   recHitsBH_ = consumes<HGCRecHitCollection>(recHitsBH);
   caloParticles_ = consumes<std::vector<CaloParticle> >(caloParticles);
 }

HGCalShowerSeparation::~HGCalShowerSeparation ( )

override

Definition at line 103 of file HGCalShowerSeparation.cc.

                                               {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

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

overrideprivate

Definition at line 166 of file HGCalShowerSeparation.cc.

References funct::abs(), caloTruthProducer_cfi::caloParticles, caloParticles_, centers_, funct::cos(), KineDebug3::count(), debug_, deltaEtaPhi_, SoftLeptonByDistance_cfi::distance, distanceOnLayer_, SimCluster::energy(), energy1_, energy2_, energytot_, eta1_, eta2_, etaPhi_, JetChargeProducer_cfi::exp, MonitorElement::Fill(), filterOnEnergyAndCaloP_, edm::Event::getByToken(), hgcal::RecHitTools::getEventSetup(), hgcal::RecHitTools::getLayerWithOffset(), hgcal::RecHitTools::getPosition(), globalProfileOnLayer_, SimCluster::hits_and_fractions(), mps_fire::i, idealDeltaXY_, idealDistanceOnLayer_, IfLogTrace, layerDistance_, layerEnergy_, or, profileOnLayer_, recHitsBH_, recHitsEE_, recHitsFH_, recHitTools_, scEnergy_, showerProfile_, SimCluster::simEnergy(), funct::sin(), edm::RefVector< C, T, F >::size(), findQualityFiles::size, mathSSE::sqrt(), funct::tan(), and PV3DBase< T, PVType, FrameType >::x().

                                                                {
   using namespace edm;
 
   recHitTools_.getEventSetup(iSetup);
 
   Handle<HGCRecHitCollection> recHitHandleEE;
   Handle<HGCRecHitCollection> recHitHandleFH;
   Handle<HGCRecHitCollection> recHitHandleBH;
 
   Handle<std::vector<CaloParticle> > caloParticleHandle;
   iEvent.getByToken(caloParticles_, caloParticleHandle);
   const std::vector<CaloParticle>& caloParticles = *caloParticleHandle;
 
 
   iEvent.getByToken(recHitsEE_, recHitHandleEE);
   iEvent.getByToken(recHitsFH_, recHitHandleFH);
   iEvent.getByToken(recHitsBH_, recHitHandleBH);
   const auto& rechitsEE = *recHitHandleEE;
   const auto& rechitsFH = *recHitHandleFH;
   const auto& rechitsBH = *recHitHandleBH;
 
   std::map<DetId, const HGCRecHit*> hitmap;
   for (unsigned int i = 0; i < rechitsEE.size(); ++i) {
     hitmap[rechitsEE[i].detid()] = &rechitsEE[i];
   }
   for (unsigned int i = 0; i < rechitsFH.size(); ++i) {
     hitmap[rechitsFH[i].detid()] = &rechitsFH[i];
   }
   for (unsigned int i = 0; i < rechitsBH.size(); ++i) {
     hitmap[rechitsBH[i].detid()] = &rechitsBH[i];
   }
 
   // loop over caloParticles
   IfLogTrace(debug_ > 0, "HGCalShowerSeparation")
     << "Number of caloParticles: " << caloParticles.size() << std::endl;
   if (caloParticles.size() == 2) {
     auto eta1 = caloParticles[0].eta();
     auto phi1 = caloParticles[0].phi();
     auto theta1 = 2.*atan(exp(-eta1));
     auto eta2 = caloParticles[1].eta();
     auto phi2 = caloParticles[1].phi();
     auto theta2 = 2.*atan(exp(-eta2));
     eta1_->Fill(eta1);
     eta2_->Fill(eta2);
 
 
     // Select event only if the sum of the energy of its recHits
     // is close enough to the gen energy
     int count = 0;
     int size = 0;
     float energy = 0.;
     float energy_tmp = 0.;
     for (const auto& it_caloPart : caloParticles) {
       count++;
       const SimClusterRefVector& simClusterRefVector = it_caloPart.simClusters();
       size += simClusterRefVector.size();
       for (const auto& it_sc : simClusterRefVector) {
     const SimCluster& simCluster = (*(it_sc));
     const std::vector<std::pair<uint32_t, float> >& hits_and_fractions =
           simCluster.hits_and_fractions();
     for (const auto& it_haf : hits_and_fractions) {
       if (hitmap.count(it_haf.first))
         energy += hitmap[it_haf.first]->energy()*it_haf.second;
     } //hits and fractions
       } // simcluster
       if (count == 1) {
     energy1_->Fill(energy);
     energy_tmp = energy;
       } else {
     energy2_->Fill(energy-energy_tmp);
       }
     } // caloParticle
     energytot_->Fill(energy);
     if (filterOnEnergyAndCaloP_ && (energy < 2.*0.8*80 or size !=2))
       return;
 
     deltaEtaPhi_->Fill(eta1-eta2, phi1-phi2);
 
     for (const auto& it_caloPart : caloParticles) {
       const SimClusterRefVector& simClusterRefVector = it_caloPart.simClusters();
       IfLogTrace(debug_ > 0, "HGCalShowerSeparation")
     << ">>> " << simClusterRefVector.size() << std::endl;
       for (const auto& it_sc : simClusterRefVector) {
     const SimCluster& simCluster = (*(it_sc));
     if (simCluster.energy() < 80*0.8)
       continue;
     scEnergy_->Fill(simCluster.energy());
     IfLogTrace(debug_ > 1, "HGCalShowerSeparation")
       << ">>> SC.energy(): " << simCluster.energy()
       << " SC.simEnergy(): " << simCluster.simEnergy()
       << std::endl;
     const std::vector<std::pair<uint32_t, float> >& hits_and_fractions =
           simCluster.hits_and_fractions();
 
     for (const auto& it_haf : hits_and_fractions) {
       if (!hitmap.count(it_haf.first))
         continue;
       unsigned int hitlayer = recHitTools_.getLayerWithOffset(it_haf.first);
       auto global = recHitTools_.getPosition(it_haf.first);
       float globalx = global.x();
       float globaly = global.y();
       float globalz = global.z();
       if (globalz == 0)
         continue;
       auto rho1 = globalz*tan(theta1);
       auto rho2 = globalz*tan(theta2);
       auto x1 = rho1*cos(phi1);
       auto y1 = rho1*sin(phi1);
       auto x2 = rho2*cos(phi2);
       auto y2 = rho2*sin(phi2);
       auto half_point_x = (x1+x2)/2.;
       auto half_point_y = (y1+y2)/2.;
       auto half_point = sqrt((x1-half_point_x)*(x1-half_point_x)+(y1-half_point_y)*(y1-half_point_y));
       auto d_len = sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
       auto dn_x = (x2-x1)/d_len;
       auto dn_y = (y2-y1)/d_len;
       auto distance = (globalx-x1)*dn_x + (globaly - y1)*dn_y;
       distance -= half_point;
       auto idealDistance = sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
       if (hitmap.count(it_haf.first)) {
         profileOnLayer_[hitlayer]->Fill(10.*(globalx-half_point_x),
                         10.*(globaly-half_point_y),
                         hitmap[it_haf.first]->energy()*it_haf.second);
         profileOnLayer_[55]->Fill(10.*(globalx-half_point_x),
                       10.*(globaly-half_point_y),
                       hitmap[it_haf.first]->energy()*it_haf.second);
         globalProfileOnLayer_[hitlayer]->Fill(globalx,
                           globaly,
                           hitmap[it_haf.first]->energy()*it_haf.second);
         globalProfileOnLayer_[55]->Fill(globalx,
                         globaly,
                         hitmap[it_haf.first]->energy()*it_haf.second);
         layerEnergy_->Fill(hitlayer, hitmap[it_haf.first]->energy());
         layerDistance_->Fill(hitlayer, std::abs(10.*distance), hitmap[it_haf.first]->energy()*it_haf.second);
         etaPhi_->Fill(global.eta(), global.phi());
         distanceOnLayer_[hitlayer]->Fill(10.*distance);//,
         idealDistanceOnLayer_[hitlayer]->Fill(10.*idealDistance);//,
         idealDeltaXY_[hitlayer]->Fill(10.*(x1-x2), 10.*(y1-y2));//,
         centers_[hitlayer]->Fill(10.*half_point_x, 10.*half_point_y);//,
         IfLogTrace(debug_ > 0, "HGCalShowerSeparation")
           << ">>> " << distance
           << " " << hitlayer
           << " " << hitmap[it_haf.first]->energy()*it_haf.second
           << std::endl;
         showerProfile_->Fill(10.*distance,
                  hitlayer,
                  hitmap[it_haf.first]->energy()*it_haf.second);
       }
     }  // end simHit
       }  // end simCluster
     }  // end caloparticle
   }
 }

void HGCalShowerSeparation::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	iRun,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements DQMEDAnalyzer.

Definition at line 108 of file HGCalShowerSeparation.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::cd(), centers_, deltaEtaPhi_, distanceOnLayer_, energy1_, energy2_, energytot_, eta1_, eta2_, etaPhi_, globalProfileOnLayer_, mps_fire::i, idealDeltaXY_, idealDistanceOnLayer_, layerDistance_, layerEnergy_, layers_, profileOnLayer_, scEnergy_, DQMStore::IBooker::setCurrentFolder(), showerProfile_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                  {
   ibooker.cd();
   ibooker.setCurrentFolder("HGCalShowerSeparation");
   scEnergy_ = ibooker.book1D("SCEnergy", "SCEnergy", 240, 0., 120.);
   eta1_ = ibooker.book1D("eta1", "eta1", 80, 0., 4.);
   eta2_ = ibooker.book1D("eta2", "eta2", 80, 0., 4.);
   energy1_ = ibooker.book1D("energy1", "energy1", 240, 0., 120.);
   energy2_ = ibooker.book1D("energy2", "energy2", 240, 0., 120.);
   energytot_ = ibooker.book1D("energytot", "energytot", 200, 100., 200.);
   showerProfile_ = ibooker.book2D("ShowerProfile", "ShowerProfile",
                   800, -400., 400.,
                   layers_, 0., (float)layers_);
   layerEnergy_ =  ibooker.book2D("LayerEnergy", "LayerEnergy",
                   60, 0., 60.,
                   50, 0., 0.1);
   layerDistance_ =  ibooker.book2D("LayerDistance", "LayerDistance",
                    60, 0., 60.,
                    400, -400., 400.);
   etaPhi_ =  ibooker.book2D("EtaPhi", "EtaPhi",
                   800, -4., 4.,
                   800, -4., 4.);
   deltaEtaPhi_ =  ibooker.book2D("DeltaEtaPhi", "DeltaEtaPhi",
                   100, -0.5, 0.5,
                   100, -0.5, 0.5);
   for (int i = 0; i < layers_; ++i) {
     profileOnLayer_.push_back(ibooker.book2D(std::string("ProfileOnLayer_") + std::to_string(i),
                          std::string("ProfileOnLayer_") + std::to_string(i),
                          120, -600., 600.,
                          120, -600., 600.)
                   );
     globalProfileOnLayer_.push_back(ibooker.book2D(std::string("GlobalProfileOnLayer_") + std::to_string(i),
                          std::string("GlobalProfileOnLayer_") + std::to_string(i),
                          320, -160., 160.,
                          320, -160., 160.)
                   );
     distanceOnLayer_.push_back(ibooker.book1D(std::string("DistanceOnLayer_") + std::to_string(i),
                           std::string("DistanceOnLayer_") + std::to_string(i),
                           120, -600., 600.)
                   );
     idealDistanceOnLayer_.push_back(ibooker.book1D(std::string("IdealDistanceOnLayer_") + std::to_string(i),
                            std::string("IdealDistanceOnLayer_") + std::to_string(i),
                            120, -600., 600.)
                     );
     idealDeltaXY_.push_back(ibooker.book2D(std::string("IdealDeltaXY_") + std::to_string(i),
                        std::string("IdealDeltaXY_") + std::to_string(i),
                        800, -400., 400.,
                        800, -400., 400.)
                     );
     centers_.push_back(ibooker.book2D(std::string("Centers_") + std::to_string(i),
                       std::string("Centers_") + std::to_string(i),
                       320, -1600., 1600.,
                       320, -1600., 1600.)
                );
  }
 }

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

static

Definition at line 323 of file HGCalShowerSeparation.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), and DEFINE_FWK_MODULE.

                                                                    {
   edm::ParameterSetDescription desc;
   desc.add<int>("debug", 1);
   desc.add<bool>("filterOnEnergyAndCaloP", false);
   desc.add<edm::InputTag>("caloParticles", edm::InputTag("mix", "MergedCaloTruth"));
   desc.add<edm::InputTag>("recHitsEE", edm::InputTag("HGCalRecHit", "HGCEERecHits"));
   desc.add<edm::InputTag>("recHitsFH", edm::InputTag("HGCalRecHit", "HGCHEFRecHits"));
   desc.add<edm::InputTag>("recHitsBH", edm::InputTag("HGCalRecHit", "HGCHEBRecHits"));
   descriptions.add("hgcalShowerSeparation", desc);
 }