Jet energy correction algorithm using tracks. More...

#include <JetPlusTrackCorrector.h>

Public Types
typedef math::XYZTLorentzVector	P4

typedef math::PtEtaPhiELorentzVectorD	PtEtaPhiE

typedef math::PtEtaPhiMLorentzVectorD	PtEtaPhiM

Public Member Functions
bool	canCorrect (const reco::Jet &) const
	Can jet be JPT-corrected? More...

double	correctAA (const reco::Jet &, const reco::TrackRefVector &, double &, const reco::TrackRefVector &, const reco::TrackRefVector &, double, const reco::TrackRefVector &) const
	For AA - correct in tracker. More...

double	correction (const reco::Jet &, const reco::Jet &, const edm::Event &, const edm::EventSetup &, P4 &, jpt::MatchedTracks &pions, jpt::MatchedTracks &muons, jpt::MatchedTracks &elecs, bool &validMatches)
	Vectorial correction method (corrected 4-momentum passed by reference) More...

double	correction (const reco::Jet &, const reco::Jet &, const edm::Event &, const edm::EventSetup &, const reco::TrackRefVector &tracksinvert, const reco::TrackRefVector &tracksincalo, P4 &, jpt::MatchedTracks &pions, jpt::MatchedTracks &muons, jpt::MatchedTracks &elecs)

double	correction (const reco::Jet &, const reco::Jet &, const edm::Event &, const edm::EventSetup &, jpt::MatchedTracks &pions, jpt::MatchedTracks &muons, jpt::MatchedTracks &elecs, bool &validMatches)
	Scalar correction method. More...

double	correction (const reco::Jet &) const
	Correction method (not used) More...

double	correction (const P4 &) const
	Correction method (not used) More...

P4	elecCorrection (const P4 &jet, const jpt::MatchedTracks &elecs) const
	Calculates correction to be applied using electrons. More...

bool	eventRequired () const
	Returns true. More...

double	getResponseOfChargedWithEff ()
	Get responses/sumPT/SumEnergy with and without Efficiency correction. More...

double	getResponseOfChargedWithoutEff ()

double	getSumEnergyWithEff ()

double	getSumEnergyWithoutEff ()

double	getSumPtForBeta ()

double	getSumPtWithEff ()

double	getSumPtWithoutEff ()

	JetPlusTrackCorrector (const edm::ParameterSet &iPS, edm::ConsumesCollector &&iC)
	Constructor. More...

bool	matchTracks (const reco::Jet &, const edm::Event &, const edm::EventSetup &, jpt::MatchedTracks &pions, jpt::MatchedTracks &muons, jpt::MatchedTracks &elecs)
	Matches tracks to different particle types. More...

void	matchTracks (const reco::Jet &, const edm::Event &, const edm::EventSetup &, const reco::TrackRefVector &tracksinvert, const reco::TrackRefVector &tracksincalo, jpt::MatchedTracks &pions, jpt::MatchedTracks &muons, jpt::MatchedTracks &elecs)

P4	muonCorrection (const P4 &jet, const jpt::MatchedTracks &muons)
	Calculates correction to be applied using muons. More...

P4	pionCorrection (const P4 &jet, const jpt::MatchedTracks &pions)
	Calculates corrections to be applied using pions. More...

bool	vectorialCorrection () const
	Returns value of configurable. More...

virtual	~JetPlusTrackCorrector ()
	Destructor. More...

Protected Types
typedef reco::JetTracksAssociation::Container	JetTracksAssociations

typedef edm::ValueMap< float >	RecoElectronIds

typedef reco::GsfElectronCollection	RecoElectrons

typedef reco::MuonCollection	RecoMuons
	Get reponses. More...

typedef reco::TrackRefVector	TrackRefs

Protected Member Functions
P4	calculateCorr (const P4 &jet, const TrackRefs &, jpt::Efficiency &, bool in_cone_at_vertex, bool in_cone_at_calo_face, double mass, bool is_pion, double mip)
	Generic method to calculates 4-momentum correction to be applied. More...

double	checkScale (const P4 &jet, P4 &corrected) const
	Check corrected 4-momentum does not give negative scale. More...

const jpt::Map &	efficiencyMap () const

P4	elecCorrection (const P4 &jet, const TrackRefs &elecs, bool in_cone_at_vertex, bool in_cone_at_calo_face)
	Calculates individual electron corrections. More...

void	excludeJta (const reco::Jet &, const JetTracksAssociations &, TrackRefs &included, const TrackRefs &excluded) const
	Exclude jet-track association. More...

bool	failTrackQuality (TrackRefs::const_iterator &) const
	Check on track quality. More...

bool	findTrack (const jpt::JetTracks &, TrackRefs::const_iterator &, TrackRefs::iterator &) const
	Find track in JetTracks collection. More...

bool	findTrack (const jpt::MatchedTracks &pions, const jpt::MatchedTracks &muons, const jpt::MatchedTracks &electrons, TrackRefs::const_iterator &) const
	Find track in MatchedTracks collections. More...

bool	getElectrons (const edm::Event &, edm::Handle< RecoElectrons > &, edm::Handle< RecoElectronIds > &) const
	Get RECO electrons. More...

bool	getElectrons (const edm::Event &, edm::Handle< pat::ElectronCollection > &) const

bool	getMuons (const edm::Event &, edm::Handle< RecoMuons > &) const
	Get RECO muons. More...

bool	getMuons (const edm::Event &, edm::Handle< pat::MuonCollection > &) const

P4	jetDirFromTracks (const P4 &jet, const jpt::MatchedTracks &pions, const jpt::MatchedTracks &muons, const jpt::MatchedTracks &elecs) const
	Calculates vectorial correction using total track 3-momentum. More...

	JetPlusTrackCorrector ()
	Default constructor. More...

virtual bool	jetTrackAssociation (const reco::Jet &, const edm::Event &, const edm::EventSetup &, jpt::JetTracks &) const
	Associates tracks to jets (overriden in derived class) More...

bool	jtaUsingEventData (const reco::Jet &, const edm::Event &, jpt::JetTracks &) const
	JTA using collections from event. More...

const jpt::Map &	leakageMap () const

bool	matchElectrons (TrackRefs::const_iterator &, const edm::Handle< RecoElectrons > &, const edm::Handle< RecoElectronIds > &) const
	Matches tracks to RECO electrons. More...

bool	matchElectrons (TrackRefs::const_iterator &, const edm::Handle< pat::ElectronCollection > &) const

bool	matchMuons (TrackRefs::const_iterator &, const edm::Handle< RecoMuons > &) const
	Matches tracks to RECO muons. More...

bool	matchMuons (TrackRefs::const_iterator &, const edm::Handle< pat::MuonCollection > &) const

virtual void	matchTracks (const jpt::JetTracks &, const edm::Event &, jpt::MatchedTracks &pions, jpt::MatchedTracks &muons, jpt::MatchedTracks &elecs)
	Matches tracks to different particle types (overriden in derived class) More...

P4	muonCorrection (const P4 &jet, const TrackRefs &muons, bool in_cone_at_vertex, bool in_cone_at_calo_face)
	Calculates individual muons corrections. More...

P4	pionCorrection (const P4 &jet, const TrackRefs &pions, jpt::Efficiency &, bool in_cone_at_vertex, bool in_cone_at_calo_face)
	Calculates individual pion corrections. More...

P4	pionEfficiency (const P4 &jet, const jpt::Efficiency &, bool in_cone_at_calo_face)
	Correction to be applied using tracking efficiency. More...

void	rebuildJta (const reco::Jet &, const JetTracksAssociations &, TrackRefs &included, TrackRefs &excluded) const
	Rebuild jet-track association. More...

const jpt::Map &	responseMap () const

bool	tracksInCalo (const jpt::MatchedTracks &pions, const jpt::MatchedTracks &muons, const jpt::MatchedTracks &elecs) const
	Determines if any tracks in cone at CaloFace. More...

Protected Attributes
double	dzVertexCut_

const jpt::Map	efficiency_

double	elecMass_

double	electronDRmatch_

edm::InputTag	electronIds_

edm::InputTag	electrons_

int	jetSplitMerge_

edm::InputTag	jetTracksAtCalo_

edm::InputTag	jetTracksAtVertex_

const jpt::Map	leakage_

double	maxEta_

double	muonEtamatch_

double	muonMass_

double	muonPhimatch_

double	muonPtmatch_

edm::InputTag	muons_

jpt::Efficiency	not_used {response_, efficiency_, leakage_}

edm::InputTag	patelectrons_

edm::InputTag	patmuons_

double	pionMass_

double	ptErrorQuality_

const jpt::Map	response_

edm::InputTag	srcPVs_

float	theResponseOfChargedWithEff

float	theResponseOfChargedWithoutEff

float	theSumEnergyWithEff

float	theSumEnergyWithoutEff

float	theSumPtForBeta

float	theSumPtWithEff

float	theSumPtWithoutEff

reco::TrackBase::TrackQuality	trackQuality_

bool	useEff_

bool	useElecs_

bool	useInConeTracks_

bool	useMuons_

bool	useOutOfConeTracks_

bool	useOutOfVertexTracks_

bool	usePAT_

bool	usePions_

bool	useTrackQuality_

bool	vecResponse_

bool	vectorial_

bool	verbose_

reco::Particle::Point	vertex_

Detailed Description

Jet energy correction algorithm using tracks.

Definition at line 171 of file JetPlusTrackCorrector.h.

Member Typedef Documentation

◆ JetTracksAssociations

typedef reco::JetTracksAssociation::Container JetPlusTrackCorrector::JetTracksAssociations

protected

Definition at line 296 of file JetPlusTrackCorrector.h.

◆ P4

typedef math::XYZTLorentzVector JetPlusTrackCorrector::P4

Definition at line 182 of file JetPlusTrackCorrector.h.

◆ PtEtaPhiE

typedef math::PtEtaPhiELorentzVectorD JetPlusTrackCorrector::PtEtaPhiE

Definition at line 183 of file JetPlusTrackCorrector.h.

◆ PtEtaPhiM

typedef math::PtEtaPhiMLorentzVectorD JetPlusTrackCorrector::PtEtaPhiM

Definition at line 184 of file JetPlusTrackCorrector.h.

◆ RecoElectronIds

typedef edm::ValueMap<float> JetPlusTrackCorrector::RecoElectronIds

protected

Definition at line 295 of file JetPlusTrackCorrector.h.

◆ RecoElectrons

typedef reco::GsfElectronCollection JetPlusTrackCorrector::RecoElectrons

protected

Definition at line 294 of file JetPlusTrackCorrector.h.

◆ RecoMuons

typedef reco::MuonCollection JetPlusTrackCorrector::RecoMuons

protected

Get reponses.

Definition at line 293 of file JetPlusTrackCorrector.h.

◆ TrackRefs

typedef reco::TrackRefVector JetPlusTrackCorrector::TrackRefs

protected

Definition at line 297 of file JetPlusTrackCorrector.h.

Constructor & Destructor Documentation

◆ JetPlusTrackCorrector() [1/2]

JetPlusTrackCorrector::JetPlusTrackCorrector	(	const edm::ParameterSet &	iPS,
		edm::ConsumesCollector &&	iC
	)

Constructor.

Definition at line 24 of file JetPlusTrackCorrector.cc.

