JetPlusTrackCorrector Class Reference

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 &, 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...
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	getMuons (const edm::Event &, edm::Handle< RecoMuons > &) const
	Get RECO muons. More...
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	matchMuons (TrackRefs::const_iterator &, const edm::Handle< RecoMuons > &) const
	Matches tracks to RECO muons. More...
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_
edm::InputTag	electronIds_
edm::InputTag	electrons_
int	jetSplitMerge_
edm::InputTag	jetTracksAtCalo_
edm::InputTag	jetTracksAtVertex_
const jpt::Map	leakage_
double	maxEta_
double	muonMass_
edm::InputTag	muons_
jpt::Efficiency	not_used {response_, efficiency_, leakage_}
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	usePions_
bool	useTrackQuality_
bool	vecResponse_
bool	vectorial_
bool	verbose_
reco::Particle::Point	vertex_

Private Attributes
edm::EDGetTokenT< reco::JetTracksAssociation::Container >	input_jetTracksAtCalo_token_
edm::EDGetTokenT< reco::JetTracksAssociation::Container >	input_jetTracksAtVertex_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 >	inut_reco_muons_token_

Detailed Description

Jet energy correction algorithm using tracks.

Definition at line 168 of file JetPlusTrackCorrector.h.

Member Typedef Documentation

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

protected

Definition at line 274 of file JetPlusTrackCorrector.h.

typedef math::XYZTLorentzVector JetPlusTrackCorrector::P4

Definition at line 179 of file JetPlusTrackCorrector.h.

typedef math::PtEtaPhiELorentzVectorD JetPlusTrackCorrector::PtEtaPhiE

Definition at line 180 of file JetPlusTrackCorrector.h.

typedef math::PtEtaPhiMLorentzVectorD JetPlusTrackCorrector::PtEtaPhiM

Definition at line 181 of file JetPlusTrackCorrector.h.

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

protected

Definition at line 273 of file JetPlusTrackCorrector.h.

typedef reco::GsfElectronCollection JetPlusTrackCorrector::RecoElectrons

protected

Definition at line 272 of file JetPlusTrackCorrector.h.

typedef reco::MuonCollection JetPlusTrackCorrector::RecoMuons

protected

Get reponses.

Definition at line 271 of file JetPlusTrackCorrector.h.

typedef reco::TrackRefVector JetPlusTrackCorrector::TrackRefs

protected

Definition at line 275 of file JetPlusTrackCorrector.h.

Constructor & Destructor Documentation

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

Constructor.

Definition at line 22 of file JetPlusTrackCorrector.cc.

References electronIds_, electrons_, edm::ParameterSet::getParameter(), input_jetTracksAtCalo_token_, input_jetTracksAtVertex_token_, input_pvCollection_token_, input_reco_elec_ids_token_, input_reco_elecs_token_, inut_reco_muons_token_, jetSplitMerge_, jetTracksAtCalo_, jetTracksAtVertex_, muons_, srcPVs_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, useEff_, useElecs_, useInConeTracks_, useMuons_, useOutOfConeTracks_, useOutOfVertexTracks_, usePions_, useTrackQuality_, vecResponse_, vectorial_, and verbose_.

    : verbose_(pset.getParameter<bool>("Verbose")),
      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")),
      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_)),
      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_);
  inut_reco_muons_token_ = iC.consumes<RecoMuons>(muons_);
  input_pvCollection_token_ = iC.consumes<reco::VertexCollection>(srcPVs_);
  input_reco_elecs_token_ = iC.consumes<RecoElectrons>(electrons_);
  input_reco_elec_ids_token_ = iC.consumes<RecoElectronIds>(electronIds_);
}

JetPlusTrackCorrector::~JetPlusTrackCorrector ( )

virtual

Destructor.

Definition at line 101 of file JetPlusTrackCorrector.cc.

{ ; }

JetPlusTrackCorrector::JetPlusTrackCorrector ( )

inlineprotected

Default constructor.

Definition at line 364 of file JetPlusTrackCorrector.h.

{ ; }

Member Function Documentation

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 842 of file JetPlusTrackCorrector.cc.

