Inheritance diagram for PFElecTkProducer:

Public Member Functions
	PFElecTkProducer (const edm::ParameterSet &, const convbremhelpers::HeavyObjectCache *)
	Constructor. More...

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

static void	globalEndJob (convbremhelpers::HeavyObjectCache const *)

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

Private Member Functions
bool	applySelection (const reco::GsfTrack &)

void	beginRun (const edm::Run &, const edm::EventSetup &) override

void	createGsfPFRecTrackRef (const edm::OrphanHandle< reco::GsfPFRecTrackCollection > &gsfPfHandle, std::vector< reco::GsfPFRecTrack > &gsfPFRecTrackPrimary, const std::map< unsigned int, std::vector< reco::GsfPFRecTrack > > &MapPrimSec)

void	endRun (const edm::Run &, const edm::EventSetup &) override

int	findPfRef (const reco::PFRecTrackCollection &pfRTkColl, const reco::GsfTrack &, edm::soa::EtaPhiTableView trackEtaPhiTable)

bool	isInnerMost (const reco::GsfTrackRef &nGsfTrack, const reco::GsfTrackRef &iGsfTrack, bool &sameLayer)

bool	isInnerMostWithLostHits (const reco::GsfTrackRef &nGsfTrack, const reco::GsfTrackRef &iGsfTrack, bool &sameLayer)

bool	isSameEgSC (const reco::ElectronSeed &nSeed, const reco::ElectronSeed &iSeed, bool &bothGsfEcalDriven, float &SCEnergy)

bool	isSharingEcalEnergyWithEgSC (const reco::GsfPFRecTrack &nGsfPFRecTrack, const reco::GsfPFRecTrack &iGsfPFRecTrack, const reco::ElectronSeed &nSeed, const reco::ElectronSeed &iSeed, const reco::PFClusterCollection &theEClus, bool &bothGsfTrackerDriven, bool &nEcalDriven, bool &iEcalDriven, float &nEnergy, float &iEnergy)

float	minTangDist (const reco::GsfPFRecTrack &primGsf, const reco::GsfPFRecTrack &secGsf)

void	produce (edm::Event &, const edm::EventSetup &) override
	Produce the PFRecTrack collection. More...

bool	resolveGsfTracks (const std::vector< reco::GsfPFRecTrack > &GsfPFVec, unsigned int ngsf, std::vector< unsigned int > &secondaries, const reco::PFClusterCollection &theEClus)

Private Attributes
bool	applyAngularGsfClean_

bool	applyGsfClean_

bool	applySel_

edm::ParameterSet	conf_

std::unique_ptr< ConvBremPFTrackFinder >	convBremFinder_

bool	debugGsfCleaning_

double	detaCutGsfClean_

double	detaGsfSC_

double	dphiCutGsfClean_

double	dphiGsfSC_

std::vector< double >	gsfInnerMomentumCache_

edm::EDGetTokenT< reco::GsfTrackCollection >	gsfTrackLabel_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magFieldToken_

double	maxPtConvReco_

bool	modemomentum_

MultiTrajectoryStateTransform	mtsTransform_

double	mvaConvBremFinderIDBarrelHighPt_

double	mvaConvBremFinderIDBarrelLowPt_

double	mvaConvBremFinderIDEndcapsHighPt_

double	mvaConvBremFinderIDEndcapsLowPt_

std::string	path_mvaWeightFileConvBremBarrelHighPt_

std::string	path_mvaWeightFileConvBremBarrelLowPt_

std::string	path_mvaWeightFileConvBremEndcapsHighPt_

std::string	path_mvaWeightFileConvBremEndcapsLowPt_

edm::EDGetTokenT< reco::PFConversionCollection >	pfConv_

edm::EDGetTokenT< reco::PFClusterCollection >	pfEcalClusters_

edm::EDGetTokenT< reco::PFDisplacedTrackerVertexCollection >	pfNuclear_

reco::GsfPFRecTrack	pftrack_

edm::EDGetTokenT< reco::PFRecTrackCollection >	pfTrackLabel_

std::unique_ptr< PFTrackTransformer >	pfTransformer_
	PFTrackTransformer. More...

edm::EDGetTokenT< reco::PFV0Collection >	pfV0_

edm::EDGetTokenT< reco::VertexCollection >	primVtxLabel_

double	SCEne_

reco::GsfPFRecTrack	secpftrack_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	tkerGeomToken_

bool	trajinev_
	Trajectory of GSfTracks in the event? More...

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	transientTrackToken_

bool	useConvBremFinder_
	Conv Brem Finder. More...

bool	useConversions_

bool	useFifthStepForEcalDriven_

bool	useFifthStepForTrackDriven_

bool	useNuclear_

bool	useV0_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< convbremhelpers::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

Detailed Description

Definition at line 62 of file PFElecTkProducer.cc.

Constructor & Destructor Documentation

◆ PFElecTkProducer()

PFElecTkProducer::PFElecTkProducer	(	const edm::ParameterSet &	iConfig,
		const convbremhelpers::HeavyObjectCache *
	)

explicit

Constructor.

Definition at line 234 of file PFElecTkProducer.cc.

References applyAngularGsfClean_, applyGsfClean_, applySel_, edm::BeginRun, debugGsfCleaning_, detaCutGsfClean_, detaGsfSC_, dphiCutGsfClean_, dphiGsfSC_, edm::ParameterSet::getParameter(), gsfTrackLabel_, maxPtConvReco_, modemomentum_, mvaConvBremFinderIDBarrelHighPt_, mvaConvBremFinderIDBarrelLowPt_, mvaConvBremFinderIDEndcapsHighPt_, mvaConvBremFinderIDEndcapsLowPt_, pfConv_, pfEcalClusters_, pfNuclear_, pfTrackLabel_, pfV0_, primVtxLabel_, SCEne_, trajinev_, useConvBremFinder_, useConversions_, useFifthStepForEcalDriven_, useFifthStepForTrackDriven_, useNuclear_, and useV0_.

     : conf_(iConfig),
       magFieldToken_(esConsumes<edm::Transition::BeginRun>()),
       tkerGeomToken_(esConsumes<edm::Transition::BeginRun>()),
       transientTrackToken_(esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("", "TransientTrackBuilder"))) {
   gsfTrackLabel_ = consumes<reco::GsfTrackCollection>(iConfig.getParameter<InputTag>("GsfTrackModuleLabel"));
 
   pfTrackLabel_ = consumes<reco::PFRecTrackCollection>(iConfig.getParameter<InputTag>("PFRecTrackLabel"));
 
   primVtxLabel_ = consumes<reco::VertexCollection>(iConfig.getParameter<InputTag>("PrimaryVertexLabel"));
 
   pfEcalClusters_ = consumes<reco::PFClusterCollection>(iConfig.getParameter<InputTag>("PFEcalClusters"));
 
   pfNuclear_ = consumes<reco::PFDisplacedTrackerVertexCollection>(iConfig.getParameter<InputTag>("PFNuclear"));
 
   pfConv_ = consumes<reco::PFConversionCollection>(iConfig.getParameter<InputTag>("PFConversions"));
 
   pfV0_ = consumes<reco::PFV0Collection>(iConfig.getParameter<InputTag>("PFV0"));
 
   useNuclear_ = iConfig.getParameter<bool>("useNuclear");
   useConversions_ = iConfig.getParameter<bool>("useConversions");
   useV0_ = iConfig.getParameter<bool>("useV0");
   debugGsfCleaning_ = iConfig.getParameter<bool>("debugGsfCleaning");
 
   produces<GsfPFRecTrackCollection>();
   produces<GsfPFRecTrackCollection>("Secondary").setBranchAlias("secondary");
 
   trajinev_ = iConfig.getParameter<bool>("TrajInEvents");
   modemomentum_ = iConfig.getParameter<bool>("ModeMomentum");
   applySel_ = iConfig.getParameter<bool>("applyEGSelection");
   applyGsfClean_ = iConfig.getParameter<bool>("applyGsfTrackCleaning");
   applyAngularGsfClean_ = iConfig.getParameter<bool>("applyAlsoGsfAngularCleaning");
   detaCutGsfClean_ = iConfig.getParameter<double>("maxDEtaGsfAngularCleaning");
   dphiCutGsfClean_ = iConfig.getParameter<double>("maxDPhiBremTangGsfAngularCleaning");
   useFifthStepForTrackDriven_ = iConfig.getParameter<bool>("useFifthStepForTrackerDrivenGsf");
   useFifthStepForEcalDriven_ = iConfig.getParameter<bool>("useFifthStepForEcalDrivenGsf");
   maxPtConvReco_ = iConfig.getParameter<double>("MaxConvBremRecoPT");
   detaGsfSC_ = iConfig.getParameter<double>("MinDEtaGsfSC");
   dphiGsfSC_ = iConfig.getParameter<double>("MinDPhiGsfSC");
   SCEne_ = iConfig.getParameter<double>("MinSCEnergy");
 
   // set parameter for convBremFinder
   useConvBremFinder_ = iConfig.getParameter<bool>("useConvBremFinder");
 
   mvaConvBremFinderIDBarrelLowPt_ = iConfig.getParameter<double>("pf_convBremFinderID_mvaCutBarrelLowPt");
   mvaConvBremFinderIDBarrelHighPt_ = iConfig.getParameter<double>("pf_convBremFinderID_mvaCutBarrelHighPt");
   mvaConvBremFinderIDEndcapsLowPt_ = iConfig.getParameter<double>("pf_convBremFinderID_mvaCutEndcapsLowPt");
   mvaConvBremFinderIDEndcapsHighPt_ = iConfig.getParameter<double>("pf_convBremFinderID_mvaCutEndcapsHighPt");
 }

