#include <RecoEgamma/EgammaElectronProducers/plugins/LowPtGsfElectronSeedProducer.cc>

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

Public Member Functions
	LowPtGsfElectronSeedProducer (const edm::ParameterSet &, const lowptgsfeleseed::HeavyObjectCache *)

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

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< lowptgsfeleseed::HeavyObjectCache > >
	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 &)

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

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 edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	builderToken_

const edm::EDGetTokenT< EcalRecHitCollection >	ebRecHits_

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

const noZS::EcalClusterLazyTools::ESGetTokens	ecalClusterToolsESGetTokens_

const edm::EDGetTokenT< EcalRecHitCollection >	eeRecHits_

edm::ESHandle< MagneticField >	field_

std::unique_ptr< TrajectoryFitter >	fitterPtr_

edm::EDGetTokenT< reco::PFClusterCollection >	hcalClusters_

edm::EDGetTokenT< reco::TrackCollection >	kfTracks_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magToken_

const double	maxPtThreshold_

const double	minPtThreshold_

const bool	passThrough_

edm::EDGetTokenT< reco::PFRecTrackCollection >	pfTracks_

const edm::EDGetTokenT< double >	rho_

std::unique_ptr< TrajectorySmoother >	smootherPtr_

const edm::ESGetToken< TrajectoryFitter, TrajectoryFitter::Record >	trajectoryFitterToken_

const edm::ESGetToken< TrajectorySmoother, TrajectoryFitter::Record >	trajectorySmootherToken_

const bool	usePfTracks_

Static Private Attributes
static constexpr double	boundary_ = 2.50746495928 * 2.50746495928

static constexpr double	mass_ = 0.000511 * 0.000511

Detailed Description

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

Definition at line 57 of file LowPtGsfElectronSeedProducer.cc.

Member Typedef Documentation

◆ TrackIndxMap

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

Definition at line 60 of file LowPtGsfElectronSeedProducer.cc.

Constructor & Destructor Documentation

◆ LowPtGsfElectronSeedProducer()

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

explicit

Definition at line 169 of file LowPtGsfElectronSeedProducer.cc.

References edm::ParameterSet::getParameter().

     : field_(),
       fitterPtr_(),
       smootherPtr_(),
       kfTracks_(),
       pfTracks_(),
       ecalClusters_{consumes(conf.getParameter<edm::InputTag>("ecalClusters"))},
       hcalClusters_(),
       ebRecHits_{consumes(conf.getParameter<edm::InputTag>("EBRecHits"))},
       eeRecHits_{consumes(conf.getParameter<edm::InputTag>("EERecHits"))},
       rho_(consumes(conf.getParameter<edm::InputTag>("rho"))),
       beamSpot_(consumes(conf.getParameter<edm::InputTag>("BeamSpot"))),
       trajectoryFitterToken_{esConsumes(conf.getParameter<edm::ESInputTag>("Fitter"))},
       trajectorySmootherToken_{esConsumes(conf.getParameter<edm::ESInputTag>("Smoother"))},
       builderToken_{esConsumes(conf.getParameter<edm::ESInputTag>("TTRHBuilder"))},
       magToken_{esConsumes()},
       ecalClusterToolsESGetTokens_{consumesCollector()},
       passThrough_(conf.getParameter<bool>("PassThrough")),
       usePfTracks_(conf.getParameter<bool>("UsePfTracks")),
       minPtThreshold_(conf.getParameter<double>("MinPtThreshold")),
       maxPtThreshold_(conf.getParameter<double>("MaxPtThreshold")) {
   if (usePfTracks_) {
     pfTracks_ = consumes(conf.getParameter<edm::InputTag>("pfTracks"));
     hcalClusters_ = consumes(conf.getParameter<edm::InputTag>("hcalClusters"));
   }
   kfTracks_ = consumes(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()
 }

Member Function Documentation

◆ decision() [1/2]

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 593 of file LowPtGsfElectronSeedProducer.cc.

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

Referenced by 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;
 }

◆ decision() [2/2]

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 608 of file LowPtGsfElectronSeedProducer.cc.

References passThrough_.

                                                                                  {
   // No implementation currently
   return passThrough_;
 }

◆ fillDescriptions()

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

static

Definition at line 641 of file LowPtGsfElectronSeedProducer.cc.

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

                                                                                               {
   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<edm::ESInputTag>("Fitter", edm::ESInputTag{"", "GsfTrajectoryFitter_forPreId"});
   desc.add<edm::ESInputTag>("Smoother", edm::ESInputTag{"", "GsfTrajectorySmoother_forPreId"});
   desc.add<edm::ESInputTag>("TTRHBuilder", edm::ESInputTag{"", "WithAngleAndTemplate"});
   desc.add<std::vector<std::string> >("ModelNames", {});
   desc.add<std::vector<std::string> >("ModelWeights", {});
   desc.add<std::vector<double> >("ModelThresholds", {});
   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);
 }