References jpt::Efficiency::addE(), edm::RefVector< C, T, F >::begin(), correction(), edm::RefVector< C, T, F >::empty(), edm::RefVector< C, T, F >::end(), HCALHighEnergyHPDFilter_cfi::energy, PVValHelper::eta, jpt::Map::etaBin(), LEDCalibrationChannels::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, jpt::Map::value(), vecResponse_, vectorial_, and verbose_.

                                                                           {
  // Correction to be applied to jet 4-momentum
  P4 correction;

  /*
  std::cout<<" >>>>> Jet "<<jet.pt()<<" "<<jet.eta()<<" "<<jet.phi()<<" Number of tracks "<<tracks.size()<<" Pions? "<<is_pion<<" InVert "<<in_cone_at_vertex<<
  " InCalo "<<in_cone_at_calo_face<<std::endl;
  
  std::cout<<" calculateCorr Start::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
  theResponseOfChargedWithoutEff <<" "<<
  theSumPtWithEff <<" "<<
  theSumPtWithoutEff <<" "<<
  theSumEnergyWithEff <<" "<<
  theSumEnergyWithoutEff <<std::endl;
*/

  // 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;
  }
  /*
  std::cout<<" calculateCorr End::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
  theResponseOfChargedWithoutEff <<" "<<
  theSumPtWithEff <<" "<<
  theSumPtWithoutEff <<" "<<
  theSumEnergyWithEff <<" "<<
  theSumEnergyWithoutEff <<std::endl;
*/
  return correction;
}

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

inline

Can jet be JPT-corrected?

Definition at line 447 of file JetPlusTrackCorrector.h.

References reco::LeafCandidate::eta().

Referenced by correction().

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

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

inlineprotected

Check corrected 4-momentum does not give negative scale.

Definition at line 468 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();
}

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 1249 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(), LEDCalibrationChannels::ieta, M_PI, jpt::Map::nEtaBins(), jpt::Map::nPtBins(), DiDispStaMuonMonitor_cfi::pt, jpt::Map::ptBin(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, response_, mathSSE::sqrt(), and jpt::Map::value().

                                                                                       {
  double mScale = 1.;
  double NewResponse = fJet.energy();

  //std::cout<<"---JetPlusTrackCorrector::correctAA, Jet initial: NewResponse="<<NewResponse <<" et = "<<fJet.et()
  //         <<" pt= "<<fJet.pt()<<" eta="<<fJet.eta()<<" phi="<<fJet.phi() <<" ja="<<ja
  //        <<" trBgOutOfVertex="<<trBgOutOfVertex.size()<< " trBgOutOfCalo="<<trBgOutOfCalo.size()<<std::endl;

  if (trBgOutOfVertex.empty())
    return mScale;
  double EnergyOfBackgroundCharged = 0.;
  double ResponseOfBackgroundCharged = 0.;

  //
  // calculate the mean response
  //
  //     double MeanResponseOfBackgroundCharged = 0.;
  //     double MeanEnergyOfBackgroundCharged   = 0.;

  //================= EnergyOfBackgroundCharged ==================>
  for (reco::TrackRefVector::iterator iBgtV = trBgOutOfVertex.begin(); iBgtV != trBgOutOfVertex.end(); iBgtV++) {
    // Temporary solution>>>>>> Remove tracks with pt>50 GeV
    //   if( (**iBgtV).pt() >= 50. ) continue;
    //response_.value(ieta,ipt);
    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;

    //      // Check bins (not for mips)
    //         if ( ieta >= response_.nEtaBins() ) { continue; }
    //   if ( ipt >= response_.nPtBins() ) { ipt = response_.nPtBins() - 1; }

    double echarBg = sqrt((**iBgtV).px() * (**iBgtV).px() + (**iBgtV).py() * (**iBgtV).py() +
                          (**iBgtV).pz() * (**iBgtV).pz() + 0.14 * 0.14);

    //   ResponseOfBackgroundCharged += echarBg*response_.value(ieta,ipt)/efficiency_.value(ieta,ipt);

    //   std::cout<<" Efficiency of bg tracks "<<efficiency_.value(ieta,ipt)<<std::endl;

    EnergyOfBackgroundCharged += echarBg / efficiency_.value(ieta, ipt);

  }  // Energy BG tracks

  //============= ResponseOfBackgroundCharged =======================>

  for (reco::TrackRefVector::iterator iBgtC = trBgOutOfCalo.begin(); iBgtC != trBgOutOfCalo.end(); iBgtC++) {
    // Temporary solution>>>>>> Remove tracks with pt>50 GeV
    //   if( (**iBgtC).pt() >= 50. ) continue;
    //response_.value(ieta,ipt);
    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);

    //       std::cout<<" Efficiency of bg tracks "<<efficiency_.value(ieta,ipt)<<std::endl;

  }  // 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++) {
    //          std::cout<<" Track in out, size= "<<pioninout.size()<<" p= "<<(*it)->p()<<" pt= "<<(*it)->pt()
    //                   <<" eta=  "<<(*it)->eta()<<" phi= "<<(*it)->phi()<<std::endl;

    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++) {
    //          std::cout<<" Track in in, size= "<<pioninin.size()<<" p= "<<(*it)->p()<<" pt= "<<(*it)->pt()
    //                   <<" eta= "<<(*it)->eta()<<" phi= "<<(*it)->phi()<<std::endl;

    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 = 4*(M_PI*mConeSize - mConeSize*mConeSize);
  double SquareEtaRingWithoutJets = ja;

  //   std::cout<<"---SquareEtaRingWithoutJets="<<SquareEtaRingWithoutJets<<std::endl;

  EnergyOfBackgroundCharged = EnergyOfBackgroundCharged / SquareEtaRingWithoutJets;
  ResponseOfBackgroundCharged = ResponseOfBackgroundCharged / SquareEtaRingWithoutJets;
  //    NumberOfBackgroundCharged   = NumberOfBackgroundCharged/SquareEtaRingWithoutJets;

  EnergyOfBackgroundCharged = M_PI * mConeSize * mConeSize * EnergyOfBackgroundCharged;
  ResponseOfBackgroundCharged = M_PI * mConeSize * mConeSize * ResponseOfBackgroundCharged;
  //    NumberOfBackgroundCharged   = M_PI*mConeSize*mConeSize*NumberOfBackgroundCharged;

  NewResponse = NewResponse - EnergyOfBackgroundCharged + ResponseOfBackgroundCharged;

  //      std::cout<<"====JetPlusTrackCorrector, Old response=fJet.energy()"<<fJet.energy()
  //               <<" EnergyOfBackgroundCharged="<<EnergyOfBackgroundCharged
  //               <<" ResponseOfBackgroundCharged="<<ResponseOfBackgroundCharged

  mScale = NewResponse / fJet.energy();
  if (mScale < 0.)
    mScale = 0.;
  return mScale;
}

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 105 of file JetPlusTrackCorrector.cc.