References electronIds_, electrons_, input_jetTracksAtCalo_token_, input_jetTracksAtVertex_token_, input_pat_elecs_token_, input_pat_muons_token_, input_pvCollection_token_, input_reco_elec_ids_token_, input_reco_elecs_token_, input_reco_muons_token_, jetSplitMerge_, jetTracksAtCalo_, jetTracksAtVertex_, muons_, patelectrons_, patmuons_, muonDTDigis_cfi::pset, srcPVs_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, useEff_, useElecs_, useInConeTracks_, useMuons_, useOutOfConeTracks_, useOutOfVertexTracks_, usePAT_, usePions_, useTrackQuality_, vecResponse_, vectorial_, and verbose_.

     : verbose_(pset.getParameter<bool>("Verbose")),
       usePAT_(pset.getParameter<bool>("UsePAT")),
       vectorial_(pset.getParameter<bool>("VectorialCorrection")),
       vecResponse_(pset.getParameter<bool>("UseResponseInVecCorr")),
       useInConeTracks_(pset.getParameter<bool>("UseInConeTracks")),
       useOutOfConeTracks_(pset.getParameter<bool>("UseOutOfConeTracks")),
       useOutOfVertexTracks_(pset.getParameter<bool>("UseOutOfVertexTracks")),
       usePions_(pset.getParameter<bool>("UsePions")),
       useEff_(pset.getParameter<bool>("UseEfficiency")),
       useMuons_(pset.getParameter<bool>("UseMuons")),
       useElecs_(pset.getParameter<bool>("UseElectrons")),
       useTrackQuality_(pset.getParameter<bool>("UseTrackQuality")),
       jetTracksAtVertex_(pset.getParameter<edm::InputTag>("JetTracksAssociationAtVertex")),
       jetTracksAtCalo_(pset.getParameter<edm::InputTag>("JetTracksAssociationAtCaloFace")),
       jetSplitMerge_(pset.getParameter<int>("JetSplitMerge")),
       srcPVs_(pset.getParameter<edm::InputTag>("srcPVs")),
       ptErrorQuality_(pset.getParameter<double>("PtErrorQuality")),
       dzVertexCut_(pset.getParameter<double>("DzVertexCut")),
       muons_(pset.getParameter<edm::InputTag>("Muons")),
       electrons_(pset.getParameter<edm::InputTag>("Electrons")),
       electronIds_(pset.getParameter<edm::InputTag>("ElectronIds")),
       patmuons_(pset.getParameter<edm::InputTag>("PatMuons")),
       patelectrons_(pset.getParameter<edm::InputTag>("PatElectrons")),
       trackQuality_(reco::TrackBase::qualityByName(pset.getParameter<std::string>("TrackQuality"))),
       response_(Map(pset.getParameter<std::string>("ResponseMap"), verbose_)),
       efficiency_(Map(pset.getParameter<std::string>("EfficiencyMap"), verbose_)),
       leakage_(Map(pset.getParameter<std::string>("LeakageMap"), verbose_)),
       muonPtmatch_(pset.getParameter<double>("muonPtmatch")),
       muonEtamatch_(pset.getParameter<double>("muonEtamatch")),
       muonPhimatch_(pset.getParameter<double>("muonPhimatch")),
       electronDRmatch_(pset.getParameter<double>("electronDRmatch")),
       pionMass_(0.140),
       muonMass_(0.105),
       elecMass_(0.000511),
       maxEta_(pset.getParameter<double>("MaxJetEta")) {
   if (verbose_) {
     std::stringstream ss;
     ss << "[JetPlusTrackCorrector::" << __func__ << "] Configuration for JPT corrector: " << std::endl
        << " Particles" << std::endl
        << "  UsePions             : " << (usePions_ ? "true" : "false") << std::endl
        << "  UseMuons             : " << (useMuons_ ? "true" : "false") << std::endl
        << "  UseElecs             : " << (useElecs_ ? "true" : "false") << std::endl
        << " Corrections" << std::endl
        << "  UseInConeTracks      : " << (useInConeTracks_ ? "true" : "false") << std::endl
        << "  UseOutOfConeTracks   : " << (useOutOfConeTracks_ ? "true" : "false") << std::endl
        << "  UseOutOfVertexTracks : " << (useOutOfVertexTracks_ ? "true" : "false") << std::endl
        << "  ResponseMap          : " << pset.getParameter<std::string>("ResponseMap") << std::endl
        << " Efficiency" << std::endl
        << "  UsePionEfficiency    : " << (useEff_ ? "true" : "false") << std::endl
        << "  EfficiencyMap        : " << pset.getParameter<std::string>("EfficiencyMap") << std::endl
        << "  LeakageMap           : " << pset.getParameter<std::string>("LeakageMap") << std::endl
        << " Tracks" << std::endl
        << "  JetTracksAtVertex    : " << jetTracksAtVertex_ << std::endl
        << "  JetTracksAtCalo      : " << jetTracksAtCalo_ << std::endl
        << "  JetSplitMerge        : " << jetSplitMerge_ << std::endl
        << "  UseTrackQuality      : " << (useTrackQuality_ ? "true" : "false") << std::endl
        << " Collections" << std::endl
        << "  Muons                : " << muons_ << std::endl
        << "  Electrons            : " << electrons_ << std::endl
        << " Vectorial" << std::endl
        << "  UseTracksAndResponse : " << ((vectorial_ && vecResponse_) ? "true" : "false") << std::endl
        << "  UseTracksOnly        : " << ((vectorial_ && !vecResponse_) ? "true" : "false");
     edm::LogInfo("JetPlusTrackCorrector") << ss.str();
   }
 
   if (!useInConeTracks_ || !useOutOfConeTracks_ || !useOutOfVertexTracks_) {
     std::stringstream ss;
     ss << "[JetPlusTrackCorrector::" << __func__ << "]"
        << " You are using JPT algorithm in a non-standard way!" << std::endl
        << " UseInConeTracks      : " << (useInConeTracks_ ? "true" : "false") << std::endl
        << " UseOutOfConeTracks   : " << (useOutOfConeTracks_ ? "true" : "false") << std::endl
        << " UseOutOfVertexTracks : " << (useOutOfVertexTracks_ ? "true" : "false");
     edm::LogWarning("JetPlusTrackCorrector") << ss.str();
   }
 
   input_jetTracksAtVertex_token_ = iC.consumes<reco::JetTracksAssociation::Container>(jetTracksAtVertex_);
   input_jetTracksAtCalo_token_ = iC.consumes<reco::JetTracksAssociation::Container>(jetTracksAtCalo_);
   input_pvCollection_token_ = iC.consumes<reco::VertexCollection>(srcPVs_);
 
   input_reco_muons_token_ = iC.consumes<RecoMuons>(muons_);
   input_reco_elecs_token_ = iC.consumes<RecoElectrons>(electrons_);
   input_reco_elec_ids_token_ = iC.consumes<RecoElectronIds>(electronIds_);
   if (usePAT_) {
     input_pat_muons_token_ = iC.consumes<pat::MuonCollection>(patmuons_);
     input_pat_elecs_token_ = iC.consumes<pat::ElectronCollection>(patelectrons_);
   }
 }

◆ ~JetPlusTrackCorrector()

JetPlusTrackCorrector::~JetPlusTrackCorrector ( )

virtual

Destructor.

Definition at line 115 of file JetPlusTrackCorrector.cc.

115 { ; }

◆ JetPlusTrackCorrector() [2/2]

JetPlusTrackCorrector::JetPlusTrackCorrector ( )

inlineprotected

Default constructor.

Definition at line 392 of file JetPlusTrackCorrector.h.

392 { ; }

Member Function Documentation

◆ calculateCorr()

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::calculateCorr	(	const P4 &	jet,
		const TrackRefs &	tracks,
		jpt::Efficiency &	eff,
		bool	in_cone_at_vertex,
		bool	in_cone_at_calo_face,
		double	mass,
		bool	is_pion,
		double	mip
	)

protected

Generic method to calculates 4-momentum correction to be applied.

Definition at line 879 of file JetPlusTrackCorrector.cc.

References jpt::Efficiency::addE(), correction(), hcalRecHitTable_cff::energy, PVValHelper::eta, jpt::Map::etaBin(), hcalRecHitTable_cff::ieta, SurfaceOrientation::inner, edm::isDebugEnabled(), metsig::jet, LogDebug, EgHLTOffHistBins_cfi::mass, jpt::Map::nEtaBins(), jpt::Map::nPtBins(), SurfaceOrientation::outer, DiDispStaMuonMonitor_cfi::pt, jpt::Map::ptBin(), jpt::Efficiency::reset(), response_, mathSSE::sqrt(), contentValuesCheck::ss, groupFilesInBlocks::temp, theResponseOfChargedWithEff, theResponseOfChargedWithoutEff, theSumEnergyWithEff, theSumEnergyWithoutEff, theSumPtWithEff, theSumPtWithoutEff, DiMuonV_cfg::tracks, jpt::Map::value(), vecResponse_, vectorial_, and verbose_.

Referenced by elecCorrection(), muonCorrection(), and pionCorrection().

                                                                            {
   // Correction to be applied to jet 4-momentum
   P4 correction;
 
   // Reset efficiency container
   eff.reset();
 
   double theSumResp = 0;
   double theSumPt = 0;
   double theSumEnergy = 0;
 
   // Iterate through tracks
   if (!tracks.empty()) {
     TrackRefs::iterator itrk = tracks.begin();
     TrackRefs::iterator jtrk = tracks.end();
 
     for (; itrk != jtrk; ++itrk) {
       // Ignore high-pt tracks (only when in-cone and not a mip)
       if (in_cone_at_calo_face && is_pion && (*itrk)->pt() >= 50.) {
         continue;
       }
 
       // Inner track 4-momentum
       P4 inner;
       if (vectorial_ && vecResponse_) {
         inner = PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), mass);
       } else {
         double energy = sqrt((*itrk)->px() * (*itrk)->px() + (*itrk)->py() * (*itrk)->py() +
                              (*itrk)->pz() * (*itrk)->pz() + mass * mass);
         inner = (jet.energy() > 0. ? energy / jet.energy() : 1.) * jet;
       }
 
       // Add track momentum (if in-cone at vertex)
       if (in_cone_at_vertex) {
         correction += inner;
       }
 
       // Find appropriate eta/pt bin for given track
       double eta = fabs((*itrk)->eta());
       double pt = fabs((*itrk)->pt());
       uint32_t ieta = response_.etaBin(eta);
       uint32_t ipt = response_.ptBin(pt);
 
       // Check bins (not for mips)
       if (is_pion && (ieta == response_.nEtaBins() || ipt == response_.nPtBins())) {
         continue;
       }
 
       // Outer track 4-momentum
       P4 outer;
       if (in_cone_at_calo_face) {
         if (vectorial_ && vecResponse_) {
           // Build 4-momentum from outer track (SHOULD USE IMPACT POINT?!)
           double outer_pt = (*itrk)->pt();
           double outer_eta = (*itrk)->eta();
           double outer_phi = (*itrk)->phi();
           if ((*itrk)->extra().isNonnull()) {
             outer_pt = (*itrk)->pt();
             outer_eta = (*itrk)->outerPosition().eta();  //@@ outerMomentum().eta()
             outer_phi = (*itrk)->outerPosition().phi();  //@@ outerMomentum().phi()
           }
           outer = PtEtaPhiM(outer_pt, outer_eta, outer_phi, mass);
           // Check if mip or not
           if (!is_pion) {
             outer *= (outer.energy() > 0. ? mip / outer.energy() : 1.);
           }  //@@ Scale to mip energy
           else {
             outer *= (outer.energy() > 0. ? inner.energy() / outer.energy() : 1.);
           }  //@@ Scale to inner track energy
         } else {
           // Check if mip or not
           if (!is_pion) {
             outer = (jet.energy() > 0. ? mip / jet.energy() : 1.) * jet;
           }  //@@ Jet 4-mom scaled by mip energy
           else {
             outer = inner;
           }  //@@ Set to inner track 4-momentum
         }
         if (is_pion) {
           outer *= response_.value(ieta, ipt);
         }                     //@@ Scale by pion response
         correction -= outer;  //@@ Subtract
 
         // Calculate the sum of responses
         theSumResp += response_.value(ieta, ipt);
       }
 
       // Calculate the sum of pt and energies
       theSumPt += inner.pt();
       theSumEnergy += inner.energy();
 
       // Record inner track energy for pion efficiency correction
       if (is_pion) {
         eff.addE(ieta, ipt, inner.energy());
       }
 
       // Debug
       if (verbose_ && edm::isDebugEnabled()) {
         std::stringstream temp;
         temp << " Response[" << ieta << "," << ipt << "]";
         std::stringstream ss;
         ss << "[JetPlusTrackCorrector::" << __func__ << "]" << std::endl
            << " Track eta / pt    : " << eta << " / " << pt << std::endl
            << temp.str() << std::setw(21 - temp.str().size()) << " : " << response_.value(ieta, ipt) << std::endl
            << " Track momentum added : " << inner.energy() << std::endl
            << " Response subtracted  : " << outer.energy() << std::endl
            << " Energy correction    : " << correction.energy();
         LogDebug("JetPlusTrackCorrector") << ss.str();
       }
 
     }  // loop through tracks
   }    // ntracks != 0
 
   if (in_cone_at_vertex) {
     theResponseOfChargedWithEff += theSumResp;
     theResponseOfChargedWithoutEff += theSumResp;
     theSumPtWithEff += theSumPt;
     theSumPtWithoutEff += theSumPt;
     theSumEnergyWithEff += theSumEnergy;
     theSumEnergyWithoutEff += theSumEnergy;
   }
   return correction;
 }