Member Function Documentation

◆ applySelection()

bool PFElecTkProducer::applySelection ( const reco::GsfTrack & gsftk )

private

Definition at line 605 of file PFElecTkProducer.cc.

References runTheMatrix::const, reco::GsfTrack::etaMode(), reco::Track::extra(), JetMETHLTOfflineSource_cfi::feta, edm::RefToBase< T >::get(), reco::GsfTrack::phiMode(), Pi, reco::Track::seedRef(), and TwoPi.

                                                                {
   if (gsftk.seedRef().get() == nullptr)
     return false;
   auto const& ElSeedFromRef = static_cast<ElectronSeed const&>(*(gsftk.extra()->seedRef()));
 
   bool passCut = false;
   if (ElSeedFromRef.ctfTrack().isNull()) {
     if (ElSeedFromRef.caloCluster().isNull())
       return passCut;
     auto const* scRef = static_cast<SuperCluster const*>(ElSeedFromRef.caloCluster().get());
     //do this just to know if exist a SC?
     if (scRef) {
       float caloEne = scRef->energy();
       float feta = fabs(scRef->eta() - gsftk.etaMode());
       float fphi = fabs(scRef->phi() - gsftk.phiMode());
       if (fphi > TMath::Pi())
         fphi -= TMath::TwoPi();
       if (caloEne > SCEne_ && feta < detaGsfSC_ && fabs(fphi) < dphiGsfSC_)
         passCut = true;
     }
   } else {
     // get all the gsf found by tracker driven
     passCut = true;
   }
   return passCut;
 }

◆ beginRun()

void PFElecTkProducer::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 1169 of file PFElecTkProducer.cc.

References edm::EventSetup::getData(), HLT_2024v13_cff::magneticField, and PbPb_ZMuSkimMuonDPG_cff::tracker.

                                                                            {
   auto const& magneticField = &iSetup.getData(magFieldToken_);
   auto const& tracker = &iSetup.getData(tkerGeomToken_);
 
   mtsTransform_ = MultiTrajectoryStateTransform(tracker, magneticField);
 
   pfTransformer_ = std::make_unique<PFTrackTransformer>(math::XYZVector(magneticField->inTesla(GlobalPoint(0, 0, 0))));
 
   TransientTrackBuilder thebuilder = iSetup.getData(transientTrackToken_);
 
   convBremFinder_ = std::make_unique<ConvBremPFTrackFinder>(thebuilder,
                                                             mvaConvBremFinderIDBarrelLowPt_,
                                                             mvaConvBremFinderIDBarrelHighPt_,
                                                             mvaConvBremFinderIDEndcapsLowPt_,
                                                             mvaConvBremFinderIDEndcapsHighPt_);
 }

◆ createGsfPFRecTrackRef()

void PFElecTkProducer::createGsfPFRecTrackRef	(	const edm::OrphanHandle< reco::GsfPFRecTrackCollection > &	gsfPfHandle,
		std::vector< reco::GsfPFRecTrack > &	gsfPFRecTrackPrimary,
		const std::map< unsigned int, std::vector< reco::GsfPFRecTrack > > &	MapPrimSec
	)

private

Definition at line 516 of file PFElecTkProducer.cc.

References genParticles_cff::map.

                                                                            {
   unsigned int cgsf = 0;
   unsigned int csecgsf = 0;
   for (std::map<unsigned int, std::vector<reco::GsfPFRecTrack> >::const_iterator igsf = MapPrimSec.begin();
        igsf != MapPrimSec.end();
        igsf++, cgsf++) {
     vector<reco::GsfPFRecTrack> SecGsfPF = igsf->second;
     for (unsigned int iSecGsf = 0; iSecGsf < SecGsfPF.size(); iSecGsf++) {
       edm::Ref<reco::GsfPFRecTrackCollection> refgprt(gsfPfHandle, csecgsf);
       gsfPFRecTrackPrimary[cgsf].addConvBremGsfPFRecTrackRef(refgprt);
       ++csecgsf;
     }
   }
 
   return;
 }

◆ endRun()

void PFElecTkProducer::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 1187 of file PFElecTkProducer.cc.

                                                                          {
   pfTransformer_.reset();
   convBremFinder_.reset();
 }

◆ fillDescriptions()

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

static

Definition at line 175 of file PFElecTkProducer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   {
   edm::ParameterSetDescription desc;
   desc.add<bool>("TrajInEvents", false);
   desc.add<std::string>("Fitter", "GsfElectronFittingSmoother");
   desc.add<bool>("ModeMomentum", true);
   desc.add<bool>("applyEGSelection", false);
   desc.add<bool>("applyGsfTrackCleaning", true);
   desc.add<bool>("applyAlsoGsfAngularCleaning", true);
   desc.add<double>("maxDEtaGsfAngularCleaning", 0.05);
   desc.add<double>("maxDPhiBremTangGsfAngularCleaning", 0.05);
   desc.add<bool>("useFifthStepForTrackerDrivenGsf", false);
   desc.add<bool>("useFifthStepForEcalDrivenGsf", false);
   desc.add<double>("MaxConvBremRecoPT", 49.0);
   desc.add<double>("MinDEtaGsfSC", 0.06);
   desc.add<double>("MinDPhiGsfSC", 0.15);
   desc.add<double>("MinSCEnergy", 4.0);
   desc.add<std::string>("TTRHBuilder", "WithTrackAngle");
   desc.add<edm::InputTag>("GsfTrackModuleLabel", {"electronGsfTracks"});
   desc.add<std::string>("Propagator", "fwdElectronPropagator");
   desc.add<edm::InputTag>("PFRecTrackLabel", {"pfTrack"});
   desc.add<edm::InputTag>("PFEcalClusters", {"particleFlowClusterECAL"});
   desc.add<edm::InputTag>("PrimaryVertexLabel", {"offlinePrimaryVertices"});
   desc.add<bool>("useConvBremFinder", true);
   desc.add<edm::InputTag>("PFNuclear", {"pfDisplacedTrackerVertex"});
   desc.add<edm::InputTag>("PFConversions", {"pfConversions"});
   desc.add<edm::InputTag>("PFV0", {"pfV0"});
   desc.add<bool>("useNuclear", false);
   desc.add<bool>("useV0", false);
   desc.add<bool>("useConversions", false);
   desc.add<bool>("debugGsfCleaning", false);
   desc.add<double>("AbsEtaBarrelEndcapsSeparation", 1.479);
   desc.add<double>("PtLowHighSeparation", 20);
   desc.add<double>("pf_convBremFinderID_mvaCutBarrelLowPt", 0.6);
   desc.add<double>("pf_convBremFinderID_mvaCutBarrelHighPt", 0.97);
   desc.add<double>("pf_convBremFinderID_mvaCutEndcapsLowPt", 0.9);
   desc.add<double>("pf_convBremFinderID_mvaCutEndcapsHighPt", 0.995);
   desc.add<edm::FileInPath>(
       "pf_convBremFinderID_mvaWeightFileBarrelLowPt",
       edm::FileInPath("RecoParticleFlow/PFTracking/data/"
                       "TMVAClassification_ConvBremFinder_Testetlt20absetalt1_479_BDT.weights.xml"));
   desc.add<edm::FileInPath>(
       "pf_convBremFinderID_mvaWeightFileBarrelHighPt",
       edm::FileInPath("RecoParticleFlow/PFTracking/data/"
                       "TMVAClassification_ConvBremFinder_Testetgt20absetalt1_479_BDT.weights.xml"));
   desc.add<edm::FileInPath>(
       "pf_convBremFinderID_mvaWeightFileEndcapsLowPt",
       edm::FileInPath("RecoParticleFlow/PFTracking/data/"
                       "TMVAClassification_ConvBremFinder_Testetlt20absetagt1_479_BDT.weights.xml"));
   desc.add<edm::FileInPath>(
       "pf_convBremFinderID_mvaWeightFileEndcapsHighPt",
       edm::FileInPath("RecoParticleFlow/PFTracking/data/"
                       "TMVAClassification_ConvBremFinder_Testetgt20absetagt1_479_BDT.weights.xml"));
   descriptions.addWithDefaultLabel(desc);
 }