References canCorrect(), checkScale(), elecCorrection(), singleTopDQM_cfi::elecs, reco::LeafCandidate::energy(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), alignBH_cfg::fixed, jetDirFromTracks(), reco::LeafCandidate::mass(), matchTracks(), muonCorrection(), PDWG_BPHSkim_cff::muons, reco::LeafCandidate::p4(), reco::LeafCandidate::phi(), pionCorrection(), reco::LeafCandidate::pt(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), Scenarios_cff::scale, contentValuesCheck::ss, theResponseOfChargedWithEff, theResponseOfChargedWithoutEff, theSumEnergyWithEff, theSumEnergyWithoutEff, theSumPtForBeta, theSumPtWithEff, theSumPtWithoutEff, useElecs_, useMuons_, usePions_, vecResponse_, vectorial_, and verbose_.

Referenced by calculateCorr(), and pionEfficiency().

                                                             {
  //  std::cout<<" JetPlusTrackCorrector::correction "<<std::endl;

  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.;
  }

  //  std::cout<<" Jet can be corrected "<<std::endl;

  // std::cout<<" Tracks are matched "<<std::endl;

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

  //   std::cout << " mScale= " << scale
  //        << " NewResponse " << corrected.energy()
  //        << " Jet energy " << fJet.energy()
  //        << " event " << event.id().event() << std::endl;

  /*
  std::cout<<" Correction::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
  theResponseOfChargedWithoutEff <<" "<<
  theSumPtWithEff <<" "<<
  theSumPtWithoutEff <<" "<<
  theSumEnergyWithEff <<" "<<
  theSumEnergyWithoutEff <<std::endl;
*/

  // Return energy correction
  return scale;
}

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 433 of file JetPlusTrackCorrector.h.

References pfMETCorrectionType0_cfi::correction.

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

double JetPlusTrackCorrector::correction

(

const reco::Jet &

jet

)

const

Correction method (not used)

Definition at line 212 of file JetPlusTrackCorrector.cc.

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

double JetPlusTrackCorrector::correction

(

const P4 &

jet

)

const

Correction method (not used)

Definition at line 219 of file JetPlusTrackCorrector.cc.

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

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

