Inheritance diagram for EgammaHLTNxNClusterProducer:

Public Member Functions
	EgammaHLTNxNClusterProducer (const edm::ParameterSet &ps)

void	produce (edm::Event &, const edm::EventSetup &) override

	~EgammaHLTNxNClusterProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Private Member Functions
bool	checkStatusOfEcalRecHit (const EcalChannelStatus &channelStatus, const EcalRecHit &rh)

void	makeNxNClusters (edm::Event &evt, const edm::EventSetup &es, const EcalRecHitCollection &hits, const reco::CaloID::Detectors detector)

Private Attributes
const std::string	barrelClusterCollection_

const edm::EDGetTokenT< EcalRecHitCollection >	barrelHitProducer_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	caloGeometryToken_

const int	clusEtaSize_

const int	clusPhiSize_

const double	clusSeedThr_

const double	clusSeedThrEndCap_

const int	debug_

const bool	doBarrel_

const bool	doEndcaps_

const edm::ESGetToken< EcalChannelStatus, EcalChannelStatusRcd >	ecalChannelStatusToken_

const std::string	endcapClusterCollection_

const edm::EDGetTokenT< EcalRecHitCollection >	endcapHitProducer_

const int	flagLevelRecHitsToUse_

const int	maxNumberofClusters_

const int	maxNumberofSeeds_

PositionCalc	posCalculator_

const int	statusLevelRecHitsToUse_

const bool	useDBStatus_

const bool	useRecoFlag_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Description: simple NxN ( 3x3 etc) clustering ,( for low energy photon reconstrution, currently used for pi0/eta HLT path)

Implementation: <Notes on="" implementation>="">

Definition at line 46 of file EgammaHLTNxNClusterProducer.cc.

Constructor & Destructor Documentation

◆ EgammaHLTNxNClusterProducer()

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

Definition at line 91 of file EgammaHLTNxNClusterProducer.cc.

References deDxTools::esConsumes().

     : doBarrel_(ps.getParameter<bool>("doBarrel")),
       doEndcaps_(ps.getParameter<bool>("doEndcaps")),
       barrelHitProducer_(consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("barrelHitProducer"))),
       endcapHitProducer_(consumes<EcalRecHitCollection>(ps.getParameter<edm::InputTag>("endcapHitProducer"))),
       caloGeometryToken_{esConsumes()},
       ecalChannelStatusToken_{esConsumes()},
       clusEtaSize_(ps.getParameter<int>("clusEtaSize")),
       clusPhiSize_(ps.getParameter<int>("clusPhiSize")),
       barrelClusterCollection_(ps.getParameter<std::string>("barrelClusterCollection")),
       endcapClusterCollection_(ps.getParameter<std::string>("endcapClusterCollection")),
       clusSeedThr_(ps.getParameter<double>("clusSeedThr")),
       clusSeedThrEndCap_(ps.getParameter<double>("clusSeedThrEndCap")),
       useRecoFlag_(ps.getParameter<bool>("useRecoFlag")),
       flagLevelRecHitsToUse_(ps.getParameter<int>("flagLevelRecHitsToUse")),
       useDBStatus_(ps.getParameter<bool>("useDBStatus")),
       statusLevelRecHitsToUse_(ps.getParameter<int>("statusLevelRecHitsToUse")),
       maxNumberofSeeds_(ps.getParameter<int>("maxNumberofSeeds")),
       maxNumberofClusters_(ps.getParameter<int>("maxNumberofClusters")),
       debug_(ps.getParameter<int>("debugLevel")),
       posCalculator_(PositionCalc(ps.getParameter<edm::ParameterSet>("posCalcParameters"))) {
   produces<reco::BasicClusterCollection>(barrelClusterCollection_);
   produces<reco::BasicClusterCollection>(endcapClusterCollection_);
 }

◆ ~EgammaHLTNxNClusterProducer()

EgammaHLTNxNClusterProducer::~EgammaHLTNxNClusterProducer ( )

override

Definition at line 116 of file EgammaHLTNxNClusterProducer.cc.

