LowPtGsfElectronSeedProducer Class Reference

#include <LowPtGsfElectronSeedProducer.h>

Inheritance diagram for LowPtGsfElectronSeedProducer:

Public Types
using	TrackIndxMap = std::unordered_map< reco::TrackRef::key_type, size_t >
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
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 Member Functions
void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) override
	LowPtGsfElectronSeedProducer (const edm::ParameterSet &, const lowptgsfeleseed::HeavyObjectCache *)
void	produce (edm::Event &, const edm::EventSetup &) override
	~LowPtGsfElectronSeedProducer () override
Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &)
static void	globalEndJob (lowptgsfeleseed::HeavyObjectCache const *)
static std::unique_ptr< lowptgsfeleseed::HeavyObjectCache >	initializeGlobalCache (const edm::ParameterSet &conf)

Private Member Functions
bool	decision (const reco::PFRecTrackRef &pfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
bool	decision (const reco::TrackRef &kfTrackRef, reco::PreId &ecal, reco::PreId &hcal, double rho, const reco::BeamSpot &spot, noZS::EcalClusterLazyTools &ecalTools)
template<typename CollType >
void	fillPreIdRefValueMap (edm::Handle< CollType > tracksHandle, const TrackIndxMap &trksToPreIdIndx, const edm::OrphanHandle< reco::PreIdCollection > &preIdHandle, edm::ValueMap< reco::PreIdRef >::Filler &filler)
reco::TrackRef	getBaseRef (edm::Handle< std::vector< reco::Track > > handle, int idx) const
reco::TrackRef	getBaseRef (edm::Handle< std::vector< reco::PFRecTrack > > handle, int idx) const
bool	lightGsfTracking (reco::PreId &, const reco::TrackRef &, const reco::ElectronSeed &, const edm::EventSetup &)
template<typename T >
void	loop (const edm::Handle< std::vector< T > > &handle, edm::Handle< reco::PFClusterCollection > &hcalClusters, reco::ElectronSeedCollection &seeds, reco::PreIdCollection &ecalPreIds, reco::PreIdCollection &hcalPreIds, TrackIndxMap &trksToPreIdIndx, edm::Event &, const edm::EventSetup &)
void	propagateTrackToCalo (const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)
void	propagateTrackToCalo (const reco::PFRecTrackRef &pfTrackRef, const edm::Handle< reco::PFClusterCollection > &clusters, std::vector< int > &matchedClusters, reco::PreId &preId, bool ecal)
void	propagateTrackToCalo (const reco::TrackRef &pfTrack, const edm::Handle< reco::PFClusterCollection > &ecalClusters, const edm::Handle< reco::PFClusterCollection > &hcalClusters, std::vector< int > &matchedEcalClusters, std::vector< int > &matchedHcalClusters, reco::PreId &ecalPreId, reco::PreId &hcalPreId)

Private Attributes
const edm::EDGetTokenT< reco::BeamSpot >	beamSpot_
const std::string	builder_
const edm::EDGetTokenT< EcalRecHitCollection >	ebRecHits_
const edm::EDGetTokenT< reco::PFClusterCollection >	ecalClusters_
const edm::EDGetTokenT< EcalRecHitCollection >	eeRecHits_
edm::ESHandle< MagneticField >	field_
const std::string	fitter_
std::unique_ptr< TrajectoryFitter >	fitterPtr_
edm::EDGetTokenT< reco::PFClusterCollection >	hcalClusters_
edm::EDGetTokenT< reco::TrackCollection >	kfTracks_
const double	maxPtThreshold_
const double	minPtThreshold_
const bool	passThrough_
edm::EDGetTokenT< reco::PFRecTrackCollection >	pfTracks_
const edm::EDGetTokenT< double >	rho_
const std::string	smoother_
std::unique_ptr< TrajectorySmoother >	smootherPtr_
const bool	usePfTracks_

Static Private Attributes
static double	boundary_ = 2.50746495928 * 2.50746495928
static double	mass_ = 0.000511 * 0.000511

Detailed Description

Description: EDProducer of ElectronSeed objects Implementation: <Notes on="" implementation>="">

Definition at line 28 of file LowPtGsfElectronSeedProducer.h.

Member Typedef Documentation

using LowPtGsfElectronSeedProducer::TrackIndxMap = std::unordered_map<reco::TrackRef::key_type, size_t>

Definition at line 31 of file LowPtGsfElectronSeedProducer.h.

Constructor & Destructor Documentation

LowPtGsfElectronSeedProducer::LowPtGsfElectronSeedProducer ( const edm::ParameterSet &  conf, const lowptgsfeleseed::HeavyObjectCache *    )

explicit

Definition at line 38 of file LowPtGsfElectronSeedProducer.cc.

References beamSpot_, builder_, ebRecHits_, eeRecHits_, fitter_, edm::ParameterSet::getParameter(), hcalClusters_, kfTracks_, maxPtThreshold_, minPtThreshold_, passThrough_, pfTracks_, rho_, smoother_, AlCaHLTBitMon_QueryRunRegistry::string, and usePfTracks_.

    : field_(),
      fitterPtr_(),
      smootherPtr_(),
      kfTracks_(),
      pfTracks_(),
      ecalClusters_{consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("ecalClusters"))},
      hcalClusters_(),
      ebRecHits_{consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("EBRecHits"))},
      eeRecHits_{consumes<EcalRecHitCollection>(conf.getParameter<edm::InputTag>("EERecHits"))},
      rho_(consumes<double>(conf.getParameter<edm::InputTag>("rho"))),
      beamSpot_(consumes<reco::BeamSpot>(conf.getParameter<edm::InputTag>("BeamSpot"))),
      fitter_(conf.getParameter<std::string>("Fitter")),
      smoother_(conf.getParameter<std::string>("Smoother")),
      builder_(conf.getParameter<std::string>("TTRHBuilder")),
      passThrough_(conf.getParameter<bool>("PassThrough")),
      usePfTracks_(conf.getParameter<bool>("UsePfTracks")),
      minPtThreshold_(conf.getParameter<double>("MinPtThreshold")),
      maxPtThreshold_(conf.getParameter<double>("MaxPtThreshold")) {
  if (usePfTracks_) {
    pfTracks_ = consumes<reco::PFRecTrackCollection>(conf.getParameter<edm::InputTag>("pfTracks"));
    hcalClusters_ = consumes<reco::PFClusterCollection>(conf.getParameter<edm::InputTag>("hcalClusters"));
  }
  kfTracks_ = consumes<reco::TrackCollection>(conf.getParameter<edm::InputTag>("tracks"));

  produces<reco::ElectronSeedCollection>();
  produces<reco::PreIdCollection>();
  produces<reco::PreIdCollection>("HCAL");
  produces<edm::ValueMap<reco::PreIdRef> >();  // indexed by edm::Ref<ElectronSeed>.index()
}