inlineprotected

Definition at line 476 of file JetPlusTrackCorrector.h.

Referenced by pionCorrection().

{ return efficiency_; }

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

Calculates correction to be applied using electrons.

Definition at line 737 of file JetPlusTrackCorrector.cc.

References jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, jpt::MatchedTracks::outOfVertexInCalo_, edm::RefVector< C, T, F >::size(), 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
}

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 461 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::eventRequired ( ) const

inline

Returns true.

Definition at line 445 of file JetPlusTrackCorrector.h.

{ return true; }

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

protected

Exclude jet-track association.

Definition at line 1215 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(), jetSplitMerge_, edm::RefVector< C, T, F >::push_back(), and PDWG_EXOHSCP_cff::tracks.

Referenced by jtaUsingEventData().

                                                                    {
  //std::cout<<" NEW2" << std::endl;

  tracksthis = reco::JetTracksAssociation::getValue(jtV0, fJet);
  if (Excl.empty())
    return;
  if (jetSplitMerge_ < 0)
    return;

  TrackRefs tracks = tracksthis;
  tracksthis.clear();

  //std::cout<<" Size of initial vector "<<tracks.size()<<" "<<fJet.et()<<" "<<fJet.eta()<<" "<<fJet.phi()<<std::endl;

  for (TrackRefs::iterator it = tracks.begin(); it != tracks.end(); it++) {
    //std::cout<<" Track at calo surface "
    //<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<std::endl;
    TrackRefs::iterator itold = find(Excl.begin(), Excl.end(), (*it));
    if (itold == Excl.end()) {
      tracksthis.push_back(*it);
    }
    //else { std::cout<<"Exclude "<<(**it).eta()<<" "<<(**it).phi()<<std::endl; }
  }

  //std::cout<<" Size of calo tracks "<<tracksthis.size()<<std::endl;

  return;
}

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

protected

Check on track quality.

Definition at line 558 of file JetPlusTrackCorrector.cc.

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

Referenced by matchTracks().

                                                                                {
  //  if ( useTrackQuality_ && !(*itrk)->quality(trackQuality_) ) { return true; }
  //  else { return false; }

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

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 582 of file JetPlusTrackCorrector.cc.

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

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

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 595 of file JetPlusTrackCorrector.cc.

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

                                                                           {
  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;
  }
}

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 534 of file JetPlusTrackCorrector.cc.

References electronIds_, electrons_, edm::HandleBase::failedToGet(), input_reco_elec_ids_token_, input_reco_elecs_token_, edm::InputTag::instance(), edm::HandleBase::isValid(), edm::InputTag::label(), and edm::InputTag::process().

Referenced by matchTracks().

                                                                                          {
  event.getByToken(input_reco_elecs_token_, reco_elecs);
  if (!reco_elecs.isValid() || reco_elecs.failedToGet()) {
    edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                           << " Invalid handle to reco::GsfElectron collection"
                                           << " with InputTag (label:instance:process) \"" << electrons_.label() << ":"
                                           << electrons_.instance() << ":" << electrons_.process() << "\"";
    return false;
  }
  event.getByToken(input_reco_elec_ids_token_, reco_elec_ids);
  if (!reco_elec_ids.isValid() || reco_elec_ids.failedToGet()) {
    edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                           << " Invalid handle to reco::GsfElectron collection"
                                           << " with InputTag (label:instance:process) \"" << electronIds_.label()
                                           << ":" << electronIds_.instance() << ":" << electronIds_.process() << "\"";
    return false;
  }
  return true;
}

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

protected

Get RECO muons.

Definition at line 349 of file JetPlusTrackCorrector.cc.

References edm::HandleBase::failedToGet(), edm::InputTag::instance(), inut_reco_muons_token_, edm::HandleBase::isValid(), edm::InputTag::label(), muons_, and edm::InputTag::process().

Referenced by matchTracks().

                                                                                                  {
  event.getByToken(inut_reco_muons_token_, reco_muons);
  if (!reco_muons.isValid() || reco_muons.failedToGet()) {
    edm::LogError("JetPlusTrackCorrector") << "[JetPlusTrackCorrector::" << __func__ << "]"
                                           << " Invalid handle to reco::Muon collection"
                                           << " with InputTag (label:instance:process) \"" << muons_.label() << ":"
                                           << muons_.instance() << ":" << muons_.process() << "\"";
    return false;
  }
  return true;
}