◆ canCorrect()

bool JetPlusTrackCorrector::canCorrect ( const reco::Jet & jet ) const

inline

Can jet be JPT-corrected?

Definition at line 486 of file JetPlusTrackCorrector.h.

References metsig::jet, and maxEta_.

Referenced by correction().

486 { return (fabs(jet.eta()) <= maxEta_); }

metsig::jet

Definition: SignAlgoResolutions.h:47

JetPlusTrackCorrector::maxEta_

double maxEta_

Definition: JetPlusTrackCorrector.h:447

◆ checkScale()

double JetPlusTrackCorrector::checkScale	(	const P4 &	jet,
		P4 &	corrected
	)		const

inlineprotected

Check corrected 4-momentum does not give negative scale.

Definition at line 507 of file JetPlusTrackCorrector.h.

References metsig::jet.

Referenced by correction().

                                                                                   {
   if (jet.energy() > 0. && (corrected.energy() / jet.energy()) < 0.) {
     corrected = jet;
   }
   return corrected.energy() / jet.energy();
 }

◆ correctAA()

double JetPlusTrackCorrector::correctAA	(	const reco::Jet &	fJet,
		const reco::TrackRefVector &	trBgOutOfVertex,
		double &	mConeSize,
		const reco::TrackRefVector &	pioninin,
		const reco::TrackRefVector &	pioninout,
		double	ja,
		const reco::TrackRefVector &	trBgOutOfCalo
	)		const

For AA - correct in tracker.

Definition at line 1260 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), efficiency_, edm::RefVector< C, T, F >::empty(), edm::RefVector< C, T, F >::end(), reco::LeafCandidate::energy(), PVValHelper::eta, reco::LeafCandidate::eta(), jpt::Map::etaBin(), hcalRecHitTable_cff::ieta, M_PI, jpt::Map::nEtaBins(), jpt::Map::nPtBins(), DiDispStaMuonMonitor_cfi::pt, jpt::Map::ptBin(), response_, mathSSE::sqrt(), and jpt::Map::value().

                                                                                        {
   double mScale = 1.;
   double NewResponse = fJet.energy();
 
   if (trBgOutOfVertex.empty())
     return mScale;
   double EnergyOfBackgroundCharged = 0.;
   double ResponseOfBackgroundCharged = 0.;
 
   //
   // calculate the mean response
   //
 
   //================= EnergyOfBackgroundCharged ==================>
   for (reco::TrackRefVector::iterator iBgtV = trBgOutOfVertex.begin(); iBgtV != trBgOutOfVertex.end(); iBgtV++) {
     double eta = fabs((**iBgtV).eta());
     double pt = fabs((**iBgtV).pt());
     uint32_t ieta = response_.etaBin(eta);
     uint32_t ipt = response_.ptBin(pt);
 
     if (fabs(fJet.eta() - (**iBgtV).eta()) > mConeSize)
       continue;
 
     double echarBg = sqrt((**iBgtV).px() * (**iBgtV).px() + (**iBgtV).py() * (**iBgtV).py() +
                           (**iBgtV).pz() * (**iBgtV).pz() + 0.14 * 0.14);
 
     EnergyOfBackgroundCharged += echarBg / efficiency_.value(ieta, ipt);
 
   }  // Energy BG tracks
 
   //============= ResponseOfBackgroundCharged =======================>
 
   for (reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) {
     double eta = fabs((**iBgtC).eta());
     double pt = fabs((**iBgtC).pt());
     uint32_t ieta = response_.etaBin(eta);
     uint32_t ipt = response_.ptBin(pt);
 
     if (fabs(fJet.eta() - (**iBgtC).eta()) > mConeSize)
       continue;
 
     // Check bins (not for mips)
     if (ieta >= response_.nEtaBins()) {
       continue;
     }
     if (ipt >= response_.nPtBins()) {
       ipt = response_.nPtBins() - 1;
     }
 
     double echarBg = sqrt((**iBgtC).px() * (**iBgtC).px() + (**iBgtC).py() * (**iBgtC).py() +
                           (**iBgtC).pz() * (**iBgtC).pz() + 0.14 * 0.14);
 
     ResponseOfBackgroundCharged += echarBg * response_.value(ieta, ipt) / efficiency_.value(ieta, ipt);
 
   }  // Response of BG tracks
 
   //=================================================================>
 
   /*
   //=================================================================>
   // Look for in-out tracks
 
   double en = 0.;
   double px = 0.;
   double py = 0.;
   double pz = 0.;
 
   for (reco::TrackRefVector::const_iterator it = pioninout.begin(); it != pioninout.end(); it++) {
     px += (*it)->px();
     py += (*it)->py();
     pz += (*it)->pz();
     en += sqrt((*it)->p() * (*it)->p() + 0.14 * 0.14);
   }
 
   // Look for in-in tracks
 
   double en_in = 0.;
   double px_in = 0.;
   double py_in = 0.;
   double pz_in = 0.;
 
   for (reco::TrackRefVector::const_iterator it = pioninin.begin(); it != pioninin.end(); it++) {
     px_in += (*it)->px();
     py_in += (*it)->py();
     pz_in += (*it)->pz();
     en_in += sqrt((*it)->p() * (*it)->p() + 0.14 * 0.14);
   }
 
   //===================================================================>
 
   //=>
 */
   double SquareEtaRingWithoutJets = ja;
 
   EnergyOfBackgroundCharged = EnergyOfBackgroundCharged / SquareEtaRingWithoutJets;
   ResponseOfBackgroundCharged = ResponseOfBackgroundCharged / SquareEtaRingWithoutJets;
 
   EnergyOfBackgroundCharged = M_PI * mConeSize * mConeSize * EnergyOfBackgroundCharged;
   ResponseOfBackgroundCharged = M_PI * mConeSize * mConeSize * ResponseOfBackgroundCharged;
 
   NewResponse = NewResponse - EnergyOfBackgroundCharged + ResponseOfBackgroundCharged;
 
   mScale = NewResponse / fJet.energy();
   if (mScale < 0.)
     mScale = 0.;
   return mScale;
 }

◆ correction() [1/5]

double JetPlusTrackCorrector::correction	(	const reco::Jet &	fJet,
		const reco::Jet &	fJetcalo,
		const edm::Event &	event,
		const edm::EventSetup &	setup,
		P4 &	corrected,
		jpt::MatchedTracks &	pions,
		jpt::MatchedTracks &	muons,
		jpt::MatchedTracks &	elecs,
		bool &	validMatches
	)

Vectorial correction method (corrected 4-momentum passed by reference)

Definition at line 151 of file JetPlusTrackCorrector.cc.

