#include <EgammaHLTNxNClusterProducer.h>

Inheritance diagram for EgammaHLTNxNClusterProducer:

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

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

	~EgammaHLTNxNClusterProducer ()

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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 edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (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 int	clusEtaSize_

const int	clusPhiSize_

const double	clusSeedThr_

const double	clusSeedThrEndCap_

const int	debug_

const bool	doBarrel_

const bool	doEndcaps_

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<>
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::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

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 47 of file EgammaHLTNxNClusterProducer.h.

Constructor & Destructor Documentation

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

Definition at line 27 of file EgammaHLTNxNClusterProducer.cc.

References barrelClusterCollection_, and endcapClusterCollection_.

                                                                                  :
   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"))),
   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 ( )

Definition at line 52 of file EgammaHLTNxNClusterProducer.cc.

53 {}

Member Function Documentation

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

private

from recoFlag()

good

good || PoorCalib

good || PoorCalib || LeadingEdgeRecovered || kNeighboursRecovered,

Definition at line 122 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; 
 }

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

static

Definition at line 55 of file EgammaHLTNxNClusterProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), 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);  
 }

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 147 of file EgammaHLTNxNClusterProducer.cc.

References barrelClusterCollection_, edm::SortedCollection< T, SORT >::begin(), PositionCalc::Calculate_Location(), checkStatusOfEcalRecHit(), clusEtaSize_, clusPhiSize_, clusSeedThr_, clusSeedThrEndCap_, fastPrimaryVertexProducer_cfi::clusters, debug_, reco::CaloID::DET_ECAL_BARREL, DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, edm::SortedCollection< T, SORT >::end(), endcapClusterCollection_, edm::EventID::event(), spr::find(), edm::SortedCollection< T, SORT >::find(), edm::EventSetup::get(), CaloGeometry::getSubdetectorGeometry(), edm::EventBase::id(), reco::CaloCluster::island, LogDebug, maxNumberofClusters_, maxNumberofSeeds_, eostools::move(), posCalculator_, edm::Event::put(), edm::EventID::run(), and useDBStatus_.

Referenced by produce().

 {
   
   
   edm::ESHandle<EcalChannelStatus> csHandle;
   if ( useDBStatus_ ) es.get<EcalChannelStatusRcd>().get(csHandle);
   const EcalChannelStatus &channelStatus = *csHandle; 
     
   
   std::vector<EcalRecHit> seeds;
   
   double clusterSeedThreshold ; 
   if (detector == reco::CaloID::DET_ECAL_BARREL){
     clusterSeedThreshold = clusSeedThr_;
   }else{
     clusterSeedThreshold = clusSeedThrEndCap_; 
   }
   
 
   for(EcalRecHitCollection::const_iterator itt = hits->begin(); itt != hits->end(); itt++){
     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:
   edm::ESHandle<CaloGeometry> geoHandle;
   es.get<CaloGeometryRecord>().get(geoHandle);
   
   const CaloSubdetectorGeometry *geometry_p;
   std::unique_ptr<CaloSubdetectorTopology> topology_p;
   if (detector == reco::CaloID::DET_ECAL_BARREL) {
     geometry_p = geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
     topology_p.reset(new EcalBarrelTopology(geoHandle));
   }else {
     geometry_p = geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
     topology_p.reset(new EcalEndcapTopology(geoHandle)); 
   }
   
   const CaloSubdetectorGeometry *geometryES_p;
   geometryES_p = geoHandle->getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
     
 
   
   std::vector<reco::BasicCluster> clusters;
   std::vector<DetId> usedXtals;
   
   // sort seed according to Energy
   sort(seeds.begin(), seeds.end(), ecalRecHitSort());
   
   
   
   for (std::vector<EcalRecHit>::iterator itseed=seeds.begin(); itseed!=seeds.end(); itseed++) {
     DetId seed_id = itseed->id();
     std::vector<DetId>::const_iterator usedIds;
     
     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 (std::vector<DetId>::iterator det=clus_v.begin(); det!=clus_v.end(); det++) {
     DetId detid = *det;
     
     //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_);
   }
   
 }

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

override

Definition at line 88 of file EgammaHLTNxNClusterProducer.cc.

References barrelHitProducer_, debug_, reco::CaloID::DET_ECAL_BARREL, reco::CaloID::DET_ECAL_ENDCAP, doBarrel_, doEndcaps_, endcapHitProducer_, edm::EventID::event(), 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,es,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,es,hits_ee, reco::CaloID::DET_ECAL_ENDCAP);
   }
 }