#include <EgammaHLTHybridClusterProducer.h>

Inheritance diagram for EgammaHLTHybridClusterProducer:

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

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

	~EgammaHLTHybridClusterProducer () override

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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

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

Private Attributes
const std::string	basicclusterCollection_

const bool	doIsolated_

const edm::InputTag	hitcollection_

const edm::EDGetTokenT< EcalRecHitCollection >	hittoken_

HybridClusterAlgo *const	hybrid_p

const double	l1LowerThr_

const double	l1LowerThrIgnoreIsolation_

const edm::EDGetTokenT< l1extra::L1EmParticleCollection >	l1TagIsolated_

const edm::EDGetTokenT< l1extra::L1EmParticleCollection >	l1TagNonIsolated_

const double	l1UpperThr_

const PositionCalc	posCalculator_

const double	regionEtaMargin_

const double	regionPhiMargin_

const std::string	superclusterCollection_

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

Detailed Description

Definition at line 23 of file EgammaHLTHybridClusterProducer.h.

Constructor & Destructor Documentation

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

Definition at line 46 of file EgammaHLTHybridClusterProducer.cc.

References basicclusterCollection_, cosmicSuperClusters_cfi::bremRecoveryPset, edm::ParameterSet::getParameter(), hybrid_p, HybridClusterAlgo::setDynamicPhiRoad(), and superclusterCollection_.

   : basicclusterCollection_ (ps.getParameter<std::string>("basicclusterCollection"))
   , superclusterCollection_ (ps.getParameter<std::string>("superclusterCollection"))
   , hittoken_               (consumes<EcalRecHitCollection>(hitcollection_))
   , hitcollection_          (ps.getParameter<edm::InputTag>("ecalhitcollection"))
   
   // L1 matching parameters
   , l1TagIsolated_    (consumes<l1extra::L1EmParticleCollection>(ps.getParameter< edm::InputTag > ("l1TagIsolated")))
   , l1TagNonIsolated_ (consumes<l1extra::L1EmParticleCollection>(ps.getParameter< edm::InputTag > ("l1TagNonIsolated")))
 
   , doIsolated_   (ps.getParameter<bool>("doIsolated"))
 
   , l1LowerThr_ (ps.getParameter<double> ("l1LowerThr"))
   , l1UpperThr_ (ps.getParameter<double> ("l1UpperThr"))
   , l1LowerThrIgnoreIsolation_ (ps.getParameter<double> ("l1LowerThrIgnoreIsolation"))
 
   , regionEtaMargin_   (ps.getParameter<double>("regionEtaMargin"))
   , regionPhiMargin_   (ps.getParameter<double>("regionPhiMargin"))
 
   // Parameters for the position calculation:
   , posCalculator_ (PositionCalc( ps.getParameter<edm::ParameterSet>("posCalcParameters") ))
 
   , hybrid_p (new HybridClusterAlgo(
               ps.getParameter<double>("HybridBarrelSeedThr"), 
               ps.getParameter<int>("step"),
               ps.getParameter<double>("ethresh"),
               ps.getParameter<double>("eseed"),
               ps.getParameter<double>("xi"),
               ps.getParameter<bool>("useEtForXi"),
               ps.getParameter<double>("ewing"),
               StringToEnumValue<EcalRecHit::Flags>(
                   ps.getParameter<std::vector<std::string> >("RecHitFlagToBeExcluded")),
               posCalculator_,
               ps.getParameter<bool>("dynamicEThresh"),
               ps.getParameter<double>("eThreshA"),
               ps.getParameter<double>("eThreshB"),
               StringToEnumValue<EcalSeverityLevel::SeverityLevel>(
                   ps.getParameter<std::vector<std::string> >("RecHitSeverityToBeExcluded")),
               ps.getParameter<bool>("excludeFlagged")))
 {
   if (ps.getParameter<bool>("dynamicPhiRoad")) {
      edm::ParameterSet bremRecoveryPset = ps.getParameter<edm::ParameterSet>("bremRecoveryPset");
      hybrid_p->setDynamicPhiRoad(bremRecoveryPset);
   }
 
   produces< reco::BasicClusterCollection >(basicclusterCollection_);
   produces< reco::SuperClusterCollection >(superclusterCollection_);
 }

