CMS 3D CMS Logo

JetPlusTrackCorrector.h
Go to the documentation of this file.
1 #ifndef RecoJets_JetPlusTrack_JetPlusTrackCorrector_h
2 #define RecoJets_JetPlusTrack_JetPlusTrackCorrector_h
3 
8 
22 
23 #include "boost/range/iterator_range.hpp"
24 #include <sstream>
25 #include <string>
26 
27 namespace edm {
28  class Event;
29  class EventSetup;
30  class ParameterSet;
31 }
32 
33 // --------------------------------------------------------
34 // -------------------- Helper classes --------------------
35 // --------------------------------------------------------
36 
37 
38 namespace jpt {
39 
41  class Map {
42 
43  public:
44 
45  Map( std::string, bool verbose = false );
46  Map();
47  ~Map();
48 
49  uint32_t nEtaBins() const;
50  uint32_t nPtBins() const;
51 
52  double eta( uint32_t ) const;
53  double pt( uint32_t ) const;
54 
55  uint32_t etaBin( double eta ) const;
56  uint32_t ptBin( double pt ) const;
57 
58  double value( uint32_t eta_bin, uint32_t pt_bin ) const;
59 
60  double binCenterEta( uint32_t ) const;
61  double binCenterPt( uint32_t ) const;
62 
63  void clear();
64  void print( std::stringstream& ss ) const;
65 
66  private:
67 
68  class Element {
69  public:
70  Element() : ieta_(0), ipt_(0), eta_(0.), pt_(0.), val_(0.) {;}
71  uint32_t ieta_;
72  uint32_t ipt_;
73  double eta_;
74  double pt_;
75  double val_;
76  };
77 
78  typedef std::vector<double> VDouble;
79  typedef std::vector<VDouble> VVDouble;
80 
81  std::vector<double> eta_;
82  std::vector<double> pt_;
83  VVDouble data_;
84 
85  };
86 
87  inline uint32_t Map::nEtaBins() const { return eta_.size(); }
88  inline uint32_t Map::nPtBins() const { return pt_.size(); }
89 
91  class Efficiency {
92 
93  public:
94 
95  Efficiency( const jpt::Map& response,
96  const jpt::Map& efficiency,
97  const jpt::Map& leakage );
98 
99  typedef std::pair<uint16_t,double> Pair;
100 
101  uint16_t nTrks( uint32_t eta_bin, uint32_t pt_bin ) const;
102 
103  double inConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const;
104  double outOfConeCorr( uint32_t eta_bin, uint32_t pt_bin ) const;
105 
106  uint32_t nEtaBins() const;
107  uint32_t nPtBins() const;
108 
109  uint32_t size() const;
110  bool empty() const;
111 
112  void addE( uint32_t eta_bin, uint32_t pt_bin, double energy );
113  void reset();
114 
115  void print() const;
116 
117  private:
118 
119  Efficiency() = delete;
120 
121  double sumE( uint32_t eta_bin, uint32_t pt_bin ) const;
122  double meanE( uint32_t eta_bin, uint32_t pt_bin ) const;
123 
124  bool check( uint32_t eta_bin, uint32_t pt_bin, std::string name = "check" ) const;
125 
126  typedef std::vector<Pair> VPair;
127  typedef std::vector<VPair> VVPair;
128  VVPair data_;
129 
133 
134  };
135 
136  inline uint32_t Efficiency::nEtaBins() const { return response_.nEtaBins(); }
137  inline uint32_t Efficiency::nPtBins() const { return response_.nPtBins(); }
138  inline uint32_t Efficiency::size() const { return data_.size(); }
139  inline bool Efficiency::empty() const { return data_.empty(); }
140 
142  class JetTracks {
143  public:
144  JetTracks();
145  ~JetTracks();
146  void clear();
149  };
150 
153  public:
154  MatchedTracks();
155  ~MatchedTracks();
156  void clear();
160  };
161 
162 //class Sum {
163 //public:
164 // Sum() { theResponseOfChargedWithEff = 0.; theResponseOfChargedFull = 0.;}
165 // void set( double a, double b) const {theResponseOfChargedWithEff=a;theResponseOfChargedFull=b;}
166 // double theResponseOfChargedWithEff;
167 // double theResponseOfChargedFull;
168 //};
169 
170 }
171 
172 
173 // -------------------------------------------------------
174 // -------------------- JPT algorithm --------------------
175 // -------------------------------------------------------
176 
181 
182  // ---------- Public interface ----------
183 
184  public:
185 
188 
190  virtual ~JetPlusTrackCorrector();
191 
192  // Typedefs for 4-momentum
196 
198  double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&, P4&,
199  jpt::MatchedTracks &pions,
202  bool &validMatches) ;
203 
205  double correction( const reco::Jet&, const reco::Jet&, const edm::Event&, const edm::EventSetup&,
206  jpt::MatchedTracks &pions,
209  bool &validMatches) ;
210 
212  double correction( const reco::Jet& ) const;
213 
215  double correction( const P4& ) const;
216 
218 
219 // double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&, double&) const;
220  double correctAA( const reco::Jet&, const reco::TrackRefVector&, double&, const reco::TrackRefVector&,const reco::TrackRefVector&,
221  double,
222  const reco::TrackRefVector&) const;
223 
224 
226  bool eventRequired() const;
227 
229  bool vectorialCorrection() const;
230 
231  // ---------- Extended interface ----------
232 
234 
235  double getResponseOfChargedWithEff() {return theResponseOfChargedWithEff;}
236  double getResponseOfChargedWithoutEff() {return theResponseOfChargedWithoutEff;}
237  double getSumPtWithEff() {return theSumPtWithEff;}
238  double getSumPtWithoutEff() {return theSumPtWithoutEff;}
239  double getSumEnergyWithEff() {return theSumEnergyWithEff;}
240  double getSumEnergyWithoutEff() {return theSumEnergyWithoutEff;}
241  double getSumPtForBeta() {return theSumPtForBeta;}
242 
243 
245  bool canCorrect( const reco::Jet& ) const;
246 
248  bool matchTracks( const reco::Jet&,
249  const edm::Event&,
250  const edm::EventSetup&,
251  jpt::MatchedTracks& pions,
254 
256  P4 pionCorrection( const P4& jet, const jpt::MatchedTracks& pions ) ;
257 
259  P4 muonCorrection( const P4& jet, const jpt::MatchedTracks& muons ) ;
260 
262  P4 elecCorrection( const P4& jet, const jpt::MatchedTracks& elecs ) const;
263 
265 
266 // double theResponseOfChargedWithEff;
267 // double theResponseOfChargedFull;
268 // double setResp(double a) const {return a;}
269 // double getChargedResponsesWithEff() { return theResponseOfChargedWithEff;}
270 // double getChargedResponsesFull() { return theResponseOfChargedFull;}
271 
272  // ---------- Protected interface ----------
273 
274  protected:
275 
276  // Some useful typedefs
282 
284  virtual bool jetTrackAssociation( const reco::Jet&,
285  const edm::Event&,
286  const edm::EventSetup&,
287  jpt::JetTracks& ) const;
288 
290  bool jtaUsingEventData( const reco::Jet&,
291  const edm::Event&,
292  jpt::JetTracks& ) const;
293 
295  virtual void matchTracks( const jpt::JetTracks&,
296  const edm::Event&,
297  jpt::MatchedTracks& pions,
298  jpt::MatchedTracks& muons,
299  jpt::MatchedTracks& elecs ) ;
300 
302  P4 pionCorrection( const P4& jet,
303  const TrackRefs& pions,
305  bool in_cone_at_vertex,
306  bool in_cone_at_calo_face ) ;
307 
309  P4 muonCorrection( const P4& jet,
310  const TrackRefs& muons,
311  bool in_cone_at_vertex,
312  bool in_cone_at_calo_face ) ;
313 
315  P4 elecCorrection( const P4& jet,
316  const TrackRefs& elecs,
317  bool in_cone_at_vertex,
318  bool in_cone_at_calo_face ) ;
319 
321  P4 jetDirFromTracks( const P4& jet,
322  const jpt::MatchedTracks& pions,
323  const jpt::MatchedTracks& muons,
324  const jpt::MatchedTracks& elecs ) const;
325 
327  P4 calculateCorr( const P4& jet,
328  const TrackRefs&,
330  bool in_cone_at_vertex,
331  bool in_cone_at_calo_face,
332  double mass,
333  bool is_pion,
334  double mip ) ;
335 
337  P4 pionEfficiency( const P4& jet,
338  const jpt::Efficiency&,
339  bool in_cone_at_calo_face ) ;
340 
342  double checkScale( const P4& jet, P4& corrected ) const;
343 
345  bool getMuons( const edm::Event&, edm::Handle<RecoMuons>& ) const;
346 
348  bool getElectrons( const edm::Event&,
351 
353  bool matchMuons( TrackRefs::const_iterator&,
354  const edm::Handle<RecoMuons>& ) const;
355 
357  bool matchElectrons( TrackRefs::const_iterator&,
359  const edm::Handle<RecoElectronIds>& ) const;
360 
362  bool failTrackQuality( TrackRefs::const_iterator& ) const;
363 
365  bool findTrack( const jpt::JetTracks&,
367  TrackRefs::iterator& ) const;
368 
370  bool findTrack( const jpt::MatchedTracks& pions,
371  const jpt::MatchedTracks& muons,
373  TrackRefs::const_iterator& ) const;
374 
376  bool tracksInCalo( const jpt::MatchedTracks& pions,
377  const jpt::MatchedTracks& muons,
378  const jpt::MatchedTracks& elecs ) const;
379 
381  void rebuildJta( const reco::Jet&,
382  const JetTracksAssociations&,
383  TrackRefs& included,
384  TrackRefs& excluded ) const;
385 
387  void excludeJta( const reco::Jet&,
388  const JetTracksAssociations&,
389  TrackRefs& included,
390  const TrackRefs& excluded ) const;
391 
392  const jpt::Map& responseMap() const;
393  const jpt::Map& efficiencyMap() const;
394  const jpt::Map& leakageMap() const;
395 
398 
399  // ---------- Protected member data ----------
400 
401  protected:
402 
403  // Some general configuration
404  bool verbose_;
410  bool usePions_;
411  bool useEff_;
412  bool useMuons_;
413  bool useElecs_;
415 
416  // Jet-track association
422  double dzVertexCut_;
424 
425  // Muons and electrons
429 
430  // Filter tracks by quality
432 
433  // Response and efficiency maps
437 
438  // Mass
439  double pionMass_;
440  double muonMass_;
441  double elecMass_;
442 
443  // Jet-related
444  double maxEta_;
452  jpt::Efficiency not_used{response_,efficiency_,leakage_};
453 
454  // ---------- Private data members ----------
455 
456  private:
463 
464 };
465 
466 // ---------- Inline methods ----------
467 
468 inline double JetPlusTrackCorrector::correction( const reco::Jet& fJet, const reco::Jet& fJetcalo,
469  const edm::Event& event,
470  const edm::EventSetup& setup,
471  jpt::MatchedTracks &pions,
474  bool &validMatches) {
475  P4 not_used_for_scalar_correction;
476  return correction( fJet, fJetcalo, event, setup, not_used_for_scalar_correction,pions,muons,elecs,validMatches );
477 }
478 
479 inline bool JetPlusTrackCorrector::eventRequired() const { return true; }
480 inline bool JetPlusTrackCorrector::vectorialCorrection() const { return vectorial_; }
481 inline bool JetPlusTrackCorrector::canCorrect( const reco::Jet& jet ) const { return ( fabs( jet.eta() ) <= maxEta_ ); }
482 
484  const TrackRefs& pions,
485  jpt::Efficiency& eff,
486  bool in_cone_at_vertex,
487  bool in_cone_at_calo_face ) {
488  return calculateCorr( jet, pions, eff, in_cone_at_vertex, in_cone_at_calo_face, pionMass_, true, -1. );
489 }
490 
492  const TrackRefs& muons,
493  bool in_cone_at_vertex,
494  bool in_cone_at_calo_face ) {
495  return calculateCorr( jet, muons, not_used, in_cone_at_vertex, in_cone_at_calo_face, muonMass_, false, 2. );
496 }
497 
499  const TrackRefs& elecs,
500  bool in_cone_at_vertex,
501  bool in_cone_at_calo_face ) {
502  return calculateCorr( jet, elecs, not_used, in_cone_at_vertex, in_cone_at_calo_face, elecMass_, false, 0. );
503 }
504 
505 inline double JetPlusTrackCorrector::checkScale( const P4& jet, P4& corrected ) const {
506  if ( jet.energy() > 0. && ( corrected.energy() / jet.energy() ) < 0. ) {
507  corrected = jet;
508  }
509  return corrected.energy() / jet.energy();
510 }
511 
512 inline const jpt::Map& JetPlusTrackCorrector::responseMap() const { return response_; }
513 inline const jpt::Map& JetPlusTrackCorrector::efficiencyMap() const { return efficiency_; }
514 inline const jpt::Map& JetPlusTrackCorrector::leakageMap() const { return leakage_; }
515 
516 #endif // RecoJets_JetPlusTracks_JetPlusTrackCorrector_h
size
Write out results.
math::XYZTLorentzVector P4
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< double > > PtEtaPhiMLorentzVectorD
Lorentz vector with cartesian internal representation.
Definition: LorentzVector.h:10
double eta() const final
momentum pseudorapidity
bool vectorialCorrection() const
Returns value of configurable.
edm::EDGetTokenT< RecoMuons > inut_reco_muons_token_
TrackQuality
track quality
Definition: TrackBase.h:151
Base class for all types of Jets.
Definition: Jet.h:20
const jpt::Map & responseMap() const
reco::TrackRefVector inVertexInCalo_
def setup(process, global_tag, zero_tesla=False)
Definition: GeneralSetup.py:2
reco::TrackRefVector vertex_
reco::TrackRefVector inVertexOutOfCalo_
reco::GsfElectronCollection RecoElectrons
std::pair< uint16_t, double > Pair
Container class for response & efficiency maps.
S & print(S &os, JobReport::InputFile const &f)
Definition: JobReport.cc:66
double checkScale(const P4 &jet, P4 &corrected) const
Check corrected 4-momentum does not give negative scale.
edm::ValueMap< float > RecoElectronIds
std::vector< GsfElectron > GsfElectronCollection
collection of GsfElectron objects
const jpt::Map & efficiency_
std::pair< double, double > matchTracks(const reco::Track &ref, const reco::Track &probe)
std::vector< Muon > MuonCollection
collection of Muon objects
Definition: MuonFwd.h:9
P4 pionCorrection(const P4 &jet, const jpt::MatchedTracks &pions)
Calculates corrections to be applied using pions.
edm::EDGetTokenT< RecoElectronIds > input_reco_elec_ids_token_
const jpt::Map & efficiencyMap() const
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
reco::Particle::Point vertex_
edm::EDGetTokenT< RecoElectrons > input_reco_elecs_token_
bool canCorrect(const reco::Jet &) const
Can jet be JPT-corrected?
bool eventRequired() const
Returns true.
const jpt::Map & response_
reco::TrackRefVector caloFace_
void clear(CLHEP::HepGenMatrix &m)
Helper function: Reset all elements of a matrix to 0.
Definition: matutil.cc:167
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)
const jpt::Map & leakageMap() const
double getResponseOfChargedWithEff()
Get responses/sumPT/SumEnergy with and without Efficiency correction.
reco::TrackRefVector TrackRefs
math::XYZPoint Point
point in the space
Definition: Particle.h:25
reco::TrackRefVector outOfVertexInCalo_
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiE4D< double > > PtEtaPhiELorentzVectorD
Lorentz vector with cartesian internal representation.
Definition: LorentzVector.h:12
math::PtEtaPhiELorentzVectorD PtEtaPhiE
reco::JetTracksAssociation::Container JetTracksAssociations
std::vector< VPair > VVPair
std::vector< VDouble > VVDouble
P4 elecCorrection(const P4 &jet, const jpt::MatchedTracks &elecs) const
Calculates correction to be applied using electrons.
Tracks associated to jets that are in-cone at Vertex and CaloFace.
std::vector< double > pt_
reco::TrackBase::TrackQuality trackQuality_
std::vector< Pair > VPair
P4 muonCorrection(const P4 &jet, const jpt::MatchedTracks &muons)
Calculates correction to be applied using muons.
std::vector< double > eta_
Particles matched to tracks that are in/in, in/out, out/in at Vertex and CaloFace.
HLT enums.
Jet energy correction algorithm using tracks.
JetPlusTrackCorrector()
Default constructor.
edm::EDGetTokenT< reco::JetTracksAssociation::Container > input_jetTracksAtCalo_token_
edm::EDGetTokenT< reco::JetTracksAssociation::Container > input_jetTracksAtVertex_token_
reco::MuonCollection RecoMuons
Get reponses.
edm::EDGetTokenT< reco::VertexCollection > input_pvCollection_token_
void reset(double vett[256])
Definition: TPedValues.cc:11
Generic container class.
static void check(T const &p, std::string const &id, SelectedProducts const &iProducts)
std::vector< double > VDouble
math::PtEtaPhiMLorentzVectorD PtEtaPhiM
Definition: event.py:1
const jpt::Map & leakage_