Inheritance diagram for ElectronSeedProducer:

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

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

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
reco::SuperClusterRefVector	filterClusters (math::XYZPoint const &beamSpotPosition, const edm::Handle< reco::SuperClusterCollection > &superClusters, HcalPFCuts const *hcalCuts) const

Private Attributes
bool	allowHGCal_

bool	applyHOverECut_ = true

edm::EDGetTokenT< reco::BeamSpot >	beamSpotTag_

bool	cutsFromDB_

edm::ESGetToken< HcalPFCuts, HcalPFCutsRcd >	hcalCutsToken_

std::unique_ptr< ElectronHcalHelper >	hcalHelper_ = nullptr

std::unique_ptr< hgcal::ClusterTools >	hgcClusterTools_

std::vector< edm::EDGetTokenT< TrajectorySeedCollection > >	initialSeeds_

std::unique_ptr< ElectronSeedGenerator >	matcher_

double	maxHOverEBarrel_

double	maxHOverEEndcaps_

double	SCEtCut_

edm::EDGetTokenT< reco::SuperClusterCollection >	superClusters_ [2]

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: EDProducer of ElectronSeed objects

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

Definition at line 36 of file ElectronSeedProducer.cc.

Constructor & Destructor Documentation

◆ ElectronSeedProducer()

ElectronSeedProducer::ElectronSeedProducer ( const edm::ParameterSet & conf )

explicit

Definition at line 70 of file ElectronSeedProducer.cc.