double JetPlusTrackCorrector::getResponseOfChargedWithEff ( )

inline

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

Definition at line 231 of file JetPlusTrackCorrector.h.

{ return theResponseOfChargedWithEff; }

double JetPlusTrackCorrector::getResponseOfChargedWithoutEff ( )

inline

Definition at line 232 of file JetPlusTrackCorrector.h.

{ return theResponseOfChargedWithoutEff; }

double JetPlusTrackCorrector::getSumEnergyWithEff ( )

inline

Definition at line 235 of file JetPlusTrackCorrector.h.

{ return theSumEnergyWithEff; }

double JetPlusTrackCorrector::getSumEnergyWithoutEff ( )

inline

Definition at line 236 of file JetPlusTrackCorrector.h.

{ return theSumEnergyWithoutEff; }

double JetPlusTrackCorrector::getSumPtForBeta ( )

inline

Definition at line 237 of file JetPlusTrackCorrector.h.

References singleTopDQM_cfi::elecs, metsig::jet, muonid::matchTracks(), and PDWG_BPHSkim_cff::muons.

{ return theSumPtForBeta; }

double JetPlusTrackCorrector::getSumPtWithEff ( )

inline

Definition at line 233 of file JetPlusTrackCorrector.h.

{ return theSumPtWithEff; }

double JetPlusTrackCorrector::getSumPtWithoutEff ( )

inline

Definition at line 234 of file JetPlusTrackCorrector.h.

{ return theSumPtWithoutEff; }

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 757 of file JetPlusTrackCorrector.cc.

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

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 = true;
      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.);
      //      tracks_present = true;
    }
  }

  // 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;
}

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 259 of file JetPlusTrackCorrector.cc.

References jpt::JetTracks::clear(), edm::InputTag::instance(), jetTracksAtCalo_, jetTracksAtVertex_, jtaUsingEventData(), edm::InputTag::label(), and edm::InputTag::process().

Referenced by matchTracks().

                                                                       {
  // Some init
  trks.clear();

  // Check if labels are given
  if (!jetTracksAtVertex_.label().empty() && !jetTracksAtCalo_.label().empty()) {
    //std::cout<<" Try to associate with splitting "<< std::endl;

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

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

protected

JTA using collections from event.

Definition at line 286 of file JetPlusTrackCorrector.cc.

References jpt::JetTracks::caloFace_, edm::RefVector< C, T, F >::empty(), 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(), verbose_, and jpt::JetTracks::vertex_.

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

  // std::cout<<" JetPlusTrackCorrector::jtaUsingEventData::here "<<jetSplitMerge_<<std::endl;

  // Retrieve jet-tracks association for given jet
  const reco::JetTracksAssociation::Container jtV = *(jetTracksAtVertex.product());
  TrackRefs excluded;
  if (jetSplitMerge_ < 0) {
    trks.vertex_ = reco::JetTracksAssociation::getValue(jtV, fJet);
  } else {
    rebuildJta(fJet, jtV, trks.vertex_, excluded);
  }

  // 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);
  }

  //   std::cout<<" JTA:Tracks in vertex "<<trks.vertex_.size()<<" in calo "<<trks.caloFace_.size()<<std::endl;

  // Successful
  return true;
}

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

inlineprotected

Definition at line 477 of file JetPlusTrackCorrector.h.

Referenced by pionCorrection().

{ return leakage_; }

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 1099 of file JetPlusTrackCorrector.cc.

References funct::abs(), PbPb_ZMuSkimMuonDPG_cff::deltaR, MillePedeFileConverter_cfg::e, funct::pow(), and mathSSE::sqrt().

Referenced by matchTracks().

                                                                                             {
  if (elecs->empty()) {
    return false;
  }

  double deltaR = 999.;
  double deltaRMIN = 999.;

  uint32_t electron_index = 0;
  RecoElectrons::const_iterator ielec = elecs->begin();
  RecoElectrons::const_iterator jelec = elecs->end();
  for (; ielec != jelec; ++ielec) {
    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
    double deltaphi = fabs(ielec->phi() - (*itrk)->momentum().phi());
    if (deltaphi > 6.283185308)
      deltaphi -= 6.283185308;
    if (deltaphi > 3.141592654)
      deltaphi = 6.283185308 - deltaphi;
    deltaR = abs(sqrt(pow((ielec->eta() - (*itrk)->momentum().eta()), 2) + pow(deltaphi, 2)));
    if (deltaR < deltaRMIN) {
      deltaRMIN = deltaR;
    }
  }

  if (deltaR < 0.02)
    return true;
  else
    return false;
}

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