◆ findPfRef()

int PFElecTkProducer::findPfRef	(	const reco::PFRecTrackCollection &	pfRTkColl,
		const reco::GsfTrack &	gsftk,
		edm::soa::EtaPhiTableView	trackEtaPhiTable
	)

private

Definition at line 536 of file PFElecTkProducer.cc.

References TrackingRecHit::all, runTheMatrix::const, ALPAKA_ACCELERATOR_NAMESPACE::brokenline::constexpr(), reco::deltaR2(), reco::TrackBase::eta(), reco::Track::extra(), f, edm::RefToBase< T >::get(), reco::TrackBase::phi(), FastTrackerRecHitMaskProducer_cfi::recHits, TrajectorySeed::recHits(), reco::Track::seedRef(), and square().

                                                                         {
   if (gsftk.seedRef().get() == nullptr) {
     return -1;
   }
 
   // maximum delta_r2 for matching
   constexpr float maxDR2 = square(0.05f);
 
   // precompute expensive trigonometry
   float gsftkEta = gsftk.eta();
   float gsftkPhi = gsftk.phi();
   auto const& gsftkHits = gsftk.seedRef()->recHits();
 
   auto const& electronSeedFromRef = static_cast<ElectronSeed const&>(*(gsftk.extra()->seedRef()));
   //CASE 1 ELECTRONSEED DOES NOT HAVE A REF TO THE CKFTRACK
   if (electronSeedFromRef.ctfTrack().isNull()) {
     unsigned int i_pf = 0;
     int ibest = -1;
     unsigned int ish_max = 0;
     float dr2_min = square(1000.f);
 
     //SEARCH THE PFRECTRACK THAT SHARES HITS WITH THE ELECTRON SEED
     // Here the cpu time has been be improved.
     for (auto const& pft : trackEtaPhiTable) {
       unsigned int ish = 0;
 
       using namespace edm::soa::col;
       const float dr2 = reco::deltaR2(pft.get<Eta>(), pft.get<Phi>(), gsftkEta, gsftkPhi);
 
       if (dr2 <= maxDR2) {
         for (auto const& hhit : pfRTkColl[i_pf].trackRef()->recHits()) {
           if (!hhit->isValid())
             continue;
           for (auto const& hit : gsftkHits) {
             if (hit.isValid() && hhit->sharesInput(&hit, TrackingRecHit::all))
               ish++;
           }
         }
 
         if ((ish > ish_max) || ((ish == ish_max) && (dr2 < dr2_min))) {
           ish_max = ish;
           dr2_min = dr2;
           ibest = i_pf;
         }
       }
 
       i_pf++;
     }
 
     return ((ish_max == 0) || (dr2_min > maxDR2)) ? -1 : ibest;
   } else {
     //ELECTRON SEED HAS A REFERENCE
 
     unsigned int i_pf = 0;
 
     for (auto const& pft : pfRTkColl) {
       //REF COMPARISON
       if (pft.trackRef() == electronSeedFromRef.ctfTrack()) {
         return i_pf;
       }
       i_pf++;
     }
   }
   return -1;
 }

◆ globalEndJob()

static void PFElecTkProducer::globalEndJob ( convbremhelpers::HeavyObjectCache const * )

inlinestatic

Definition at line 71 of file PFElecTkProducer.cc.

71 {}

◆ initializeGlobalCache()

static std::unique_ptr<convbremhelpers::HeavyObjectCache> PFElecTkProducer::initializeGlobalCache ( const edm::ParameterSet & conf )

inlinestatic

Definition at line 67 of file PFElecTkProducer.cc.

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

◆ isInnerMost()

bool PFElecTkProducer::isInnerMost	(	const reco::GsfTrackRef &	nGsfTrack,
		const reco::GsfTrackRef &	iGsfTrack,
		bool &	sameLayer
	)

private

Definition at line 1117 of file PFElecTkProducer.cc.

References reco::HitPattern::getHitPattern(), reco::HitPattern::getLayer(), and reco::HitPattern::getSubStructure().

                                                     {
   // copied by the class RecoEgamma/EgammaElectronAlgos/src/EgAmbiguityTools.cc
   // obsolete but the code is kept: now using lost hits method
 
   const reco::HitPattern& gsfHitPattern1 = nGsfTrack->hitPattern();
   const reco::HitPattern& gsfHitPattern2 = iGsfTrack->hitPattern();
 
   // retrieve first valid hit
   int gsfHitCounter1 = 0;
   for (auto const& hit : nGsfTrack->recHits()) {
     if (hit->isValid())
       break;
     gsfHitCounter1++;
   }
 
   int gsfHitCounter2 = 0;
   for (auto const& hit : iGsfTrack->recHits()) {
     if (hit->isValid())
       break;
     gsfHitCounter2++;
   }
 
   uint32_t gsfHit1 = gsfHitPattern1.getHitPattern(HitPattern::TRACK_HITS, gsfHitCounter1);
   uint32_t gsfHit2 = gsfHitPattern2.getHitPattern(HitPattern::TRACK_HITS, gsfHitCounter2);
 
   if (gsfHitPattern1.getSubStructure(gsfHit1) != gsfHitPattern2.getSubStructure(gsfHit2)) {
     return (gsfHitPattern2.getSubStructure(gsfHit2) < gsfHitPattern1.getSubStructure(gsfHit1));
   } else if (gsfHitPattern1.getLayer(gsfHit1) != gsfHitPattern2.getLayer(gsfHit2)) {
     return (gsfHitPattern2.getLayer(gsfHit2) < gsfHitPattern1.getLayer(gsfHit1));
   } else {
     sameLayer = true;
     return false;
   }
 }

◆ isInnerMostWithLostHits()

bool PFElecTkProducer::isInnerMostWithLostHits	(	const reco::GsfTrackRef &	nGsfTrack,
		const reco::GsfTrackRef &	iGsfTrack,
		bool &	sameLayer
	)

private

Definition at line 1153 of file PFElecTkProducer.cc.

                                                                 {
   // define closest using the lost hits on the expectedhitsineer
   unsigned int nLostHits = nGsfTrack->missingInnerHits();
   unsigned int iLostHits = iGsfTrack->missingInnerHits();
 
   if (nLostHits != iLostHits) {
     return (nLostHits > iLostHits);
   } else {
     sameLayer = true;
     return false;
   }
 }

◆ isSameEgSC()

bool PFElecTkProducer::isSameEgSC	(	const reco::ElectronSeed &	nSeed,
		const reco::ElectronSeed &	iSeed,
		bool &	bothGsfEcalDriven,
		float &	SCEnergy
	)

private

Definition at line 912 of file PFElecTkProducer.cc.

References reco::ElectronSeed::caloCluster(), runTheMatrix::const, edm::RefToBase< T >::get(), edm::RefToBase< T >::isNonnull(), and TrendClient_cfi::SCEnergy.

                                                    {
   bool isSameSC = false;
 
   if (nSeed.caloCluster().isNonnull() && iSeed.caloCluster().isNonnull()) {
     auto const* nscRef = static_cast<SuperCluster const*>(nSeed.caloCluster().get());
     auto const* iscRef = static_cast<SuperCluster const*>(iSeed.caloCluster().get());
 
     if (nscRef && iscRef) {
       bothGsfEcalDriven = true;
       if (nscRef == iscRef) {
         isSameSC = true;
         // retrieve the supercluster energy
         SCEnergy = nscRef->energy();
       }
     }
   }
   return isSameSC;
 }