References edm::ParameterSet::getParameter(), makeGlobalPositionRcd_cfg::tag, and edm::vector_transform().

     :
 
       initialSeeds_{
           edm::vector_transform(conf.getParameter<std::vector<edm::InputTag>>("initialSeedsVector"),
                                 [this](edm::InputTag const& tag) { return consumes<TrajectorySeedCollection>(tag); })}
 
 {
   SCEtCut_ = conf.getParameter<double>("SCEtCut");
   auto theconsumes = consumesCollector();
 
   // new beamSpot tag
   beamSpotTag_ = consumes(conf.getParameter<edm::InputTag>("beamSpot"));
 
   // for H/E
   applyHOverECut_ = conf.getParameter<bool>("applyHOverECut");
   if (applyHOverECut_) {
     ElectronHcalHelper::Configuration hcalCfg{};
     hcalCfg.hOverEConeSize = conf.getParameter<double>("hOverEConeSize");
     if (hcalCfg.hOverEConeSize > 0) {
       hcalCfg.onlyBehindCluster = false;
       hcalCfg.checkHcalStatus = false;
 
       hcalCfg.hbheRecHits = consumes<HBHERecHitCollection>(conf.getParameter<edm::InputTag>("hbheRecHits"));
 
       hcalCfg.eThresHB = conf.getParameter<EgammaHcalIsolation::arrayHB>("recHitEThresholdHB");
       hcalCfg.maxSeverityHB = conf.getParameter<int>("maxHcalRecHitSeverity");
       hcalCfg.eThresHE = conf.getParameter<EgammaHcalIsolation::arrayHE>("recHitEThresholdHE");
       hcalCfg.maxSeverityHE = hcalCfg.maxSeverityHB;
     }
     hcalHelper_ = std::make_unique<ElectronHcalHelper>(hcalCfg, consumesCollector());
 
     allowHGCal_ = conf.getParameter<bool>("allowHGCal");
     if (allowHGCal_) {
       const edm::ParameterSet& hgcCfg = conf.getParameterSet("HGCalConfig");
       hgcClusterTools_ = std::make_unique<hgcal::ClusterTools>(hgcCfg, theconsumes);
     }
 
     maxHOverEBarrel_ = conf.getParameter<double>("maxHOverEBarrel");
     maxHOverEEndcaps_ = conf.getParameter<double>("maxHOverEEndcaps");
   }
 
   //Retrieve HCAL PF thresholds - from config or from DB
   cutsFromDB_ = conf.getParameter<bool>("usePFThresholdsFromDB");
   if (cutsFromDB_) {
     hcalCutsToken_ = esConsumes<HcalPFCuts, HcalPFCutsRcd>(edm::ESInputTag("", "withTopo"));
   }
 
   ElectronSeedGenerator::Tokens esg_tokens;
   esg_tokens.token_bs = beamSpotTag_;
   esg_tokens.token_vtx = mayConsume<reco::VertexCollection>(conf.getParameter<edm::InputTag>("vertices"));
 
   matcher_ = std::make_unique<ElectronSeedGenerator>(conf, esg_tokens, consumesCollector());
 
   superClusters_[0] = consumes(conf.getParameter<edm::InputTag>("barrelSuperClusters"));
   superClusters_[1] = consumes(conf.getParameter<edm::InputTag>("endcapSuperClusters"));
 
   //register your products
   produces<ElectronSeedCollection>();
 }

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 223 of file ElectronSeedProducer.cc.

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

                                                                                       {
   edm::ParameterSetDescription desc;
 
   // steering
   desc.add<std::vector<edm::InputTag>>("initialSeedsVector", {});
   desc.add<bool>("useRecoVertex", false);
   desc.add<edm::InputTag>("vertices", {"offlinePrimaryVerticesWithBS"});
   desc.add<edm::InputTag>("beamSpot", {"offlineBeamSpot"});
   desc.add<bool>("dynamicPhiRoad", true);
 
   // SC filtering
   desc.add<double>("SCEtCut", 0.0);
 
   // H/E
   desc.add<bool>("applyHOverECut", true);
   desc.add<double>("hOverEConeSize", 0.15);
   desc.add<double>("maxHOverEBarrel", 0.15);
   desc.add<double>("maxHOverEEndcaps", 0.15);
   desc.add<edm::InputTag>("hbheRecHits", {"hbhereco"});
   desc.add<std::vector<double>>("recHitEThresholdHB", {0., 0., 0., 0.});
   desc.add<std::vector<double>>("recHitEThresholdHE", {0., 0., 0., 0., 0., 0., 0.});
   desc.add<int>("maxHcalRecHitSeverity", 999999);
   desc.add<bool>("usePFThresholdsFromDB", false);
 
   // H/E equivalent for HGCal
   desc.add<bool>("allowHGCal", false);
   edm::ParameterSetDescription psd4;
   psd4.add<edm::InputTag>("HGCEEInput", {"HGCalRecHit", "HGCEERecHits"});
   psd4.add<edm::InputTag>("HGCFHInput", {"HGCalRecHit", "HGCHEFRecHits"});
   psd4.add<edm::InputTag>("HGCBHInput", {"HGCalRecHit", "HGCHEBRecHits"});
   psd4.add<edm::InputTag>("hgcalHitMap", {"recHitMapProducer", "hgcalRecHitMap"});
   desc.add<edm::ParameterSetDescription>("HGCalConfig", psd4);
 
   // r/z windows
   desc.add<double>("nSigmasDeltaZ1", 5.0);      // in case beam spot is used for the matching
   desc.add<double>("deltaZ1WithVertex", 25.0);  // in case reco vertex is used for the matching
   desc.add<double>("z2MaxB", 0.09);
   desc.add<double>("r2MaxF", 0.15);
   desc.add<double>("rMaxI", 0.2);  // intermediate region SC in EB and 2nd hits in PXF
 
   // phi windows (dynamic)
   desc.add<double>("LowPtThreshold", 5.0);
   desc.add<double>("HighPtThreshold", 35.0);
   desc.add<double>("SizeWindowENeg", 0.675);
   desc.add<double>("DeltaPhi1Low", 0.23);
   desc.add<double>("DeltaPhi1High", 0.08);
   desc.add<double>("DeltaPhi2B", 0.008);
   desc.add<double>("DeltaPhi2F", 0.012);
 
   // phi windows (non dynamic, overwritten in case dynamic is selected)
   desc.add<double>("ePhiMin1", -0.125);
   desc.add<double>("ePhiMax1", 0.075);
   desc.add<double>("PhiMax2B", 0.002);
   desc.add<double>("PhiMax2F", 0.003);
 
   desc.add<edm::InputTag>("barrelSuperClusters",
                           {"particleFlowSuperClusterECAL", "particleFlowSuperClusterECALBarrel"});
   desc.add<edm::InputTag>("endcapSuperClusters",
                           {"particleFlowSuperClusterECAL", "particleFlowSuperClusterECALEndcapWithPreshower"});
 
   descriptions.add("ecalDrivenElectronSeedsDefault", desc);
 }

