ElectronSeedProducer Class Reference

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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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

Private Attributes
bool	allowHGCal_
bool	applyHOverECut_ = true
edm::EDGetTokenT< reco::BeamSpot >	beamSpotTag_
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<>
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

Description: EDProducer of ElectronSeed objects

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

Definition at line 33 of file ElectronSeedProducer.cc.

Constructor & Destructor Documentation

ElectronSeedProducer()

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

explicit

Definition at line 63 of file ElectronSeedProducer.cc.

    :
 
      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.useTowers = true;
      hcalCfg.hcalTowers = consumes(conf.getParameter<edm::InputTag>("hcalTowers"));
      hcalCfg.hOverEPtMin = conf.getParameter<double>("hOverEPtMin");
    }
    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");
  }
 
  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>();
}

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

Member Function Documentation

fillDescriptions()

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

static

Definition at line 197 of file ElectronSeedProducer.cc.

                                                                                      {
  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);
 
  // H/E towers
  desc.add<edm::InputTag>("hcalTowers", {"towerMaker"});
  desc.add<double>("hOverEPtMin", 0.0);
 
  // 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"});
  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("ecalDrivenElectronSeeds", desc);
}

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

filterClusters()

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

private

Definition at line 161 of file ElectronSeedProducer.cc.

                                                                                                            {
  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_->hcalESumDepth1(scl) + hcalHelper_->hcalESumDepth2(scl);
        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;
}

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_FULL_cff::superClusters.

Referenced by produce().

produce()

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

final

Definition at line 112 of file ElectronSeedProducer.cc.

                                                                           {
  LogDebug("ElectronSeedProducer") << "[ElectronSeedProducer::produce] entering ";
 
  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& beamSportPosition = e.get(beamSpotTag_).position();
 
  // loop over barrel + endcap
  for (unsigned int i = 0; i < 2; i++) {
    auto clusterRefs = filterClusters(beamSportPosition, e.getHandle(superClusters_[i]));
    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));
}

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

Member Data Documentation

allowHGCal_

bool ElectronSeedProducer::allowHGCal_

private

Definition at line 57 of file ElectronSeedProducer.cc.

Referenced by filterClusters(), and produce().

applyHOverECut_

bool ElectronSeedProducer::applyHOverECut_ = true

private

Definition at line 51 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

beamSpotTag_

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

private

Definition at line 47 of file ElectronSeedProducer.cc.

Referenced by produce().

hcalHelper_

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

private

Definition at line 52 of file ElectronSeedProducer.cc.

Referenced by filterClusters(), and produce().

hgcClusterTools_

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

private

Definition at line 58 of file ElectronSeedProducer.cc.

Referenced by filterClusters(), and produce().

initialSeeds_

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

private

Definition at line 46 of file ElectronSeedProducer.cc.

Referenced by produce().

matcher_

std::unique_ptr<ElectronSeedGenerator> ElectronSeedProducer::matcher_

private

Definition at line 49 of file ElectronSeedProducer.cc.

Referenced by produce().

maxHOverEBarrel_

double ElectronSeedProducer::maxHOverEBarrel_

private

Definition at line 53 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

maxHOverEEndcaps_

double ElectronSeedProducer::maxHOverEEndcaps_

private

Definition at line 54 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

SCEtCut_

double ElectronSeedProducer::SCEtCut_

private

Definition at line 55 of file ElectronSeedProducer.cc.

Referenced by filterClusters().

superClusters_

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

private

Definition at line 45 of file ElectronSeedProducer.cc.

Referenced by produce().