protected

Matches tracks to RECO muons.

Definition at line 1067 of file JetPlusTrackCorrector.cc.

References edm::Ref< C, T, F >::id(), muon::isGoodMuon(), 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;
}

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 226 of file JetPlusTrackCorrector.cc.

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

Referenced by correction(), and matchTracks().

                                                                 {
  // Associate tracks to jet at both the Vertex and CaloFace
  JetTracks jet_tracks;
  bool ok = jetTrackAssociation(fJet, event, setup, jet_tracks);

  // std::cout<<"JetPlusTrackCorrector::matchTracks, JetTrackAssociation ok="<<ok<<std::endl;

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

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 363 of file JetPlusTrackCorrector.cc.

References edm::RefVector< C, T, F >::begin(), jpt::JetTracks::caloFace_, jpt::MatchedTracks::clear(), 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(), edm::HandleBase::isValid(), LogTrace, matchElectrons(), matchMuons(), jpt::MatchedTracks::outOfVertexInCalo_, edm::RefVector< C, T, F >::push_back(), anotherprimaryvertexanalyzer_cfi::pvCollection, findQualityFiles::rr, edm::RefVector< C, T, F >::size(), contentValuesCheck::ss, theSumPtForBeta, trackQuality_, tracksInCalo(), useElecs_, useMuons_, 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;
  bool found_reco_muons = true;
  if (useMuons_) {
    getMuons(event, reco_muons);
  }

  // Get RECO electrons and their ids
  edm::Handle<RecoElectrons> reco_elecs;
  edm::Handle<RecoElectronIds> reco_elec_ids;
  bool found_reco_elecs = true;
  if (useElecs_) {
    getElectrons(event, reco_elecs, reco_elec_ids);
  }

  // Check RECO products found
  if (!found_reco_muons || !found_reco_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();

    //    std::cout<<" Print theSumPtForBeta "<<theSumPtForBeta<<std::endl;

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

      //      std::cout<<" Size of PV "<<pvCollection->size()<<std::endl;

      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++;
          //          std::cout<<" Numpv "<<numpv<<std::endl;
          break;
        }

      }  // all vertices

      //      std::cout<<" Track in PV "<<itrack_belong<<" "<<numpv<<std::endl;

      if (numpv > 1 && itrack_belong == 0) {
        //       std::cout<<" Drop track "<<std::endl;
        continue;
      }

      // std::cout<<" we take it "<<numpv<<" "<<itrack_belong<<std::endl;

      if (failTrackQuality(itrk)) {
        continue;
      }

      //     std::cout<<" Track accepted "<<std::endl;

      TrackRefs::iterator it = jet_tracks.caloFace_.end();
      bool found = findTrack(jet_tracks, itrk, it);

      //       std::cout<<"JetPlusTrackCorrector::matchTracks:  jet_tracks.caloFace_.size()="<<jet_tracks.caloFace_.size()
      //                <<" found = "<<found<<std::endl;

      bool is_muon = useMuons_ && matchMuons(itrk, reco_muons);
      bool is_ele = useElecs_ && matchElectrons(itrk, reco_elecs, reco_elec_ids);

      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);
          //         std::cout<<"JetPlusTrackCorrector::matchTracks: pions.inVertexOutOfCalo_.push_back(*itrk), size="
          //                  <<pions.inVertexOutOfCalo_.size() <<std::endl;
        }
      }
    }
  }

  // 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 is_muon = useMuons_ && matchMuons(itrk, reco_muons);
        bool is_ele = useElecs_ && matchElectrons(itrk, reco_elecs, reco_elec_ids);

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

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

Calculates correction to be applied using muons.

Definition at line 698 of file JetPlusTrackCorrector.cc.

References jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, jpt::MatchedTracks::outOfVertexInCalo_, edm::RefVector< C, T, F >::size(), 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;
}

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 454 of file JetPlusTrackCorrector.h.

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

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

Calculates corrections to be applied using pions.

Definition at line 623 of file JetPlusTrackCorrector.cc.