◆ isSharingEcalEnergyWithEgSC()

bool PFElecTkProducer::isSharingEcalEnergyWithEgSC	(	const reco::GsfPFRecTrack &	nGsfPFRecTrack,
		const reco::GsfPFRecTrack &	iGsfPFRecTrack,
		const reco::ElectronSeed &	nSeed,
		const reco::ElectronSeed &	iSeed,
		const reco::PFClusterCollection &	theEClus,
		bool &	bothGsfTrackerDriven,
		bool &	nEcalDriven,
		bool &	iEcalDriven,
		float &	nEnergy,
		float &	iEnergy
	)

private

Definition at line 933 of file PFElecTkProducer.cc.

References cms::cuda::assert(), reco::PFCluster::calculatePositionREP(), reco::ElectronSeed::caloCluster(), runTheMatrix::const, reco::PFTrajectoryPoint::ECALShowerMax, reco::PFCluster::energy(), reco::CaloCluster::energy(), reco::PFTrack::extrapolatedPoint(), edm::RefToBase< T >::get(), reco::GsfPFRecTrack::gsfTrackRef(), edm::RefToBase< T >::isNonnull(), reco::PFTrajectoryPoint::isValid(), ClusterClusterMapping::overlap(), packedPFCandidateRefMixer_cfi::pf, reco::GsfPFRecTrack::PFRecBrem(), Pi, reco::CaloCluster::position(), LinkByRecHit::testTrackAndClusterByRecHit(), and TwoPi.

                                                                    {
   bool isSharingEnergy = false;
 
   //which is EcalDriven?
   bool oneEcalDriven = true;
   SuperCluster const* scRef = nullptr;
   GsfPFRecTrack gsfPfTrack;
 
   if (nSeed.caloCluster().isNonnull()) {
     scRef = static_cast<SuperCluster const*>(nSeed.caloCluster().get());
     assert(scRef);
     nEnergy = scRef->energy();
     nEcalDriven = true;
     gsfPfTrack = iGsfPFRecTrack;
   } else if (iSeed.caloCluster().isNonnull()) {
     scRef = static_cast<SuperCluster const*>(iSeed.caloCluster().get());
     assert(scRef);
     iEnergy = scRef->energy();
     iEcalDriven = true;
     gsfPfTrack = nGsfPFRecTrack;
   } else {
     oneEcalDriven = false;
   }
 
   if (oneEcalDriven) {
     //run a basic reconstruction for the particle flow
 
     vector<PFCluster> vecPFClusters;
     vecPFClusters.clear();
 
     for (PFClusterCollection::const_iterator clus = theEClus.begin(); clus != theEClus.end(); clus++) {
       PFCluster clust = *clus;
       clust.calculatePositionREP();
 
       float deta = fabs(scRef->position().eta() - clust.position().eta());
       float dphi = fabs(scRef->position().phi() - clust.position().phi());
       if (dphi > TMath::Pi())
         dphi -= TMath::TwoPi();
 
       // Angle preselection between the supercluster and pfclusters
       // this is needed just to save some cpu-time for this is hard-coded
       if (deta < 0.5 && fabs(dphi) < 1.0) {
         double distGsf = gsfPfTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax).isValid()
                              ? LinkByRecHit::testTrackAndClusterByRecHit(gsfPfTrack, clust)
                              : -1.;
         // check if it touch the GsfTrack
         if (distGsf > 0.) {
           if (nEcalDriven)
             iEnergy += clust.energy();
           else
             nEnergy += clust.energy();
           vecPFClusters.push_back(clust);
         }
         // check if it touch the Brem-tangents
         else {
           vector<PFBrem> primPFBrem = gsfPfTrack.PFRecBrem();
           for (unsigned ipbrem = 0; ipbrem < primPFBrem.size(); ipbrem++) {
             if (primPFBrem[ipbrem].indTrajPoint() == 99)
               continue;
             const reco::PFRecTrack& pfBremTrack = primPFBrem[ipbrem];
             double dist = pfBremTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax).isValid()
                               ? LinkByRecHit::testTrackAndClusterByRecHit(pfBremTrack, clust, true)
                               : -1.;
             if (dist > 0.) {
               if (nEcalDriven)
                 iEnergy += clust.energy();
               else
                 nEnergy += clust.energy();
               vecPFClusters.push_back(clust);
             }
           }
         }
       }  // END if angle preselection
     }    // PFClusters Loop
     if (!vecPFClusters.empty()) {
       for (unsigned int pf = 0; pf < vecPFClusters.size(); pf++) {
         bool isCommon = ClusterClusterMapping::overlap(vecPFClusters[pf], *scRef);
         if (isCommon) {
           isSharingEnergy = true;
         }
         break;
       }
     }
   } else {
     // both tracks are trackerDriven, try ECAL energy matching also in this case.
 
     bothGsfTrackerDriven = true;
     vector<PFCluster> nPFCluster;
     vector<PFCluster> iPFCluster;
 
     nPFCluster.clear();
     iPFCluster.clear();
 
     for (PFClusterCollection::const_iterator clus = theEClus.begin(); clus != theEClus.end(); clus++) {
       PFCluster clust = *clus;
       clust.calculatePositionREP();
 
       float ndeta = fabs(nGsfPFRecTrack.gsfTrackRef()->eta() - clust.position().eta());
       float ndphi = fabs(nGsfPFRecTrack.gsfTrackRef()->phi() - clust.position().phi());
       if (ndphi > TMath::Pi())
         ndphi -= TMath::TwoPi();
       // Apply loose preselection with the track
       // just to save cpu time, for this hard-coded
       if (ndeta < 0.5 && fabs(ndphi) < 1.0) {
         double distGsf = nGsfPFRecTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax).isValid()
                              ? LinkByRecHit::testTrackAndClusterByRecHit(nGsfPFRecTrack, clust)
                              : -1.;
         if (distGsf > 0.) {
           nPFCluster.push_back(clust);
           nEnergy += clust.energy();
         } else {
           const vector<PFBrem>& primPFBrem = nGsfPFRecTrack.PFRecBrem();
           for (unsigned ipbrem = 0; ipbrem < primPFBrem.size(); ipbrem++) {
             if (primPFBrem[ipbrem].indTrajPoint() == 99)
               continue;
             const reco::PFRecTrack& pfBremTrack = primPFBrem[ipbrem];
             double dist = pfBremTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax).isValid()
                               ? LinkByRecHit::testTrackAndClusterByRecHit(pfBremTrack, clust, true)
                               : -1.;
             if (dist > 0.) {
               nPFCluster.push_back(clust);
               nEnergy += clust.energy();
               break;
             }
           }
         }
       }
 
       float ideta = fabs(iGsfPFRecTrack.gsfTrackRef()->eta() - clust.position().eta());
       float idphi = fabs(iGsfPFRecTrack.gsfTrackRef()->phi() - clust.position().phi());
       if (idphi > TMath::Pi())
         idphi -= TMath::TwoPi();
       // Apply loose preselection with the track
       // just to save cpu time, for this hard-coded
       if (ideta < 0.5 && fabs(idphi) < 1.0) {
         double dist = iGsfPFRecTrack.extrapolatedPoint(reco::PFTrajectoryPoint::ECALShowerMax).isValid()
                           ? LinkByRecHit::testTrackAndClusterByRecHit(iGsfPFRecTrack, clust)
                           : -1.;
         if (dist > 0.) {
           iPFCluster.push_back(clust);
           iEnergy += clust.energy();
         } else {
           vector<PFBrem> primPFBrem = iGsfPFRecTrack.PFRecBrem();
           for (unsigned ipbrem = 0; ipbrem < primPFBrem.size(); ipbrem++) {
             if (primPFBrem[ipbrem].indTrajPoint() == 99)
               continue;
             const reco::PFRecTrack& pfBremTrack = primPFBrem[ipbrem];
             double dist = LinkByRecHit::testTrackAndClusterByRecHit(pfBremTrack, clust, true);
             if (dist > 0.) {
               iPFCluster.push_back(clust);
               iEnergy += clust.energy();
               break;
             }
           }
         }
       }
     }
 
     if (!nPFCluster.empty() && !iPFCluster.empty()) {
       for (unsigned int npf = 0; npf < nPFCluster.size(); npf++) {
         for (unsigned int ipf = 0; ipf < iPFCluster.size(); ipf++) {
           bool isCommon = ClusterClusterMapping::overlap(nPFCluster[npf], iPFCluster[ipf]);
           if (isCommon) {
             isSharingEnergy = true;
             break;
           }
         }
         if (isSharingEnergy)
           break;
       }
     }
   }
 
   return isSharingEnergy;
 }

