Inheritance diagram for L1TkElectronTrackProducer:

Public Types
typedef std::vector< L1TTTrackType >	L1TTTrackCollectionType

typedef TTTrack< Ref_Phase2TrackerDigi_ >	L1TTTrackType

Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

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

	~L1TkElectronTrackProducer () override

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

Private Member Functions
double	getPtScaledCut (double pt, std::vector< double > &parameters)

float	isolation (const edm::Handle< L1TTTrackCollectionType > &trkHandle, int match_index)

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

bool	selectMatchedTrack (double &d_r, double &d_phi, double &d_eta, double &tk_pt, float &eg_eta)

Private Attributes
float	deltaZ_

std::vector< double >	dEtaCutoff_

std::vector< double >	dPhiCutoff_

std::vector< double >	dRCutoff_

float	dRMax_

float	dRMin_

const edm::EDGetTokenT< EGammaBxCollection >	egToken_

float	etMin_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	geomToken_

float	isoCut_

std::string	label

std::string	matchType_

float	maxChi2IsoTracks_

unsigned int	minNStubsIsoTracks_

bool	primaryVtxConstrain_

float	pTMinTra_

bool	relativeIsolation_

const edm::EDGetTokenT< std::vector< TTTrack< Ref_Phase2TrackerDigi_ > > >	trackToken_

float	trkQualityChi2_

float	trkQualityPtMin_

bool	useClusterET_

bool	useTwoStubsPT_

Detailed Description

Definition at line 54 of file L1TkElectronTrackProducer.cc.

Member Typedef Documentation

◆ L1TTTrackCollectionType

typedef std::vector<L1TTTrackType> L1TkElectronTrackProducer::L1TTTrackCollectionType

Definition at line 57 of file L1TkElectronTrackProducer.cc.

◆ L1TTTrackType

typedef TTTrack<Ref_Phase2TrackerDigi_> L1TkElectronTrackProducer::L1TTTrackType

Definition at line 56 of file L1TkElectronTrackProducer.cc.

Constructor & Destructor Documentation

◆ L1TkElectronTrackProducer()

L1TkElectronTrackProducer::L1TkElectronTrackProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 107 of file L1TkElectronTrackProducer.cc.

     : egToken_(consumes<EGammaBxCollection>(iConfig.getParameter<edm::InputTag>("L1EGammaInputTag"))),
       trackToken_(consumes<std::vector<TTTrack<Ref_Phase2TrackerDigi_> > >(
           iConfig.getParameter<edm::InputTag>("L1TrackInputTag"))),
       geomToken_(esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>()) {
   // label of the collection produced
   // e.g. EG or IsoEG if all objects are kept
   // EGIsoTrk or IsoEGIsoTrk if only the EG or IsoEG
   // objects that pass a cut RelIso < isoCut_ are written
   // in the new collection.
   label = iConfig.getParameter<std::string>("label");
  
   etMin_ = (float)iConfig.getParameter<double>("ETmin");
  
   // parameters for the calculation of the isolation :
   pTMinTra_ = (float)iConfig.getParameter<double>("PTMINTRA");
   dRMin_ = (float)iConfig.getParameter<double>("DRmin");
   dRMax_ = (float)iConfig.getParameter<double>("DRmax");
   deltaZ_ = (float)iConfig.getParameter<double>("DeltaZ");
   maxChi2IsoTracks_ = iConfig.getParameter<double>("maxChi2IsoTracks");
   minNStubsIsoTracks_ = iConfig.getParameter<int>("minNStubsIsoTracks");
   // cut applied on the isolation (if this number is <= 0, no cut is applied)
   isoCut_ = (float)iConfig.getParameter<double>("IsoCut");
   relativeIsolation_ = iConfig.getParameter<bool>("RelativeIsolation");
  
   // parameters to select tracks to match with L1EG
   trkQualityChi2_ = (float)iConfig.getParameter<double>("TrackChi2");
   trkQualityPtMin_ = (float)iConfig.getParameter<double>("TrackMinPt");
   useTwoStubsPT_ = iConfig.getParameter<bool>("useTwoStubsPT");
   useClusterET_ = iConfig.getParameter<bool>("useClusterET");
   dPhiCutoff_ = iConfig.getParameter<std::vector<double> >("TrackEGammaDeltaPhi");
   dRCutoff_ = iConfig.getParameter<std::vector<double> >("TrackEGammaDeltaR");
   dEtaCutoff_ = iConfig.getParameter<std::vector<double> >("TrackEGammaDeltaEta");
   matchType_ = iConfig.getParameter<std::string>("TrackEGammaMatchType");
  
   produces<TkElectronCollection>(label);
 }

References deltaZ_, dEtaCutoff_, dPhiCutoff_, dRCutoff_, dRMax_, dRMin_, etMin_, dqmMemoryStats::float, edm::ParameterSet::getParameter(), isoCut_, label, matchType_, maxChi2IsoTracks_, minNStubsIsoTracks_, pTMinTra_, relativeIsolation_, AlCaHLTBitMon_QueryRunRegistry::string, trkQualityChi2_, trkQualityPtMin_, useClusterET_, and useTwoStubsPT_.

