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