EgammaHLTHybridClusterProducer::~EgammaHLTHybridClusterProducer ( )

override

Definition at line 96 of file EgammaHLTHybridClusterProducer.cc.

References hybrid_p.

 {
   delete hybrid_p;
 }

Member Function Documentation

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

static

Definition at line 101 of file EgammaHLTHybridClusterProducer.cc.

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

                                                                                                 {
 
   edm::ParameterSetDescription desc;
   desc.add<std::string>("debugLevel" , "INFO");
   desc.add<std::string>("basicclusterCollection", "");
   desc.add<std::string>("superclusterCollection", "");
   desc.add<edm::InputTag>("ecalhitcollection", edm::InputTag("ecalRecHit","EcalRecHitsEB"));
   desc.add<edm::InputTag>("l1TagIsolated", edm::InputTag("l1extraParticles","Isolated"));
   desc.add<edm::InputTag>("l1TagNonIsolated", edm::InputTag("l1extraParticles","NonIsolated"));
   desc.add<bool>("doIsolated", true);
   desc.add<double>("l1LowerThr", 0);
   desc.add<double>("l1UpperThr", 9999.0);
   desc.add<double>("l1LowerThrIgnoreIsolation", 999.0);
   desc.add<double>("regionEtaMargin", 0.14);
   desc.add<double>("regionPhiMargin", 0.4);
 
   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<std::vector<std::string>>("RecHitFlagToBeExcluded", std::vector<std::string>());
   desc.add<std::vector<std::string> >("RecHitSeverityToBeExcluded", std::vector<std::string>());
   desc.add<double>("severityRecHitThreshold", 4.0);
   desc.add<double>("HybridBarrelSeedThr", 1.0);
   desc.add<int>("step", 10);
   desc.add<double>("ethresh", 0.1);
   desc.add<double>("eseed", 0.35);
   desc.add<double>("xi", 0);
   desc.add<bool>("useEtForXi", true);
   desc.add<double>("ewing", 1.0);
   desc.add<bool>("dynamicEThresh", false);
   desc.add<double>("eThreshA", 0.003);
   desc.add<double>("eThreshB", 0.1);
   desc.add<bool>("excludeFlagged", false);
   desc.add<bool>("dynamicPhiRoad", false);
   //desc.add<edm::ParameterSet>("bremRecoveryPset", edm::ParameterSet());
   
   descriptions.add("hltEgammaHLTHybridClusterProducer", desc);  
 }

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

override

Definition at line 147 of file EgammaHLTHybridClusterProducer.cc.