◆ ~L1TkElectronTrackProducer()

L1TkElectronTrackProducer::~L1TkElectronTrackProducer ( )

override

Definition at line 145 of file L1TkElectronTrackProducer.cc.

145 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 290 of file L1TkElectronTrackProducer.cc.

                                                                                            {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.setUnknown();
   descriptions.addDefault(desc);
 }

References edm::ConfigurationDescriptions::addDefault(), and edm::ParameterSetDescription::setUnknown().

◆ getPtScaledCut()

double L1TkElectronTrackProducer::getPtScaledCut	(	double	pt,
		std::vector< double > &	parameters
	)

private

Definition at line 331 of file L1TkElectronTrackProducer.cc.

                                                                                          {
   return (parameters[0] + parameters[1] * exp(parameters[2] * pt));
 }

References JetChargeProducer_cfi::exp, and DiDispStaMuonMonitor_cfi::pt.

Referenced by selectMatchedTrack().

◆ isolation()

float L1TkElectronTrackProducer::isolation	(	const edm::Handle< L1TTTrackCollectionType > &	trkHandle,
		int	match_index
	)

private

Definition at line 298 of file L1TkElectronTrackProducer.cc.

                                                                                                                {
   edm::Ptr<L1TTTrackType> matchedTrkPtr(trkHandle, match_index);
   L1TTTrackCollectionType::const_iterator trackIter;
  
   float sumPt = 0.0;
   int itr = 0;
  
   float dRMin2 = dRMin_ * dRMin_;
   float dRMax2 = dRMax_ * dRMax_;
  
   for (trackIter = trkHandle->begin(); trackIter != trkHandle->end(); ++trackIter) {
     if (itr++ != match_index) {
       if (trackIter->chi2() > maxChi2IsoTracks_ || trackIter->momentum().perp() <= pTMinTra_ ||
           trackIter->getStubRefs().size() < minNStubsIsoTracks_) {
         continue;
       }
  
       float dZ = std::abs(trackIter->POCA().z() - matchedTrkPtr->POCA().z());
  
       float phi1 = trackIter->momentum().phi();
       float phi2 = matchedTrkPtr->momentum().phi();
       float dPhi = reco::deltaPhi(phi1, phi2);
       float dEta = (trackIter->momentum().eta() - matchedTrkPtr->momentum().eta());
       float dR2 = (dPhi * dPhi + dEta * dEta);
  
       if (dR2 > dRMin2 && dR2 < dRMax2 && dZ < deltaZ_ && trackIter->momentum().perp() > pTMinTra_) {
         sumPt += trackIter->momentum().perp();
       }
     }
   }
  
   return sumPt;
 }

References funct::abs(), reco::deltaPhi(), HLT_2018_cff::dEta, HLT_2018_cff::dPhi, dRMax_, dRMin_, PV3DBase< T, PVType, FrameType >::eta(), maxChi2IsoTracks_, minNStubsIsoTracks_, TTTrack< T >::momentum(), PV3DBase< T, PVType, FrameType >::phi(), TTTrack< T >::POCA(), pTMinTra_, TtFullHadEvtBuilder_cfi::sumPt, and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

◆ produce()

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

overrideprivate