116 {}

Member Function Documentation

◆ checkStatusOfEcalRecHit()

bool EgammaHLTNxNClusterProducer::checkStatusOfEcalRecHit	(	const EcalChannelStatus &	channelStatus,
		const EcalRecHit &	rh
	)

private

from recoFlag()

good

good || PoorCalib

good || PoorCalib || LeadingEdgeRecovered || kNeighboursRecovered,

Definition at line 181 of file EgammaHLTNxNClusterProducer.cc.

References RemoveAddSevLevel::flag, flagLevelRecHitsToUse_, EcalRecHit::id(), createfilelist::int, DetId::rawId(), EcalRecHit::recoFlag(), mps_update::status, statusLevelRecHitsToUse_, useDBStatus_, and useRecoFlag_.

Referenced by makeNxNClusters().

                                                                                 {
   if (useRecoFlag_) {  
     int flag = rh.recoFlag();
     if (flagLevelRecHitsToUse_ == 0) {  
       if (flag != 0)
         return false;
     } else if (flagLevelRecHitsToUse_ == 1) {  
       if (flag != 0 && flag != 4)
         return false;
     } else if (flagLevelRecHitsToUse_ == 2) {  
       if (flag != 0 && flag != 4 && flag != 6 && flag != 7)
         return false;
     }
   }
   if (useDBStatus_) {  
     int status = int(channelStatus[rh.id().rawId()].getStatusCode());
     if (status > statusLevelRecHitsToUse_)
       return false;
   }
 
   return true;
 }

◆ fillDescriptions()

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

static

Definition at line 118 of file EgammaHLTNxNClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<bool>(("doBarrel"), true);
   desc.add<bool>(("doEndcaps"), true);
   desc.add<edm::InputTag>(("barrelHitProducer"), edm::InputTag("hltEcalRegionalPi0EtaRecHit", "EcalRecHitsEB"));
   desc.add<edm::InputTag>(("endcapHitProducer"), edm::InputTag("hltEcalRegionalPi0EtaRecHit", "EcalRecHitsEE"));
   desc.add<int>(("clusEtaSize"), 3);
   desc.add<int>(("clusPhiSize"), 3);
   desc.add<std::string>(("barrelClusterCollection"), "Simple3x3ClustersBarrel");
   desc.add<std::string>(("endcapClusterCollection"), "Simple3x3ClustersEndcap");
   desc.add<double>(("clusSeedThr"), 0.5);
   desc.add<double>(("clusSeedThrEndCap"), 1.0);
   desc.add<bool>(("useRecoFlag"), false);
   desc.add<int>(("flagLevelRecHitsToUse"), 1);
   desc.add<bool>(("useDBStatus"), true);
   desc.add<int>(("statusLevelRecHitsToUse"), 1);
 
   edm::ParameterSetDescription posCalcPSET;
   posCalcPSET.add<double>("T0_barl", 7.4);
   posCalcPSET.add<double>("T0_endc", 3.1);
   posCalcPSET.add<double>("T0_endcPresh", 1.2);
   posCalcPSET.add<double>("W0", 4.2);
   posCalcPSET.add<double>("X0", 0.89);
   posCalcPSET.add<bool>("LogWeighted", true);
   desc.add<edm::ParameterSetDescription>("posCalcParameters", posCalcPSET);
 
   desc.add<int>(("maxNumberofSeeds"), 1000);
   desc.add<int>(("maxNumberofClusters"), 200);
   desc.add<int>(("debugLevel"), 0);
   descriptions.add(("hltEgammaHLTNxNClusterProducer"), desc);
 }

◆ makeNxNClusters()

void EgammaHLTNxNClusterProducer::makeNxNClusters	(	edm::Event &	evt,
		const edm::EventSetup &	es,
		const EcalRecHitCollection &	hits,
		const reco::CaloID::Detectors	detector
	)

private

get status from DB

if too much clusters made, then return 0 also

Definition at line 205 of file EgammaHLTNxNClusterProducer.cc.