References basicclusterCollection_, doIsolated_, DetId::Ecal, EcalBarrel, EcalEndcap, EcalPreshower, L1CaloGeometry::emJetPhiBinHighEdge(), L1CaloGeometry::emJetPhiBinLowEdge(), L1CaloGeometry::etaBinHighEdge(), L1CaloGeometry::etaBinLowEdge(), edm::EventSetup::get(), edm::Event::getByToken(), CaloGeometry::getSubdetectorGeometry(), hitcollection_, hittoken_, hybrid_p, mps_fire::i, edm::InputTag::instance(), edm::OrphanHandleBase::isValid(), edm::HandleBase::isValid(), l1LowerThr_, l1LowerThrIgnoreIsolation_, l1TagIsolated_, l1TagNonIsolated_, l1UpperThr_, HybridClusterAlgo::makeClusters(), HybridClusterAlgo::makeSuperClusters(), eostools::move(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), edm::PtrVector< T >::push_back(), edm::Event::put(), regionEtaMargin_, regionPhiMargin_, superclusterCollection_, and ecaldqm::topology().

                                                                                    {
 
   // get the hit collection from the event:
   edm::Handle<EcalRecHitCollection> rhcHandle;
   evt.getByToken(hittoken_, rhcHandle);
   
   if (!(rhcHandle.isValid()))  
     {
       edm::LogError("ProductNotFound")<< "could not get a handle on the EcalRecHitCollection!" << std::endl;
       return;
     }
   const EcalRecHitCollection *hit_collection = rhcHandle.product();
 
   // get the collection geometry:
   edm::ESHandle<CaloGeometry> geoHandle;
   es.get<CaloGeometryRecord>().get(geoHandle);
   const CaloGeometry& geometry = *geoHandle;
   const CaloSubdetectorGeometry *geometry_p;
   std::unique_ptr<const CaloSubdetectorTopology> topology;
 
   //edm::ESHandle<EcalChannelStatus> chStatus;
   //es.get<EcalChannelStatusRcd>().get(chStatus);
   //const EcalChannelStatus* theEcalChStatus = chStatus.product();
   
   edm::ESHandle<EcalSeverityLevelAlgo> sevlv;
   es.get<EcalSeverityLevelAlgoRcd>().get(sevlv);
   const EcalSeverityLevelAlgo* sevLevel = sevlv.product();
  
   if(hitcollection_.instance() == "EcalRecHitsEB") {
     geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalBarrel);
     topology = std::make_unique<EcalBarrelTopology>(*geoHandle);
   } else if(hitcollection_.instance() == "EcalRecHitsEE") {
     geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalEndcap);
     topology = std::make_unique<EcalEndcapTopology>(*geoHandle);
   } else if(hitcollection_.instance() == "EcalRecHitsPS") {
     geometry_p = geometry.getSubdetectorGeometry(DetId::Ecal, EcalPreshower);
     topology = std::make_unique<EcalPreshowerTopology>();
   } else throw(std::runtime_error("\n\nHybrid Cluster Producer encountered invalied ecalhitcollection type.\n\n"));
     
   //Get the L1 EM Particle Collection
   //Get the L1 EM Particle Collection
   edm::Handle< l1extra::L1EmParticleCollection > emIsolColl ;
   if(doIsolated_)
     evt.getByToken(l1TagIsolated_, emIsolColl);
 
   //Get the L1 EM Particle Collection
   edm::Handle< l1extra::L1EmParticleCollection > emNonIsolColl ;
   evt.getByToken(l1TagNonIsolated_, emNonIsolColl);
 
   // Get the CaloGeometry
   edm::ESHandle<L1CaloGeometry> l1CaloGeom ;
   es.get<L1CaloGeometryRecord>().get(l1CaloGeom) ;
 
   std::vector<RectangularEtaPhiRegion> regions;
 
   if(doIsolated_) {
     for( l1extra::L1EmParticleCollection::const_iterator emItr = emIsolColl->begin(); emItr != emIsolColl->end() ;++emItr ){
 
     if (emItr->et() > l1LowerThr_ && emItr->et() < l1UpperThr_) {
 
       // Access the GCT hardware object corresponding to the L1Extra EM object.
       int etaIndex = emItr->gctEmCand()->etaIndex() ;
       int phiIndex = emItr->gctEmCand()->phiIndex() ;
       // Use the L1CaloGeometry to find the eta, phi bin boundaries.
       double etaLow  = l1CaloGeom->etaBinLowEdge( etaIndex ) ;
       double etaHigh = l1CaloGeom->etaBinHighEdge( etaIndex ) ;
       double phiLow  = l1CaloGeom->emJetPhiBinLowEdge( phiIndex ) ;
       double phiHigh = l1CaloGeom->emJetPhiBinHighEdge( phiIndex ) ;
 
        int isbarl=0;
        //Part of the region is in the barel if either the upper or lower
        //edge of the region is within the barrel
        if(((float)(etaLow)>-1.479 && (float)(etaLow)<1.479) || 
       ((float)(etaHigh)>-1.479 && (float)(etaHigh)<1.479)) isbarl=1;
 
 
       etaLow -= regionEtaMargin_;
       etaHigh += regionEtaMargin_;
       phiLow -= regionPhiMargin_;
       phiHigh += regionPhiMargin_;
 
       if (etaHigh>1.479) etaHigh=1.479;
       if (etaLow<-1.479) etaLow=-1.479;
 
       if(isbarl) regions.push_back(RectangularEtaPhiRegion(etaLow,etaHigh,phiLow,phiHigh));
 
     }
   }
   }
 
   if(!doIsolated_||l1LowerThrIgnoreIsolation_<64) {
     for( l1extra::L1EmParticleCollection::const_iterator emItr = emNonIsolColl->begin(); emItr != emNonIsolColl->end() ;++emItr ){
 
       if(doIsolated_&&emItr->et()<l1LowerThrIgnoreIsolation_) continue;
 
     if (emItr->et() > l1LowerThr_ && emItr->et() < l1UpperThr_) {
 
       // Access the GCT hardware object corresponding to the L1Extra EM object.
       int etaIndex = emItr->gctEmCand()->etaIndex() ;
       int phiIndex = emItr->gctEmCand()->phiIndex() ;
       // Use the L1CaloGeometry to find the eta, phi bin boundaries.
       double etaLow  = l1CaloGeom->etaBinLowEdge( etaIndex ) ;
       double etaHigh = l1CaloGeom->etaBinHighEdge( etaIndex ) ;
       double phiLow  = l1CaloGeom->emJetPhiBinLowEdge( phiIndex ) ;
       double phiHigh = l1CaloGeom->emJetPhiBinHighEdge( phiIndex ) ;
 
        int isbarl=0;
        //Part of the region is in the barel if either the upper or lower
        //edge of the region is within the barrel
        if(((float)(etaLow)>-1.479 && (float)(etaLow)<1.479) || 
           ((float)(etaHigh)>-1.479 && (float)(etaHigh)<1.479)) isbarl=1;
        
        
        etaLow -= regionEtaMargin_;
        etaHigh += regionEtaMargin_;
        phiLow -= regionPhiMargin_;
        phiHigh += regionPhiMargin_;
        
        if (etaHigh>1.479) etaHigh=1.479;
        if (etaLow<-1.479) etaLow=-1.479;
        
        if(isbarl) regions.push_back(RectangularEtaPhiRegion(etaLow,etaHigh,phiLow,phiHigh));
        
     }
     }
   }
   
   // make the Basic clusters!
   reco::BasicClusterCollection basicClusters;
   hybrid_p->makeClusters(hit_collection, geometry_p, basicClusters, sevLevel, true, regions);
   
   // create an unique_ptr to a BasicClusterCollection, copy the clusters into it and put in the Event:
   auto basicclusters_p = std::make_unique<reco::BasicClusterCollection>();
   basicclusters_p->assign(basicClusters.begin(), basicClusters.end());
   edm::OrphanHandle<reco::BasicClusterCollection> bccHandle =  evt.put(std::move(basicclusters_p),
                                                                        basicclusterCollection_);
   if (!(bccHandle.isValid())) {
     return;
   }
   reco::BasicClusterCollection clusterCollection = *bccHandle;
 
   reco::CaloClusterPtrVector clusterRefVector;
   for (unsigned int i = 0; i < clusterCollection.size(); i++){
     clusterRefVector.push_back(reco::CaloClusterPtr(bccHandle, i));
   }
 
   reco::SuperClusterCollection superClusters = hybrid_p->makeSuperClusters(clusterRefVector);
 
   auto superclusters_p = std::make_unique<reco::SuperClusterCollection>();
   superclusters_p->assign(superClusters.begin(), superClusters.end());
   evt.put(std::move(superclusters_p), superclusterCollection_);
 }