◆ minTangDist()

float PFElecTkProducer::minTangDist	(	const reco::GsfPFRecTrack &	primGsf,
		const reco::GsfPFRecTrack &	secGsf
	)

private

Definition at line 869 of file PFElecTkProducer.cc.

References reco::PFTrajectoryPoint::ECALEntrance, reco::PFTrajectoryPoint::isValid(), HLT_2024v13_cff::minDphi, reco::GsfPFRecTrack::PFRecBrem(), Pi, reco::PFTrajectoryPoint::positionREP(), and TwoPi.

                                                                                                      {
   float minDphi = 1000.;
 
   std::vector<reco::PFBrem> primPFBrem = primGsf.PFRecBrem();
   std::vector<reco::PFBrem> secPFBrem = secGsf.PFRecBrem();
 
   unsigned int cbrem = 0;
   for (unsigned isbrem = 0; isbrem < secPFBrem.size(); isbrem++) {
     if (secPFBrem[isbrem].indTrajPoint() == 99)
       continue;
     const reco::PFTrajectoryPoint& atSecECAL =
         secPFBrem[isbrem].extrapolatedPoint(reco::PFTrajectoryPoint::ECALEntrance);
     if (!atSecECAL.isValid())
       continue;
     float secPhi = atSecECAL.positionREP().Phi();
 
     unsigned int sbrem = 0;
     for (unsigned ipbrem = 0; ipbrem < primPFBrem.size(); ipbrem++) {
       if (primPFBrem[ipbrem].indTrajPoint() == 99)
         continue;
       const reco::PFTrajectoryPoint& atPrimECAL =
           primPFBrem[ipbrem].extrapolatedPoint(reco::PFTrajectoryPoint::ECALEntrance);
       if (!atPrimECAL.isValid())
         continue;
       sbrem++;
       if (sbrem <= 3) {
         float primPhi = atPrimECAL.positionREP().Phi();
 
         float dphi = fabs(primPhi - secPhi);
         if (dphi > TMath::Pi())
           dphi -= TMath::TwoPi();
         if (fabs(dphi) < minDphi) {
           minDphi = fabs(dphi);
         }
       }
     }
 
     cbrem++;
     if (cbrem == 3)
       break;
   }
   return minDphi;
 }

◆ produce()

void PFElecTkProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Produce the PFRecTrack collection.

Definition at line 289 of file PFElecTkProducer.cc.