References barrelClusterCollection_, PositionCalc::Calculate_Location(), caloGeometryToken_, checkStatusOfEcalRecHit(), clusEtaSize_, clusPhiSize_, clusSeedThr_, clusSeedThrEndCap_, bsc_activity_cfg::clusters, debug_, reco::CaloID::DET_ECAL_BARREL, hgcalTestNeighbor_cfi::detector, DetId::Ecal, EcalBarrel, ecalChannelStatusToken_, EcalEndcap, EcalPreshower, endcapClusterCollection_, HCALHighEnergyHPDFilter_cfi::energy, edm::EventID::event(), options_cfi::eventSetup, spr::find(), hfClusterShapes_cfi::hits, edm::EventBase::id(), reco::CaloCluster::island, LogDebug, maxNumberofClusters_, maxNumberofSeeds_, eostools::move(), posCalculator_, edm::Event::put(), edm::EventID::run(), DetachedQuadStep_cff::seeds, jetUpdater_cfi::sort, useDBStatus_, x, and y.

Referenced by produce().

                                                                                       {
   edm::ESHandle<EcalChannelStatus> csHandle;
   if (useDBStatus_) {
     csHandle = eventSetup.getHandle(ecalChannelStatusToken_);
   }
   const EcalChannelStatus &channelStatus = *csHandle;
 
   std::vector<EcalRecHit> seeds;
 
   double clusterSeedThreshold;
   if (detector == reco::CaloID::DET_ECAL_BARREL) {
     clusterSeedThreshold = clusSeedThr_;
   } else {
     clusterSeedThreshold = clusSeedThrEndCap_;
   }
 
   for (auto const itt : hits) {
     double energy = itt.energy();
     if (!checkStatusOfEcalRecHit(channelStatus, itt))
       continue;
     if (energy > clusterSeedThreshold)
       seeds.push_back(itt);
 
     if (int(seeds.size()) > maxNumberofSeeds_) {  //too many seeds, like beam splash events
       seeds.clear();                              
       break;
     }
   }
 
   // get the geometry and topology from the event setup:
   auto const &caloGeometry = eventSetup.getData(caloGeometryToken_);
 
   const CaloSubdetectorGeometry *geometry_p;
   std::unique_ptr<CaloSubdetectorTopology> topology_p;
   if (detector == reco::CaloID::DET_ECAL_BARREL) {
     geometry_p = caloGeometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
     topology_p = std::make_unique<EcalBarrelTopology>(caloGeometry);
   } else {
     geometry_p = caloGeometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
     topology_p = std::make_unique<EcalEndcapTopology>(caloGeometry);
   }
 
   const CaloSubdetectorGeometry *geometryES_p;
   geometryES_p = caloGeometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
 
   std::vector<reco::BasicCluster> clusters;
   std::vector<DetId> usedXtals;
 
   // sort seed according to Energy
   sort(seeds.begin(), seeds.end(), [](auto const &x, auto const &y) { return (x.energy() > y.energy()); });
 
   for (std::vector<EcalRecHit>::iterator itseed = seeds.begin(); itseed != seeds.end(); itseed++) {
     DetId seed_id = itseed->id();
 
     std::vector<DetId>::iterator itdet = find(usedXtals.begin(), usedXtals.end(), seed_id);
     if (itdet != usedXtals.end())
       continue;
 
     std::vector<DetId> clus_v = topology_p->getWindow(seed_id, clusEtaSize_, clusPhiSize_);
     std::vector<std::pair<DetId, float> > clus_used;
 
     float clus_energy = 0;
 
     for (auto const &detid : clus_v) {
       //not yet used
       std::vector<DetId>::iterator itdet = find(usedXtals.begin(), usedXtals.end(), detid);
       if (itdet != usedXtals.end())
         continue;
       //inside the collection
       EcalRecHitCollection::const_iterator hit = hits.find(detid);
       if (hit == hits.end())
         continue;
 
       if (!checkStatusOfEcalRecHit(channelStatus, *hit))
         continue;
 
       usedXtals.push_back(detid);
       clus_used.push_back(std::pair<DetId, float>(detid, 1.));
       clus_energy += hit->energy();
 
     }  
 
     if (clus_energy <= 0)
       continue;
 
     math::XYZPoint clus_pos = posCalculator_.Calculate_Location(clus_used, &hits, geometry_p, geometryES_p);
 
     if (debug_ >= 2)
       LogDebug("") << "nxn_cluster in run " << evt.id().run() << " event " << evt.id().event()
                    << " energy: " << clus_energy << " eta: " << clus_pos.Eta() << " phi: " << clus_pos.Phi()
                    << " nRecHits: " << clus_used.size() << std::endl;
 
     clusters.push_back(reco::BasicCluster(
         clus_energy, clus_pos, reco::CaloID(detector), clus_used, reco::CaloCluster::island, seed_id));
     if (int(clusters.size()) > maxNumberofClusters_) {  
       clusters.clear();
       break;
     }
   }
 
   //Create empty output collections
   auto clusters_p = std::make_unique<reco::BasicClusterCollection>();
   clusters_p->assign(clusters.begin(), clusters.end());
   if (detector == reco::CaloID::DET_ECAL_BARREL) {
     if (debug_ >= 1)
       LogDebug("") << "nxnclusterProducer: " << clusters_p->size() << " made in barrel" << std::endl;
     evt.put(std::move(clusters_p), barrelClusterCollection_);
   } else {
     if (debug_ >= 1)
       LogDebug("") << "nxnclusterProducer: " << clusters_p->size() << " made in endcap" << std::endl;
     evt.put(std::move(clusters_p), endcapClusterCollection_);
   }
 }