Referenced by calculateCorr(), correction(), and pionEfficiency().

                                                              {
   theResponseOfChargedWithEff = 0.;
   theResponseOfChargedWithoutEff = 0.;
   theSumPtWithEff = 0.;
   theSumPtWithoutEff = 0.;
   theSumEnergyWithEff = 0.;
   theSumEnergyWithoutEff = 0.;
   theSumPtForBeta = 0.;
 
   // Corrected 4-momentum for jet
   corrected = fJet.p4();
 
   // Match tracks to different particle types
   validMatches = matchTracks(fJetcalo, event, setup, pions, muons, elecs);
   if (!validMatches) {
     return 1.;
   }
 
   // Check if jet can be JPT-corrected
   if (!canCorrect(fJet)) {
     return 1.;
   }
 
   // Debug
   if (verbose_) {
     edm::LogInfo("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                           << " Applying JPT corrections...";
   }
 
   // Pion corrections (both scalar and vectorial)
   if (usePions_) {
     corrected += pionCorrection(fJet.p4(), pions);
   }
 
   // Muon corrections (both scalar and vectorial)
   if (useMuons_) {
     corrected += muonCorrection(fJet.p4(), muons);
   }
 
   // Electrons corrections (both scalar and vectorial)
   if (useElecs_) {
     corrected += elecCorrection(fJet.p4(), elecs);
   }
 
   // Define jet direction using total 3-momentum of tracks (overrides above)
   if (vectorial_ && !vecResponse_) {
     if (fabs(corrected.eta()) < 2.) {
       corrected = jetDirFromTracks(corrected, pions, muons, elecs);
     }
   }
 
   // Check if corrected 4-momentum gives negative scale
   double scale = checkScale(fJet.p4(), corrected);
 
   // Debug
   if (verbose_) {
     std::stringstream ss;
     ss << "Total correction:" << std::endl
        << std::fixed << std::setprecision(6) << " Uncorrected (Px,Py,Pz,E)   : "
        << "(" << fJet.px() << "," << fJet.py() << "," << fJet.pz() << "," << fJet.energy() << ")" << std::endl
        << " Corrected (Px,Py,Pz,E)     : "
        << "(" << corrected.px() << "," << corrected.py() << "," << corrected.pz() << "," << corrected.energy() << ")"
        << std::endl
        << " Uncorrected (Pt,Eta,Phi,M) : "
        << "(" << fJet.pt() << "," << fJet.eta() << "," << fJet.phi() << "," << fJet.mass() << ")" << std::endl
        << " Corrected (Pt,Eta,Phi,M)   : "
        << "(" << corrected.pt() << "," << corrected.eta() << "," << corrected.phi() << "," << corrected.mass() << ")"
        << std::endl
        << " Scalar correction to E     : " << scale << std::endl
        << " Scalar correction to Et    : " << (fJet.et() > 0. ? corrected.Et() / fJet.et() : 1.);  // << std::endl
     edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
   }
 
   // Return energy correction
   return scale;
 }

◆ correction() [2/5]

double JetPlusTrackCorrector::correction	(	const reco::Jet &	fJet,
		const reco::Jet &	fJetcalo,
		const edm::Event &	event,
		const edm::EventSetup &	setup,
		const reco::TrackRefVector &	tracksinvert,
		const reco::TrackRefVector &	tracksincalo,
		P4 &	corrected,
		jpt::MatchedTracks &	pions,
		jpt::MatchedTracks &	muons,
		jpt::MatchedTracks &	elecs
	)

Definition at line 119 of file JetPlusTrackCorrector.cc.

References checkScale(), elecCorrection(), singleTopDQM_cfi::elecs, matchTracks(), muonCorrection(), DiMuonV_cfg::muons, reco::LeafCandidate::p4(), pionCorrection(), l1tEGammaCrystalsEmulatorProducer_cfi::scale, singleTopDQM_cfi::setup, useElecs_, useMuons_, usePAT_, and usePions_.

                                                                {
   double scale = 1.;
   corrected = fJet.p4();
   matchTracks(fJetcalo, event, setup, tracksinvert, tracksincalo, pions, muons, elecs);
   if (!usePAT_) {
     if (usePions_) {
       corrected += pionCorrection(fJet.p4(), pions);
     }
     if (useMuons_) {
       corrected += muonCorrection(fJet.p4(), muons);
     }
     if (useElecs_) {
       corrected += elecCorrection(fJet.p4(), elecs);
     }
   } else {
     corrected += fJetcalo.p4();
   }
   scale = checkScale(fJet.p4(), corrected);
   return scale;
 }

◆ correction() [3/5]

double JetPlusTrackCorrector::correction	(	const reco::Jet &	fJet,
		const reco::Jet &	fJetcalo,
		const edm::Event &	event,
		const edm::EventSetup &	setup,
		jpt::MatchedTracks &	pions,
		jpt::MatchedTracks &	muons,
		jpt::MatchedTracks &	elecs,
		bool &	validMatches
	)

inline

Scalar correction method.

Definition at line 472 of file JetPlusTrackCorrector.h.

References correction(), singleTopDQM_cfi::elecs, DiMuonV_cfg::muons, and singleTopDQM_cfi::setup.

                                                                     {
   P4 not_used_for_scalar_correction;
   return correction(fJet, fJetcalo, event, setup, not_used_for_scalar_correction, pions, muons, elecs, validMatches);
 }

◆ correction() [4/5]

double JetPlusTrackCorrector::correction ( const reco::Jet & jet ) const

Correction method (not used)

Definition at line 238 of file JetPlusTrackCorrector.cc.

                                                                  {
   edm::LogError("JetPlusTrackCorrector") << "JetPlusTrackCorrector can be run on entire event only";
   return 1.;
 }

◆ correction() [5/5]

double JetPlusTrackCorrector::correction ( const P4 & jet ) const

Correction method (not used)

Definition at line 245 of file JetPlusTrackCorrector.cc.

                                                                                    {
   edm::LogError("JetPlusTrackCorrector") << "JetPlusTrackCorrector can be run on entire event only";
   return 1.;
 }

◆ efficiencyMap()

const jpt::Map & JetPlusTrackCorrector::efficiencyMap ( ) const

inlineprotected

Definition at line 515 of file JetPlusTrackCorrector.h.

References efficiency_.

Referenced by pionCorrection().

515 { return efficiency_; }

JetPlusTrackCorrector::efficiency_

const jpt::Map efficiency_

Definition: JetPlusTrackCorrector.h:432

◆ elecCorrection() [1/2]

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection	(	const P4 &	jet,
		const jpt::MatchedTracks &	elecs
	)		const

Calculates correction to be applied using electrons.

Definition at line 776 of file JetPlusTrackCorrector.cc.

References singleTopDQM_cfi::elecs, contentValuesCheck::ss, and verbose_.

Referenced by correction().

                                                                                                              {
   P4 null;  //@@ null 4-momentum
 
   if (verbose_) {
     std::stringstream ss;
     ss << " Electron corrections:" << std::endl
        << "  In/In      : "
        << "(" << elecs.inVertexInCalo_.size() << ") " << null.energy() << std::endl
        << "  In/Out     : "
        << "(" << elecs.inVertexOutOfCalo_.size() << ") " << null.energy() << std::endl
        << "  Out/In     : "
        << "(" << elecs.outOfVertexInCalo_.size() << ") " << null.energy();
     edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
   }
 
   return null;  //@@ to be implemented
 }

◆ elecCorrection() [2/2]

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::elecCorrection	(	const P4 &	jet,
		const TrackRefs &	elecs,
		bool	in_cone_at_vertex,
		bool	in_cone_at_calo_face
	)

inlineprotected

Calculates individual electron corrections.

Definition at line 500 of file JetPlusTrackCorrector.h.

References calculateCorr(), elecMass_, singleTopDQM_cfi::elecs, metsig::jet, and not_used.

                                                                                                   {
   return calculateCorr(jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0.);
 }

◆ eventRequired()

bool JetPlusTrackCorrector::eventRequired ( ) const

inline

Returns true.

Definition at line 484 of file JetPlusTrackCorrector.h.

484 { return true; }

◆ excludeJta()

void JetPlusTrackCorrector::excludeJta	(	const reco::Jet &	fJet,
		const JetTracksAssociations &	jtV0,
		TrackRefs &	included,
		const TrackRefs &	excluded
	)		const

protected

Exclude jet-track association.

Definition at line 1235 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::clear(), edm::RefVector< C, T, F >::empty(), edm::RefVector< C, T, F >::end(), spr::find(), reco::JetTracksAssociation::getValue(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, jetSplitMerge_, edm::RefVector< C, T, F >::push_back(), and DiMuonV_cfg::tracks.

Referenced by jtaUsingEventData().

                                                                     {
   tracksthis = reco::JetTracksAssociation::getValue(jtV0, fJet);
   if (Excl.empty())
     return;
   if (jetSplitMerge_ < 0)
     return;
 
   TrackRefs tracks = tracksthis;
   tracksthis.clear();
 
   for (TrackRefs::iterator it = tracks.begin(); it != tracks.end(); it++) {
     TrackRefs::iterator itold = find(Excl.begin(), Excl.end(), (*it));
     if (itold == Excl.end()) {
       tracksthis.push_back(*it);
     }
   }
 
   return;
 }

◆ failTrackQuality()

bool JetPlusTrackCorrector::failTrackQuality ( TrackRefs::const_iterator & itrk ) const

protected

Check on track quality.

Definition at line 608 of file JetPlusTrackCorrector.cc.

References dzVertexCut_, ptErrorQuality_, trackQuality_, useTrackQuality_, and vertex_.

Referenced by matchTracks().

                                                                                 {
   bool retcode = false;
 
   if (useTrackQuality_ && !(*itrk)->quality(trackQuality_)) {
     retcode = true;
     return retcode;
   }
   if (((*itrk)->ptError() / (*itrk)->pt()) > ptErrorQuality_) {
     retcode = true;
     return retcode;
   }
   if (fabs((*itrk)->dz(vertex_)) > dzVertexCut_) {
     retcode = true;
     return retcode;
   }
 
   return retcode;
 }

◆ findTrack() [1/2]

bool JetPlusTrackCorrector::findTrack	(	const jpt::JetTracks &	jet_tracks,
		TrackRefs::const_iterator &	itrk,
		TrackRefs::iterator &	it
	)		const

protected

Find track in JetTracks collection.

Definition at line 629 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), jpt::JetTracks::caloFace_, edm::RefVector< C, T, F >::end(), spr::find(), and ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it.

Referenced by matchTracks().

                                                                    {
   it = find(jet_tracks.caloFace_.begin(), jet_tracks.caloFace_.end(), *itrk);
   if (it != jet_tracks.caloFace_.end()) {
     return true;
   } else {
     return false;
   }
 }

◆ findTrack() [2/2]

bool JetPlusTrackCorrector::findTrack	(	const jpt::MatchedTracks &	pions,
		const jpt::MatchedTracks &	muons,
		const jpt::MatchedTracks &	electrons,
		TrackRefs::const_iterator &	itrk
	)		const

protected

Find track in MatchedTracks collections.

Definition at line 642 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), singleTopDQM_cfi::elecs, edm::RefVector< C, T, F >::end(), spr::find(), jpt::MatchedTracks::inVertexInCalo_, and DiMuonV_cfg::muons.

                                                                            {
   TrackRefs::iterator ip = find(pions.inVertexInCalo_.begin(), pions.inVertexInCalo_.end(), *itrk);
   TrackRefs::iterator im = find(muons.inVertexInCalo_.begin(), muons.inVertexInCalo_.end(), *itrk);
   TrackRefs::iterator ie = find(elecs.inVertexInCalo_.begin(), elecs.inVertexInCalo_.end(), *itrk);
   if (ip == pions.inVertexInCalo_.end() && im == muons.inVertexInCalo_.end() && ie == elecs.inVertexInCalo_.end()) {
     return false;
   } else {
     return true;
   }
 }

◆ getElectrons() [1/2]

bool JetPlusTrackCorrector::getElectrons	(	const edm::Event &	event,
		edm::Handle< RecoElectrons > &	reco_elecs,
		edm::Handle< RecoElectronIds > &	reco_elec_ids
	)		const

protected

Get RECO electrons.

Definition at line 592 of file JetPlusTrackCorrector.cc.

References input_reco_elec_ids_token_, and input_reco_elecs_token_.

Referenced by matchTracks().

                                                                                           {
   event.getByToken(input_reco_elecs_token_, reco_elecs);
   event.getByToken(input_reco_elec_ids_token_, reco_elec_ids);
   return true;
 }

◆ getElectrons() [2/2]

bool JetPlusTrackCorrector::getElectrons	(	const edm::Event &	event,
		edm::Handle< pat::ElectronCollection > &	pat_elecs
	)		const

protected

Definition at line 600 of file JetPlusTrackCorrector.cc.

References input_pat_elecs_token_.

                                                                                             {
   event.getByToken(input_pat_elecs_token_, pat_elecs);
   return true;
 }

◆ getMuons() [1/2]

bool JetPlusTrackCorrector::getMuons	(	const edm::Event &	event,
		edm::Handle< RecoMuons > &	reco_muons
	)		const

protected

Get RECO muons.

Definition at line 385 of file JetPlusTrackCorrector.cc.

References input_reco_muons_token_.

Referenced by matchTracks().

                                                                                                   {
   event.getByToken(input_reco_muons_token_, reco_muons);
   return true;
 }

◆ getMuons() [2/2]

bool JetPlusTrackCorrector::getMuons	(	const edm::Event &	,
		edm::Handle< pat::MuonCollection > &
	)		const

protected

◆ getResponseOfChargedWithEff()

double JetPlusTrackCorrector::getResponseOfChargedWithEff ( )

inline

Get responses/sumPT/SumEnergy with and without Efficiency correction.

Definition at line 244 of file JetPlusTrackCorrector.h.

References theResponseOfChargedWithEff.

244 { return theResponseOfChargedWithEff; }

JetPlusTrackCorrector::theResponseOfChargedWithEff

float theResponseOfChargedWithEff

Definition: JetPlusTrackCorrector.h:448

◆ getResponseOfChargedWithoutEff()

double JetPlusTrackCorrector::getResponseOfChargedWithoutEff ( )

inline

Definition at line 245 of file JetPlusTrackCorrector.h.

References theResponseOfChargedWithoutEff.

245 { return theResponseOfChargedWithoutEff; }

JetPlusTrackCorrector::theResponseOfChargedWithoutEff

float theResponseOfChargedWithoutEff

Definition: JetPlusTrackCorrector.h:449

◆ getSumEnergyWithEff()

double JetPlusTrackCorrector::getSumEnergyWithEff ( )

inline

Definition at line 248 of file JetPlusTrackCorrector.h.

References theSumEnergyWithEff.

248 { return theSumEnergyWithEff; }

JetPlusTrackCorrector::theSumEnergyWithEff

float theSumEnergyWithEff

Definition: JetPlusTrackCorrector.h:452

◆ getSumEnergyWithoutEff()

double JetPlusTrackCorrector::getSumEnergyWithoutEff ( )

inline

Definition at line 249 of file JetPlusTrackCorrector.h.

References theSumEnergyWithoutEff.

249 { return theSumEnergyWithoutEff; }

JetPlusTrackCorrector::theSumEnergyWithoutEff

float theSumEnergyWithoutEff

Definition: JetPlusTrackCorrector.h:453

◆ getSumPtForBeta()

double JetPlusTrackCorrector::getSumPtForBeta ( )

inline

Definition at line 250 of file JetPlusTrackCorrector.h.

References theSumPtForBeta.

250 { return theSumPtForBeta; }

JetPlusTrackCorrector::theSumPtForBeta

float theSumPtForBeta

Definition: JetPlusTrackCorrector.h:454

◆ getSumPtWithEff()

double JetPlusTrackCorrector::getSumPtWithEff ( )

inline

Definition at line 246 of file JetPlusTrackCorrector.h.

References theSumPtWithEff.

246 { return theSumPtWithEff; }

JetPlusTrackCorrector::theSumPtWithEff

float theSumPtWithEff

Definition: JetPlusTrackCorrector.h:450

◆ getSumPtWithoutEff()

double JetPlusTrackCorrector::getSumPtWithoutEff ( )

inline

Definition at line 247 of file JetPlusTrackCorrector.h.

References theSumPtWithoutEff.

247 { return theSumPtWithoutEff; }

JetPlusTrackCorrector::theSumPtWithoutEff

float theSumPtWithoutEff

Definition: JetPlusTrackCorrector.h:451

◆ jetDirFromTracks()

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::jetDirFromTracks	(	const P4 &	jet,
		const jpt::MatchedTracks &	pions,
		const jpt::MatchedTracks &	muons,
		const jpt::MatchedTracks &	elecs
	)		const

protected

Calculates vectorial correction using total track 3-momentum.

Definition at line 796 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), alignCSCRings::corr, singleTopDQM_cfi::elecs, edm::RefVector< C, T, F >::empty(), edm::RefVector< C, T, F >::end(), jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, and DiMuonV_cfg::muons.