References ALCARECOTkAlJpsiMuMu_cff::charge, runTheMatrix::const, edm::Ref< C, T, F >::get(), reco::PFRecTrack::GSF, iEvent, cuy::ii, electrons_cff::isEcalDriven, PFTrackAlgoTools::isFifthStep(), edm::Ref< C, T, F >::isNonnull(), TrajectoryStateOnSurface::isValid(), PV3DBase< T, PVType, FrameType >::mag(), multiTrajectoryStateMode::momentumFromModeCartesian(), eostools::move(), edm::Handle< T >::product(), and edm::swap().

                                                                       {
   //create the empty collections
   auto gsfPFRecTrackCollection = std::make_unique<GsfPFRecTrackCollection>();
 
   auto gsfPFRecTrackCollectionSecondary = std::make_unique<GsfPFRecTrackCollection>();
 
   //read collections of tracks
   Handle<GsfTrackCollection> gsftrackscoll;
   iEvent.getByToken(gsfTrackLabel_, gsftrackscoll);
 
   //read collections of trajectories
   Handle<vector<Trajectory> > TrajectoryCollection;
 
   //read pfrectrack collection
   Handle<PFRecTrackCollection> thePfRecTrackCollection;
   iEvent.getByToken(pfTrackLabel_, thePfRecTrackCollection);
 
   // SoA structure for frequently used track information.
   // LazyConstructed so it is only filled when needed, i.e., when there is an electron in the event.
   auto trackEtaPhiTable = makeLazy<edm::soa::EtaPhiTable>(*thePfRecTrackCollection);
 
   // PFClusters
   Handle<PFClusterCollection> theECPfClustCollection;
   iEvent.getByToken(pfEcalClusters_, theECPfClustCollection);
   const PFClusterCollection& theEcalClusters = *(theECPfClustCollection.product());
 
   //Primary Vertexes
   Handle<reco::VertexCollection> thePrimaryVertexColl;
   iEvent.getByToken(primVtxLabel_, thePrimaryVertexColl);
 
   // Displaced Vertex
   Handle<reco::PFDisplacedTrackerVertexCollection> pfNuclears;
   if (useNuclear_)
     iEvent.getByToken(pfNuclear_, pfNuclears);
 
   // Conversions
   Handle<reco::PFConversionCollection> pfConversions;
   if (useConversions_)
     iEvent.getByToken(pfConv_, pfConversions);
 
   // V0
   Handle<reco::PFV0Collection> pfV0;
   if (useV0_)
     iEvent.getByToken(pfV0_, pfV0);
 
   GsfTrackCollection gsftracks = *(gsftrackscoll.product());
   vector<Trajectory> tjvec(0);
   if (trajinev_) {
     iEvent.getByToken(gsfTrackLabel_, TrajectoryCollection);
 
     tjvec = *(TrajectoryCollection.product());
   }
 
   vector<reco::GsfPFRecTrack> selGsfPFRecTracks;
   vector<reco::GsfPFRecTrack> primaryGsfPFRecTracks;
   std::map<unsigned int, std::vector<reco::GsfPFRecTrack> > GsfPFMap;
 
   for (unsigned igsf = 0; igsf < gsftracks.size(); igsf++) {
     GsfTrackRef trackRef(gsftrackscoll, igsf);
     gsfInnerMomentumCache_.push_back(trackRef->pMode());
     TrajectoryStateOnSurface i_inTSOS = mtsTransform_.innerStateOnSurface((*trackRef));
     GlobalVector i_innMom;
     if (i_inTSOS.isValid()) {
       multiTrajectoryStateMode::momentumFromModeCartesian(i_inTSOS, i_innMom);
       gsfInnerMomentumCache_.back() = i_innMom.mag();
     }
   }
 
   for (unsigned int igsf = 0; igsf < gsftracks.size(); igsf++) {
     GsfTrackRef trackRef(gsftrackscoll, igsf);
 
     int kf_ind = findPfRef(*thePfRecTrackCollection, gsftracks[igsf], trackEtaPhiTable.value());
 
     if (kf_ind >= 0) {
       PFRecTrackRef kf_ref(thePfRecTrackCollection, kf_ind);
 
       // remove fifth step tracks
       if (useFifthStepForEcalDriven_ == false || useFifthStepForTrackDriven_ == false) {
         bool isFifthStepTrack = PFTrackAlgoTools::isFifthStep(kf_ref->trackRef()->algo());
         bool isEcalDriven = true;
         bool isTrackerDriven = true;
 
         if (trackRef->seedRef().get() == nullptr) {
           isEcalDriven = false;
           isTrackerDriven = false;
         } else {
           auto const& SeedFromRef = static_cast<ElectronSeed const&>(*(trackRef->extra()->seedRef()));
           if (SeedFromRef.caloCluster().isNull())
             isEcalDriven = false;
           if (SeedFromRef.ctfTrack().isNull())
             isTrackerDriven = false;
         }
         //note: the same track could be both ecalDriven and trackerDriven
         if (isFifthStepTrack && isEcalDriven && isTrackerDriven == false && useFifthStepForEcalDriven_ == false) {
           continue;
         }
 
         if (isFifthStepTrack && isTrackerDriven && isEcalDriven == false && useFifthStepForTrackDriven_ == false) {
           continue;
         }
 
         if (isFifthStepTrack && isTrackerDriven && isEcalDriven && useFifthStepForTrackDriven_ == false &&
             useFifthStepForEcalDriven_ == false) {
           continue;
         }
       }
 
       pftrack_ = GsfPFRecTrack(gsftracks[igsf].charge(), reco::PFRecTrack::GSF, igsf, trackRef, kf_ref);
     } else {
       PFRecTrackRef dummyRef;
       pftrack_ = GsfPFRecTrack(gsftracks[igsf].charge(), reco::PFRecTrack::GSF, igsf, trackRef, dummyRef);
     }
 
     bool validgsfbrem = false;
     if (trajinev_) {
       validgsfbrem = pfTransformer_->addPointsAndBrems(pftrack_, gsftracks[igsf], tjvec[igsf], modemomentum_);
     } else {
       validgsfbrem = pfTransformer_->addPointsAndBrems(pftrack_, gsftracks[igsf], mtsTransform_);
     }
 
     bool passSel = true;
     if (applySel_)
       passSel = applySelection(gsftracks[igsf]);
 
     if (validgsfbrem && passSel)
       selGsfPFRecTracks.push_back(pftrack_);
   }
 
   unsigned int count_primary = 0;
   if (!selGsfPFRecTracks.empty()) {
     for (unsigned int ipfgsf = 0; ipfgsf < selGsfPFRecTracks.size(); ipfgsf++) {
       vector<unsigned int> secondaries(0);
       secondaries.clear();
       bool keepGsf = true;
 
       if (applyGsfClean_) {
         keepGsf = resolveGsfTracks(selGsfPFRecTracks, ipfgsf, secondaries, theEcalClusters);
       }
 
       //is primary?
       if (keepGsf == true) {
         // Find kf tracks from converted brem photons
         if (convBremFinder_->foundConvBremPFRecTrack(thePfRecTrackCollection,
                                                      thePrimaryVertexColl,
                                                      pfNuclears,
                                                      pfConversions,
                                                      pfV0,
                                                      globalCache(),
                                                      useNuclear_,
                                                      useConversions_,
                                                      useV0_,
                                                      theEcalClusters,
                                                      selGsfPFRecTracks[ipfgsf])) {
           const vector<PFRecTrackRef>& convBremPFRecTracks(convBremFinder_->getConvBremPFRecTracks());
           for (unsigned int ii = 0; ii < convBremPFRecTracks.size(); ii++) {
             selGsfPFRecTracks[ipfgsf].addConvBremPFRecTrackRef(convBremPFRecTracks[ii]);
           }
         }
 
         // save primaries gsf tracks
         //  gsfPFRecTrackCollection->push_back(selGsfPFRecTracks[ipfgsf]);
         primaryGsfPFRecTracks.push_back(selGsfPFRecTracks[ipfgsf]);
 
         // NOTE:: THE TRACKID IS USED TO LINK THE PRIMARY GSF TRACK. THIS NEEDS
         // TO BE CHANGED AS SOON AS IT IS POSSIBLE TO CHANGE DATAFORMATS
         // A MODIFICATION HERE IMPLIES A MODIFICATION IN PFBLOCKALGO.CC/H
         unsigned int primGsfIndex = selGsfPFRecTracks[ipfgsf].trackId();
         vector<reco::GsfPFRecTrack> trueGsfPFRecTracks;
         if (!secondaries.empty()) {
           // loop on secondaries gsf tracks (from converted brems)
           for (unsigned int isecpfgsf = 0; isecpfgsf < secondaries.size(); isecpfgsf++) {
             PFRecTrackRef refsecKF = selGsfPFRecTracks[(secondaries[isecpfgsf])].kfPFRecTrackRef();
 
             unsigned int secGsfIndex = selGsfPFRecTracks[(secondaries[isecpfgsf])].trackId();
             GsfTrackRef secGsfRef = selGsfPFRecTracks[(secondaries[isecpfgsf])].gsfTrackRef();
 
             if (refsecKF.isNonnull()) {
               // NOTE::IT SAVED THE TRACKID OF THE PRIMARY!!! THIS IS USED IN PFBLOCKALGO.CC/H
               secpftrack_ = GsfPFRecTrack(
                   gsftracks[secGsfIndex].charge(), reco::PFRecTrack::GSF, primGsfIndex, secGsfRef, refsecKF);
             } else {
               PFRecTrackRef dummyRef;
               // NOTE::IT SAVED THE TRACKID OF THE PRIMARY!!! THIS IS USED IN PFBLOCKALGO.CC/H
               secpftrack_ = GsfPFRecTrack(
                   gsftracks[secGsfIndex].charge(), reco::PFRecTrack::GSF, primGsfIndex, secGsfRef, dummyRef);
             }
 
             bool validgsfbrem = false;
             if (trajinev_) {
               validgsfbrem = pfTransformer_->addPointsAndBrems(
                   secpftrack_, gsftracks[secGsfIndex], tjvec[secGsfIndex], modemomentum_);
             } else {
               validgsfbrem = pfTransformer_->addPointsAndBrems(secpftrack_, gsftracks[secGsfIndex], mtsTransform_);
             }
 
             if (validgsfbrem) {
               gsfPFRecTrackCollectionSecondary->push_back(secpftrack_);
               trueGsfPFRecTracks.push_back(secpftrack_);
             }
           }
         }
         GsfPFMap.insert(pair<unsigned int, std::vector<reco::GsfPFRecTrack> >(count_primary, trueGsfPFRecTracks));
         trueGsfPFRecTracks.clear();
         count_primary++;
       }
     }
   }
 
   const edm::OrphanHandle<GsfPFRecTrackCollection> gsfPfRefProd =
       iEvent.put(std::move(gsfPFRecTrackCollectionSecondary), "Secondary");
 
   //now the secondary GsfPFRecTracks are in the event, the Ref can be created
   createGsfPFRecTrackRef(gsfPfRefProd, primaryGsfPFRecTracks, GsfPFMap);
 
   for (unsigned int iGSF = 0; iGSF < primaryGsfPFRecTracks.size(); iGSF++) {
     gsfPFRecTrackCollection->push_back(primaryGsfPFRecTracks[iGSF]);
   }
   iEvent.put(std::move(gsfPFRecTrackCollection));
 
   selGsfPFRecTracks.clear();
   GsfPFMap.clear();
   primaryGsfPFRecTracks.clear();
 
   std::vector<double>().swap(gsfInnerMomentumCache_);
 }

◆ resolveGsfTracks()

bool PFElecTkProducer::resolveGsfTracks	(	const std::vector< reco::GsfPFRecTrack > &	GsfPFVec,
		unsigned int	ngsf,
		std::vector< unsigned int > &	secondaries,
		const reco::PFClusterCollection &	theEClus
	)

private

Definition at line 631 of file PFElecTkProducer.cc.