References efficiencyMap(), jpt::MatchedTracks::inVertexInCalo_, jpt::MatchedTracks::inVertexOutOfCalo_, 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;
  /*
  std::cout<<" pionCorrection::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
  theResponseOfChargedWithoutEff <<" "<<
  theSumPtWithEff <<" "<<
  theSumPtWithoutEff <<" "<<
  theSumEnergyWithEff <<" "<<
  theSumEnergyWithoutEff <<std::endl;
*/

  // 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;
}

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 449 of file JetPlusTrackCorrector.h.

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

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 995 of file JetPlusTrackCorrector.cc.

References jpt::Map::binCenterEta(), jpt::Map::binCenterPt(), corr, correction(), LEDCalibrationChannels::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;
  /*      
      std::cout<<" Efficiency correction End::Corrections for jet "<<  theResponseOfChargedWithEff <<" "<<
      theResponseOfChargedWithoutEff <<" "<<
      theSumPtWithEff <<" "<<
      theSumPtWithoutEff <<" "<<
      theSumEnergyWithEff <<" "<<
      theSumEnergyWithoutEff <<std::endl;
*/
  return correction;
}

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

protected

Rebuild jet-track association.

Definition at line 1140 of file JetPlusTrackCorrector.cc.

References reco::JetTracksAssociation::allJets(), edm::RefVector< C, T, F >::begin(), edm::RefVector< C, T, F >::clear(), HLTMuonOfflineAnalyzer_cfi::deltaR2, edm::RefVector< C, T, F >::end(), reco::LeafCandidate::et(), reco::LeafCandidate::eta(), RemoveAddSevLevel::flag, reco::JetTracksAssociation::getValue(), cuy::ii, reco::btau::jetEta, reco::btau::jetPhi, jetSplitMerge_, reco::LeafCandidate::phi(), edm::RefVector< C, T, F >::push_back(), Scenarios_cff::scale, and PDWG_EXOHSCP_cff::tracks.

Referenced by jtaUsingEventData().

                                                              {
  // std::cout<<" NEW1 Merge/Split schema "<<jetSplitMerge_<<std::endl;

  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();

  //  std::cout<<" Size of initial vector "<<tracks.size()<<" "<<fJet.et()<<" "<<fJet.eta()<<" "<<fJet.phi()<<std::endl;

  int tr = 0;

  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;
    tr++;
    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) {
        //std::cout<<" Track belong to another jet also "<<dR2<<" "<<
        //(*ii)->et()<<" "<<(*ii)->eta()<<" "<< (*ii)->phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<" "<<scalethis<<" "<<scale<<" "<<flag<<std::endl;
        break;
      }
    }

    //std::cout<<" Track "<<tr<<" "<<flag<<" "<<dR2this<<" "<<dR2check<<" Jet "<<fJet.eta()<<" "<< fJet.phi()<<" Track "<<(**it).eta()<<" "<<(**it).phi()<<std::endl;
    if (flag == 1) {
      tracksthis.push_back(*it);
    } else {
      Excl.push_back(*it);
    }
  }

  //std::cout<<" The new size of tracks "<<tracksthis.size()<<" Excludede "<<Excl.size()<<std::endl;
  return;
}

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

inlineprotected

Definition at line 475 of file JetPlusTrackCorrector.h.

Referenced by pionCorrection().

{ return response_; }

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 611 of file JetPlusTrackCorrector.cc.

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

Referenced by matchTracks().

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

bool JetPlusTrackCorrector::vectorialCorrection ( ) const

inline

Returns value of configurable.

Definition at line 446 of file JetPlusTrackCorrector.h.

{ return vectorial_; }

Member Data Documentation

double JetPlusTrackCorrector::dzVertexCut_

protected

Definition at line 388 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality().

const jpt::Map JetPlusTrackCorrector::efficiency_

protected

Definition at line 401 of file JetPlusTrackCorrector.h.

Referenced by correctAA().

double JetPlusTrackCorrector::elecMass_

protected

Definition at line 407 of file JetPlusTrackCorrector.h.

edm::InputTag JetPlusTrackCorrector::electronIds_

protected

Definition at line 394 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

edm::InputTag JetPlusTrackCorrector::electrons_

protected

Definition at line 393 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

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

private

Definition at line 424 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and jtaUsingEventData().

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

private

Definition at line 423 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and jtaUsingEventData().

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

private

Definition at line 426 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and matchTracks().

edm::EDGetTokenT<RecoElectronIds> JetPlusTrackCorrector::input_reco_elec_ids_token_

private

Definition at line 428 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

edm::EDGetTokenT<RecoElectrons> JetPlusTrackCorrector::input_reco_elecs_token_

private