LowPtGsfElectronSeedProducer::~LowPtGsfElectronSeedProducer ( )

override

Definition at line 72 of file LowPtGsfElectronSeedProducer.cc.

{}

Member Function Documentation

void LowPtGsfElectronSeedProducer::beginLuminosityBlock ( edm::LuminosityBlock const &  , edm::EventSetup const &  setup  )

override

Definition at line 76 of file LowPtGsfElectronSeedProducer.cc.

References field_, and edm::EventSetup::get().

Referenced by globalEndJob().

                                                                                                             {
  setup.get<IdealMagneticFieldRecord>().get(field_);
}

bool LowPtGsfElectronSeedProducer::decision ( const reco::PFRecTrackRef &  pfTrackRef, reco::PreId &  ecal, reco::PreId &  hcal, double  rho, const reco::BeamSpot &  spot, noZS::EcalClusterLazyTools &  ecalTools  )

private

Definition at line 476 of file LowPtGsfElectronSeedProducer.cc.

References maxPtThreshold_, Skims_PA_cff::name, passThrough_, and mps_fire::result.

Referenced by globalEndJob(), and loop().

                                                                                 {
  bool result = false;
  for (auto& name : globalCache()->modelNames()) {
    result |= globalCache()->eval(name, ecalPreId, hcalPreId, rho, spot, ecalTools);
  }
  return passThrough_ || (pfTrackRef->trackRef()->pt() > maxPtThreshold_) || result;
}

bool LowPtGsfElectronSeedProducer::decision ( const reco::TrackRef &  kfTrackRef, reco::PreId &  ecal, reco::PreId &  hcal, double  rho, const reco::BeamSpot &  spot, noZS::EcalClusterLazyTools &  ecalTools  )

private

Definition at line 491 of file LowPtGsfElectronSeedProducer.cc.

References passThrough_.

                                                                                 {
  // No implementation currently
  return passThrough_;
}

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

static

Definition at line 524 of file LowPtGsfElectronSeedProducer.cc.

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