References runTheMatrix::const, gather_cfg::cout, JetMETHLTOfflineSource_cfi::feta, edm::Ref< C, T, F >::get(), hcalRecHitTable_cff::ieta, hcalRecHitTable_cff::iphi, edm::Ref< C, T, F >::key(), neta, nphi, Pi, TrendClient_cfi::SCEnergy, and TwoPi.

                                                                                  {
   bool debugCleaning = debugGsfCleaning_;
   bool n_keepGsf = true;
 
   const reco::GsfTrackRef& nGsfTrack = GsfPFVec[ngsf].gsfTrackRef();
 
   if (nGsfTrack->seedRef().get() == nullptr)
     return false;
   auto const& nElSeedFromRef = static_cast<ElectronSeed const&>(*(nGsfTrack->extra()->seedRef()));
 
   /* // now gotten from cache below
   TrajectoryStateOnSurface inTSOS = mtsTransform_.innerStateOnSurface((*nGsfTrack));
   GlobalVector ninnMom;
   float nPin =  nGsfTrack->pMode();
   if(inTSOS.isValid()){
     multiTrajectoryStateMode::momentumFromModeCartesian(inTSOS,ninnMom);
     nPin = ninnMom.mag();
   }
   */
   float nPin = gsfInnerMomentumCache_[nGsfTrack.key()];
 
   float neta = nGsfTrack->innerMomentum().eta();
   float nphi = nGsfTrack->innerMomentum().phi();
 
   if (debugCleaning)
     cout << " PFElecTkProducer:: considering track " << nGsfTrack->pt() << " eta,phi " << nGsfTrack->eta() << ", "
          << nGsfTrack->phi() << endl;
 
   for (unsigned int igsf = 0; igsf < GsfPFVec.size(); igsf++) {
     if (igsf != ngsf) {
       reco::GsfTrackRef iGsfTrack = GsfPFVec[igsf].gsfTrackRef();
 
       if (debugCleaning)
         cout << " PFElecTkProducer:: and  comparing with track " << iGsfTrack->pt() << " eta,phi " << iGsfTrack->eta()
              << ", " << iGsfTrack->phi() << endl;
 
       float ieta = iGsfTrack->innerMomentum().eta();
       float iphi = iGsfTrack->innerMomentum().phi();
       float feta = fabs(neta - ieta);
       float fphi = fabs(nphi - iphi);
       if (fphi > TMath::Pi())
         fphi -= TMath::TwoPi();
 
       // apply a superloose preselection only to avoid un-useful cpu time: hard-coded for this reason
       if (feta < 0.5 && fabs(fphi) < 1.0) {
         if (debugCleaning)
           cout << " Entering angular superloose preselection " << endl;
 
         /* //now taken from cache below
         TrajectoryStateOnSurface i_inTSOS = mtsTransform_.innerStateOnSurface((*iGsfTrack));
         GlobalVector i_innMom;
         float iPin = iGsfTrack->pMode();
         if(i_inTSOS.isValid()){
           multiTrajectoryStateMode::momentumFromModeCartesian(i_inTSOS,i_innMom);
           iPin = i_innMom.mag();
         }
         */
         float iPin = gsfInnerMomentumCache_[iGsfTrack.key()];
 
         if (iGsfTrack->seedRef().get() == nullptr)
           continue;
         auto const& iElSeedFromRef = static_cast<ElectronSeed const&>(*(iGsfTrack->extra()->seedRef()));
 
         float SCEnergy = -1.;
         // Check if two tracks match the same SC
         bool areBothGsfEcalDriven = false;
         ;
         bool isSameSC = isSameEgSC(nElSeedFromRef, iElSeedFromRef, areBothGsfEcalDriven, SCEnergy);
 
         // CASE1 both GsfTracks ecalDriven and match the same SC
         if (areBothGsfEcalDriven) {
           if (isSameSC) {
             float nEP = SCEnergy / nPin;
             float iEP = SCEnergy / iPin;
             if (debugCleaning)
               cout << " Entering SAME supercluster case "
                    << " nEP " << nEP << " iEP " << iEP << endl;
 
             // if same SC take the closest or if same
             // distance the best E/p
 
             // Innermost using LostHits technology
             bool isSameLayer = false;
             bool iGsfInnermostWithLostHits = isInnerMostWithLostHits(nGsfTrack, iGsfTrack, isSameLayer);
 
             if (debugCleaning)
               cout << " iGsf is InnerMostWithLostHits " << iGsfInnermostWithLostHits << " isSameLayer " << isSameLayer
                    << endl;
 
             if (iGsfInnermostWithLostHits) {
               n_keepGsf = false;
               return n_keepGsf;
             } else if (isSameLayer) {
               if (fabs(iEP - 1) < fabs(nEP - 1)) {
                 n_keepGsf = false;
                 return n_keepGsf;
               } else {
                 secondaries.push_back(igsf);
               }
             } else {
               // save secondaries gsf track (put selection)
               secondaries.push_back(igsf);
             }
           }  // end same SC case
         } else {
           // enter in the condition where at least one track is trackerDriven
           float minBremDphi = minTangDist(GsfPFVec[ngsf], GsfPFVec[igsf]);
           float nETot = 0.;
           float iETot = 0.;
           bool isBothGsfTrackerDriven = false;
           bool nEcalDriven = false;
           bool iEcalDriven = false;
           bool isSameScEgPf = isSharingEcalEnergyWithEgSC(GsfPFVec[ngsf],
                                                           GsfPFVec[igsf],
                                                           nElSeedFromRef,
                                                           iElSeedFromRef,
                                                           theEClus,
                                                           isBothGsfTrackerDriven,
                                                           nEcalDriven,
                                                           iEcalDriven,
                                                           nETot,
                                                           iETot);
 
           // check if the first hit of iGsfTrack < nGsfTrack
           bool isSameLayer = false;
           bool iGsfInnermostWithLostHits = isInnerMostWithLostHits(nGsfTrack, iGsfTrack, isSameLayer);
 
           if (isSameScEgPf) {
             // CASE 2 : One Gsf has reference to a SC and the other one not or both not
 
             if (debugCleaning) {
               cout << " Sharing ECAL energy passed "
                    << " nEtot " << nETot << " iEtot " << iETot << endl;
               if (isBothGsfTrackerDriven)
                 cout << " Both Track are trackerDriven " << endl;
             }
 
             // Innermost using LostHits technology
             if (iGsfInnermostWithLostHits) {
               n_keepGsf = false;
               return n_keepGsf;
             } else if (isSameLayer) {
               // Thirt Case:  One Gsf has reference to a SC and the other one not or both not
               // gsf tracks starts from the same layer
               // check number of sharing modules (at least 50%)
               // check number of sharing hits (at least 2)
               // check charge flip inner/outer
 
               // they share energy
               if (isBothGsfTrackerDriven == false) {
                 // if at least one Gsf track is EcalDriven choose that one.
                 if (iEcalDriven) {
                   n_keepGsf = false;
                   return n_keepGsf;
                 } else {
                   secondaries.push_back(igsf);
                 }
               } else {
                 // if both tracks are tracker driven choose that one with the best E/p
                 // with ETot = max(En,Ei)
 
                 float ETot = -1;
                 if (nETot != iETot) {
                   if (nETot > iETot)
                     ETot = nETot;
                   else
                     ETot = iETot;
                 } else {
                   ETot = nETot;
                 }
                 float nEP = ETot / nPin;
                 float iEP = ETot / iPin;
 
                 if (debugCleaning)
                   cout << " nETot " << nETot << " iETot " << iETot << " ETot " << ETot << endl
                        << " nPin " << nPin << " iPin " << iPin << " nEP " << nEP << " iEP " << iEP << endl;
 
                 if (fabs(iEP - 1) < fabs(nEP - 1)) {
                   n_keepGsf = false;
                   return n_keepGsf;
                 } else {
                   secondaries.push_back(igsf);
                 }
               }
             } else {
               secondaries.push_back(igsf);
             }
           } else if (feta < detaCutGsfClean_ && minBremDphi < dphiCutGsfClean_) {
             // very close tracks
             bool secPushedBack = false;
             if (nEcalDriven == false && nETot == 0.) {
               n_keepGsf = false;
               return n_keepGsf;
             } else if (iEcalDriven == false && iETot == 0.) {
               secondaries.push_back(igsf);
               secPushedBack = true;
             }
             if (debugCleaning)
               cout << " Close Tracks "
                    << " feta " << feta << " fabs(fphi) " << fabs(fphi) << " minBremDphi " << minBremDphi << " nETot "
                    << nETot << " iETot " << iETot << " nLostHits " << nGsfTrack->missingInnerHits() << " iLostHits "
                    << iGsfTrack->missingInnerHits() << endl;
 
             // apply selection only if one track has lost hits
             if (applyAngularGsfClean_) {
               if (iGsfInnermostWithLostHits) {
                 n_keepGsf = false;
                 return n_keepGsf;
               } else if (isSameLayer == false) {
                 if (secPushedBack == false)
                   secondaries.push_back(igsf);
               }
             }
           } else if (feta < 0.1 && minBremDphi < 0.2) {
             // failed all the conditions, discard only tracker driven tracks
             // with no PFClusters linked.
             if (debugCleaning)
               cout << " Close Tracks and failed all the conditions "
                    << " feta " << feta << " fabs(fphi) " << fabs(fphi) << " minBremDphi " << minBremDphi << " nETot "
                    << nETot << " iETot " << iETot << " nLostHits " << nGsfTrack->missingInnerHits() << " iLostHits "
                    << iGsfTrack->missingInnerHits() << endl;
 
             if (nEcalDriven == false && nETot == 0.) {
               n_keepGsf = false;
               return n_keepGsf;
             }
             // Here I do not push back the secondary because considered fakes...
           }
         }
       }
     }
   }
 
   return n_keepGsf;
 }

Member Data Documentation

◆ applyAngularGsfClean_

bool PFElecTkProducer::applyAngularGsfClean_

private