◆ filterClusters()

SuperClusterRefVector ElectronSeedProducer::filterClusters	(	math::XYZPoint const &	beamSpotPosition,
		const edm::Handle< reco::SuperClusterCollection > &	superClusters,
		HcalPFCuts const *	hcalCuts
	)		const

private

Definition at line 185 of file ElectronSeedProducer.cc.

References allowHGCal_, applyHOverECut_, hgcalTestNeighbor_cfi::detector, EcalBarrel, EcalEndcap, PVValHelper::eta, hcalHelper_, hgcClusterTools_, mps_fire::i, EcalTools::isHGCalDet(), LogDebug, maxHOverEBarrel_, maxHOverEEndcaps_, edm::RefVector< C, T, F >::push_back(), SCEtCut_, edm::RefVector< C, T, F >::size(), and HLT_2024v14_cff::superClusters.

Referenced by produce().

                                       {
   SuperClusterRefVector sclRefs;
 
   for (unsigned int i = 0; i < superClusters->size(); ++i) {
     auto const& scl = (*superClusters)[i];
     double sclEta = EleRelPoint(scl.position(), beamSpotPosition).eta();
     if (scl.energy() / cosh(sclEta) > SCEtCut_) {
       if (applyHOverECut_) {
         bool hoeVeto = false;
         double had = hcalHelper_->hcalESum(scl, 0, hcalCuts);
         double scle = scl.energy();
         int det_group = scl.seed()->hitsAndFractions()[0].first.det();
         int detector = scl.seed()->hitsAndFractions()[0].first.subdetId();
         if (detector == EcalBarrel && had / scle < maxHOverEBarrel_)
           hoeVeto = true;
         else if (!allowHGCal_ && detector == EcalEndcap && had / scle < maxHOverEEndcaps_)
           hoeVeto = true;
         else if (allowHGCal_ && EcalTools::isHGCalDet((DetId::Detector)det_group)) {
           float had_fraction = hgcClusterTools_->getClusterHadronFraction(*(scl.seed()));
           hoeVeto = (had_fraction >= 0.f && had_fraction < maxHOverEEndcaps_);
         }
         if (hoeVeto) {
           sclRefs.push_back({superClusters, i});
         }
       } else {
         sclRefs.push_back({superClusters, i});
       }
     }
   }
   LogDebug("ElectronSeedProducer") << "Filtered out " << sclRefs.size() << " superclusters from "
                                    << superClusters->size();
 
   return sclRefs;
 }

◆ produce()

void ElectronSeedProducer::produce	(	edm::Event &	e,
		const edm::EventSetup &	iSetup
	)

final

Definition at line 131 of file ElectronSeedProducer.cc.

References allowHGCal_, beamSpotTag_, cutsFromDB_, MillePedeFileConverter_cfg::e, filterClusters(), edm::EventSetup::getData(), hcalCutsToken_, hcalHelper_, hgcClusterTools_, mps_fire::i, edm::Ref< C, T, F >::id(), initialSeeds_, LogDebug, matcher_, eostools::move(), fileCollector::seed, HLT_2024v14_cff::seeds, and superClusters_.

                                                                            {
   LogDebug("ElectronSeedProducer") << "[ElectronSeedProducer::produce] entering ";
 
   HcalPFCuts const* hcalCuts = nullptr;
   if (cutsFromDB_) {
     hcalCuts = &iSetup.getData(hcalCutsToken_);
   }
 
   std::vector<TrajectorySeedCollection const*> initialSeedCollections;
   std::unique_ptr<TrajectorySeedCollection> initialSeedCollectionPtr = nullptr;  //created on the fly
 
   if (hcalHelper_) {
     hcalHelper_->beginEvent(e, iSetup);
     if (allowHGCal_) {
       hgcClusterTools_->getEventSetup(iSetup);
       hgcClusterTools_->getEvent(e);
     }
   }
 
   matcher_->setupES(iSetup);
 
   // get initial TrajectorySeeds
   initialSeedCollections.clear();
   for (auto const& seeds : initialSeeds_) {
     initialSeedCollections.push_back(&e.get(seeds));
   }
 
   auto seeds = std::make_unique<ElectronSeedCollection>();
   auto const& beamSpotPosition = e.get(beamSpotTag_).position();
 
   // loop over barrel + endcap
   for (unsigned int i = 0; i < 2; i++) {
     auto clusterRefs = filterClusters(beamSpotPosition, e.getHandle(superClusters_[i]), hcalCuts);
     matcher_->run(e, clusterRefs, initialSeedCollections, *seeds);
   }
 
   // store the accumulated result
 #ifdef EDM_ML_DEBUG
   for (auto const& seed : *seeds) {
     SuperClusterRef superCluster = seed.caloCluster().castTo<SuperClusterRef>();
     LogDebug("ElectronSeedProducer") << "new seed with " << seed.nHits() << " hits"
                                      << ", charge " << seed.getCharge() << " and cluster energy "
                                      << superCluster->energy() << " PID " << superCluster.id();
   }
 #endif
   e.put(std::move(seeds));
 }