Referenced by globalEndJob().

                                                                                              {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
  desc.add<edm::InputTag>("pfTracks", edm::InputTag("lowPtGsfElePfTracks"));
  desc.add<edm::InputTag>("ecalClusters", edm::InputTag("particleFlowClusterECAL"));
  desc.add<edm::InputTag>("hcalClusters", edm::InputTag("particleFlowClusterHCAL"));
  desc.add<edm::InputTag>("EBRecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEB"));
  desc.add<edm::InputTag>("EERecHits", edm::InputTag("ecalRecHit", "EcalRecHitsEE"));
  desc.add<edm::InputTag>("rho", edm::InputTag("fixedGridRhoFastjetAllTmp"));
  desc.add<edm::InputTag>("BeamSpot", edm::InputTag("offlineBeamSpot"));
  desc.add<std::string>("Fitter", "GsfTrajectoryFitter_forPreId");
  desc.add<std::string>("Smoother", "GsfTrajectorySmoother_forPreId");
  desc.add<std::string>("TTRHBuilder", "WithAngleAndTemplate");
  desc.add<std::vector<std::string> >("ModelNames", std::vector<std::string>());
  desc.add<std::vector<std::string> >("ModelWeights", std::vector<std::string>());
  desc.add<std::vector<double> >("ModelThresholds", std::vector<double>());
  desc.add<bool>("PassThrough", false);
  desc.add<bool>("UsePfTracks", true);
  desc.add<double>("MinPtThreshold", 1.0);
  desc.add<double>("MaxPtThreshold", 15.);
  descriptions.add("lowPtGsfElectronSeeds", desc);
}

template<typename CollType >

void LowPtGsfElectronSeedProducer::fillPreIdRefValueMap ( edm::Handle< CollType >  tracksHandle, const TrackIndxMap &  trksToPreIdIndx, const edm::OrphanHandle< reco::PreIdCollection > &  preIdHandle, edm::ValueMap< reco::PreIdRef >::Filler &  filler  )

private

Definition at line 502 of file LowPtGsfElectronSeedProducer.cc.

References edm::Ref< C, T, F >::index(), edm::helper::Filler< Map >::insert(), and contentValuesCheck::values.

Referenced by globalEndJob(), and produce().

                                                                                                 {
  std::vector<reco::PreIdRef> values;

  unsigned ntracks = tracksHandle->size();
  for (unsigned itrack = 0; itrack < ntracks; ++itrack) {
    edm::Ref<CollType> trackRef(tracksHandle, itrack);
    auto preIdRefIt = trksToPreIdIndx.find(trackRef.index());
    if (preIdRefIt == trksToPreIdIndx.end()) {
      values.push_back(reco::PreIdRef());
    } else {
      edm::Ref<reco::PreIdCollection> preIdRef(preIdHandle, preIdRefIt->second);
      values.push_back(preIdRef);
    }
  }
  filler.insert(tracksHandle, values.begin(), values.end());
}

reco::TrackRef LowPtGsfElectronSeedProducer::getBaseRef ( edm::Handle< std::vector< reco::Track > >  handle, int  idx  ) const

private

Definition at line 148 of file LowPtGsfElectronSeedProducer.cc.

References patZpeak::handle.

Referenced by globalEndJob(), and loop().

                                                                                                            {
  return reco::TrackRef(handle, idx);
}

reco::TrackRef LowPtGsfElectronSeedProducer::getBaseRef ( edm::Handle< std::vector< reco::PFRecTrack > >  handle, int  idx  ) const

private

Definition at line 152 of file LowPtGsfElectronSeedProducer.cc.

References patZpeak::handle.

                                                                       {
  return reco::PFRecTrackRef(handle, idx)->trackRef();
}

static void LowPtGsfElectronSeedProducer::globalEndJob ( lowptgsfeleseed::HeavyObjectCache const *  )

inlinestatic

Definition at line 40 of file LowPtGsfElectronSeedProducer.h.

References beginLuminosityBlock(), bsc_activity_cfg::clusters, decision(), bsc_activity_cfg::ecal, RecoEcal_cff::ecalClusters, fillDescriptions(), trigObjTnPSource_cfi::filler, fillPreIdRefValueMap(), getBaseRef(), patZpeak::handle, lowPtGsfElectronSeeds_cfi::hcalClusters, training_settings::idx, lightGsfTracking(), loop(), pfTrack_cfi::pfTrack, produce(), propagateTrackToCalo(), and rho.

{}