Definition at line 132 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ applyGsfClean_

bool PFElecTkProducer::applyGsfClean_

private

Definition at line 149 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ applySel_

bool PFElecTkProducer::applySel_

private

Definition at line 148 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ conf_

edm::ParameterSet PFElecTkProducer::conf_

private

Definition at line 121 of file PFElecTkProducer.cc.

◆ convBremFinder_

std::unique_ptr<ConvBremPFTrackFinder> PFElecTkProducer::convBremFinder_

private

Definition at line 143 of file PFElecTkProducer.cc.

◆ debugGsfCleaning_

bool PFElecTkProducer::debugGsfCleaning_

private

Definition at line 153 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ detaCutGsfClean_

double PFElecTkProducer::detaCutGsfClean_

private

Definition at line 133 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ detaGsfSC_

double PFElecTkProducer::detaGsfSC_

private

Definition at line 155 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ dphiCutGsfClean_

double PFElecTkProducer::dphiCutGsfClean_

private

Definition at line 134 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ dphiGsfSC_

double PFElecTkProducer::dphiGsfSC_

private

Definition at line 156 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ gsfInnerMomentumCache_

std::vector<double> PFElecTkProducer::gsfInnerMomentumCache_

private

Definition at line 172 of file PFElecTkProducer.cc.

◆ gsfTrackLabel_

edm::EDGetTokenT<reco::GsfTrackCollection> PFElecTkProducer::gsfTrackLabel_

private

Definition at line 122 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ magFieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> PFElecTkProducer::magFieldToken_

private

Definition at line 136 of file PFElecTkProducer.cc.

◆ maxPtConvReco_

double PFElecTkProducer::maxPtConvReco_

private

Definition at line 157 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ modemomentum_

bool PFElecTkProducer::modemomentum_

private

Definition at line 147 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ mtsTransform_

MultiTrajectoryStateTransform PFElecTkProducer::mtsTransform_

private

Definition at line 142 of file PFElecTkProducer.cc.

◆ mvaConvBremFinderIDBarrelHighPt_

double PFElecTkProducer::mvaConvBremFinderIDBarrelHighPt_

private

Definition at line 163 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ mvaConvBremFinderIDBarrelLowPt_

double PFElecTkProducer::mvaConvBremFinderIDBarrelLowPt_

private

Definition at line 162 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ mvaConvBremFinderIDEndcapsHighPt_

double PFElecTkProducer::mvaConvBremFinderIDEndcapsHighPt_

private

Definition at line 165 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ mvaConvBremFinderIDEndcapsLowPt_

double PFElecTkProducer::mvaConvBremFinderIDEndcapsLowPt_

private

Definition at line 164 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ path_mvaWeightFileConvBremBarrelHighPt_

std::string PFElecTkProducer::path_mvaWeightFileConvBremBarrelHighPt_

private

Definition at line 167 of file PFElecTkProducer.cc.

◆ path_mvaWeightFileConvBremBarrelLowPt_

std::string PFElecTkProducer::path_mvaWeightFileConvBremBarrelLowPt_

private

Definition at line 166 of file PFElecTkProducer.cc.

◆ path_mvaWeightFileConvBremEndcapsHighPt_

std::string PFElecTkProducer::path_mvaWeightFileConvBremEndcapsHighPt_

private

Definition at line 169 of file PFElecTkProducer.cc.

◆ path_mvaWeightFileConvBremEndcapsLowPt_

std::string PFElecTkProducer::path_mvaWeightFileConvBremEndcapsLowPt_

private

Definition at line 168 of file PFElecTkProducer.cc.

◆ pfConv_

edm::EDGetTokenT<reco::PFConversionCollection> PFElecTkProducer::pfConv_

private

Definition at line 127 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ pfEcalClusters_

edm::EDGetTokenT<reco::PFClusterCollection> PFElecTkProducer::pfEcalClusters_

private

Definition at line 125 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ pfNuclear_

edm::EDGetTokenT<reco::PFDisplacedTrackerVertexCollection> PFElecTkProducer::pfNuclear_

private

Definition at line 126 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ pftrack_

reco::GsfPFRecTrack PFElecTkProducer::pftrack_

private

Definition at line 119 of file PFElecTkProducer.cc.

◆ pfTrackLabel_

edm::EDGetTokenT<reco::PFRecTrackCollection> PFElecTkProducer::pfTrackLabel_

private

Definition at line 123 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ pfTransformer_

std::unique_ptr<PFTrackTransformer> PFElecTkProducer::pfTransformer_

private

PFTrackTransformer.

Definition at line 141 of file PFElecTkProducer.cc.

◆ pfV0_

edm::EDGetTokenT<reco::PFV0Collection> PFElecTkProducer::pfV0_

private

Definition at line 128 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ primVtxLabel_

edm::EDGetTokenT<reco::VertexCollection> PFElecTkProducer::primVtxLabel_

private

Definition at line 124 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ SCEne_

double PFElecTkProducer::SCEne_

private

Definition at line 154 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ secpftrack_

reco::GsfPFRecTrack PFElecTkProducer::secpftrack_

private

Definition at line 120 of file PFElecTkProducer.cc.

◆ tkerGeomToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> PFElecTkProducer::tkerGeomToken_

private

Definition at line 137 of file PFElecTkProducer.cc.

◆ trajinev_

bool PFElecTkProducer::trajinev_

private

Trajectory of GSfTracks in the event?

Definition at line 146 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ transientTrackToken_

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> PFElecTkProducer::transientTrackToken_

private

Definition at line 138 of file PFElecTkProducer.cc.

◆ useConvBremFinder_

bool PFElecTkProducer::useConvBremFinder_

private

Conv Brem Finder.

Definition at line 160 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ useConversions_

bool PFElecTkProducer::useConversions_

private

Definition at line 130 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ useFifthStepForEcalDriven_

bool PFElecTkProducer::useFifthStepForEcalDriven_

private

Definition at line 150 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ useFifthStepForTrackDriven_

bool PFElecTkProducer::useFifthStepForTrackDriven_

private

Definition at line 151 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ useNuclear_

bool PFElecTkProducer::useNuclear_

private

Definition at line 129 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

◆ useV0_

bool PFElecTkProducer::useV0_

private

Definition at line 131 of file PFElecTkProducer.cc.

Referenced by PFElecTkProducer().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PFElecTkProducer()

Member Function Documentation

◆ applySelection()

◆ beginRun()

◆ createGsfPFRecTrackRef()

◆ endRun()

◆ fillDescriptions()

◆ findPfRef()

◆ globalEndJob()

◆ initializeGlobalCache()

◆ isInnerMost()

◆ isInnerMostWithLostHits()

◆ isSameEgSC()

◆ isSharingEcalEnergyWithEgSC()

◆ minTangDist()

◆ produce()

◆ resolveGsfTracks()

Member Data Documentation

◆ applyAngularGsfClean_

◆ applyGsfClean_

◆ applySel_

◆ conf_

◆ convBremFinder_

◆ debugGsfCleaning_

◆ detaCutGsfClean_

◆ detaGsfSC_

◆ dphiCutGsfClean_

◆ dphiGsfSC_

◆ gsfInnerMomentumCache_

◆ gsfTrackLabel_

◆ magFieldToken_

◆ maxPtConvReco_

◆ modemomentum_

◆ mtsTransform_

◆ mvaConvBremFinderIDBarrelHighPt_

◆ mvaConvBremFinderIDBarrelLowPt_

◆ mvaConvBremFinderIDEndcapsHighPt_

◆ mvaConvBremFinderIDEndcapsLowPt_

◆ path_mvaWeightFileConvBremBarrelHighPt_

◆ path_mvaWeightFileConvBremBarrelLowPt_

◆ path_mvaWeightFileConvBremEndcapsHighPt_

◆ path_mvaWeightFileConvBremEndcapsLowPt_

◆ pfConv_

◆ pfEcalClusters_

◆ pfNuclear_

◆ pftrack_

◆ pfTrackLabel_

◆ pfTransformer_

◆ pfV0_

◆ primVtxLabel_

◆ SCEne_

◆ secpftrack_

◆ tkerGeomToken_

◆ trajinev_

◆ transientTrackToken_

◆ useConvBremFinder_

◆ useConversions_

◆ useFifthStepForEcalDriven_

◆ useFifthStepForTrackDriven_

◆ useNuclear_

◆ useV0_