Referenced by correction().

                                                                                                     {
   // Correction to be applied to jet 4-momentum
   P4 corr;
 
   //  bool tracks_present = false;
   bool tracks_present_inin = false;
 
   // Correct using pions in-cone at vertex
 
   if (!pions.inVertexInCalo_.empty()) {
     TrackRefs::iterator itrk = pions.inVertexInCalo_.begin();
     TrackRefs::iterator jtrk = pions.inVertexInCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
       tracks_present_inin = true;
     }
   }
 
   if (!pions.inVertexOutOfCalo_.empty()) {
     TrackRefs::iterator itrk = pions.inVertexOutOfCalo_.begin();
     TrackRefs::iterator jtrk = pions.inVertexOutOfCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
     }
   }
 
   // Correct using muons in-cone at vertex
 
   if (!muons.inVertexInCalo_.empty()) {
     TrackRefs::iterator itrk = muons.inVertexInCalo_.begin();
     TrackRefs::iterator jtrk = muons.inVertexInCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
       //      tracks_present = true;
     }
   }
 
   if (!muons.inVertexOutOfCalo_.empty()) {
     TrackRefs::iterator itrk = muons.inVertexOutOfCalo_.begin();
     TrackRefs::iterator jtrk = muons.inVertexOutOfCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
       //      tracks_present = true;
     }
   }
 
   // Correct using electrons in-cone at vertex
 
   if (!elecs.inVertexInCalo_.empty()) {
     TrackRefs::iterator itrk = elecs.inVertexInCalo_.begin();
     TrackRefs::iterator jtrk = elecs.inVertexInCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
       //      tracks_present = true;
     }
   }
 
   if (!elecs.inVertexOutOfCalo_.empty()) {
     TrackRefs::iterator itrk = elecs.inVertexOutOfCalo_.begin();
     TrackRefs::iterator jtrk = elecs.inVertexOutOfCalo_.end();
     for (; itrk != jtrk; ++itrk) {
       corr += PtEtaPhiM((*itrk)->pt(), (*itrk)->eta(), (*itrk)->phi(), 0.);
       //      tracks_present = true;
     }
   }
 
   // Adjust direction if in cone tracks are present
 
   if (!tracks_present_inin) {
     corr = corrected;
   } else {
     corr *= (corr.P() > 0. ? corrected.P() / corr.P() : 1.);
     corr = P4(corr.px(), corr.py(), corr.pz(), corrected.energy());
   }
 
   return corr;
 }

◆ jetTrackAssociation()

bool JetPlusTrackCorrector::jetTrackAssociation	(	const reco::Jet &	fJet,
		const edm::Event &	event,
		const edm::EventSetup &	setup,
		jpt::JetTracks &	trks
	)		const

protectedvirtual

Associates tracks to jets (overriden in derived class)

Definition at line 299 of file JetPlusTrackCorrector.cc.

References edm::InputTag::instance(), jetTracksAtCalo_, jetTracksAtVertex_, jtaUsingEventData(), edm::InputTag::label(), edm::InputTag::process(), and hltEgammaHLTExtra_cfi::trks.