static std::unique_ptr<lowptgsfeleseed::HeavyObjectCache> LowPtGsfElectronSeedProducer::initializeGlobalCache ( const edm::ParameterSet &  conf )

inlinestatic

Definition at line 36 of file LowPtGsfElectronSeedProducer.h.

                                                                                                           {
    return std::make_unique<lowptgsfeleseed::HeavyObjectCache>(lowptgsfeleseed::HeavyObjectCache(conf));
  }

bool LowPtGsfElectronSeedProducer::lightGsfTracking ( reco::PreId &  preId, const reco::TrackRef &  trackRef, const reco::ElectronSeed &  seed, const edm::EventSetup &  setup  )

private

Definition at line 437 of file LowPtGsfElectronSeedProducer.cc.

References Trajectory::chiSquared(), field_, Trajectory::firstMeasurement(), fitterPtr_, TrajectoryStateOnSurface::globalMomentum(), runTauDisplay::gp, hfClusterShapes_cfi::hits, Trajectory::isValid(), Trajectory::lastMeasurement(), PV3DBase< T, PVType, FrameType >::perp(), reco::PreId::setTrackProperties(), smootherPtr_, and TrajectoryMeasurement::updatedState().

Referenced by globalEndJob(), and loop().

                                                                                {
  Trajectory::ConstRecHitContainer hits;
  for (unsigned int ihit = 0; ihit < trackRef->recHitsSize(); ++ihit) {
    hits.push_back(trackRef->recHit(ihit)->cloneSH());
  }

  GlobalVector gv(trackRef->innerMomentum().x(), trackRef->innerMomentum().y(), trackRef->innerMomentum().z());
  GlobalPoint gp(trackRef->innerPosition().x(), trackRef->innerPosition().y(), trackRef->innerPosition().z());

  GlobalTrajectoryParameters gtps(gp, gv, trackRef->charge(), &*field_);

  TrajectoryStateOnSurface tsos(gtps, trackRef->innerStateCovariance(), *hits[0]->surface());

  // Track fitted and smoothed under electron hypothesis
  Trajectory traj1 = fitterPtr_->fitOne(seed, hits, tsos);
  if (!traj1.isValid()) {
    return false;
  }
  Trajectory traj2 = smootherPtr_->trajectory(traj1);
  if (!traj2.isValid()) {
    return false;
  }

  // Set PreId content
  float chi2Ratio = trackRef->chi2() > 0. ? traj2.chiSquared() / trackRef->chi2() : -1.;
  float gsfReducedChi2 = chi2Ratio > -1. ? chi2Ratio * trackRef->normalizedChi2() : -1.;
  float ptOut = traj2.firstMeasurement().updatedState().globalMomentum().perp();
  float ptIn = traj2.lastMeasurement().updatedState().globalMomentum().perp();
  float gsfDpt = (ptIn > 0) ? fabs(ptOut - ptIn) / ptIn : 0.;
  preId.setTrackProperties(gsfReducedChi2, chi2Ratio, gsfDpt);

  return true;
}

template<typename T >

void LowPtGsfElectronSeedProducer::loop ( const edm::Handle< std::vector< T > > &  handle, edm::Handle< reco::PFClusterCollection > &  hcalClusters, reco::ElectronSeedCollection &  seeds, reco::PreIdCollection &  ecalPreIds, reco::PreIdCollection &  hcalPreIds, TrackIndxMap &  trksToPreIdIndx, edm::Event &  event, const edm::EventSetup &  setup  )

private

Definition at line 160 of file LowPtGsfElectronSeedProducer.cc.

References beamSpot_, builder_, TrajectorySmoother::clone(), TrajectoryFitter::clone(), watchdog::const, decision(), ebRecHits_, RecoEcal_cff::ecalClusters, ecalClusters_, eeRecHits_, fitter_, fitterPtr_, edm::EventSetup::get(), getBaseRef(), patZpeak::handle, lowPtGsfElectronSeeds_cfi::hcalClusters, edm::Ref< C, T, F >::index(), lightGsfTracking(), minPtThreshold_, passThrough_, edm::ESHandle< T >::product(), propagateTrackToCalo(), reco::TrackBase::qualityByName(), mps_fire::result, rho, rho_, SurveyInfoScenario_cff::seed, reco::ElectronSeed::setCtfTrack(), reco::PreId::setTrack(), smoother_, and smootherPtr_.