Definition at line 427 of file JetPlusTrackCorrector.h.

Referenced by getElectrons(), and JetPlusTrackCorrector().

edm::EDGetTokenT<RecoMuons> JetPlusTrackCorrector::inut_reco_muons_token_

private

Definition at line 425 of file JetPlusTrackCorrector.h.

Referenced by getMuons(), and JetPlusTrackCorrector().

int JetPlusTrackCorrector::jetSplitMerge_

protected

Definition at line 385 of file JetPlusTrackCorrector.h.

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

edm::InputTag JetPlusTrackCorrector::jetTracksAtCalo_

protected

Definition at line 384 of file JetPlusTrackCorrector.h.

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

edm::InputTag JetPlusTrackCorrector::jetTracksAtVertex_

protected

Definition at line 383 of file JetPlusTrackCorrector.h.

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

const jpt::Map JetPlusTrackCorrector::leakage_

protected

Definition at line 402 of file JetPlusTrackCorrector.h.

double JetPlusTrackCorrector::maxEta_

protected

Definition at line 410 of file JetPlusTrackCorrector.h.

double JetPlusTrackCorrector::muonMass_

protected

Definition at line 406 of file JetPlusTrackCorrector.h.

edm::InputTag JetPlusTrackCorrector::muons_

protected

Definition at line 392 of file JetPlusTrackCorrector.h.

Referenced by getMuons(), and JetPlusTrackCorrector().

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

protected

Definition at line 418 of file JetPlusTrackCorrector.h.

Referenced by pionCorrection().

double JetPlusTrackCorrector::pionMass_

protected

Definition at line 405 of file JetPlusTrackCorrector.h.

Referenced by pionEfficiency().

double JetPlusTrackCorrector::ptErrorQuality_

protected

Definition at line 387 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality().

const jpt::Map JetPlusTrackCorrector::response_

protected

Definition at line 400 of file JetPlusTrackCorrector.h.

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

edm::InputTag JetPlusTrackCorrector::srcPVs_

protected

Definition at line 386 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector().

float JetPlusTrackCorrector::theResponseOfChargedWithEff

protected

Definition at line 411 of file JetPlusTrackCorrector.h.

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

float JetPlusTrackCorrector::theResponseOfChargedWithoutEff

protected

Definition at line 412 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), and correction().

float JetPlusTrackCorrector::theSumEnergyWithEff

protected

Definition at line 415 of file JetPlusTrackCorrector.h.

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

float JetPlusTrackCorrector::theSumEnergyWithoutEff

protected

Definition at line 416 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), and correction().

float JetPlusTrackCorrector::theSumPtForBeta

protected

Definition at line 417 of file JetPlusTrackCorrector.h.

Referenced by correction(), and matchTracks().

float JetPlusTrackCorrector::theSumPtWithEff

protected

Definition at line 413 of file JetPlusTrackCorrector.h.

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

float JetPlusTrackCorrector::theSumPtWithoutEff

protected

Definition at line 414 of file JetPlusTrackCorrector.h.

Referenced by calculateCorr(), and correction().

reco::TrackBase::TrackQuality JetPlusTrackCorrector::trackQuality_

protected

Definition at line 397 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality(), and matchTracks().

bool JetPlusTrackCorrector::useEff_

protected

Definition at line 377 of file JetPlusTrackCorrector.h.

Referenced by JetPlusTrackCorrector(), and pionCorrection().

bool JetPlusTrackCorrector::useElecs_

protected

Definition at line 379 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::useInConeTracks_

protected

Definition at line 373 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::useMuons_

protected

Definition at line 378 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::useOutOfConeTracks_

protected

Definition at line 374 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::useOutOfVertexTracks_

protected

Definition at line 375 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::usePions_

protected

Definition at line 376 of file JetPlusTrackCorrector.h.

Referenced by correction(), and JetPlusTrackCorrector().

bool JetPlusTrackCorrector::useTrackQuality_

protected

Definition at line 380 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::vecResponse_

protected

Definition at line 372 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::vectorial_

protected

Definition at line 371 of file JetPlusTrackCorrector.h.

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

bool JetPlusTrackCorrector::verbose_

protected

Definition at line 370 of file JetPlusTrackCorrector.h.

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

reco::Particle::Point JetPlusTrackCorrector::vertex_

protected

Definition at line 389 of file JetPlusTrackCorrector.h.

Referenced by failTrackQuality(), and matchTracks().