HiggsAnalysis-KITHiggsToTauTau
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
ValidDiTauPairCandidatesProducers.h
Go to the documentation of this file.
1 
2 #pragma once
3 
4 #include <boost/regex.hpp>
5 
6 #include "Kappa/DataFormats/interface/Kappa.h"
7 
8 #include "Artus/Core/interface/ProducerBase.h"
9 #include "Artus/Consumer/interface/LambdaNtupleConsumer.h"
10 #include "Artus/Utility/interface/Utility.h"
11 
12 #include "HiggsAnalysis/KITHiggsToTauTau/interface/HttTypes.h"
13 
19 template<class TLepton1, class TLepton2>
20 class ValidDiTauPairCandidatesProducerBase: public ProducerBase<HttTypes>
21 {
22 public:
23 
24  ValidDiTauPairCandidatesProducerBase(std::vector<TLepton1*> product_type::*validLeptonsMember1,
25  std::vector<TLepton2*> product_type::*validLeptonsMember2) :
26  ProducerBase<HttTypes>(),
27  m_validLeptonsMember1(validLeptonsMember1),
28  m_validLeptonsMember2(validLeptonsMember2)
29  {
30  }
31 
32  virtual void Init(setting_type const& settings, metadata_type& metadata) override
33  {
34  ProducerBase<HttTypes>::Init(settings, metadata);
35 
36  // configurations possible:
37  // "cut" --> applied to all pairs
38  // "<index in setting HltPaths>:<cut>" --> applied to pairs that fired and matched ONLY the indexed HLT path
39  // "<HLT path regex>:<cut>" --> applied to pairs that fired and matched ONLY the given HLT path
40  m_lepton1LowerPtCutsByIndex = Utility::ParseMapTypes<size_t, float>(
41  Utility::ParseVectorToMap(settings.GetDiTauPairLepton1LowerPtCuts()), m_lepton1LowerPtCutsByHltName
42  );
43  m_lepton2LowerPtCutsByIndex = Utility::ParseMapTypes<size_t, float>(
44  Utility::ParseVectorToMap(settings.GetDiTauPairLepton2LowerPtCuts()), m_lepton2LowerPtCutsByHltName
45  );
46  m_hltFiredBranchNames = Utility::ParseVectorToMap(settings.GetHLTBranchNames());
47 
48  // add possible quantities for the lambda ntuples consumers
49  LambdaNtupleConsumer<HttTypes>::AddIntQuantity(metadata, "nDiTauPairCandidates", [](event_type const& event, product_type const& product)
50  {
51  return static_cast<int>(product.m_validDiTauPairCandidates.size());
52  });
53  LambdaNtupleConsumer<HttTypes>::AddIntQuantity(metadata, "nAllDiTauPairCandidates", [](event_type const& event, product_type const& product)
54  {
55  return static_cast<int>(product.m_validDiTauPairCandidates.size()+product.m_invalidDiTauPairCandidates.size());
56  });
57  std::vector<std::string> hltPathsWithoutCommonMatch = settings.GetDiTauPairHltPathsWithoutCommonMatchRequired();
58  /*
59  for(unsigned int i = 0; i < hltPathsWithoutCommonMatch.size(); i++)
60  {
61  std::cout << "Trigger without common match: " << hltPathsWithoutCommonMatch.at(i) << std::endl;
62  }
63  std::cout << "Settings for Lepton 1 Pt Cuts: " << std::endl;
64  for(unsigned int i = 0; i < settings.GetDiTauPairLepton1LowerPtCuts().size(); i++)
65  {
66  std::cout << settings.GetDiTauPairLepton1LowerPtCuts().at(i) << std::endl;
67  }
68  std::cout << "Settings for Lepton 2 Pt Cuts: " << std::endl;
69  for(unsigned int i = 0; i < settings.GetDiTauPairLepton2LowerPtCuts().size(); i++)
70  {
71  std::cout << settings.GetDiTauPairLepton2LowerPtCuts().at(i) << std::endl;
72  }
73  std::cout << "Amount of lepton 1 Pt Cuts by Hlt Name: " << m_lepton1LowerPtCutsByHltName.size() << std::endl;
74  std::cout << "Amount of lepton 2 Pt Cuts by Hlt Name: " << m_lepton2LowerPtCutsByHltName.size() << std::endl;
75  */
76  for(auto hltNames: m_hltFiredBranchNames)
77  {
78  std::map<std::string, std::vector<float>> lepton1LowerPtCutsByHltName = m_lepton1LowerPtCutsByHltName;
79  std::map<std::string, std::vector<float>> lepton2LowerPtCutsByHltName = m_lepton2LowerPtCutsByHltName;
80  LambdaNtupleConsumer<HttTypes>::AddBoolQuantity(metadata, hltNames.first, [hltNames, hltPathsWithoutCommonMatch, lepton1LowerPtCutsByHltName, lepton2LowerPtCutsByHltName](event_type const& event, product_type const& product)
81  {
82  bool diTauPairFiredTrigger = false;
83  //std::cout << "Beginning of lambda function for " << hltNames.first << std::endl;
84  for (auto hltName: hltNames.second)
85  {
86  if(std::find(hltPathsWithoutCommonMatch.begin(), hltPathsWithoutCommonMatch.end(), hltName) == hltPathsWithoutCommonMatch.end())
87  {
88  //std::cout << "Common match required for " << hltName << std::endl;
89  // we do require a common match, check, whether both leptons are matched to trigger objects.
90  if (product.m_detailedTriggerMatchedLeptons.find(static_cast<KLepton*>(product.m_validDiTauPairCandidates.at(0).first)) != product.m_detailedTriggerMatchedLeptons.end() &&
91  product.m_detailedTriggerMatchedLeptons.find(static_cast<KLepton*>(product.m_validDiTauPairCandidates.at(0).second)) != product.m_detailedTriggerMatchedLeptons.end())
92  {
93  auto trigger1 = product.m_detailedTriggerMatchedLeptons.at(static_cast<KLepton*>(product.m_validDiTauPairCandidates.at(0).first));
94  auto trigger2 = product.m_detailedTriggerMatchedLeptons.at(static_cast<KLepton*>(product.m_validDiTauPairCandidates.at(0).second));
95  bool hltFired1 = false;
96  bool hltFired2 = false;
97  for (auto hlts: (*trigger1))
98  {
99  if (boost::regex_search(hlts.first, boost::regex(hltName, boost::regex::icase | boost::regex::extended)))
100  {
101  for (auto matchedObjects: hlts.second)
102  {
103  if (matchedObjects.second.size() > 0) hltFired1 = true;
104  }
105  }
106  }
107  //std::cout << "Found trigger for the lepton 1? " << hltFired1 << std::endl;
108  for (auto hlts: (*trigger2))
109  {
110  if (boost::regex_search(hlts.first, boost::regex(hltName, boost::regex::icase | boost::regex::extended)))
111  {
112  for (auto matchedObjects: hlts.second)
113  {
114  if (matchedObjects.second.size() > 0) hltFired2 = true;
115  }
116  }
117  }
118  //std::cout << "Found trigger for the lepton 2? " << hltFired1 << std::endl;
119  bool hltFired = hltFired1 && hltFired2;
120  // passing kinematic cuts for trigger
121  if (lepton1LowerPtCutsByHltName.find(hltName) != lepton1LowerPtCutsByHltName.end())
122  {
123  hltFired = hltFired &&
124  (product.m_validDiTauPairCandidates.at(0).first->p4.Pt() > *std::max_element(lepton1LowerPtCutsByHltName.at(hltName).begin(), lepton1LowerPtCutsByHltName.at(hltName).end()));
125  //std::cout << "lepton 1 Pt: " << product.m_validDiTauPairCandidates.at(0).first->p4.Pt() << " threshold: " << *std::max_element(lepton1LowerPtCutsByHltName.at(hltName).begin(), lepton1LowerPtCutsByHltName.at(hltName).end()) << std::endl;
126  }
127  if (lepton2LowerPtCutsByHltName.find(hltName) != lepton2LowerPtCutsByHltName.end())
128  {
129  hltFired = hltFired &&
130  (product.m_validDiTauPairCandidates.at(0).second->p4.Pt() > *std::max_element(lepton2LowerPtCutsByHltName.at(hltName).begin(), lepton2LowerPtCutsByHltName.at(hltName).end()));
131  //std::cout << "lepton 2 Pt: " << product.m_validDiTauPairCandidates.at(0).second->p4.Pt() << " threshold: " << *std::max_element(lepton2LowerPtCutsByHltName.at(hltName).begin(), lepton2LowerPtCutsByHltName.at(hltName).end()) << std::endl;
132  }
133  //std::cout << "Both leptons passed kinematic cuts? " << hltFired << std::endl;
134  diTauPairFiredTrigger = diTauPairFiredTrigger || hltFired;
135  }
136  }
137  else
138  {
139  //std::cout << "Common match NOT required for " << hltName << std::endl;
140  // we do not require a common match, check the matching only for the first lepton.
141  if (product.m_detailedTriggerMatchedLeptons.find(static_cast<KLepton*>(product.m_validDiTauPairCandidates.at(0).first)) != product.m_detailedTriggerMatchedLeptons.end())
142  {
143  auto trigger = product.m_detailedTriggerMatchedLeptons.at(static_cast<KLepton*>(product.m_validDiTauPairCandidates.at(0).first));
144  bool hltFired = false;
145  for (auto hlts: (*trigger))
146  {
147  if (boost::regex_search(hlts.first, boost::regex(hltName, boost::regex::icase | boost::regex::extended)))
148  {
149  for (auto matchedObjects: hlts.second)
150  {
151  if (matchedObjects.second.size() > 0) hltFired = true;
152  }
153  }
154  }
155  //std::cout << "Found trigger for the lepton 1? " << hltFired << std::endl;
156  // passing kinematic cuts for trigger
157  if (lepton1LowerPtCutsByHltName.find(hltName) != lepton1LowerPtCutsByHltName.end())
158  {
159  hltFired = hltFired &&
160  (product.m_validDiTauPairCandidates.at(0).first->p4.Pt() > *std::max_element(lepton1LowerPtCutsByHltName.at(hltName).begin(), lepton1LowerPtCutsByHltName.at(hltName).end()));
161  //std::cout << "lepton 1 Pt: " << product.m_validDiTauPairCandidates.at(0).first->p4.Pt() << " threshold: " << *std::max_element(lepton1LowerPtCutsByHltName.at(hltName).begin(), lepton1LowerPtCutsByHltName.at(hltName).end()) << std::endl;
162  }
163  if (lepton2LowerPtCutsByHltName.find(hltName) != lepton2LowerPtCutsByHltName.end())
164  {
165  hltFired = hltFired &&
166  (product.m_validDiTauPairCandidates.at(0).second->p4.Pt() > *std::max_element(lepton2LowerPtCutsByHltName.at(hltName).begin(), lepton2LowerPtCutsByHltName.at(hltName).end()));
167  //std::cout << "lepton 2 Pt: " << product.m_validDiTauPairCandidates.at(0).second->p4.Pt() << " threshold: " << *std::max_element(lepton2LowerPtCutsByHltName.at(hltName).begin(), lepton2LowerPtCutsByHltName.at(hltName).end()) << std::endl;
168  }
169  //std::cout << "Both leptons passed kinematic cuts? " << hltFired << std::endl;
170  diTauPairFiredTrigger = diTauPairFiredTrigger || hltFired;
171  }
172  }
173  }
174  //std::cout << "Tau pair with valid trigger match? " << diTauPairFiredTrigger << std::endl << std::endl;
175  return diTauPairFiredTrigger;
176  });
177  }
178  }
179 
180  virtual void Produce(event_type const& event, product_type & product,
181  setting_type const& settings, metadata_type const& metadata) const override
182  {
183  product.m_validDiTauPairCandidates.clear();
184 
185  // build pairs for all combinations
186  for (typename std::vector<TLepton1*>::iterator lepton1 = (product.*m_validLeptonsMember1).begin();
187  lepton1 != (product.*m_validLeptonsMember1).end(); ++lepton1)
188  {
189  for (typename std::vector<TLepton2*>::iterator lepton2 = (product.*m_validLeptonsMember2).begin();
190  lepton2 != (product.*m_validLeptonsMember2).end(); ++lepton2)
191  {
192  DiTauPair diTauPair(*lepton1, *lepton2);
193 
194  // pair selections
195  bool validDiTauPair = true;
196 
197  // OS charge requirement
198  //validDiTauPair = validDiTauPair && diTauPair.IsOppositelyCharged();
199 
200  // delta R cut
201  validDiTauPair = validDiTauPair && ((settings.GetDiTauPairMinDeltaRCut() < 0.0) || (diTauPair.GetDeltaR() > static_cast<double>(settings.GetDiTauPairMinDeltaRCut())));
202 
203  // require matchings with the same triggers
204  if ((! settings.GetDiTauPairNoHLT()) && (! settings.GetDiTauPairHLTLast()))
205  {
206  std::vector<std::string> commonHltPaths = diTauPair.GetCommonHltPaths(product.m_detailedTriggerMatchedLeptons, settings.GetDiTauPairHltPathsWithoutCommonMatchRequired());
207  validDiTauPair = validDiTauPair && (commonHltPaths.size() > 0);
208 
209  // pt cuts in case one or more HLT paths are matched
210  if (validDiTauPair)
211  {
212  //vector to hold the results for the individual HLTPaths, all results default to true
213  std::vector<bool> hltValidDiTauPair(commonHltPaths.size(), true);
214  for (std::vector<std::string>::size_type hltPathNumber = 0; hltPathNumber != commonHltPaths.size(); ++hltPathNumber)
215  {
216  // lepton 1
217  for (std::map<size_t, std::vector<float> >::const_iterator lowerPtCutByIndex = m_lepton1LowerPtCutsByIndex.begin();
218  lowerPtCutByIndex != m_lepton1LowerPtCutsByIndex.end() && hltValidDiTauPair.at(hltPathNumber); ++lowerPtCutByIndex)
219  {
220  if ((diTauPair.first->p4.Pt() <= *std::max_element(lowerPtCutByIndex->second.begin(), lowerPtCutByIndex->second.end())) &&
221  boost::regex_search(commonHltPaths.at(hltPathNumber), boost::regex(settings.GetHltPaths().at(lowerPtCutByIndex->first), boost::regex::icase | boost::regex::extended)))
222  {
223  hltValidDiTauPair.at(hltPathNumber) = false;
224  }
225  }
226 
227  // lepton 1
228  for (std::map<std::string, std::vector<float> >::const_iterator lowerPtCutByHltName = m_lepton1LowerPtCutsByHltName.begin();
229  lowerPtCutByHltName != m_lepton1LowerPtCutsByHltName.end() && hltValidDiTauPair.at(hltPathNumber); ++lowerPtCutByHltName)
230  {
231  if ((diTauPair.first->p4.Pt() <= *std::max_element(lowerPtCutByHltName->second.begin(), lowerPtCutByHltName->second.end())) &&
232  boost::regex_search(commonHltPaths.at(hltPathNumber), boost::regex(lowerPtCutByHltName->first, boost::regex::icase | boost::regex::extended)))
233  {
234  hltValidDiTauPair.at(hltPathNumber) = false;
235  }
236  }
237 
238  // lepton 2
239  for (std::map<size_t, std::vector<float> >::const_iterator lowerPtCutByIndex = m_lepton2LowerPtCutsByIndex.begin();
240  lowerPtCutByIndex != m_lepton2LowerPtCutsByIndex.end() && hltValidDiTauPair.at(hltPathNumber); ++lowerPtCutByIndex)
241  {
242  if ((diTauPair.second->p4.Pt() <= *std::max_element(lowerPtCutByIndex->second.begin(), lowerPtCutByIndex->second.end())) &&
243  boost::regex_search(commonHltPaths.at(hltPathNumber), boost::regex(settings.GetHltPaths().at(lowerPtCutByIndex->first), boost::regex::icase | boost::regex::extended)))
244  {
245  hltValidDiTauPair.at(hltPathNumber) = false;
246  }
247  }
248 
249  // lepton 2
250  for (std::map<std::string, std::vector<float> >::const_iterator lowerPtCutByHltName = m_lepton2LowerPtCutsByHltName.begin();
251  lowerPtCutByHltName != m_lepton2LowerPtCutsByHltName.end() && hltValidDiTauPair.at(hltPathNumber); ++lowerPtCutByHltName)
252  {
253  if ((diTauPair.second->p4.Pt() <= *std::max_element(lowerPtCutByHltName->second.begin(), lowerPtCutByHltName->second.end())) &&
254  boost::regex_search(commonHltPaths.at(hltPathNumber), boost::regex(lowerPtCutByHltName->first, boost::regex::icase | boost::regex::extended)))
255  {
256  hltValidDiTauPair.at(hltPathNumber) = false;
257  }
258  }
259  }
260  //default validity of ditaupair to false and set it to true in case it is a valid pair for at least one HLTPath
261  validDiTauPair = false;
262  for (std::vector<bool>::const_iterator hltPathResult = hltValidDiTauPair.begin(); hltPathResult != hltValidDiTauPair.end(); ++hltPathResult)
263  {
264  if(*hltPathResult)
265  {
266  validDiTauPair = true;
267  break;
268  }
269  }
270  if (settings.GetRequireFirstTriggering())
271  {
272  bool hltFired = false;
273  auto trigger = product.m_detailedTriggerMatchedLeptons[static_cast<KLepton*>(diTauPair.first)];
274  for (auto hltName : settings.GetHltPaths())
275  {
276  for (auto hlts: (*trigger))
277  {
278  if (boost::regex_search(hlts.first, boost::regex(hltName, boost::regex::icase | boost::regex::extended)))
279  {
280  for (auto matchedObjects: hlts.second)
281  {
282  if (matchedObjects.second.size() > 0) hltFired = true;
283  }
284  }
285  }
286  }
287  validDiTauPair = validDiTauPair && hltFired;
288  validDiTauPair = validDiTauPair && (diTauPair.first->p4.Pt() >= diTauPair.second->p4.Pt());
289  }
290  }
291  }
292  else if(!settings.GetDiTauPairHLTLast())// will hopefully become obsolete towards the end of 2016 when the trigger is included in simulation
293  {
294  if (validDiTauPair)
295  {
296  // lepton 1
297  for (std::map<size_t, std::vector<float> >::const_iterator lowerPtCutByIndex = m_lepton1LowerPtCutsByIndex.begin();
298  lowerPtCutByIndex != m_lepton1LowerPtCutsByIndex.end(); ++lowerPtCutByIndex)
299  {
300  if (diTauPair.first->p4.Pt() <= *std::max_element(lowerPtCutByIndex->second.begin(), lowerPtCutByIndex->second.end()))
301  {
302  validDiTauPair = false;
303  }
304  }
305 
306  // lepton 1
307  for (std::map<std::string, std::vector<float> >::const_iterator lowerPtCutByHltName = m_lepton1LowerPtCutsByHltName.begin();
308  lowerPtCutByHltName != m_lepton1LowerPtCutsByHltName.end(); ++lowerPtCutByHltName)
309  {
310  if (diTauPair.first->p4.Pt() <= *std::max_element(lowerPtCutByHltName->second.begin(), lowerPtCutByHltName->second.end()))
311  {
312  validDiTauPair = false;
313  }
314  }
315 
316  // lepton 2
317  for (std::map<size_t, std::vector<float> >::const_iterator lowerPtCutByIndex = m_lepton2LowerPtCutsByIndex.begin();
318  lowerPtCutByIndex != m_lepton2LowerPtCutsByIndex.end(); ++lowerPtCutByIndex)
319  {
320  if (diTauPair.second->p4.Pt() <= *std::max_element(lowerPtCutByIndex->second.begin(), lowerPtCutByIndex->second.end()))
321  {
322  validDiTauPair = false;
323  }
324  }
325 
326  // lepton 2
327  for (std::map<std::string, std::vector<float> >::const_iterator lowerPtCutByHltName = m_lepton2LowerPtCutsByHltName.begin();
328  lowerPtCutByHltName != m_lepton2LowerPtCutsByHltName.end(); ++lowerPtCutByHltName)
329  {
330  if (diTauPair.second->p4.Pt() <= *std::max_element(lowerPtCutByHltName->second.begin(), lowerPtCutByHltName->second.end()))
331  {
332  validDiTauPair = false;
333  }
334  }
335  }
336  // require at least one of the leptons to pass a higher pt threshold. this is needed for double-lepton or cross triggers
337  validDiTauPair = validDiTauPair && (diTauPair.first->p4.Pt() > settings.GetLowerCutHardLepPt() || diTauPair.second->p4.Pt() > settings.GetLowerCutHardLepPt());
338  }
339  // check possible additional criteria from subclasses
340  validDiTauPair = validDiTauPair && AdditionalCriteria(diTauPair, event, product, settings, metadata);
341  if (validDiTauPair)
342  {
343  product.m_validDiTauPairCandidates.push_back(diTauPair);
344  }
345  else
346  {
347  product.m_invalidDiTauPairCandidates.push_back(diTauPair);
348  }
349  }
350  }
351  // sort pairs
352  std::sort(product.m_validDiTauPairCandidates.begin(), product.m_validDiTauPairCandidates.end(),
353  DiTauPairIsoPtComparator(&(product.m_leptonIsolationOverPt), settings.GetDiTauPairIsTauIsoMVA()));
354  std::sort(product.m_invalidDiTauPairCandidates.begin(), product.m_invalidDiTauPairCandidates.end(),
355  DiTauPairIsoPtComparator(&(product.m_leptonIsolationOverPt), settings.GetDiTauPairIsTauIsoMVA()));
356  }
357 
358 
359 protected:
360  // Can be overwritten for special use cases
361  virtual bool AdditionalCriteria(DiTauPair const& diTauPair, event_type const& event,
362  product_type& product, setting_type const& settings, metadata_type const& metadata) const
363  {
364  bool validDiTauPair = true;
365  return validDiTauPair;
366  }
367 
368 
369 private:
370  std::vector<TLepton1*> product_type::*m_validLeptonsMember1;
371  std::vector<TLepton2*> product_type::*m_validLeptonsMember2;
372 
373  std::map<size_t, std::vector<float> > m_lepton1LowerPtCutsByIndex;
374  std::map<std::string, std::vector<float> > m_lepton1LowerPtCutsByHltName;
375  std::map<size_t, std::vector<float> > m_lepton2LowerPtCutsByIndex;
376  std::map<std::string, std::vector<float> > m_lepton2LowerPtCutsByHltName;
377  std::map<std::string, std::vector<std::string> > m_hltFiredBranchNames;
378 
379 };
380 
381 
382 class ValidTTPairCandidatesProducer: public ValidDiTauPairCandidatesProducerBase<KTau, KTau>
383 {
384 public:
385  ValidTTPairCandidatesProducer();
386  virtual std::string GetProducerId() const override;
387 };
388 
389 class ValidMTPairCandidatesProducer: public ValidDiTauPairCandidatesProducerBase<KMuon, KTau>
390 {
391 public:
392  ValidMTPairCandidatesProducer();
393  virtual std::string GetProducerId() const override;
394 };
395 
396 class ValidETPairCandidatesProducer: public ValidDiTauPairCandidatesProducerBase<KElectron, KTau>
397 {
398 public:
399  ValidETPairCandidatesProducer();
400  virtual std::string GetProducerId() const override;
401 };
402 
403 class ValidEMPairCandidatesProducer: public ValidDiTauPairCandidatesProducerBase<KMuon, KElectron>
404 {
405 public:
406  ValidEMPairCandidatesProducer();
407  virtual std::string GetProducerId() const override;
408 };
409 
410 class ValidMMPairCandidatesProducer: public ValidDiTauPairCandidatesProducerBase<KMuon, KMuon>
411 {
412 public:
413  ValidMMPairCandidatesProducer();
414  virtual std::string GetProducerId() const override;
415 };
416 
417 class ValidEEPairCandidatesProducer: public ValidDiTauPairCandidatesProducerBase<KElectron, KElectron>
418 {
419 public:
420  ValidEEPairCandidatesProducer();
421  virtual std::string GetProducerId() const override;
422 };
423 
ValidDiTauPairCandidatesProducerBase::Init
virtual void Init(setting_type const &settings, metadata_type &metadata) override
Definition: ValidDiTauPairCandidatesProducers.h:32
ValidTTPairCandidatesProducer::GetProducerId
virtual std::string GetProducerId() const override
Definition: ValidDiTauPairCandidatesProducers.cc:13
ValidDiTauPairCandidatesProducerBase::ValidDiTauPairCandidatesProducerBase
ValidDiTauPairCandidatesProducerBase(std::vector< TLepton1 * > product_type::*validLeptonsMember1, std::vector< TLepton2 * > product_type::*validLeptonsMember2)
Definition: ValidDiTauPairCandidatesProducers.h:24
ValidMMPairCandidatesProducer::ValidMMPairCandidatesProducer
ValidMMPairCandidatesProducer()
Definition: ValidDiTauPairCandidatesProducers.cc:61
ValidETPairCandidatesProducer::GetProducerId
virtual std::string GetProducerId() const override
Definition: ValidDiTauPairCandidatesProducers.cc:41
ValidMTPairCandidatesProducer::ValidMTPairCandidatesProducer
ValidMTPairCandidatesProducer()
Definition: ValidDiTauPairCandidatesProducers.cc:19
ValidEEPairCandidatesProducer::ValidEEPairCandidatesProducer
ValidEEPairCandidatesProducer()
Definition: ValidDiTauPairCandidatesProducers.cc:75
DiTauPairIsoPtComparator
Definition: DiTauPair.h:23
ValidDiTauPairCandidatesProducerBase::AdditionalCriteria
virtual bool AdditionalCriteria(DiTauPair const &diTauPair, event_type const &event, product_type &product, setting_type const &settings, metadata_type const &metadata) const
Definition: ValidDiTauPairCandidatesProducers.h:361
ValidDiTauPairCandidatesProducerBase
Producers for candidates of di-tau pairs.
Definition: ValidDiTauPairCandidatesProducers.h:20
ValidEMPairCandidatesProducer
Definition: ValidDiTauPairCandidatesProducers.h:403
ValidTTPairCandidatesProducer::ValidTTPairCandidatesProducer
ValidTTPairCandidatesProducer()
Definition: ValidDiTauPairCandidatesProducers.cc:5
ValidMMPairCandidatesProducer
Definition: ValidDiTauPairCandidatesProducers.h:410
ValidETPairCandidatesProducer
Definition: ValidDiTauPairCandidatesProducers.h:396
ValidEEPairCandidatesProducer::GetProducerId
virtual std::string GetProducerId() const override
Definition: ValidDiTauPairCandidatesProducers.cc:83
ValidDiTauPairCandidatesProducerBase::Produce
virtual void Produce(event_type const &event, product_type &product, setting_type const &settings, metadata_type const &metadata) const override
Definition: ValidDiTauPairCandidatesProducers.h:180
ValidEMPairCandidatesProducer::GetProducerId
virtual std::string GetProducerId() const override
Definition: ValidDiTauPairCandidatesProducers.cc:55
ValidTTPairCandidatesProducer
Definition: ValidDiTauPairCandidatesProducers.h:382
ValidMMPairCandidatesProducer::GetProducerId
virtual std::string GetProducerId() const override
Definition: ValidDiTauPairCandidatesProducers.cc:69
ValidMTPairCandidatesProducer
Definition: ValidDiTauPairCandidatesProducers.h:389
HttTypes
all data types which are used for Htt analyses
Definition: HttTypes.h:27
plot_overtraining.regex
tuple regex
Definition: plot_overtraining.py:51
ValidETPairCandidatesProducer::ValidETPairCandidatesProducer
ValidETPairCandidatesProducer()
Definition: ValidDiTauPairCandidatesProducers.cc:33
DiTauPair::GetCommonHltPaths
std::vector< std::string > GetCommonHltPaths(std::map< KLepton *, std::map< std::string, std::map< std::string, std::vector< KLV * > > > * > const &detailedTriggerMatchedLeptons, std::vector< std::string > const &hltPathsWithoutCommonMatchRequired)
Definition: DiTauPair.cc:22
ValidEEPairCandidatesProducer
Definition: ValidDiTauPairCandidatesProducers.h:417
DiGenTauPair::GetDeltaR
double GetDeltaR()
Definition: DiGenTauPair.cc:14
ValidEMPairCandidatesProducer::ValidEMPairCandidatesProducer
ValidEMPairCandidatesProducer()
Definition: ValidDiTauPairCandidatesProducers.cc:47
DiTauPair
Definition: DiTauPair.h:9
ValidMTPairCandidatesProducer::GetProducerId
virtual std::string GetProducerId() const override
Definition: ValidDiTauPairCandidatesProducers.cc:27