Referenced by globalEndJob(), and produce().

                                                                    {
  // Pileup
  edm::Handle<double> rho;
  event.getByToken(rho_, rho);

  // Beam spot
  edm::Handle<reco::BeamSpot> spot;
  event.getByToken(beamSpot_, spot);

  // Track fitter
  edm::ESHandle<TrajectoryFitter> fitter;
  setup.get<TrajectoryFitter::Record>().get(fitter_, fitter);
  fitterPtr_ = fitter->clone();

  // Track smoother
  edm::ESHandle<TrajectorySmoother> smoother;
  setup.get<TrajectoryFitter::Record>().get(smoother_, smoother);
  smootherPtr_.reset(smoother->clone());

  // RecHit cloner
  edm::ESHandle<TransientTrackingRecHitBuilder> builder;
  setup.get<TransientRecHitRecord>().get(builder_, builder);
  TkClonerImpl hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(builder.product())->cloner();
  fitterPtr_->setHitCloner(&hitCloner);
  smootherPtr_->setHitCloner(&hitCloner);

  // ECAL clusters
  edm::Handle<reco::PFClusterCollection> ecalClusters;
  event.getByToken(ecalClusters_, ecalClusters);

  // Utility to access to shower shape vars
  noZS::EcalClusterLazyTools ecalTools(event, setup, ebRecHits_, eeRecHits_);

  // Ensure each cluster is only matched once to a track
  std::vector<int> matchedEcalClusters;
  std::vector<int> matchedHcalClusters;

  // Reserve
  seeds.reserve(handle->size());
  ecalPreIds.reserve(handle->size());
  hcalPreIds.reserve(handle->size());

  // Iterate through (PF or KF) tracks
  for (unsigned int itrk = 0; itrk < handle.product()->size(); itrk++) {
    edm::Ref<std::vector<T> > templatedRef(handle, itrk);  // TrackRef or PFRecTrackRef
    reco::TrackRef trackRef = getBaseRef(handle, itrk);

    if (!(trackRef->quality(reco::TrackBase::qualityByName("highPurity")))) {
      continue;
    }
    if (!passThrough_ && (trackRef->pt() < minPtThreshold_)) {
      continue;
    }

    // Create ElectronSeed
    reco::ElectronSeed seed(*(trackRef->seedRef()));
    seed.setCtfTrack(trackRef);

    // Create PreIds
    unsigned int nModels = globalCache()->modelNames().size();
    reco::PreId ecalPreId(nModels);
    reco::PreId hcalPreId(nModels);

    // Add track ref to PreId
    ecalPreId.setTrack(trackRef);
    hcalPreId.setTrack(trackRef);

    // Add Track-Calo matching variables to PreIds
    propagateTrackToCalo(
        templatedRef, ecalClusters, hcalClusters, matchedEcalClusters, matchedHcalClusters, ecalPreId, hcalPreId);

    // Add variables related to GSF tracks to PreId
    lightGsfTracking(ecalPreId, trackRef, seed, setup);

    // Decision based on BDT
    bool result = decision(templatedRef, ecalPreId, hcalPreId, *rho, *spot, ecalTools);

    // If fails BDT, do not store seed
    if (!result) {
      continue;
    }

    // Store PreId
    ecalPreIds.push_back(ecalPreId);
    hcalPreIds.push_back(hcalPreId);
    trksToPreIdIndx[trackRef.index()] = ecalPreIds.size() - 1;

    // Store ElectronSeed and corresponding edm::Ref<PreId>.index()
    seeds.push_back(seed);
  }
}

void LowPtGsfElectronSeedProducer::produce ( edm::Event &  event, const edm::EventSetup &  setup  )

override

Definition at line 82 of file LowPtGsfElectronSeedProducer.cc.

References Exception, fillPreIdRefValueMap(), lowPtGsfElectronSeeds_cfi::hcalClusters, hcalClusters_, edm::HandleBase::id(), kfTracks_, loop(), eostools::move(), lowPtGsfElectronSeeds_cfi::pfTracks, pfTracks_, and usePfTracks_.