◆ produce()

void EgammaHLTNxNClusterProducer::produce	(	edm::Event &	evt,
		const edm::EventSetup &	eventSetup
	)

override

Definition at line 150 of file EgammaHLTNxNClusterProducer.cc.

References barrelHitProducer_, debug_, reco::CaloID::DET_ECAL_BARREL, reco::CaloID::DET_ECAL_ENDCAP, doBarrel_, doEndcaps_, endcapHitProducer_, edm::EventID::event(), options_cfi::eventSetup, edm::Event::getByToken(), edm::EventBase::id(), edm::HandleBase::isValid(), LogDebug, makeNxNClusters(), edm::Handle< T >::product(), edm::EventID::run(), and edm::SortedCollection< T, SORT >::size().

                                                                                         {
   if (doBarrel_) {
     edm::Handle<EcalRecHitCollection> barrelRecHitsHandle;
     evt.getByToken(barrelHitProducer_, barrelRecHitsHandle);
     if (!barrelRecHitsHandle.isValid()) {
       LogDebug("") << "EgammaHLTNxNClusterProducer Error! can't get product eb hit!" << std::endl;
     }
 
     const EcalRecHitCollection *hits_eb = barrelRecHitsHandle.product();
     if (debug_ >= 2)
       LogDebug("") << "EgammaHLTNxNClusterProducer nEBrechits: " << evt.id().run() << " event " << evt.id().event()
                    << " " << hits_eb->size() << std::endl;
 
     makeNxNClusters(evt, eventSetup, *hits_eb, reco::CaloID::DET_ECAL_BARREL);
   }
 
   if (doEndcaps_) {
     edm::Handle<EcalRecHitCollection> endcapRecHitsHandle;
     evt.getByToken(endcapHitProducer_, endcapRecHitsHandle);
     if (!endcapRecHitsHandle.isValid()) {
       LogDebug("") << "EgammaHLTNxNClusterProducer Error! can't get product ee hit!" << std::endl;
     }
 
     const EcalRecHitCollection *hits_ee = endcapRecHitsHandle.product();
     if (debug_ >= 2)
       LogDebug("") << "EgammaHLTNxNClusterProducer nEErechits: " << evt.id().run() << " event " << evt.id().event()
                    << " " << hits_ee->size() << std::endl;
     makeNxNClusters(evt, eventSetup, *hits_ee, reco::CaloID::DET_ECAL_ENDCAP);
   }
 }