Member Data Documentation

◆ allowHGCal_

bool ElectronSeedProducer::allowHGCal_

private

Definition at line 61 of file ElectronSeedProducer.cc.

Referenced by filterClusters(), and produce().

◆ applyHOverECut_

bool ElectronSeedProducer::applyHOverECut_ = true

private

Definition at line 55 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

◆ beamSpotTag_

edm::EDGetTokenT<reco::BeamSpot> ElectronSeedProducer::beamSpotTag_

private

Definition at line 51 of file ElectronSeedProducer.cc.

Referenced by produce().

◆ cutsFromDB_

bool ElectronSeedProducer::cutsFromDB_

private

Definition at line 65 of file ElectronSeedProducer.cc.

Referenced by produce().

◆ hcalCutsToken_

edm::ESGetToken<HcalPFCuts, HcalPFCutsRcd> ElectronSeedProducer::hcalCutsToken_

private

Definition at line 64 of file ElectronSeedProducer.cc.

Referenced by produce().

◆ hcalHelper_

std::unique_ptr<ElectronHcalHelper> ElectronSeedProducer::hcalHelper_ = nullptr

private

Definition at line 56 of file ElectronSeedProducer.cc.

Referenced by filterClusters(), and produce().

◆ hgcClusterTools_

std::unique_ptr<hgcal::ClusterTools> ElectronSeedProducer::hgcClusterTools_

private

Definition at line 62 of file ElectronSeedProducer.cc.

Referenced by filterClusters(), and produce().

◆ initialSeeds_

std::vector<edm::EDGetTokenT<TrajectorySeedCollection> > ElectronSeedProducer::initialSeeds_

private

Definition at line 50 of file ElectronSeedProducer.cc.

Referenced by produce().

◆ matcher_

std::unique_ptr<ElectronSeedGenerator> ElectronSeedProducer::matcher_

private

Definition at line 53 of file ElectronSeedProducer.cc.

Referenced by produce().

◆ maxHOverEBarrel_

double ElectronSeedProducer::maxHOverEBarrel_

private

Definition at line 57 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

◆ maxHOverEEndcaps_

double ElectronSeedProducer::maxHOverEEndcaps_

private

Definition at line 58 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

◆ SCEtCut_

double ElectronSeedProducer::SCEtCut_

private

Definition at line 59 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

◆ superClusters_

edm::EDGetTokenT<reco::SuperClusterCollection> ElectronSeedProducer::superClusters_[2]

private

Definition at line 49 of file ElectronSeedProducer.cc.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ElectronSeedProducer()

Member Function Documentation

◆ fillDescriptions()

◆ filterClusters()

◆ produce()

Member Data Documentation

◆ allowHGCal_

◆ applyHOverECut_

◆ beamSpotTag_

◆ cutsFromDB_

◆ hcalCutsToken_

◆ hcalHelper_

◆ hgcClusterTools_

◆ initialSeeds_

◆ matcher_

◆ maxHOverEBarrel_

◆ maxHOverEEndcaps_

◆ SCEtCut_

◆ superClusters_