Referenced by globalEndJob().

                                                                                      {
  // Products
  auto seeds = std::make_unique<reco::ElectronSeedCollection>();
  auto ecalPreIds = std::make_unique<reco::PreIdCollection>();
  auto hcalPreIds = std::make_unique<reco::PreIdCollection>();

  const edm::RefProd<reco::PreIdCollection> preIdsRefProd = event.getRefBeforePut<reco::PreIdCollection>();

  // HCAL clusters (only used with PF tracks)
  edm::Handle<reco::PFClusterCollection> hcalClusters;

  //we always need kftracks as we link the preids to them
  edm::Handle<reco::TrackCollection> kfTracks;
  event.getByToken(kfTracks_, kfTracks);

  TrackIndxMap trksToPreIdIndx;
  if (usePfTracks_) {
    edm::Handle<reco::PFRecTrackCollection> pfTracks;
    event.getByToken(pfTracks_, pfTracks);
    event.getByToken(hcalClusters_, hcalClusters);

    //check consistency between kfTracks and pfTracks collection
    for (auto& trk : *pfTracks) {
      if (trk.trackRef().isNonnull()) {
        if (trk.trackRef().id() != kfTracks.id()) {
          throw cms::Exception("ConfigError")
              << "kfTracks is not the collection that pfTracks was built from, please fix this";
        }
        break;  //we only need one valid track ref to check this so end the loop
      }
    }

    loop(pfTracks,  // PF tracks
         hcalClusters,
         *seeds,
         *ecalPreIds,
         *hcalPreIds,
         trksToPreIdIndx,
         event,
         setup);

  } else {
    loop(kfTracks,  // KF tracks
         hcalClusters,
         *seeds,
         *ecalPreIds,
         *hcalPreIds,
         trksToPreIdIndx,
         event,
         setup);
  }

  auto ecalPreIdsHandle = event.put(std::move(ecalPreIds));
  event.put(std::move(hcalPreIds), "HCAL");
  event.put(std::move(seeds));

  auto preIdVMOut = std::make_unique<edm::ValueMap<reco::PreIdRef> >();
  edm::ValueMap<reco::PreIdRef>::Filler mapFiller(*preIdVMOut);
  fillPreIdRefValueMap(kfTracks, trksToPreIdIndx, ecalPreIdsHandle, mapFiller);
  mapFiller.fill();
  event.put(std::move(preIdVMOut));
}

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::PFRecTrackRef &  pfTrackRef, const edm::Handle< reco::PFClusterCollection > &  ecalClusters, const edm::Handle< reco::PFClusterCollection > &  hcalClusters, std::vector< int > &  matchedEcalClusters, std::vector< int > &  matchedHcalClusters, reco::PreId &  ecalPreId, reco::PreId &  hcalPreId  )

private

Definition at line 283 of file LowPtGsfElectronSeedProducer.cc.

Referenced by globalEndJob(), and loop().

                                                                              {
  propagateTrackToCalo(pfTrackRef, ecalClusters, matchedEcalClusters, ecalPreId, true);
  propagateTrackToCalo(pfTrackRef, hcalClusters, matchedHcalClusters, hcalPreId, false);
}

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::PFRecTrackRef &  pfTrackRef, const edm::Handle< reco::PFClusterCollection > &  clusters, std::vector< int > &  matchedClusters, reco::PreId &  preId, bool  ecal  )

private

Definition at line 296 of file LowPtGsfElectronSeedProducer.cc.

References reco::deltaPhi(), reco::deltaR2(), SiStripBadComponentsDQMServiceTemplate_cfg::ep, spr::find(), info(), reco::PFTrajectoryPoint::isValid(), point, reco::PFTrajectoryPoint::position(), reco::PFTrajectoryPoint::positionREP(), edm::Handle< T >::product(), reco::PreId::setECALMatchingProperties(), and mathSSE::sqrt().

                                                                   {
  // Store info for PreId
  struct Info {
    reco::PFClusterRef cluRef = reco::PFClusterRef();
    float dr2min = 1.e6;
    float deta = 1.e6;
    float dphi = 1.e6;
    math::XYZPoint showerPos = math::XYZPoint(0., 0., 0.);
  } info;

  // Find closest "seed cluster" to KF track extrapolated to ECAL (or HCAL)
  reco::PFTrajectoryPoint point;
  if (ecal) {
    point = pfTrackRef->extrapolatedPoint(reco::PFTrajectoryPoint::LayerType::ECALShowerMax);
  } else {
    point = pfTrackRef->extrapolatedPoint(reco::PFTrajectoryPoint::LayerType::HCALEntrance);
  }

  if (point.isValid()) {
    Info info;
    for (unsigned int iclu = 0; iclu < clusters.product()->size(); iclu++) {
      if (std::find(matched.begin(), matched.end(), iclu) == matched.end()) {
        reco::PFClusterRef cluRef(clusters, iclu);

        // Determine dR squared
        float dr2 = reco::deltaR2(cluRef->positionREP(), point.positionREP());

        if (dr2 < info.dr2min) {
          info.dr2min = dr2;
          info.cluRef = cluRef;
          info.deta = cluRef->positionREP().eta() - point.positionREP().eta();
          info.dphi =
              reco::deltaPhi(cluRef->positionREP().phi(), point.positionREP().phi()) * pfTrackRef->trackRef()->charge();
          info.showerPos = point.position();
        }
      }
    }

    // Set PreId content if match found
    if (info.dr2min < 1.e5) {
      float ep = info.cluRef->correctedEnergy() / std::sqrt(pfTrackRef->trackRef()->innerMomentum().mag2());
      preId.setECALMatchingProperties(info.cluRef,
                                      point.position(),  // ECAL or HCAL surface
                                      info.showerPos,    //
                                      info.deta,
                                      info.dphi,
                                      0.f,                                       // chieta
                                      0.f,                                       // chiphi
                                      pfTrackRef->trackRef()->normalizedChi2(),  // chi2
                                      ep);
    }

  }  // clusters
}