Referenced by matchTracks().

                                                                        {
   // Some init
   trks.clear();
 
   // Check if labels are given
   if (!jetTracksAtVertex_.label().empty() && !jetTracksAtCalo_.label().empty()) {
     return jtaUsingEventData(fJet, event, trks);
   } else {
     edm::LogWarning("PatJPTCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                        << " Empty label for the reco::JetTracksAssociation::Containers" << std::endl
                                        << " InputTag for JTA \"at vertex\"    (label:instance:process) \""
                                        << jetTracksAtVertex_.label() << ":" << jetTracksAtVertex_.instance() << ":"
                                        << jetTracksAtVertex_.process() << "\"" << std::endl
                                        << " InputTag for JTA \"at calo face\" (label:instance:process) \""
                                        << jetTracksAtCalo_.label() << ":" << jetTracksAtCalo_.instance() << ":"
                                        << jetTracksAtCalo_.process() << "\"";
     return false;
   }
 }

◆ jtaUsingEventData()

bool JetPlusTrackCorrector::jtaUsingEventData	(	const reco::Jet &	fJet,
		const edm::Event &	event,
		jpt::JetTracks &	trks
	)		const

protected

JTA using collections from event.

Definition at line 324 of file JetPlusTrackCorrector.cc.

References excludeJta(), edm::HandleBase::failedToGet(), reco::JetTracksAssociation::getValue(), input_jetTracksAtCalo_token_, input_jetTracksAtVertex_token_, edm::InputTag::instance(), edm::isDebugEnabled(), edm::HandleBase::isValid(), jetSplitMerge_, jetTracksAtCalo_, jetTracksAtVertex_, edm::InputTag::label(), edm::InputTag::process(), edm::Handle< T >::product(), rebuildJta(), hltEgammaHLTExtra_cfi::trks, and verbose_.

Referenced by jetTrackAssociation().

                                                                                                                {
   // Get Jet-track association at Vertex
   edm::Handle<reco::JetTracksAssociation::Container> jetTracksAtVertex;
   event.getByToken(input_jetTracksAtVertex_token_, jetTracksAtVertex);
 
   if (!jetTracksAtVertex.isValid() || jetTracksAtVertex.failedToGet()) {
     if (verbose_ && edm::isDebugEnabled()) {
       edm::LogWarning("JetPlusTrackCorrector")
           << "[JetPlusTrackCorrector::" << __func__ << "]"
           << " Invalid handle to reco::JetTracksAssociation::Container (for Vertex)"
           << " with InputTag (label:instance:process) \"" << jetTracksAtVertex_.label() << ":"
           << jetTracksAtVertex_.instance() << ":" << jetTracksAtVertex_.process() << "\"";
     }
     return false;
   }
 
   // Retrieve jet-tracks association for given jet
   const reco::JetTracksAssociation::Container jtV = *(jetTracksAtVertex.product());
   TrackRefs excluded;
   TrackRefs relocate;
   if (jetSplitMerge_ < 0) {
     trks.vertex_ = reco::JetTracksAssociation::getValue(jtV, fJet);
   } else {
     rebuildJta(fJet, jtV, trks.vertex_, excluded);
     rebuildJta(fJet, jtV, relocate, excluded);
     trks.vertex_ = relocate;
   }
 
   // Check if any tracks are associated to jet at vertex
   if (trks.vertex_.empty()) {
     return false;
   }
 
   // Get Jet-track association at Calo
   edm::Handle<reco::JetTracksAssociation::Container> jetTracksAtCalo;
   event.getByToken(input_jetTracksAtCalo_token_, jetTracksAtCalo);
 
   if (!jetTracksAtCalo.isValid() || jetTracksAtCalo.failedToGet()) {
     if (verbose_ && edm::isDebugEnabled()) {
       edm::LogWarning("JetPlusTrackCorrector")
           << "[JetPlusTrackCorrector::" << __func__ << "]"
           << " Invalid handle to reco::JetTracksAssociation::Container (for CaloFace)"
           << " with InputTag (label:instance:process) \"" << jetTracksAtCalo_.label() << ":"
           << jetTracksAtCalo_.instance() << ":" << jetTracksAtCalo_.process() << "\"";
     }
     return false;
   }
 
   // Retrieve jet-tracks association for given jet
   const reco::JetTracksAssociation::Container jtC = *(jetTracksAtCalo.product());
   if (jetSplitMerge_ < 0) {
     trks.caloFace_ = reco::JetTracksAssociation::getValue(jtC, fJet);
   } else {
     excludeJta(fJet, jtC, trks.caloFace_, excluded);
   }
 
   return true;
 }

◆ leakageMap()

const jpt::Map & JetPlusTrackCorrector::leakageMap ( ) const

inlineprotected

Definition at line 516 of file JetPlusTrackCorrector.h.

References leakage_.

Referenced by pionCorrection().

516 { return leakage_; }

JetPlusTrackCorrector::leakage_

const jpt::Map leakage_

Definition: JetPlusTrackCorrector.h:433

◆ matchElectrons() [1/2]

bool JetPlusTrackCorrector::matchElectrons	(	TrackRefs::const_iterator &	itrk,
		const edm::Handle< RecoElectrons > &	elecs,
		const edm::Handle< RecoElectronIds > &	elec_ids
	)		const

protected

Matches tracks to RECO electrons.

Definition at line 1126 of file JetPlusTrackCorrector.cc.

References HLTMuonOfflineAnalyzer_cfi::deltaR2, ALPAKA_ACCELERATOR_NAMESPACE::dR2(), MillePedeFileConverter_cfg::e, singleTopDQM_cfi::elecs, and electronDRmatch_.

Referenced by matchTracks().

                                                                                              {
   if (elecs->empty()) {
     return false;
   }
 
   double deltaRMIN = 999.;
 
   uint32_t electron_index = 0;
   for (auto const& ielec : *elecs) {
     edm::Ref<RecoElectrons> electron_ref(elecs, electron_index);
     electron_index++;
 
     if ((*elec_ids)[electron_ref] < 1.e-6) {
       continue;
     }  //@@ Check for null value
 
     // DR matching b/w electron and track
     auto dR2 = deltaR2(ielec, **itrk);
     if (dR2 < deltaRMIN) {
       deltaRMIN = dR2;
     }
   }
   return deltaRMIN < electronDRmatch_ * electronDRmatch_;
 }

◆ matchElectrons() [2/2]

bool JetPlusTrackCorrector::matchElectrons	(	TrackRefs::const_iterator &	itrk,
		const edm::Handle< pat::ElectronCollection > &	elecs
	)		const

protected

Definition at line 1153 of file JetPlusTrackCorrector.cc.

References HLTMuonOfflineAnalyzer_cfi::deltaR2, ALPAKA_ACCELERATOR_NAMESPACE::dR2(), singleTopDQM_cfi::elecs, and electronDRmatch_.

                                                                                                 {
   if (elecs->empty()) {
     return false;
   }
 
   double deltaRMIN = 999.;
   for (auto const& ielec : *elecs) {
     auto dR2 = deltaR2(ielec, **itrk);
     if (dR2 < deltaRMIN) {
       deltaRMIN = dR2;
     }
   }
   return deltaRMIN < electronDRmatch_ * electronDRmatch_;
 }

◆ matchMuons() [1/2]

bool JetPlusTrackCorrector::matchMuons	(	TrackRefs::const_iterator &	itrk,
		const edm::Handle< RecoMuons > &	muons
	)		const

protected

Matches tracks to RECO muons.

Definition at line 1076 of file JetPlusTrackCorrector.cc.

References edm::Ref< C, T, F >::id(), muon::isGoodMuon(), DiMuonV_cfg::muons, and muon::TMLastStationTight.

Referenced by matchTracks().

                                                                                                              {
   if (muons->empty()) {
     return false;
   }
 
   RecoMuons::const_iterator imuon = muons->begin();
   RecoMuons::const_iterator jmuon = muons->end();
   for (; imuon != jmuon; ++imuon) {
     if (imuon->innerTrack().isNull() || !muon::isGoodMuon(*imuon, muon::TMLastStationTight) ||
         imuon->innerTrack()->pt() < 3.0) {
       continue;
     }
 
     if (itrk->id() != imuon->innerTrack().id()) {
       edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                              << "Product id of the tracks associated to the jet " << itrk->id()
                                              << " is different from the product id of the inner track used for muons "
                                              << imuon->innerTrack().id() << "!" << std::endl
                                              << "Cannot compare tracks from different collection. Configuration Error!";
       return false;
     }
 
     if (*itrk == imuon->innerTrack())
       return true;
   }
 
   return false;
 }

◆ matchMuons() [2/2]

bool JetPlusTrackCorrector::matchMuons	(	TrackRefs::const_iterator &	,
		const edm::Handle< pat::MuonCollection > &
	)		const

protected

◆ matchTracks() [1/3]

bool JetPlusTrackCorrector::matchTracks	(	const reco::Jet &	fJet,
		const edm::Event &	event,
		const edm::EventSetup &	setup,
		jpt::MatchedTracks &	pions,
		jpt::MatchedTracks &	muons,
		jpt::MatchedTracks &	elecs
	)

Matches tracks to different particle types.

Definition at line 268 of file JetPlusTrackCorrector.cc.

References jpt::JetTracks::caloFace_, singleTopDQM_cfi::elecs, jetTrackAssociation(), DiMuonV_cfg::muons, convertSQLiteXML::ok, singleTopDQM_cfi::setup, edm::RefVector< C, T, F >::size(), contentValuesCheck::ss, verbose_, and jpt::JetTracks::vertex_.

Referenced by correction().

                                                                  {
   // Associate tracks to jet at both the Vertex and CaloFace
   JetTracks jet_tracks;
   bool ok = jetTrackAssociation(fJet, event, setup, jet_tracks);
 
   if (!ok) {
     return false;
   }
 
   // Track collections propagated to Vertex and CaloFace for "pions", muons and electrons
   matchTracks(jet_tracks, event, pions, muons, elecs);
 
   // Debug
   if (verbose_) {
     std::stringstream ss;
     ss << "Number of tracks:" << std::endl
        << " In-cone at Vertex   : " << jet_tracks.vertex_.size() << std::endl
        << " In-cone at CaloFace : " << jet_tracks.caloFace_.size();
     edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
   }
 
   return true;
 }

◆ matchTracks() [2/3]

void JetPlusTrackCorrector::matchTracks	(	const reco::Jet &	fJet,
		const edm::Event &	event,
		const edm::EventSetup &	setup,
		const reco::TrackRefVector &	tracksinvert,
		const reco::TrackRefVector &	tracksincalo,
		jpt::MatchedTracks &	pions,
		jpt::MatchedTracks &	muons,
		jpt::MatchedTracks &	elecs
	)

Definition at line 252 of file JetPlusTrackCorrector.cc.

References jpt::JetTracks::caloFace_, singleTopDQM_cfi::elecs, matchTracks(), DiMuonV_cfg::muons, and jpt::JetTracks::vertex_.

Referenced by matchTracks().

                                                                  {
   JetTracks jet_tracks;
   jet_tracks.vertex_ = tracksinvert;
   jet_tracks.caloFace_ = tracksincalo;
   matchTracks(jet_tracks, event, pions, muons, elecs);
 
   return;
 }

◆ matchTracks() [3/3]

void JetPlusTrackCorrector::matchTracks	(	const jpt::JetTracks &	jet_tracks,
		const edm::Event &	event,
		jpt::MatchedTracks &	pions,
		jpt::MatchedTracks &	muons,
		jpt::MatchedTracks &	elecs
	)

protectedvirtual

Matches tracks to different particle types (overriden in derived class)

Definition at line 397 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), jpt::JetTracks::caloFace_, jpt::MatchedTracks::clear(), singleTopDQM_cfi::elecs, edm::RefVector< C, T, F >::end(), failTrackQuality(), spr::find(), findTrack(), newFWLiteAna::found, getElectrons(), getMuons(), input_pvCollection_token_, jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, edm::isDebugEnabled(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::iv, LogTrace, matchElectrons(), matchMuons(), DiMuonV_cfg::muons, jpt::MatchedTracks::outOfVertexInCalo_, edm::RefVector< C, T, F >::push_back(), heavyFlavorDQMFirstStep_cff::pvCollection, findQualityFiles::rr, edm::RefVector< C, T, F >::size(), contentValuesCheck::ss, theSumPtForBeta, trackQuality_, tracksInCalo(), useElecs_, useMuons_, usePAT_, useTrackQuality_, verbose_, jpt::JetTracks::vertex_, and vertex_.

                                                               {
   // Some init
   pions.clear();
   muons.clear();
   elecs.clear();
 
   // Need vertex for track cleaning
 
   vertex_ = reco::Particle::Point(0, 0, 0);
   edm::Handle<reco::VertexCollection> pvCollection;
   event.getByToken(input_pvCollection_token_, pvCollection);
   if (pvCollection.isValid() && !pvCollection->empty())
     vertex_ = pvCollection->begin()->position();
 
   // Get RECO muons
   edm::Handle<RecoMuons> reco_muons;
   edm::Handle<pat::MuonCollection> pat_muons;
   bool found_reco_muons = true;
   bool found_pat_muons = true;
   if (useMuons_) {
     if (!usePAT_) {
       getMuons(event, reco_muons);
     } else {
       getMuons(event, pat_muons);
       found_reco_muons = false;
     }
   }
 
   // Get RECO electrons and their ids
   edm::Handle<RecoElectrons> reco_elecs;
   edm::Handle<pat::ElectronCollection> pat_elecs;
   edm::Handle<RecoElectronIds> reco_elec_ids;
   bool found_reco_elecs = true;
   bool found_pat_elecs = true;
   if (useElecs_) {
     if (!usePAT_) {
       getElectrons(event, reco_elecs, reco_elec_ids);
     } else {
       getElectrons(event, pat_elecs);
       found_reco_elecs = false;
     }
   }
 
   // Check RECO products found
   if (!found_reco_muons || !found_reco_elecs) {
     if (!found_pat_muons || !found_pat_elecs) {
       edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                              << " Unable to access RECO collections for muons and electrons";
       return;
     }
   }
 
   // Identify pions/muons/electrons that are "in/in" and "in/out"
   {
     TrackRefs::const_iterator itrk = jet_tracks.vertex_.begin();
     TrackRefs::const_iterator jtrk = jet_tracks.vertex_.end();
 
     double theSumPtForBetaOld = theSumPtForBeta;
 
     for (; itrk != jtrk; ++itrk) {
       if (useTrackQuality_ && (*itrk)->quality(trackQuality_) && theSumPtForBetaOld <= 0.)
         theSumPtForBeta += (**itrk).pt();
       //
       // Track either belongs to PV or do not belong to any vertex
 
       const reco::TrackBaseRef ttr1(*itrk);
 
       int numpv = 0;
 
       int itrack_belong = -1;
 
       for (reco::VertexCollection::const_iterator iv = pvCollection->begin(); iv != pvCollection->end(); iv++) {
         numpv++;
         std::vector<reco::TrackBaseRef>::const_iterator rr = find((*iv).tracks_begin(), (*iv).tracks_end(), ttr1);
         if (rr != (*iv).tracks_end()) {
           itrack_belong++;
           break;
         }
 
       }  // all vertices
 
       if (numpv > 1 && itrack_belong == 0) {
         continue;
       }
 
       if (failTrackQuality(itrk)) {
         continue;
       }
 
       TrackRefs::iterator it = jet_tracks.caloFace_.end();
       bool found = findTrack(jet_tracks, itrk, it);
       bool muaccept = false;
       bool eleaccept = false;
       if (found_reco_muons)
         muaccept = matchMuons(itrk, reco_muons);
       else if (found_pat_muons) {
         muaccept = matchMuons(itrk, pat_muons);
       }
       if (found_reco_elecs)
         eleaccept = matchElectrons(itrk, reco_elecs, reco_elec_ids);
       else if (found_pat_elecs) {
         eleaccept = matchElectrons(itrk, pat_elecs);
       }
 
       bool is_muon = useMuons_ && muaccept;
       bool is_ele = useElecs_ && eleaccept;
 
       if (found) {
         if (is_muon) {
           muons.inVertexInCalo_.push_back(*it);
         } else if (is_ele) {
           elecs.inVertexInCalo_.push_back(*it);
         } else {
           pions.inVertexInCalo_.push_back(*it);
         }
       } else {
         if (is_muon) {
           muons.inVertexOutOfCalo_.push_back(*itrk);
         } else if (is_ele) {
           elecs.inVertexOutOfCalo_.push_back(*itrk);
         } else {
           pions.inVertexOutOfCalo_.push_back(*itrk);
         }
       }
     }
   }
 
   // Identify pions/muons/electrons that are "out/in"
   {
     TrackRefs::iterator itrk = jet_tracks.caloFace_.begin();
     TrackRefs::iterator jtrk = jet_tracks.caloFace_.end();
     for (; itrk != jtrk; ++itrk) {
       if (failTrackQuality(itrk)) {
         continue;
       }
 
       if (!tracksInCalo(pions, muons, elecs)) {
         continue;
       }
 
       bool found = findTrack(pions, muons, elecs, itrk);
 
       if (!found) {
         bool muaccept = false;
         bool eleaccept = false;
         if (found_reco_muons)
           muaccept = matchMuons(itrk, reco_muons);
         else if (found_pat_muons) {
           muaccept = matchMuons(itrk, pat_muons);
         }
         if (found_reco_elecs)
           eleaccept = matchElectrons(itrk, reco_elecs, reco_elec_ids);
         else if (found_pat_elecs) {
           eleaccept = matchElectrons(itrk, pat_elecs);
         }
 
         bool is_muon = useMuons_ && muaccept;
         bool is_ele = useElecs_ && eleaccept;
 
         if (is_muon) {
           muons.outOfVertexInCalo_.push_back(*itrk);
         } else if (is_ele) {
           elecs.outOfVertexInCalo_.push_back(*itrk);
         } else {
           pions.outOfVertexInCalo_.push_back(*itrk);
         }
       }
     }
   }
 
   if (verbose_ && edm::isDebugEnabled()) {
     std::stringstream ss;
     ss << "[JetPlusTrackCorrector::" << __func__ << "] Number of tracks:" << std::endl
        << " In-cone at Vertex and in-cone at CaloFace:" << std::endl
        << "  Pions      : " << pions.inVertexInCalo_.size() << std::endl
        << "  Muons      : " << muons.inVertexInCalo_.size() << std::endl
        << "  Electrons  : " << elecs.inVertexInCalo_.size() << std::endl
        << " In-cone at Vertex and out-of-cone at CaloFace:" << std::endl
        << "  Pions      : " << pions.inVertexOutOfCalo_.size() << std::endl
        << "  Muons      : " << muons.inVertexOutOfCalo_.size() << std::endl
        << "  Electrons  : " << elecs.inVertexOutOfCalo_.size() << std::endl
        << " Out-of-cone at Vertex and in-cone at CaloFace:" << std::endl
        << "  Pions      : " << pions.outOfVertexInCalo_.size() << std::endl
        << "  Muons      : " << muons.outOfVertexInCalo_.size() << std::endl
        << "  Electrons  : " << elecs.outOfVertexInCalo_.size() << std::endl;
     LogTrace("JetPlusTrackCorrector") << ss.str();
   }
 }

◆ muonCorrection() [1/2]

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection	(	const P4 &	jet,
		const jpt::MatchedTracks &	muons
	)

Calculates correction to be applied using muons.

Definition at line 737 of file JetPlusTrackCorrector.cc.

References metsig::jet, DiMuonV_cfg::muons, contentValuesCheck::ss, useInConeTracks_, useOutOfConeTracks_, useOutOfVertexTracks_, and verbose_.

Referenced by correction().

                                                                                                        {
   P4 corr_muons;
 
   P4 corr_muons_in_cone;
   P4 corr_muons_out_of_cone;
   P4 corr_muons_out_of_vertex;
 
   if (useInConeTracks_) {
     corr_muons_in_cone = muonCorrection(jet, muons.inVertexInCalo_, true, true);
     corr_muons += corr_muons_in_cone;
   }
 
   if (useOutOfConeTracks_) {
     corr_muons_out_of_cone = muonCorrection(jet, muons.inVertexOutOfCalo_, true, false);
     corr_muons += corr_muons_out_of_cone;
   }
 
   if (useOutOfVertexTracks_) {
     corr_muons_out_of_vertex = muonCorrection(jet, muons.outOfVertexInCalo_, false, true);
     corr_muons += corr_muons_out_of_vertex;
   }
 
   if (verbose_) {
     std::stringstream ss;
     ss << " Muon corrections:" << std::endl
        << "  In/In      : "
        << "(" << muons.inVertexInCalo_.size() << ") " << corr_muons_in_cone.energy() << std::endl
        << "  In/Out     : "
        << "(" << muons.inVertexOutOfCalo_.size() << ") " << corr_muons_out_of_cone.energy() << std::endl
        << "  Out/In     : "
        << "(" << muons.outOfVertexInCalo_.size() << ") " << corr_muons_out_of_vertex.energy();
     edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
   }
 
   return corr_muons;
 }

◆ muonCorrection() [2/2]

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::muonCorrection	(	const P4 &	jet,
		const TrackRefs &	muons,
		bool	in_cone_at_vertex,
		bool	in_cone_at_calo_face
	)

inlineprotected

Calculates individual muons corrections.

Definition at line 493 of file JetPlusTrackCorrector.h.

References calculateCorr(), metsig::jet, muonMass_, DiMuonV_cfg::muons, and not_used.

                                                                                                   {
   return calculateCorr(jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2.);
 }

◆ pionCorrection() [1/2]

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection	(	const P4 &	jet,
		const jpt::MatchedTracks &	pions
	)

Calculates corrections to be applied using pions.

Definition at line 670 of file JetPlusTrackCorrector.cc.

References efficiencyMap(), jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, metsig::jet, leakageMap(), not_used, jpt::MatchedTracks::outOfVertexInCalo_, pionEfficiency(), responseMap(), edm::RefVector< C, T, F >::size(), contentValuesCheck::ss, useEff_, useInConeTracks_, useOutOfConeTracks_, useOutOfVertexTracks_, and verbose_.

Referenced by correction().

                                                                                                        {
   P4 corr_pions;
 
   // In-cone
 
   P4 corr_pions_in_cone;
   P4 corr_pions_eff_in_cone;
   Efficiency in_cone(responseMap(), efficiencyMap(), leakageMap());
 
   if (useInConeTracks_) {
     corr_pions_in_cone = pionCorrection(jet, pions.inVertexInCalo_, in_cone, true, true);
     corr_pions += corr_pions_in_cone;
     if (useEff_) {
       corr_pions_eff_in_cone = pionEfficiency(jet, in_cone, true);
       corr_pions += corr_pions_eff_in_cone;
     }
   }
 
   // Out-of-cone
 
   P4 corr_pions_out_of_cone;
   P4 corr_pions_eff_out_of_cone;
   Efficiency out_of_cone(responseMap(), efficiencyMap(), leakageMap());
 
   if (useOutOfConeTracks_) {
     corr_pions_out_of_cone = pionCorrection(jet, pions.inVertexOutOfCalo_, out_of_cone, true, false);
     corr_pions += corr_pions_out_of_cone;
     if (useEff_) {
       corr_pions_eff_out_of_cone = pionEfficiency(jet, out_of_cone, false);
       corr_pions += corr_pions_eff_out_of_cone;
     }
   }
 
   // Out-of-vertex
 
   P4 corr_pions_out_of_vertex;
   Efficiency not_used(responseMap(), efficiencyMap(), leakageMap());
 
   if (useOutOfVertexTracks_) {
     corr_pions_out_of_vertex = pionCorrection(jet, pions.outOfVertexInCalo_, not_used, false, true);
     corr_pions += corr_pions_out_of_vertex;
   }
 
   if (verbose_) {
     std::stringstream ss;
     ss << " Pion corrections:" << std::endl
        << "  In/In      : "
        << "(" << pions.inVertexInCalo_.size() << ") " << corr_pions_in_cone.energy() << std::endl
        << "  In/Out     : "
        << "(" << pions.inVertexOutOfCalo_.size() << ") " << corr_pions_out_of_cone.energy() << std::endl
        << "  Out/In     : "
        << "(" << pions.outOfVertexInCalo_.size() << ") " << corr_pions_out_of_vertex.energy() << std::endl;
     if (useEff_) {
       ss << " Pion efficiency corrections:" << std::endl
          << "  In/In      : "
          << "(" << pions.inVertexInCalo_.size() << ") " << corr_pions_eff_in_cone.energy() << std::endl
          << "  In/Out     : "
          << "(" << pions.inVertexOutOfCalo_.size() << ") " << corr_pions_eff_out_of_cone.energy();
     }
     edm::LogVerbatim("JetPlusTrackCorrector") << ss.str();
   }
 
   return corr_pions;
 }

◆ pionCorrection() [2/2]

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionCorrection	(	const P4 &	jet,
		const TrackRefs &	pions,
		jpt::Efficiency &	eff,
		bool	in_cone_at_vertex,
		bool	in_cone_at_calo_face
	)

inlineprotected

Calculates individual pion corrections.

Definition at line 488 of file JetPlusTrackCorrector.h.

References calculateCorr(), metsig::jet, and pionMass_.

                                                                                                                   {
   return calculateCorr(jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1.);
 }

◆ pionEfficiency()

JetPlusTrackCorrector::P4 JetPlusTrackCorrector::pionEfficiency	(	const P4 &	jet,
		const jpt::Efficiency &	eff,
		bool	in_cone_at_calo_face
	)

protected

Correction to be applied using tracking efficiency.

Definition at line 1012 of file JetPlusTrackCorrector.cc.

References jpt::Map::binCenterEta(), jpt::Map::binCenterPt(), alignCSCRings::corr, correction(), hcalRecHitTable_cff::ieta, cuy::ii, jpt::Efficiency::inConeCorr(), metsig::jet, jpt::Map::nEtaBins(), jpt::Map::nPtBins(), jpt::Efficiency::nTrks(), jpt::Efficiency::outOfConeCorr(), pionMass_, response_, theResponseOfChargedWithEff, theSumEnergyWithEff, theSumPtWithEff, vecResponse_, and vectorial_.

Referenced by pionCorrection().

                                                                                            {
   // Total correction to be applied
   P4 correction;
 
   double theSumResp = 0;
   double theSumPt = 0;
   double theSumEnergy = 0;
 
   // Iterate through eta/pt bins
   for (uint32_t ieta = 0; ieta < response_.nEtaBins() - 1; ++ieta) {
     for (uint32_t ipt = 0; ipt < response_.nPtBins() - 1; ++ipt) {
       // Check tracks are found in this eta/pt bin
       if (!eff.nTrks(ieta, ipt)) {
         continue;
       }
 
       for (uint16_t ii = 0; ii < 2; ++ii) {
         // Check which correction should be applied
         double corr = 0.;
         if (ii == 0) {
           corr = eff.outOfConeCorr(ieta, ipt);
         } else if (ii == 1 && in_cone_at_calo_face) {
           corr = eff.inConeCorr(ieta, ipt);
         } else {
           continue;
         }
 
         // Calculate correction to be applied
         P4 corr_p4;
         if (vectorial_ && vecResponse_) {
           double corr_eta = response_.binCenterEta(ieta);
           double corr_phi = jet.phi();  //@@ jet phi!
           double corr_pt = response_.binCenterPt(ipt);
           corr_p4 =
               PtEtaPhiM(corr_pt, corr_eta, corr_phi, pionMass_);  //@@ E^2 = p^2 + m_pion^2, |p| calc'ed from pt bin
           corr_p4 *= (corr_p4.energy() > 0. ? corr / corr_p4.energy() : 1.);  //@@ p4 scaled up by mean energy for bin
         } else {
           corr_p4 = (jet.energy() > 0. ? corr / jet.energy() : 1.) * jet;
         }
 
         // Apply correction
         if (ii == 0) {
           correction += corr_p4;
           theSumPt += corr_p4.pt();
           theSumEnergy += corr_p4.energy();
         }  //@@ Add out-of-cone
         else if (ii == 1) {
           correction -= corr_p4;
           theSumResp += corr_p4.energy();
         }  //@@ Subtract in-cone
       }
     }
   }
 
   theResponseOfChargedWithEff += theSumResp;
   theSumPtWithEff += theSumPt;
   theSumEnergyWithEff += theSumEnergy;
   return correction;
 }

◆ rebuildJta()

void JetPlusTrackCorrector::rebuildJta	(	const reco::Jet &	fJet,
		const JetTracksAssociations &	jtV0,
		TrackRefs &	included,
		TrackRefs &	excluded
	)		const

protected

Rebuild jet-track association.

Definition at line 1171 of file JetPlusTrackCorrector.cc.

References reco::JetTracksAssociation::allJets(), edm::RefVector< C, T, F >::clear(), HLTMuonOfflineAnalyzer_cfi::deltaR2, ALPAKA_ACCELERATOR_NAMESPACE::dR2(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), RemoveAddSevLevel::flag, reco::JetTracksAssociation::getValue(), cuy::ii, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, reco::btau::jetEta, reco::btau::jetPhi, jetSplitMerge_, reco::LeafCandidate::phi(), edm::RefVector< C, T, F >::push_back(), l1tEGammaCrystalsEmulatorProducer_cfi::scale, DiMuonV_cfg::tracks, run3scouting_cff::trkEta, and run3scouting_cff::trkPhi.

Referenced by jtaUsingEventData().

                                                               {
   tracksthis = reco::JetTracksAssociation::getValue(jtV0, fJet);
 
   if (jetSplitMerge_ < 0)
     return;
 
   typedef std::vector<reco::JetBaseRef>::iterator JetBaseRefIterator;
   std::vector<reco::JetBaseRef> theJets = reco::JetTracksAssociation::allJets(jtV0);
 
   TrackRefs tracks = tracksthis;
   tracksthis.clear();
 
   double jetEta = fJet.eta();
   double jetPhi = fJet.phi();
   double jetEtIn = 1.0 / fJet.et();
 
   for (TrackRefs::iterator it = tracks.begin(); it != tracks.end(); it++) {
     double trkEta = (**it).eta();
     double trkPhi = (**it).phi();
     double dR2this = deltaR2(jetEta, jetPhi, trkEta, trkPhi);
     //       double dfi = fabs(fJet.phi()-(**it).phi());
     //       if(dfi>4.*atan(1.))dfi = 8.*atan(1.)-dfi;
     //       double deta = fJet.eta() - (**it).eta();
     //       double dR2check = sqrt(dfi*dfi+deta*deta);
 
     double scalethis = dR2this;
     if (jetSplitMerge_ == 0)
       scalethis = 1. * jetEtIn;
     if (jetSplitMerge_ == 2)
       scalethis = dR2this * jetEtIn;
     int flag = 1;
     for (JetBaseRefIterator ii = theJets.begin(); ii != theJets.end(); ii++) {
       if (&(**ii) == &fJet) {
         continue;
       }
       double dR2 = deltaR2((*ii)->eta(), (*ii)->phi(), trkEta, trkPhi);
       double scale = dR2;
       if (jetSplitMerge_ == 0)
         scale = 1. / (**ii).et();
       if (jetSplitMerge_ == 2)
         scale = dR2 / (**ii).et();
       if (scale < scalethis)
         flag = 0;
 
       if (flag == 0) {
         break;
       }
     }
 
     if (flag == 1) {
       tracksthis.push_back(*it);
     } else {
       Excl.push_back(*it);
     }
   }
 
   return;
 }

◆ responseMap()

const jpt::Map & JetPlusTrackCorrector::responseMap ( ) const

inlineprotected

Definition at line 514 of file JetPlusTrackCorrector.h.

References response_.

Referenced by pionCorrection().

514 { return response_; }

JetPlusTrackCorrector::response_

const jpt::Map response_

Definition: JetPlusTrackCorrector.h:431

◆ tracksInCalo()

bool JetPlusTrackCorrector::tracksInCalo	(	const jpt::MatchedTracks &	pions,
		const jpt::MatchedTracks &	muons,
		const jpt::MatchedTracks &	elecs
	)		const

protected

Determines if any tracks in cone at CaloFace.

Definition at line 658 of file JetPlusTrackCorrector.cc.

References singleTopDQM_cfi::elecs, edm::RefVector< C, T, F >::empty(), jpt::MatchedTracks::inVertexInCalo_, and DiMuonV_cfg::muons.

Referenced by matchTracks().

                                                                            {
   if (!pions.inVertexInCalo_.empty() || !muons.inVertexInCalo_.empty() || !elecs.inVertexInCalo_.empty()) {
     return true;
   } else {
     return false;
   }
 }

◆ vectorialCorrection()

bool JetPlusTrackCorrector::vectorialCorrection ( ) const

inline

Returns value of configurable.

Definition at line 485 of file JetPlusTrackCorrector.h.

References vectorial_.

485 { return vectorial_; }

JetPlusTrackCorrector::vectorial_

bool vectorial_

Definition: JetPlusTrackCorrector.h:400

Member Data Documentation

◆ dzVertexCut_

double JetPlusTrackCorrector::dzVertexCut_

protected

Definition at line 417 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality().

◆ efficiency_

const jpt::Map JetPlusTrackCorrector::efficiency_

protected

Definition at line 432 of file JetPlusTrackCorrector.h.

Referenced by correctAA(), and efficiencyMap().

◆ elecMass_

double JetPlusTrackCorrector::elecMass_

protected

Definition at line 444 of file JetPlusTrackCorrector.h.

Referenced by elecCorrection().

◆ electronDRmatch_

double JetPlusTrackCorrector::electronDRmatch_

protected

Definition at line 439 of file JetPlusTrackCorrector.h.

Referenced by matchElectrons().

◆ electronIds_

edm::InputTag JetPlusTrackCorrector::electronIds_

protected

Definition at line 423 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ electrons_

edm::InputTag JetPlusTrackCorrector::electrons_

protected

Definition at line 422 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ input_jetTracksAtCalo_token_

edm::EDGetTokenT<reco::JetTracksAssociation::Container> JetPlusTrackCorrector::input_jetTracksAtCalo_token_

private

Definition at line 461 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and jtaUsingEventData().

◆ input_jetTracksAtVertex_token_

edm::EDGetTokenT<reco::JetTracksAssociation::Container> JetPlusTrackCorrector::input_jetTracksAtVertex_token_

private

Definition at line 460 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and jtaUsingEventData().

◆ input_pat_elecs_token_

edm::EDGetTokenT<pat::ElectronCollection> JetPlusTrackCorrector::input_pat_elecs_token_

private

Definition at line 467 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

◆ input_pat_muons_token_

edm::EDGetTokenT<pat::MuonCollection> JetPlusTrackCorrector::input_pat_muons_token_

private

Definition at line 466 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ input_pvCollection_token_

edm::EDGetTokenT<reco::VertexCollection> JetPlusTrackCorrector::input_pvCollection_token_

private

Definition at line 463 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and matchTracks().

◆ input_reco_elec_ids_token_

edm::EDGetTokenT<RecoElectronIds> JetPlusTrackCorrector::input_reco_elec_ids_token_

private

Definition at line 465 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

◆ input_reco_elecs_token_

edm::EDGetTokenT<RecoElectrons> JetPlusTrackCorrector::input_reco_elecs_token_

private

Definition at line 464 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

◆ input_reco_muons_token_

edm::EDGetTokenT<RecoMuons> JetPlusTrackCorrector::input_reco_muons_token_

private

Definition at line 462 of file JetPlusTrackCorrector.h.

Referenced by getMuons(), and JetPlusTrackCorrector().

◆ jetSplitMerge_

int JetPlusTrackCorrector::jetSplitMerge_

protected

Definition at line 414 of file JetPlusTrackCorrector.h.

Referenced by excludeJta(), JetPlusTrackCorrector(), jtaUsingEventData(), and rebuildJta().

◆ jetTracksAtCalo_

edm::InputTag JetPlusTrackCorrector::jetTracksAtCalo_

protected

Definition at line 413 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), jetTrackAssociation(), and jtaUsingEventData().