◆ fillPreIdRefValueMap()

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 619 of file LowPtGsfElectronSeedProducer.cc.

References trigObjTnPSource_cfi::filler, edm::Ref< C, T, F >::index(), vertices_cff::ntracks, and contentValuesCheck::values.

Referenced by 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());
 }

◆ getBaseRef() [1/2]

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

private

Definition at line 272 of file LowPtGsfElectronSeedProducer.cc.

References patZpeak::handle, and heavyIonCSV_trainingSettings::idx.

Referenced by loop().

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

◆ getBaseRef() [2/2]

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

private

Definition at line 276 of file LowPtGsfElectronSeedProducer.cc.

References patZpeak::handle, and heavyIonCSV_trainingSettings::idx.

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

◆ globalEndJob()

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

inlinestatic

Definition at line 67 of file LowPtGsfElectronSeedProducer.cc.

67 {}

◆ initializeGlobalCache()

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

inlinestatic

Definition at line 63 of file LowPtGsfElectronSeedProducer.cc.

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

◆ lightGsfTracking()

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

private

Definition at line 555 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(), fileCollector::seed, reco::PreId::setTrackProperties(), smootherPtr_, and TrajectoryMeasurement::updatedState().

Referenced by 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;
 }

◆ loop()

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 284 of file LowPtGsfElectronSeedProducer.cc.

References beamSpot_, builderToken_, runTheMatrix::const, decision(), ebRecHits_, RecoEcal_cff::ecalClusters, ecalClusters_, ecalClusterToolsESGetTokens_, eeRecHits_, fitterPtr_, EcalClusterLazyToolsBase::ESGetTokens::get(), getBaseRef(), patZpeak::handle, lowPtGsfElectronSeeds_cfi::hcalClusters, edm::Ref< C, T, F >::index(), lightGsfTracking(), minPtThreshold_, passThrough_, propagateTrackToCalo(), reco::TrackBase::qualityByName(), mps_fire::result, rho, rho_, fileCollector::seed, HLT_2024v12_cff::seeds, reco::PreId::setTrack(), singleTopDQM_cfi::setup, smootherPtr_, trajectoryFitterToken_, and trajectorySmootherToken_.

Referenced by produce().

                                                                     {
   // Pileup
   auto const& rho = event.get(rho_);
 
   // Beam spot
   auto const& spot = event.get(beamSpot_);
 
   // Track fitter
   fitterPtr_ = setup.getData(trajectoryFitterToken_).clone();
 
   // Track smoother
   smootherPtr_.reset(setup.getData(trajectorySmootherToken_).clone());
 
   // RecHit cloner
   TkClonerImpl hitCloner = static_cast<TkTransientTrackingRecHitBuilder const&>(setup.getData(builderToken_)).cloner();
   fitterPtr_->setHitCloner(&hitCloner);
   smootherPtr_->setHitCloner(&hitCloner);
 
   // ECAL clusters
   auto ecalClusters = event.getHandle(ecalClusters_);
 
   // Utility to access to shower shape vars
   noZS::EcalClusterLazyTools ecalTools(event, ecalClusterToolsESGetTokens_.get(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()));
     if (seed.nHits() == 0) {  //if DeepCore is used in jetCore iteration the seed are hitless, in case skip
       continue;
     }
     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);
 
     // 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);
   }
 }

◆ produce()

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

override

Definition at line 205 of file LowPtGsfElectronSeedProducer.cc.

References Exception, field_, fillPreIdRefValueMap(), lowPtGsfElectronSeeds_cfi::hcalClusters, hcalClusters_, edm::HandleBase::id(), kfTracks_, loop(), magToken_, eostools::move(), lowPtGsfElectronSeeds_cfi::pfTracks, pfTracks_, HLT_2024v12_cff::seeds, singleTopDQM_cfi::setup, and usePfTracks_.

                                                                                       {
   field_ = setup.getHandle(magToken_);
   // 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));
 }

◆ propagateTrackToCalo() [1/3]

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 401 of file LowPtGsfElectronSeedProducer.cc.

References RecoEcal_cff::ecalClusters, and lowPtGsfElectronSeeds_cfi::hcalClusters.

Referenced by loop().

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

◆ propagateTrackToCalo() [2/3]

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 414 of file LowPtGsfElectronSeedProducer.cc.

References bsc_activity_cfg::clusters, reco::deltaPhi(), reco::deltaR2(), SiStripBadComponentsDQMServiceTemplate_cfg::ep, spr::find(), info(), muonTagProbeFilters_cff::matched, point, 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
 }

◆ propagateTrackToCalo() [3/3]

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 475 of file LowPtGsfElectronSeedProducer.cc.

References funct::abs(), boundary_, reco::deltaPhi(), reco::deltaR2(), RecoEcal_cff::ecalClusters, hcalRecHitTable_cff::energy, field_, reco::PFCluster::getDepthCorrection(), info(), MagneticField::inTesla(), mass_, point, funct::pow(), 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
 }