void LowPtGsfElectronSeedProducer::propagateTrackToCalo ( const reco::TrackRef &  pfTrack, const edm::Handle< reco::PFClusterCollection > &  ecalClusters, const edm::Handle< reco::PFClusterCollection > &  hcalClusters, std::vector< int > &  matchedEcalClusters, std::vector< int > &  matchedHcalClusters, reco::PreId &  ecalPreId, reco::PreId &  hcalPreId  )

private

Definition at line 357 of file LowPtGsfElectronSeedProducer.cc.

References funct::abs(), boundary_, reco::deltaPhi(), reco::deltaR2(), HCALHighEnergyHPDFilter_cfi::energy, field_, reco::PFCluster::getDepthCorrection(), info(), MagneticField::inTesla(), mass_, point, funct::pow(), edm::Handle< T >::product(), BaseParticlePropagator::propagateToEcalEntrance(), reco::PreId::setECALMatchingProperties(), mathSSE::sqrt(), unit(), and RawParticle::z().

                            {
  // Store info for PreId
  struct Info {
    reco::PFClusterRef cluRef = reco::PFClusterRef();
    float dr2min = 1.e6;
    float deta = 1.e6;
    float dphi = 1.e6;
    math::XYZPoint showerPos = math::XYZPoint(0., 0., 0.);
  } info;

  // Propagate 'electron' to ECAL surface
  float energy = sqrt(mass_ + kfTrackRef->outerMomentum().Mag2());
  XYZTLorentzVector mom = XYZTLorentzVector(
      kfTrackRef->outerMomentum().x(), kfTrackRef->outerMomentum().y(), kfTrackRef->outerMomentum().z(), energy);
  XYZTLorentzVector pos = XYZTLorentzVector(
      kfTrackRef->outerPosition().x(), kfTrackRef->outerPosition().y(), kfTrackRef->outerPosition().z(), 0.);
  math::XYZVector field(field_->inTesla(GlobalPoint(0, 0, 0)));
  BaseParticlePropagator particle(RawParticle(mom, pos, kfTrackRef->charge()), 0, 0, field.z());
  particle.propagateToEcalEntrance(false);
  if (particle.getSuccess() == 0) {
    return;
  }

  // ECAL entry point for track
  GlobalPoint ecal_pos(
      particle.particle().vertex().x(), particle.particle().vertex().y(), particle.particle().vertex().z());

  // Preshower limit
  bool below_ps = pow(ecal_pos.z(), 2.) > boundary_ * ecal_pos.perp2();

  // Iterate through ECAL clusters
  for (unsigned int iclu = 0; iclu < ecalClusters.product()->size(); iclu++) {
    reco::PFClusterRef cluRef(ecalClusters, iclu);

    // Correct ecal_pos for shower depth
    double shower_depth = reco::PFCluster::getDepthCorrection(cluRef->correctedEnergy(), below_ps, false);
    GlobalPoint showerPos = ecal_pos + GlobalVector(particle.particle().momentum().x(),
                                                    particle.particle().momentum().y(),
                                                    particle.particle().momentum().z())
                                               .unit() *
                                           shower_depth;

    // Determine dR squared
    float dr2 = reco::deltaR2(cluRef->positionREP(), showerPos);

    // Find nearest ECAL cluster
    if (dr2 < info.dr2min) {
      info.dr2min = dr2;
      info.cluRef = cluRef;
      info.deta = std::abs(cluRef->positionREP().eta() - showerPos.eta());
      info.dphi = std::abs(reco::deltaPhi(cluRef->positionREP().phi(), showerPos.phi())) * kfTrackRef->charge();
      info.showerPos = showerPos;
    }
  }

  // Populate PreId object
  math::XYZPoint point(ecal_pos.x(), ecal_pos.y(), ecal_pos.z());

  // Set PreId content
  ecalPreId.setECALMatchingProperties(
      info.cluRef,
      point,
      info.showerPos,
      info.deta,
      info.dphi,
      0.f,                                                                              // chieta
      0.f,                                                                              // chiphi
      kfTrackRef->normalizedChi2(),                                                     // chi2
      info.cluRef->correctedEnergy() / std::sqrt(kfTrackRef->innerMomentum().mag2()));  // E/p
}