◆ jetTracksAtVertex_

edm::InputTag JetPlusTrackCorrector::jetTracksAtVertex_

protected

Definition at line 412 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), jetTrackAssociation(), and jtaUsingEventData().

◆ leakage_

const jpt::Map JetPlusTrackCorrector::leakage_

protected

Definition at line 433 of file JetPlusTrackCorrector.h.

Referenced by leakageMap().

◆ maxEta_

double JetPlusTrackCorrector::maxEta_

protected

Definition at line 447 of file JetPlusTrackCorrector.h.

Referenced by canCorrect().

◆ muonEtamatch_

double JetPlusTrackCorrector::muonEtamatch_

protected

Definition at line 437 of file JetPlusTrackCorrector.h.

◆ muonMass_

double JetPlusTrackCorrector::muonMass_

protected

Definition at line 443 of file JetPlusTrackCorrector.h.

Referenced by muonCorrection().

◆ muonPhimatch_

double JetPlusTrackCorrector::muonPhimatch_

protected

Definition at line 438 of file JetPlusTrackCorrector.h.

◆ muonPtmatch_

double JetPlusTrackCorrector::muonPtmatch_

protected

Definition at line 436 of file JetPlusTrackCorrector.h.

◆ muons_

edm::InputTag JetPlusTrackCorrector::muons_