Definition at line 148 of file L1TkElectronTrackProducer.cc.

                                                                                      {
   std::unique_ptr<TkElectronCollection> result(new TkElectronCollection);
  
   // geometry needed to call pTFrom2Stubs
   edm::ESHandle<TrackerGeometry> geomHandle = iSetup.getHandle(geomToken_);
   const TrackerGeometry* tGeom = geomHandle.product();
  
   // the L1EGamma objects
   edm::Handle<EGammaBxCollection> eGammaHandle;
   iEvent.getByToken(egToken_, eGammaHandle);
   EGammaBxCollection eGammaCollection = (*eGammaHandle.product());
   EGammaBxCollection::const_iterator egIter;
  
   // the L1Tracks
   edm::Handle<L1TTTrackCollectionType> L1TTTrackHandle;
   iEvent.getByToken(trackToken_, L1TTTrackHandle);
   L1TTTrackCollectionType::const_iterator trackIter;
  
   if (!eGammaHandle.isValid()) {
     throw cms::Exception("L1TkElectronTrackProducer")
         << "\nWarning: L1EmCollection not found in the event. Exit" << std::endl;
     return;
   }
   if (!L1TTTrackHandle.isValid()) {
     throw cms::Exception("TkEmProducer") << "\nWarning: L1TTTrackCollectionType not found in the event. Exit."
                                          << std::endl;
     return;
   }
  
   int ieg = 0;
   for (egIter = eGammaCollection.begin(0); egIter != eGammaCollection.end(0); ++egIter) {  // considering BX = only
     edm::Ref<EGammaBxCollection> EGammaRef(eGammaHandle, ieg);
     ieg++;
  
     float e_ele = egIter->energy();
     float eta_ele = egIter->eta();
     float et_ele = 0;
     float cosh_eta_ele = cosh(eta_ele);
     if (cosh_eta_ele > 0.0)
       et_ele = e_ele / cosh_eta_ele;
     else
       et_ele = -1.0;
     if (etMin_ > 0.0 && et_ele <= etMin_)
       continue;
     // match the L1EG object with a L1Track
     float drmin = 999;
     int itr = 0;
     int itrack = -1;
     for (trackIter = L1TTTrackHandle->begin(); trackIter != L1TTTrackHandle->end(); ++trackIter) {
       edm::Ptr<L1TTTrackType> L1TrackPtr(L1TTTrackHandle, itr);
       double trkPt_fit = trackIter->momentum().perp();
       double trkPt_stubs = pTFrom2Stubs::pTFrom2(trackIter, tGeom);
       double trkPt = trkPt_fit;
       if (useTwoStubsPT_)
         trkPt = trkPt_stubs;
  
       if (trkPt > trkQualityPtMin_ && trackIter->chi2() < trkQualityChi2_) {
         double dPhi = 99.;
         double dR = 99.;
         double dEta = 99.;
         if (useClusterET_)
           L1TkElectronTrackMatchAlgo::doMatchClusterET(egIter, L1TrackPtr, dPhi, dR, dEta);
         else
           L1TkElectronTrackMatchAlgo::doMatch(egIter, L1TrackPtr, dPhi, dR, dEta);
         if (dR < drmin && selectMatchedTrack(dR, dPhi, dEta, trkPt, eta_ele)) {
           drmin = dR;
           itrack = itr;
         }
       }
       itr++;
     }
     if (itrack >= 0) {
       edm::Ptr<L1TTTrackType> matchedL1TrackPtr(L1TTTrackHandle, itrack);
  
       const math::XYZTLorentzVector P4 = egIter->p4();
       float trkisol = isolation(L1TTTrackHandle, itrack);
       if (relativeIsolation_ && et_ele > 0.0) {  // relative isolation
         trkisol = trkisol / et_ele;
       }
  
       TkElectron trkEm(P4, EGammaRef, matchedL1TrackPtr, trkisol);
  
       trkEm.setTrackCurvature(matchedL1TrackPtr->rInv());  // should this have npars? 4? 5?
  
       //std::cout<<matchedL1TrackPtr->rInv()<<"  "<<matchedL1TrackPtr->rInv(4)<<"   "<<matchedL1TrackPtr->rInv()<<std::endl;
  
       if (isoCut_ <= 0) {
         // write the L1TkEm particle to the collection,
         // irrespective of its relative isolation
         result->push_back(trkEm);
       } else {
         // the object is written to the collection only
         // if it passes the isolation cut
         if (trkisol <= isoCut_)
           result->push_back(trkEm);
       }
     }
  
   }  // end loop over EGamma objects
  
   iEvent.put(std::move(result), label);
 }

References BXVector< T >::begin(), HLT_2018_cff::dEta, L1TkElectronTrackMatchAlgo::doMatch(), L1TkElectronTrackMatchAlgo::doMatchClusterET(), HLT_2018_cff::dPhi, HGC3DClusterGenMatchSelector_cfi::dR, egToken_, BXVector< T >::end(), etMin_, Exception, geomToken_, edm::EventSetup::getHandle(), iEvent, isoCut_, isolation(), edm::HandleBase::isValid(), label, eostools::move(), edm::Handle< T >::product(), edm::ESHandle< T >::product(), pTFrom2Stubs::pTFrom2(), relativeIsolation_, mps_fire::result, TTTrack< T >::rInv(), selectMatchedTrack(), l1t::TkElectron::setTrackCurvature(), trackToken_, trkQualityChi2_, trkQualityPtMin_, useClusterET_, and useTwoStubsPT_.

◆ selectMatchedTrack()

bool L1TkElectronTrackProducer::selectMatchedTrack	(	double &	d_r,
		double &	d_phi,
		double &	d_eta,
		double &	tk_pt,
		float &	eg_eta
	)

private

Definition at line 334 of file L1TkElectronTrackProducer.cc.

                                                                              {
   if (matchType_ == "PtDependentCut") {
     if (std::abs(d_phi) < getPtScaledCut(tk_pt, dPhiCutoff_) && d_r < getPtScaledCut(tk_pt, dRCutoff_))
       return true;
   } else {
     double deta_max = dEtaCutoff_[0];
     if (std::abs(eg_eta) < EB_MaxEta)
       deta_max = dEtaCutoff_[1];
     double dphi_max = dPhiCutoff_[0];
     if ((d_eta / deta_max) * (d_eta / deta_max) + (d_phi / dphi_max) * (d_phi / dphi_max) < 1)
       return true;
   }
   return false;
 }