Member Data Documentation

const edm::EDGetTokenT<reco::BeamSpot> LowPtGsfElectronSeedProducer::beamSpot_

private

Definition at line 123 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

double LowPtGsfElectronSeedProducer::boundary_ = 2.50746495928 * 2.50746495928

staticprivate

Definition at line 133 of file LowPtGsfElectronSeedProducer.h.

Referenced by propagateTrackToCalo().

const std::string LowPtGsfElectronSeedProducer::builder_

private

Definition at line 126 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const edm::EDGetTokenT<EcalRecHitCollection> LowPtGsfElectronSeedProducer::ebRecHits_

private

Definition at line 120 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const edm::EDGetTokenT<reco::PFClusterCollection> LowPtGsfElectronSeedProducer::ecalClusters_

private

Definition at line 118 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop().

const edm::EDGetTokenT<EcalRecHitCollection> LowPtGsfElectronSeedProducer::eeRecHits_

private

Definition at line 121 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

edm::ESHandle<MagneticField> LowPtGsfElectronSeedProducer::field_

private

Definition at line 113 of file LowPtGsfElectronSeedProducer.h.

Referenced by beginLuminosityBlock(), lightGsfTracking(), and propagateTrackToCalo().

const std::string LowPtGsfElectronSeedProducer::fitter_

private

Definition at line 124 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

std::unique_ptr<TrajectoryFitter> LowPtGsfElectronSeedProducer::fitterPtr_

private

Definition at line 114 of file LowPtGsfElectronSeedProducer.h.

Referenced by lightGsfTracking(), and loop().

edm::EDGetTokenT<reco::PFClusterCollection> LowPtGsfElectronSeedProducer::hcalClusters_

private

Definition at line 119 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().

edm::EDGetTokenT<reco::TrackCollection> LowPtGsfElectronSeedProducer::kfTracks_

private

Definition at line 116 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().

double LowPtGsfElectronSeedProducer::mass_ = 0.000511 * 0.000511

staticprivate

Definition at line 135 of file LowPtGsfElectronSeedProducer.h.

Referenced by propagateTrackToCalo().

const double LowPtGsfElectronSeedProducer::maxPtThreshold_

private

Definition at line 130 of file LowPtGsfElectronSeedProducer.h.

Referenced by decision(), and LowPtGsfElectronSeedProducer().

const double LowPtGsfElectronSeedProducer::minPtThreshold_

private

Definition at line 129 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const bool LowPtGsfElectronSeedProducer::passThrough_

private

Definition at line 127 of file LowPtGsfElectronSeedProducer.h.

Referenced by decision(), loop(), and LowPtGsfElectronSeedProducer().

edm::EDGetTokenT<reco::PFRecTrackCollection> LowPtGsfElectronSeedProducer::pfTracks_

private

Definition at line 117 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().

const edm::EDGetTokenT<double> LowPtGsfElectronSeedProducer::rho_

private

Definition at line 122 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

const std::string LowPtGsfElectronSeedProducer::smoother_

private

Definition at line 125 of file LowPtGsfElectronSeedProducer.h.

Referenced by loop(), and LowPtGsfElectronSeedProducer().

std::unique_ptr<TrajectorySmoother> LowPtGsfElectronSeedProducer::smootherPtr_

private

Definition at line 115 of file LowPtGsfElectronSeedProducer.h.

Referenced by lightGsfTracking(), and loop().

const bool LowPtGsfElectronSeedProducer::usePfTracks_

private

Definition at line 128 of file LowPtGsfElectronSeedProducer.h.

Referenced by LowPtGsfElectronSeedProducer(), and produce().