protected

Definition at line 421 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ not_used

jpt::Efficiency JetPlusTrackCorrector::not_used {response_, efficiency_, leakage_}

protected

Definition at line 455 of file JetPlusTrackCorrector.h.

Referenced by elecCorrection(), muonCorrection(), and pionCorrection().

◆ patelectrons_

edm::InputTag JetPlusTrackCorrector::patelectrons_

protected

Definition at line 425 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ patmuons_

edm::InputTag JetPlusTrackCorrector::patmuons_

protected

Definition at line 424 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ pionMass_

double JetPlusTrackCorrector::pionMass_

protected

Definition at line 442 of file JetPlusTrackCorrector.h.

Referenced by pionCorrection(), and pionEfficiency().

◆ ptErrorQuality_

double JetPlusTrackCorrector::ptErrorQuality_

protected

Definition at line 416 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality().

◆ response_

const jpt::Map JetPlusTrackCorrector::response_

protected

Definition at line 431 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correctAA(), pionEfficiency(), and responseMap().

◆ srcPVs_

edm::InputTag JetPlusTrackCorrector::srcPVs_

protected

Definition at line 415 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

◆ theResponseOfChargedWithEff

float JetPlusTrackCorrector::theResponseOfChargedWithEff

protected

Definition at line 448 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), getResponseOfChargedWithEff(), and pionEfficiency().

◆ theResponseOfChargedWithoutEff

float JetPlusTrackCorrector::theResponseOfChargedWithoutEff

protected

Definition at line 449 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), and getResponseOfChargedWithoutEff().

◆ theSumEnergyWithEff

float JetPlusTrackCorrector::theSumEnergyWithEff

protected

Definition at line 452 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), getSumEnergyWithEff(), and pionEfficiency().

◆ theSumEnergyWithoutEff

float JetPlusTrackCorrector::theSumEnergyWithoutEff

protected

Definition at line 453 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), and getSumEnergyWithoutEff().

◆ theSumPtForBeta

float JetPlusTrackCorrector::theSumPtForBeta

protected

Definition at line 454 of file JetPlusTrackCorrector.h.

Referenced by correction(), getSumPtForBeta(), and matchTracks().

◆ theSumPtWithEff

float JetPlusTrackCorrector::theSumPtWithEff

protected

Definition at line 450 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), getSumPtWithEff(), and pionEfficiency().

◆ theSumPtWithoutEff

float JetPlusTrackCorrector::theSumPtWithoutEff

protected

Definition at line 451 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), and getSumPtWithoutEff().

◆ trackQuality_

reco::TrackBase::TrackQuality JetPlusTrackCorrector::trackQuality_

protected

Definition at line 428 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality(), and matchTracks().

◆ useEff_

bool JetPlusTrackCorrector::useEff_

protected

Definition at line 406 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and pionCorrection().

◆ useElecs_

bool JetPlusTrackCorrector::useElecs_

protected

Definition at line 408 of file JetPlusTrackCorrector.h.

Referenced by correction(), JetPlusTrackCorrector(), and matchTracks().

◆ useInConeTracks_

bool JetPlusTrackCorrector::useInConeTracks_

protected

Definition at line 402 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), muonCorrection(), and pionCorrection().

◆ useMuons_

bool JetPlusTrackCorrector::useMuons_

protected

Definition at line 407 of file JetPlusTrackCorrector.h.

Referenced by correction(), JetPlusTrackCorrector(), and matchTracks().

◆ useOutOfConeTracks_

bool JetPlusTrackCorrector::useOutOfConeTracks_

protected

Definition at line 403 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), muonCorrection(), and pionCorrection().

◆ useOutOfVertexTracks_

bool JetPlusTrackCorrector::useOutOfVertexTracks_

protected

Definition at line 404 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), muonCorrection(), and pionCorrection().

◆ usePAT_

bool JetPlusTrackCorrector::usePAT_

protected

Definition at line 399 of file JetPlusTrackCorrector.h.

Referenced by correction(), JetPlusTrackCorrector(), and matchTracks().

◆ usePions_

bool JetPlusTrackCorrector::usePions_

protected

Definition at line 405 of file JetPlusTrackCorrector.h.

Referenced by correction(), and JetPlusTrackCorrector().

◆ useTrackQuality_

bool JetPlusTrackCorrector::useTrackQuality_

protected

Definition at line 409 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality(), JetPlusTrackCorrector(), and matchTracks().

◆ vecResponse_

bool JetPlusTrackCorrector::vecResponse_

protected

Definition at line 401 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), JetPlusTrackCorrector(), and pionEfficiency().

◆ vectorial_

bool JetPlusTrackCorrector::vectorial_

protected

Definition at line 400 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), JetPlusTrackCorrector(), pionEfficiency(), and vectorialCorrection().

◆ verbose_

bool JetPlusTrackCorrector::verbose_

protected

Definition at line 398 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), correction(), elecCorrection(), JetPlusTrackCorrector(), jtaUsingEventData(), matchTracks(), muonCorrection(), and pionCorrection().

◆ vertex_

reco::Particle::Point JetPlusTrackCorrector::vertex_

protected

Definition at line 418 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality(), and matchTracks().

Private Attributes
edm::EDGetTokenT< reco::JetTracksAssociation::Container >	input_jetTracksAtCalo_token_

edm::EDGetTokenT< reco::JetTracksAssociation::Container >	input_jetTracksAtVertex_token_

edm::EDGetTokenT< pat::ElectronCollection >	input_pat_elecs_token_

edm::EDGetTokenT< pat::MuonCollection >	input_pat_muons_token_

edm::EDGetTokenT< reco::VertexCollection >	input_pvCollection_token_

edm::EDGetTokenT< RecoElectronIds >	input_reco_elec_ids_token_

edm::EDGetTokenT< RecoElectrons >	input_reco_elecs_token_

edm::EDGetTokenT< RecoMuons >	input_reco_muons_token_

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ JetTracksAssociations

◆ P4

◆ PtEtaPhiE

◆ PtEtaPhiM

◆ RecoElectronIds

◆ RecoElectrons

◆ RecoMuons

◆ TrackRefs

Constructor & Destructor Documentation

◆ JetPlusTrackCorrector() [1/2]

◆ ~JetPlusTrackCorrector()

◆ JetPlusTrackCorrector() [2/2]

Member Function Documentation

◆ calculateCorr()

◆ canCorrect()

◆ checkScale()

◆ correctAA()

◆ correction() [1/5]

◆ correction() [2/5]

◆ correction() [3/5]

◆ correction() [4/5]

◆ correction() [5/5]

◆ efficiencyMap()

◆ elecCorrection() [1/2]

◆ elecCorrection() [2/2]

◆ eventRequired()

◆ excludeJta()

◆ failTrackQuality()

◆ findTrack() [1/2]

◆ findTrack() [2/2]

◆ getElectrons() [1/2]

◆ getElectrons() [2/2]

◆ getMuons() [1/2]

◆ getMuons() [2/2]

◆ getResponseOfChargedWithEff()

◆ getResponseOfChargedWithoutEff()

◆ getSumEnergyWithEff()

◆ getSumEnergyWithoutEff()

◆ getSumPtForBeta()

◆ getSumPtWithEff()

◆ getSumPtWithoutEff()

◆ jetDirFromTracks()

◆ jetTrackAssociation()

◆ jtaUsingEventData()

◆ leakageMap()

◆ matchElectrons() [1/2]

◆ matchElectrons() [2/2]

◆ matchMuons() [1/2]

◆ matchMuons() [2/2]

◆ matchTracks() [1/3]

◆ matchTracks() [2/3]

◆ matchTracks() [3/3]

◆ muonCorrection() [1/2]

◆ muonCorrection() [2/2]

◆ pionCorrection() [1/2]

◆ pionCorrection() [2/2]

◆ pionEfficiency()

◆ rebuildJta()

◆ responseMap()

◆ tracksInCalo()

◆ vectorialCorrection()

Member Data Documentation

◆ dzVertexCut_

◆ efficiency_

◆ elecMass_

◆ electronDRmatch_

◆ electronIds_

◆ electrons_

◆ input_jetTracksAtCalo_token_

◆ input_jetTracksAtVertex_token_

◆ input_pat_elecs_token_

◆ input_pat_muons_token_