CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
TtSemiLepHitFitProducer.h
Go to the documentation of this file.
1 #ifndef TtSemiLepHitFitProducer_h
2 #define TtSemiLepHitFitProducer_h
3 
4 #include "FWCore/Framework/interface/Event.h"
5 #include "FWCore/Framework/interface/EDProducer.h"
6 #include "FWCore/ParameterSet/interface/ParameterSet.h"
7 
8 #include "PhysicsTools/JetMCUtils/interface/combination.h"
9 #include "AnalysisDataFormats/TopObjects/interface/TtSemiLepEvtPartons.h"
10 #include "DataFormats/PatCandidates/interface/Lepton.h"
11 #include "AnalysisDataFormats/TopObjects/interface/TtSemiEvtSolution.h"
12 
13 #include "TopQuarkAnalysis/TopHitFit/interface/RunHitFit.h"
14 #include "TopQuarkAnalysis/TopHitFit/interface/Top_Decaykin.h"
15 #include "TopQuarkAnalysis/TopHitFit/interface/LeptonTranslatorBase.h"
16 #include "TopQuarkAnalysis/TopHitFit/interface/JetTranslatorBase.h"
17 #include "TopQuarkAnalysis/TopHitFit/interface/METTranslatorBase.h"
18 
19 template <typename LeptonCollection>
20 class TtSemiLepHitFitProducer : public edm::EDProducer {
21 
22  public:
23 
24  explicit TtSemiLepHitFitProducer(const edm::ParameterSet&);
25  ~TtSemiLepHitFitProducer();
26 
27  private:
28  // produce
29  virtual void produce(edm::Event&, const edm::EventSetup&);
30 
31  edm::EDGetTokenT<std::vector<pat::Jet> > jetsToken_;
32  edm::EDGetTokenT<LeptonCollection> lepsToken_;
33  edm::EDGetTokenT<std::vector<pat::MET> > metsToken_;
34 
36  int maxNJets_;
38  int maxNComb_;
39 
41  double maxEtaMu_;
43  double maxEtaEle_;
45  double maxEtaJet_;
46 
48  std::string bTagAlgo_;
50  double minBTagValueBJet_;
52  double maxBTagValueNonBJet_;
54  bool useBTag_;
55 
57  double mW_;
58  double mTop_;
59 
61  std::string jetCorrectionLevel_;
62 
64  double jes_;
65  double jesB_;
66 
67  struct FitResult {
68  int Status;
69  double Chi2;
70  double Prob;
71  double MT;
72  double SigMT;
73  pat::Particle HadB;
74  pat::Particle HadP;
75  pat::Particle HadQ;
76  pat::Particle LepB;
77  pat::Particle LepL;
78  pat::Particle LepN;
79  std::vector<int> JetCombi;
80  bool operator< (const FitResult& rhs) { return Chi2 < rhs.Chi2; };
81  };
82 
83  typedef hitfit::RunHitFit<pat::Electron,pat::Muon,pat::Jet,pat::MET> PatHitFit;
84 
85  edm::FileInPath hitfitDefault_;
86  edm::FileInPath hitfitElectronResolution_;
87  edm::FileInPath hitfitMuonResolution_;
88  edm::FileInPath hitfitUdscJetResolution_;
89  edm::FileInPath hitfitBJetResolution_;
90  edm::FileInPath hitfitMETResolution_;
91 
92  hitfit::LeptonTranslatorBase<pat::Electron> electronTranslator_;
93  hitfit::LeptonTranslatorBase<pat::Muon> muonTranslator_;
94  hitfit::JetTranslatorBase<pat::Jet> jetTranslator_;
95  hitfit::METTranslatorBase<pat::MET> metTranslator_;
96 
97  PatHitFit* HitFit;
98 };
99 
100 template<typename LeptonCollection>
101 TtSemiLepHitFitProducer<LeptonCollection>::TtSemiLepHitFitProducer(const edm::ParameterSet& cfg):
102  jetsToken_ (consumes<std::vector<pat::Jet> >(cfg.getParameter<edm::InputTag>("jets"))),
103  lepsToken_ (consumes<LeptonCollection>(cfg.getParameter<edm::InputTag>("leps"))),
104  metsToken_ (consumes<std::vector<pat::MET> >(cfg.getParameter<edm::InputTag>("mets"))),
105  maxNJets_ (cfg.getParameter<int> ("maxNJets" )),
106  maxNComb_ (cfg.getParameter<int> ("maxNComb" )),
107  bTagAlgo_ (cfg.getParameter<std::string> ("bTagAlgo" )),
108  minBTagValueBJet_ (cfg.getParameter<double> ("minBDiscBJets" )),
109  maxBTagValueNonBJet_ (cfg.getParameter<double> ("maxBDiscLightJets" )),
110  useBTag_ (cfg.getParameter<bool> ("useBTagging" )),
111  mW_ (cfg.getParameter<double> ("mW" )),
112  mTop_ (cfg.getParameter<double> ("mTop" )),
113  jetCorrectionLevel_ (cfg.getParameter<std::string> ("jetCorrectionLevel" )),
114  jes_ (cfg.getParameter<double> ("jes" )),
115  jesB_ (cfg.getParameter<double> ("jesB" )),
116 
117  // The following five initializers read the config parameters for the
118  // ASCII text files which contains the physics object resolutions.
119  hitfitDefault_ (cfg.getUntrackedParameter<edm::FileInPath>(std::string("hitfitDefault"),
120  edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/setting/RunHitFitConfiguration.txt")))),
121  hitfitElectronResolution_(cfg.getUntrackedParameter<edm::FileInPath>(std::string("hitfitElectronResolution"),
122  edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafElectronResolution.txt")))),
123  hitfitMuonResolution_ (cfg.getUntrackedParameter<edm::FileInPath>(std::string("hitfitMuonResolution"),
124  edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafMuonResolution.txt")))),
125  hitfitUdscJetResolution_ (cfg.getUntrackedParameter<edm::FileInPath>(std::string("hitfitUdscJetResolution"),
126  edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafUdscJetResolution.txt")))),
127  hitfitBJetResolution_ (cfg.getUntrackedParameter<edm::FileInPath>(std::string("hitfitBJetResolution"),
128  edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafBJetResolution.txt")))),
129  hitfitMETResolution_ (cfg.getUntrackedParameter<edm::FileInPath>(std::string("hitfitMETResolution"),
130  edm::FileInPath(std::string("TopQuarkAnalysis/TopHitFit/data/resolution/tqafKtResolution.txt")))),
131 
132  // The following four initializers instantiate the translator between PAT objects
133  // and HitFit objects using the ASCII text files which contains the resolutions.
134  electronTranslator_(hitfitElectronResolution_.fullPath()),
135  muonTranslator_ (hitfitMuonResolution_.fullPath()),
136  jetTranslator_ (hitfitUdscJetResolution_.fullPath(), hitfitBJetResolution_.fullPath(), jetCorrectionLevel_, jes_, jesB_),
137  metTranslator_ (hitfitMETResolution_.fullPath())
138 
139 {
140  // Create an instance of RunHitFit and initialize it.
141  HitFit = new PatHitFit(electronTranslator_,
142  muonTranslator_,
143  jetTranslator_,
144  metTranslator_,
145  hitfitDefault_.fullPath(),
146  mW_,
147  mW_,
148  mTop_);
149 
150  maxEtaMu_ = 2.4;
151  maxEtaEle_ = 2.5;
152  maxEtaJet_ = 2.5;
153 
154  edm::LogVerbatim( "TopHitFit" )
155  << "\n"
156  << "+++++++++++ TtSemiLepHitFitProducer ++++++++++++ \n"
157  << " Due to the eta ranges for which resolutions \n"
158  << " are provided in \n"
159  << " TopQuarkAnalysis/TopHitFit/data/resolution/ \n"
160  << " so far, the following cuts are currently \n"
161  << " implemented in the TtSemiLepHitFitProducer: \n"
162  << " |eta(muons )| <= " << maxEtaMu_ << " \n"
163  << " |eta(electrons)| <= " << maxEtaEle_ << " \n"
164  << " |eta(jets )| <= " << maxEtaJet_ << " \n"
165  << "++++++++++++++++++++++++++++++++++++++++++++++++ \n";
166 
167  produces< std::vector<pat::Particle> >("PartonsHadP");
168  produces< std::vector<pat::Particle> >("PartonsHadQ");
169  produces< std::vector<pat::Particle> >("PartonsHadB");
170  produces< std::vector<pat::Particle> >("PartonsLepB");
171  produces< std::vector<pat::Particle> >("Leptons");
172  produces< std::vector<pat::Particle> >("Neutrinos");
173 
174  produces< std::vector<std::vector<int> > >();
175  produces< std::vector<double> >("Chi2");
176  produces< std::vector<double> >("Prob");
177  produces< std::vector<double> >("MT");
178  produces< std::vector<double> >("SigMT");
179  produces< std::vector<int> >("Status");
180  produces< int >("NumberOfConsideredJets");
181 }
182 
183 template<typename LeptonCollection>
184 TtSemiLepHitFitProducer<LeptonCollection>::~TtSemiLepHitFitProducer()
185 {
186  delete HitFit;
187 }
188 
189 template<typename LeptonCollection>
190 void TtSemiLepHitFitProducer<LeptonCollection>::produce(edm::Event& evt, const edm::EventSetup& setup)
191 {
192  std::auto_ptr< std::vector<pat::Particle> > pPartonsHadP( new std::vector<pat::Particle> );
193  std::auto_ptr< std::vector<pat::Particle> > pPartonsHadQ( new std::vector<pat::Particle> );
194  std::auto_ptr< std::vector<pat::Particle> > pPartonsHadB( new std::vector<pat::Particle> );
195  std::auto_ptr< std::vector<pat::Particle> > pPartonsLepB( new std::vector<pat::Particle> );
196  std::auto_ptr< std::vector<pat::Particle> > pLeptons ( new std::vector<pat::Particle> );
197  std::auto_ptr< std::vector<pat::Particle> > pNeutrinos ( new std::vector<pat::Particle> );
198 
199  std::auto_ptr< std::vector<std::vector<int> > > pCombi ( new std::vector<std::vector<int> > );
200  std::auto_ptr< std::vector<double> > pChi2 ( new std::vector<double> );
201  std::auto_ptr< std::vector<double> > pProb ( new std::vector<double> );
202  std::auto_ptr< std::vector<double> > pMT ( new std::vector<double> );
203  std::auto_ptr< std::vector<double> > pSigMT ( new std::vector<double> );
204  std::auto_ptr< std::vector<int> > pStatus( new std::vector<int> );
205  std::auto_ptr< int > pJetsConsidered( new int );
206 
207  edm::Handle<std::vector<pat::Jet> > jets;
208  evt.getByToken(jetsToken_, jets);
209 
210  edm::Handle<std::vector<pat::MET> > mets;
211  evt.getByToken(metsToken_, mets);
212 
213  edm::Handle<LeptonCollection> leps;
214  evt.getByToken(lepsToken_, leps);
215 
216  // -----------------------------------------------------
217  // skip events with no appropriate lepton candidate in
218  // or empty MET or less jets than partons
219  // -----------------------------------------------------
220 
221  const unsigned int nPartons = 4;
222 
223  // Clear the internal state
224  HitFit->clear();
225 
226  // Add lepton into HitFit
227  bool foundLepton = false;
228  if(!leps->empty()) {
229  double maxEtaLep = maxEtaMu_;
230  if( !dynamic_cast<const reco::Muon*>(&((*leps)[0])) ) // assume electron if it is not a muon
231  maxEtaLep = maxEtaEle_;
232  for(unsigned iLep=0; iLep<(*leps).size() && !foundLepton; ++iLep) {
233  if(std::abs((*leps)[iLep].eta()) <= maxEtaLep) {
234  HitFit->AddLepton((*leps)[iLep]);
235  foundLepton = true;
236  }
237  }
238  }
239 
240  // Add jets into HitFit
241  unsigned int nJetsFound = 0;
242  for(unsigned iJet=0; iJet<(*jets).size() && (int)nJetsFound!=maxNJets_; ++iJet) {
243  double jet_eta = (*jets)[iJet].eta();
244  if ( (*jets)[iJet].isCaloJet() ) {
245  jet_eta = ((reco::CaloJet*) ((*jets)[iJet]).originalObject())->detectorP4().eta();
246  }
247  if(std::abs(jet_eta) <= maxEtaJet_) {
248  HitFit->AddJet((*jets)[iJet]);
249  nJetsFound++;
250  }
251  }
252  *pJetsConsidered = nJetsFound;
253 
254  // Add missing transverse energy into HitFit
255  if(!mets->empty())
256  HitFit->SetMet((*mets)[0]);
257 
258  if( !foundLepton || mets->empty() || nJetsFound<nPartons ) {
259  // the kinFit getters return empty objects here
260  pPartonsHadP->push_back( pat::Particle() );
261  pPartonsHadQ->push_back( pat::Particle() );
262  pPartonsHadB->push_back( pat::Particle() );
263  pPartonsLepB->push_back( pat::Particle() );
264  pLeptons ->push_back( pat::Particle() );
265  pNeutrinos ->push_back( pat::Particle() );
266  // indices referring to the jet combination
267  std::vector<int> invalidCombi;
268  for(unsigned int i = 0; i < nPartons; ++i)
269  invalidCombi.push_back( -1 );
270  pCombi->push_back( invalidCombi );
271  // chi2
272  pChi2->push_back( -1. );
273  // chi2 probability
274  pProb->push_back( -1. );
275  // fitted top mass
276  pMT->push_back( -1. );
277  pSigMT->push_back( -1. );
278  // status of the fitter
279  pStatus->push_back( -1 );
280  // feed out all products
281  evt.put(pCombi);
282  evt.put(pPartonsHadP, "PartonsHadP");
283  evt.put(pPartonsHadQ, "PartonsHadQ");
284  evt.put(pPartonsHadB, "PartonsHadB");
285  evt.put(pPartonsLepB, "PartonsLepB");
286  evt.put(pLeptons , "Leptons" );
287  evt.put(pNeutrinos , "Neutrinos" );
288  evt.put(pChi2 , "Chi2" );
289  evt.put(pProb , "Prob" );
290  evt.put(pMT , "MT" );
291  evt.put(pSigMT , "SigMT" );
292  evt.put(pStatus , "Status" );
293  evt.put(pJetsConsidered, "NumberOfConsideredJets");
294  return;
295  }
296 
297  std::list<FitResult> FitResultList;
298 
299  //
300  // BEGIN DECLARATION OF VARIABLES FROM KINEMATIC FIT
301  //
302 
303  // In this part are variables from the
304  // kinematic fit procedure
305 
306  // Number of all permutations of the event
307  size_t nHitFit = 0 ;
308 
309  // Number of jets in the event
310  size_t nHitFitJet = 0 ;
311 
312  // Results of the fit for all jet permutations of the event
313  std::vector<hitfit::Fit_Result> hitFitResult;
314 
315  //
316  // R U N H I T F I T
317  //
318  // Run the kinematic fit and get how many permutations are possible
319  // in the fit
320 
321  nHitFit = HitFit->FitAllPermutation();
322 
323  //
324  // BEGIN PART WHICH EXTRACTS INFORMATION FROM HITFIT
325  //
326 
327  // Get the number of jets
328  nHitFitJet = HitFit->GetUnfittedEvent()[0].njets();
329 
330  // Get the fit results for all permutations
331  hitFitResult = HitFit->GetFitAllPermutation();
332 
333  // Loop over all permutations and extract the information
334  for (size_t fit = 0 ; fit != nHitFit ; ++fit) {
335 
336  // Get the event after the fit
337  hitfit::Lepjets_Event fittedEvent = hitFitResult[fit].ev();
338 
339  /*
340  Get jet permutation according to TQAF convention
341  11 : leptonic b
342  12 : hadronic b
343  13 : hadronic W
344  14 : hadronic W
345  */
346  std::vector<int> hitCombi(4);
347  for (size_t jet = 0 ; jet != nHitFitJet ; ++jet) {
348  int jet_type = fittedEvent.jet(jet).type();
349 
350  switch(jet_type) {
351  case 11: hitCombi[TtSemiLepEvtPartons::LepB ] = jet;
352  break;
353  case 12: hitCombi[TtSemiLepEvtPartons::HadB ] = jet;
354  break;
355  case 13: hitCombi[TtSemiLepEvtPartons::LightQ ] = jet;
356  break;
357  case 14: hitCombi[TtSemiLepEvtPartons::LightQBar] = jet;
358  break;
359  }
360  }
361 
362  // Store the kinematic quantities in the corresponding containers.
363 
364  hitfit::Lepjets_Event_Jet hadP_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::LightQ ]);
365  hitfit::Lepjets_Event_Jet hadQ_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::LightQBar]);
366  hitfit::Lepjets_Event_Jet hadB_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::HadB ]);
367  hitfit::Lepjets_Event_Jet lepB_ = fittedEvent.jet(hitCombi[TtSemiLepEvtPartons::LepB ]);
368  hitfit::Lepjets_Event_Lep lepL_ = fittedEvent.lep(0);
369 
370  /*
372  std::string bTagAlgo_;
374  double minBTagValueBJet_;
376  double maxBTagValueNonBJet_;
378  bool useBTag_;
379  */
380 
381  if ( hitFitResult[fit].chisq() > 0 // only take into account converged fits
382  && (!useBTag_ || ( useBTag_ // use btag information if chosen
383  && jets->at(hitCombi[TtSemiLepEvtPartons::LightQ ]).bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_
384  && jets->at(hitCombi[TtSemiLepEvtPartons::LightQBar]).bDiscriminator(bTagAlgo_) < maxBTagValueNonBJet_
385  && jets->at(hitCombi[TtSemiLepEvtPartons::HadB ]).bDiscriminator(bTagAlgo_) > minBTagValueBJet_
386  && jets->at(hitCombi[TtSemiLepEvtPartons::LepB ]).bDiscriminator(bTagAlgo_) > minBTagValueBJet_
387  )
388  )
389  ) {
390  FitResult result;
391  result.Status = 0;
392  result.Chi2 = hitFitResult[fit].chisq();
393  result.Prob = exp(-1.0*(hitFitResult[fit].chisq())/2.0);
394  result.MT = hitFitResult[fit].mt();
395  result.SigMT= hitFitResult[fit].sigmt();
396  result.HadB = pat::Particle(reco::LeafCandidate(0,
397  math::XYZTLorentzVector(hadB_.p().x(), hadB_.p().y(),
398  hadB_.p().z(), hadB_.p().t()), math::XYZPoint()));
399  result.HadP = pat::Particle(reco::LeafCandidate(0,
400  math::XYZTLorentzVector(hadP_.p().x(), hadP_.p().y(),
401  hadP_.p().z(), hadP_.p().t()), math::XYZPoint()));
402  result.HadQ = pat::Particle(reco::LeafCandidate(0,
403  math::XYZTLorentzVector(hadQ_.p().x(), hadQ_.p().y(),
404  hadQ_.p().z(), hadQ_.p().t()), math::XYZPoint()));
405  result.LepB = pat::Particle(reco::LeafCandidate(0,
406  math::XYZTLorentzVector(lepB_.p().x(), lepB_.p().y(),
407  lepB_.p().z(), lepB_.p().t()), math::XYZPoint()));
408  result.LepL = pat::Particle(reco::LeafCandidate(0,
409  math::XYZTLorentzVector(lepL_.p().x(), lepL_.p().y(),
410  lepL_.p().z(), lepL_.p().t()), math::XYZPoint()));
411  result.LepN = pat::Particle(reco::LeafCandidate(0,
412  math::XYZTLorentzVector(fittedEvent.met().x(), fittedEvent.met().y(),
413  fittedEvent.met().z(), fittedEvent.met().t()), math::XYZPoint()));
414  result.JetCombi = hitCombi;
415 
416  FitResultList.push_back(result);
417  }
418 
419  }
420 
421  // sort results w.r.t. chi2 values
422  FitResultList.sort();
423 
424  // -----------------------------------------------------
425  // feed out result
426  // starting with the JetComb having the smallest chi2
427  // -----------------------------------------------------
428 
429  if( ((unsigned)FitResultList.size())<1 ) { // in case no fit results were stored in the list (all fits aborted)
430  pPartonsHadP->push_back( pat::Particle() );
431  pPartonsHadQ->push_back( pat::Particle() );
432  pPartonsHadB->push_back( pat::Particle() );
433  pPartonsLepB->push_back( pat::Particle() );
434  pLeptons ->push_back( pat::Particle() );
435  pNeutrinos ->push_back( pat::Particle() );
436  // indices referring to the jet combination
437  std::vector<int> invalidCombi;
438  for(unsigned int i = 0; i < nPartons; ++i)
439  invalidCombi.push_back( -1 );
440  pCombi->push_back( invalidCombi );
441  // chi2
442  pChi2->push_back( -1. );
443  // chi2 probability
444  pProb->push_back( -1. );
445  // fitted top mass
446  pMT->push_back( -1. );
447  pSigMT->push_back( -1. );
448  // status of the fitter
449  pStatus->push_back( -1 );
450  }
451  else {
452  unsigned int iComb = 0;
453  for(typename std::list<FitResult>::const_iterator result = FitResultList.begin(); result != FitResultList.end(); ++result) {
454  if(maxNComb_ >= 1 && iComb == (unsigned int) maxNComb_) break;
455  iComb++;
456  // partons
457  pPartonsHadP->push_back( result->HadP );
458  pPartonsHadQ->push_back( result->HadQ );
459  pPartonsHadB->push_back( result->HadB );
460  pPartonsLepB->push_back( result->LepB );
461  // lepton
462  pLeptons->push_back( result->LepL );
463  // neutrino
464  pNeutrinos->push_back( result->LepN );
465  // indices referring to the jet combination
466  pCombi->push_back( result->JetCombi );
467  // chi2
468  pChi2->push_back( result->Chi2 );
469  // chi2 probability
470  pProb->push_back( result->Prob );
471  // fitted top mass
472  pMT->push_back( result->MT );
473  pSigMT->push_back( result->SigMT );
474  // status of the fitter
475  pStatus->push_back( result->Status );
476  }
477  }
478  evt.put(pCombi);
479  evt.put(pPartonsHadP, "PartonsHadP");
480  evt.put(pPartonsHadQ, "PartonsHadQ");
481  evt.put(pPartonsHadB, "PartonsHadB");
482  evt.put(pPartonsLepB, "PartonsLepB");
483  evt.put(pLeptons , "Leptons" );
484  evt.put(pNeutrinos , "Neutrinos" );
485  evt.put(pChi2 , "Chi2" );
486  evt.put(pProb , "Prob" );
487  evt.put(pMT , "MT" );
488  evt.put(pSigMT , "SigMT" );
489  evt.put(pStatus , "Status" );
490  evt.put(pJetsConsidered, "NumberOfConsideredJets");
491 }
492 
493 #endif
TtSemiLepHitFitProducer::maxNComb_
int maxNComb_
maximal number of combinations to be written to the event
Definition: TtSemiLepHitFitProducer.h:38
TtSemiLepHitFitProducer::maxEtaEle_
double maxEtaEle_
maximum eta value for electrons, needed to limited range in which resolutions are provided ...
Definition: TtSemiLepHitFitProducer.h:43
i
int i
Definition: DBlmapReader.cc:9
TtSemiLepHitFitProducer::maxBTagValueNonBJet_
double maxBTagValueNonBJet_
max value of bTag for a non-b-jet
Definition: TtSemiLepHitFitProducer.h:52
nPartons
static const unsigned int nPartons
Definition: TtFullHadKinFitProducer.cc:3
TtSemiLepHitFitProducer::jetTranslator_
hitfit::JetTranslatorBase< pat::Jet > jetTranslator_
Definition: TtSemiLepHitFitProducer.h:94
create_public_lumi_plots.exp
tuple exp
Definition: create_public_lumi_plots.py:1087
reco::CaloJet
Jets made from CaloTowers.
Definition: CaloJet.h:29
hitfit::Lepjets_Event_Lep
Represent a lepton in an instance of Lepjets_Event class. This class hold the following information: ...
Definition: Lepjets_Event_Lep.h:68
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
TtSemiLepHitFitProducer::electronTranslator_
hitfit::LeptonTranslatorBase< pat::Electron > electronTranslator_
Definition: TtSemiLepHitFitProducer.h:92
TtSemiLepHitFitProducer::TtSemiLepHitFitProducer
TtSemiLepHitFitProducer(const edm::ParameterSet &)
Definition: TtSemiLepHitFitProducer.h:101
TtSemiLepHitFitProducer::metsToken_
edm::EDGetTokenT< std::vector< pat::MET > > metsToken_
Definition: TtSemiLepHitFitProducer.h:33
TtSemiLepHitFitProducer::muonTranslator_
hitfit::LeptonTranslatorBase< pat::Muon > muonTranslator_
Definition: TtSemiLepHitFitProducer.h:93
eta
T eta() const
Definition: Basic3DVectorLD.h:177
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
hitfit::Lepjets_Event::jet
Lepjets_Event_Jet & jet(std::vector< Lepjets_Event_Jet >::size_type i)
Return a reference to jet at index position i.
Definition: Lepjets_Event.cc:158
TtSemiLepHitFitProducer::maxEtaJet_
double maxEtaJet_
maximum eta value for jets, needed to limited range in which resolutions are provided ...
Definition: TtSemiLepHitFitProducer.h:45
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
hitfit::Lepjets_Event_Lep::type
int & type()
Return a reference to the type code.
Definition: Lepjets_Event_Lep.cc:83
TtSemiLepHitFitProducer::hitfitUdscJetResolution_
edm::FileInPath hitfitUdscJetResolution_
Definition: TtSemiLepHitFitProducer.h:88
edm::Event::put
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:116
Top_Decaykin.h
A class to hold functions to calculate kinematic quantities of interest in events.
TtSemiLepHitFitProducer::useBTag_
bool useBTag_
switch to tell whether to use b-tagging or not
Definition: TtSemiLepHitFitProducer.h:54
fwrapper::jets
vector< PseudoJet > jets
Definition: fastjetfortran_madfks.cc:42
hitfit::Lepjets_Event
Represent a simple event consisting of lepton(s) and jet(s). An instance of this class holds a list o...
Definition: Lepjets_Event.h:66
query.result
tuple result
Definition: query.py:137
TtSemiLepHitFitProducer::PatHitFit
hitfit::RunHitFit< pat::Electron, pat::Muon, pat::Jet, pat::MET > PatHitFit
Definition: TtSemiLepHitFitProducer.h:83
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
METTranslatorBase.h
Template class of function object to translate missing transverse energy object to HitFit&#39;s Fourvec o...
hitfit::Lepjets_Event_Jet
A class to represent a jet in an instance of Lepjets_Event class. The class is derived from the Lepje...
Definition: Lepjets_Event_Jet.h:81
TtSemiLepHitFitProducer::maxNJets_
int maxNJets_
maximal number of jets (-1 possible to indicate &#39;all&#39;)
Definition: TtSemiLepHitFitProducer.h:36
RunHitFit.h
Template class of experiment-independent interface to HitFit.
TtSemiLepHitFitProducer::jetsToken_
edm::EDGetTokenT< std::vector< pat::Jet > > jetsToken_
Definition: TtSemiLepHitFitProducer.h:31
hitfit::RunHitFit
Template class of experiment-independent interface to HitFit. This class is intended to be used insid...
Definition: RunHitFit.h:156
TtSemiLepHitFitProducer::metTranslator_
hitfit::METTranslatorBase< pat::MET > metTranslator_
Definition: TtSemiLepHitFitProducer.h:95
JetTranslatorBase.h
Template class of function object to translate jet physics object to HitFit&#39;s Lepjets_Event_Jet objec...
hitfit::Lepjets_Event::met
Fourvec & met()
Return a reference to the missing transverse energy.
Definition: Lepjets_Event.cc:206
hitfit::Lepjets_Event::lep
Lepjets_Event_Lep & lep(std::vector< Lepjets_Event_Lep >::size_type i)
Return a reference to lepton at index position i.
Definition: Lepjets_Event.cc:142
TtSemiLepHitFitProducer::lepsToken_
edm::EDGetTokenT< LeptonCollection > lepsToken_
Definition: TtSemiLepHitFitProducer.h:32
LeptonTranslatorBase.h
Template class of function object to translate lepton physics object to HitFit&#39;s Lepjets_Event_Lep ob...
math::XYZPoint
XYZPointD XYZPoint
point in space with cartesian internal representation
Definition: Point3D.h:12
TtSemiLepHitFitProducer::hitfitElectronResolution_
edm::FileInPath hitfitElectronResolution_
Definition: TtSemiLepHitFitProducer.h:86
pat::Particle
Analysis-level particle class.
Definition: Particle.h:32
TtSemiLepHitFitProducer::jetCorrectionLevel_
std::string jetCorrectionLevel_
jet correction level
Definition: TtSemiLepHitFitProducer.h:61
hitfit::Lepjets_Event_Lep::p
Fourvec & p()
Return a reference to the four-momentum.
Definition: Lepjets_Event_Lep.cc:59
TtSemiLepHitFitProducer::produce
virtual void produce(edm::Event &, const edm::EventSetup &)
Definition: TtSemiLepHitFitProducer.h:190
TtSemiLepHitFitProducer::maxEtaMu_
double maxEtaMu_
maximum eta value for muons, needed to limited range in which resolutions are provided ...
Definition: TtSemiLepHitFitProducer.h:41
edm::FileInPath::fullPath
std::string fullPath() const
Definition: FileInPath.cc:165
Chi2
Definition: Chi2.h:17
TtSemiLepHitFitProducer::minBTagValueBJet_
double minBTagValueBJet_
min value of bTag for a b-jet
Definition: TtSemiLepHitFitProducer.h:50
HcalObjRepresent::setup
void setup(std::vector< TH2F > &depth, std::string name, std::string units="")
Definition: HcalObjRepresent.h:628
TtSemiLepHitFitProducer::bTagAlgo_
std::string bTagAlgo_
input tag for b-tagging algorithm
Definition: TtSemiLepHitFitProducer.h:48
TtSemiLepHitFitProducer::jes_
double jes_
jet energy scale
Definition: TtSemiLepHitFitProducer.h:64
Generated for CMSSW Reference Manual by doxygen 1.8.5