DAS  3.0
Das Analysis System
Helper

#include <helper.h>

+ Collaboration diagram for Helper:

Public Member Functions

 Helper (DAS::Parameters &parameters)
 
DAS::GenJet GetGenJet (const reco::JetFlavourInfoMatching &ijet)
 
DAS::GenJet GetGenJet (const reco::Jet &ijet)
 
DAS::RecJet GetRecJet (const pat::Jet &ijet)
 
bool JetID (const pat::Jet &jet)
 
DAS::GenMuon GetGenMu (const reco::Candidate &mu)
 
DAS::RecMuon GetRecMu (const pat::Muon &mu)
 
DAS::GenPhoton GetGenPhoton (const reco::GenParticle &photon, bool zAncestor)
 
DAS::RecPhoton GetRecPhoton (const pat::Photon &photon)
 
std::vector< std::string > CollectWeightIds (const tinyxml2::XMLDocument &doc, const std::string &scaleChoice, const std::string &pdfGroupName) const
 
std::string BufferWeightGroupXML (const LHERunInfoProduct &runInfo) const
 
std::vector< std::string > GetScaleVariations (const tinyxml2::XMLDocument &doc, const std::string &scaleChoice) const
 
int CountPDFWeights (const tinyxml2::XMLDocument &doc, const std::string &pdfGroupName) const
 

Public Attributes

DAS::Parametersp
 

Constructor & Destructor Documentation

◆ Helper()

Helper ( DAS::Parameters parameters)

Constructor

Only giving parameters in reference

14 : p(parameters) {}

Member Function Documentation

◆ BufferWeightGroupXML()

string BufferWeightGroupXML ( const LHERunInfoProduct &  runInfo) const

Extracts the XML fragment starting at <weightgroup> from LHE headers.

Parameters
runInfoThe LHERunInfoProduct containing header lines to scan.
Returns
A string with the buffered XML (empty if no <weightgroup> found).
373 {
374  ostringstream buffer;
375  bool startProcessing = false;
376 
377  for (auto iter = runInfo.headers_begin(); iter != runInfo.headers_end(); ++iter) {
378  for (const string& line : iter->lines()) {
379  string current = line;
380 
381  // strip comments after '#'
382  auto cpos = current.find('#');
383  if (cpos != string::npos)
384  current.erase(cpos);
385 
386  // if we haven't hit <weightgroup> yet, look for it
387  if (!startProcessing) {
388  auto wpos = current.find("<weightgroup");
389  if (wpos != string::npos) {
390  startProcessing = true;
391  buffer << current.substr(wpos) << "\n";
392  }
393  }
394  else {
395  // already in the XML region – keep every line
396  buffer << current << "\n";
397  }
398  }
399  }
400 
401  return buffer.str();
402 }

◆ CollectWeightIds()

vector< string > CollectWeightIds ( const tinyxml2::XMLDocument &  doc,
const std::string &  scaleChoice,
const std::string &  pdfGroupName 
) const

Extracts HT/2 (dynamic) scale-variation and PDF-variation IDs from an XML document, skipping off‐diagonal static scale combinations.

Parameters
docXMLDocument containing <weightgroup> elements.
scaleChoiceSubstring to match in <weight> text (e.g. "HT/2"). If empty, scale-variation collection is disabled.
pdfGroupNameName of the PDF group (e.g. "NNPDF31_nlo_hessian_pdfas"). If empty, PDF-variation collection is disabled.
Returns
Vector containing matched weight IDs.
270 {
271  vector<string> genweight_ids;
272  constexpr double nominal = 1.0;
273 
274  const bool enableScale = !scaleChoice.empty();
275  const bool enablePDF = !pdfGroupName.empty();
276 
277  if (!enableScale)
278  cout << "scaleChoice is empty; will NOT store scale-variation IDs.\n";
279 
280  if (!enablePDF)
281  cout << "pdfGroupName is empty; will NOT store PDF-variation IDs.\n";
282 
283 
284  bool foundScale = false;
285  bool foundPDF = false;
286 
287  for (auto* wg = doc.FirstChildElement("weightgroup");
288  wg;
289  wg = wg->NextSiblingElement("weightgroup"))
290  {
291  const char* nameC = wg->Attribute("name");
292  if (!nameC)
293  continue;
294  const string name{nameC};
295 
296  // ---- Dynamic scale-variation group ----
297  if (enableScale && name == "Central scale variation") {
298  // Match: dyn_scale_choice=<scaleChoice> followed by whitespace or end
299  const regex pat("dyn_scale_choice=" + scaleChoice + R"((\s|$))",
300  regex::ECMAScript);
301 
302  for (auto* w = wg->FirstChildElement("weight");
303  w;
304  w = w->NextSiblingElement("weight"))
305  {
306  const char* txt = w->GetText();
307  if (!txt || !regex_search(txt, pat))
308  continue;
309 
310  foundScale = true;
311 
312  // Parse MUF/MUR safely; if missing, throw
313  const char* mufC = w->Attribute("MUF");
314  const char* murC = w->Attribute("MUR");
315 
316  if (!mufC || !murC)
317  throw cms::Exception("Ntupliser") << "[CollectWeightIds] Missing MUF/MUR attributes.";
318 
319  double muf = 0.0, mur = 0.0;
320  try {
321  muf = std::stod(mufC);
322  mur = std::stod(murC);
323  } catch (const std::invalid_argument& e) {
324  throw cms::Exception("Ntupliser")
325  << "[CollectWeightIds] Non-numeric MUF/MUR. MUF='" << (mufC ? mufC : "null")
326  << "', MUR='" << (murC ? murC : "null") << "'. Reason: " << e.what();
327  } catch (const std::out_of_range& e) {
328  throw cms::Exception("Ntupliser")
329  << "[CollectWeightIds] MUF/MUR out of range. MUF='" << (mufC ? mufC : "null")
330  << "', MUR='" << (murC ? murC : "null") << "'. Reason: " << e.what();
331  }
332 
333  // Skip off-diagonals: one > nominal, the other < nominal
334  if ((muf > nominal && mur < nominal) || (muf < nominal && mur > nominal))
335  continue;
336 
337  if (const char* id = w->Attribute("id"))
338  genweight_ids.emplace_back(id);
339  }
340  }
341  // ---- PDF variation group ----
342  else if (enablePDF && name == pdfGroupName) {
343  foundPDF = true;
344  for (auto* w = wg->FirstChildElement("weight");
345  w;
346  w = w->NextSiblingElement("weight"))
347  {
348  if (const char* id = w->Attribute("id"))
349  genweight_ids.emplace_back(id);
350  }
351  }
352  }
353 
354  // Only error if the user explicitly requested them (non-empty arg) but none found.
355  if (enableScale && !foundScale) {
356  throw cms::Exception("Ntupliser")
357  << "No weights found for scale choice: " << scaleChoice;
358  }
359  if (enablePDF && !foundPDF) {
360  throw cms::Exception("Ntupliser")
361  << "No weights found for PDF group: " << pdfGroupName;
362  }
363 
364  return genweight_ids;
365 }

◆ CountPDFWeights()

int CountPDFWeights ( const tinyxml2::XMLDocument &  doc,
const std::string &  pdfGroupName 
) const

Counts the number of weights in the specified PDF group.

Parameters
docThe XML document containing <weightgroup> elements.
pdfGroupNameThe exact name attribute of the PDF group to count.
Returns
The total count of <weight> tags under that group.
500 {
501  int pdfWeightCount = 0;
502 
503  for (const tinyxml2::XMLElement* group = doc.FirstChildElement("weightgroup");
504  group;
505  group = group->NextSiblingElement("weightgroup"))
506  {
507  const char* name = group->Attribute("name");
508  if (!name)
509  throw cms::Exception("Ntupliser") << "<weightgroup> element is missing required \"name\" attribute";
510 
511  if (pdfGroupName == name)
512  {
513  for (const tinyxml2::XMLElement* w = group->FirstChildElement("weight");
514  w;
515  w = w->NextSiblingElement("weight"))
516  {
517  ++pdfWeightCount;
518  }
519  }
520  }
521 
522  if (pdfWeightCount == 0)
523  throw cms::Exception("Ntupliser") << "PDF group \"" << pdfGroupName << "\" not found or empty";
524 
525  return pdfWeightCount;
526 }

◆ GetGenJet() [1/2]

DAS::GenJet GetGenJet ( const reco::Jet &  ijet)

Helper to get DAS::GenJet from MiniAOD without flavour.

19 {
20  DAS::GenJet jjet;
21 
22  // kinematics
23  jjet.p4 = DAS::FourVector(ijet.p4());
24 
25  return jjet;
26 }

◆ GetGenJet() [2/2]

DAS::GenJet GetGenJet ( const reco::JetFlavourInfoMatching &  ijet)

Helper to get DAS::GenJet from MiniAOD with flavour.

31 {
32  const reco::Jet& Jet = *(ijet.first.get());
33  const reco::JetFlavourInfo& Info = ijet.second;
34 
35  DAS::GenJet jjet = GetGenJet(Jet);
36 
37  // parton flavour
38  jjet.partonFlavour = Info.getPartonFlavour();
39 
40  // heavy-flavour hadrons
41  jjet.nBHadrons = Info.getbHadrons().size();
42  jjet.nCHadrons = Info.getcHadrons().size();
43 
44  return jjet;
45 }

◆ GetGenMu()

DAS::GenMuon GetGenMu ( const reco::Candidate &  mu)

Helper to get DAS::GenMuon from MiniAOD.

153 {
154  DAS::GenMuon Mu;
155 
156  // kinematics
157  Mu.p4 = mu.p4();
158 
159  Mu.Q = mu.charge();
160 
161  return Mu;
162 }

◆ GetGenPhoton()

DAS::GenPhoton GetGenPhoton ( const reco::GenParticle &  photon,
bool  zAncestor 
)

Helper to get DAS::GenPhoton from MiniAOD.

188 {
189  DAS::GenPhoton dasPhoton;
190 
191  // kinematics
192  dasPhoton.p4 = photon.p4();
193  dasPhoton.zAncestor = zAncestor;
194  dasPhoton.prompt = photon.isPromptFinalState();
195 
196  return dasPhoton;
197 }

◆ GetRecJet()

DAS::RecJet GetRecJet ( const pat::Jet &  ijet)

Helper to get DAS::RecJet from MiniAOD.

General instructions DeepJet

53 {
54  DAS::RecJet jjet;
55 
56  // kinematics
57  jjet.p4 = ijet.correctedP4("Uncorrected");
58 
59  // JetMET business
60  jjet.area = ijet.jetArea();
61  jjet.puID = p.PUjetID ? ijet.userFloat("pileupJetId:fullDiscriminant") : 1.;
62 
63  if (p.flavour) {
64  // parton flavour
65  jjet.partonFlavour = ijet.partonFlavour();
66 
67  // heavy-flavour hadrons
68  jjet.nBHadrons = ijet.jetFlavourInfo().getbHadrons().size();
69  jjet.nCHadrons = ijet.jetFlavourInfo().getcHadrons().size();
70 
71  // heavy-flavour tagging
72  jjet.DeepJet.probb = ijet.bDiscriminator("pfDeepFlavourJetTags:probb");
73  jjet.DeepJet.probbb = ijet.bDiscriminator("pfDeepFlavourJetTags:probbb");
74  jjet.DeepJet.problepb = ijet.bDiscriminator("pfDeepFlavourJetTags:problepb");
75  jjet.DeepJet.probc = ijet.bDiscriminator("pfDeepFlavourJetTags:probc");
76  //jjet.DeepJet.probcc = ijet.bDiscriminator("pfDeepFlavourJetTags:probcc");
77  jjet.DeepJet.probuds = ijet.bDiscriminator("pfDeepFlavourJetTags:probuds");
78  jjet.DeepJet.probg = ijet.bDiscriminator("pfDeepFlavourJetTags:probg");
79 
80  static const auto eps = 10*numeric_limits<float>::epsilon();
81  if (abs(jjet.DeepJet.probb + jjet.DeepJet.probbb + jjet.DeepJet.problepb + jjet.DeepJet.probc + /*jjet.DeepJet.probcc +*/ jjet.DeepJet.probuds + jjet.DeepJet.probg - 1) > eps)
82  cerr << abs(jjet.DeepJet.probb + jjet.DeepJet.probbb + jjet.DeepJet.problepb + jjet.DeepJet.probc + /*jjet.DeepJet.probcc +*/ jjet.DeepJet.probuds + jjet.DeepJet.probg - 1) << ' ' << eps << endl;
83  }
84 
85  jjet.scales.resize(1, 1.0);
86 
87  return jjet;
88 }

◆ GetRecMu()

DAS::RecMuon GetRecMu ( const pat::Muon &  mu)

Helper to get DAS::RecMuon from MiniAOD.

167 {
168  DAS::RecMuon Mu;
169 
170  // kinematics
171  Mu.p4 = mu.p4();
172 
173  Mu.selectors = mu.selectors();
174  Mu.Q = mu.charge();
175 
176  // tracking properties
177  Mu.Dxy = mu.dB(pat::Muon::PV2D);
178  Mu.Dz = mu.dB(pat::Muon::PVDZ);
179  if (mu.innerTrack().isNonnull())
180  Mu.nTkHits = mu.innerTrack()->hitPattern().trackerLayersWithMeasurement();
181 
182  return Mu;
183 }

◆ GetRecPhoton()

DAS::RecPhoton GetRecPhoton ( const pat::Photon &  photon)

Helper to get DAS::RecLep from MiniAOD.

202 {
203  DAS::RecPhoton dasPhoton;
204 
205  // kinematics
206  dasPhoton.p4 = photon.p4();
207 
208  if (photon.hasUserFloat("ecalEnergyPostCorr")) {
209  // Only for MiniAODv2 (Run 2). In Run 3 we need to use correctionlib.
210  const auto raw_energy = dasPhoton.p4.E();
211  dasPhoton.scales = decltype(dasPhoton.scales){{
212  photon.userFloat("ecalEnergyPostCorr") / raw_energy,
213  photon.userFloat("energyScaleUp") / raw_energy,
214  photon.userFloat("energyScaleDown") / raw_energy,
215  photon.userFloat("energySigmaPhiUp") / raw_energy,
216  photon.userFloat("energySigmaPhiDown") / raw_energy,
217  photon.userFloat("energySigmaRhoUp") / raw_energy,
218  photon.userFloat("energySigmaRhoDown") / raw_energy,
219  }};
220  dasPhoton.ecalEnergyErrPostCorr = photon.userFloat("ecalEnergyErrPostCorr");
221  }
222 
223  // supercluster
224  dasPhoton.r9 = photon.full5x5_r9();
225  dasPhoton.scEta = photon.superCluster()->eta();
226  dasPhoton.sigmaIEtaIEta = photon.full5x5_sigmaIetaIeta();
227  dasPhoton.seedCrystalGain =
228  photon.hasUserFloat("seedGain") ? photon.userInt("seedGain") : -1;
229 
230  // ID
231  dasPhoton.hOverE = photon.hadronicOverEm();
232 
233  if (photon.photonID("cutBasedPhotonID-Fall17-94X-V2-loose"))
235  if (photon.photonID("cutBasedPhotonID-Fall17-94X-V2-medium"))
237  if (photon.photonID("cutBasedPhotonID-Fall17-94X-V2-tight"))
239  if (photon.photonID("mvaPhoID-RunIIFall17-v2-wp80"))
241  if (photon.photonID("mvaPhoID-RunIIFall17-v2-wp90"))
243  if (photon.passElectronVeto())
245  if (!photon.hasPixelSeed())
247 
248  // Isolation
249  dasPhoton.chargedIsolation = photon.chargedHadronIso();
250  dasPhoton.neutralHadronIsolation = photon.neutralHadronIso();
251  dasPhoton.photonIsolation = photon.photonIso();
252  dasPhoton.worstChargedIsolation = photon.chargedHadronWorstVtxIso();
253 
254  return dasPhoton;
255 }

◆ GetScaleVariations()

vector< string > GetScaleVariations ( const tinyxml2::XMLDocument &  doc,
const std::string &  scaleChoice 
) const

Extracts only the envelope scale variations (skipping nominal, off‐diagonals and placeholder scales) from the "Central scale variation" <weightgroup>, honoring the same dyn_scale_choice filter you use in CollectWeightIds.

Parameters
docThe XMLDocument containing <weightgroup> elements.
scaleChoiceThe substring to match in the <weight> text, e.g. "HT/2".
Returns
A vector of variation names in the order they appear.
416 {
417  const double nominal = 1.0;
418  vector<string> variations;
419 
420  // Exactly like CollectWeightIds: look for name="Central scale variation"
421  for (auto* wg = doc.FirstChildElement("weightgroup");
422  wg;
423  wg = wg->NextSiblingElement("weightgroup"))
424  {
425  const char* nameC = wg->Attribute("name");
426  if (!nameC)
427  continue;
428 
429  if (string{nameC} != "Central scale variation")
430  continue;
431 
432  // Within that group, filter on dyn_scale_choice just as you do for IDs
433  for (auto* w = wg->FirstChildElement("weight");
434  w;
435  w = w->NextSiblingElement("weight"))
436  {
437  const char* txt = w->GetText();
438  regex pat("dyn_scale_choice=" + scaleChoice + "(\\s|$)");
439  if (!txt || regex_search(txt, pat))
440  continue;
441 
442  // parse static MUF/MUR
443  double muf = stod(w->Attribute("MUF"));
444  double mur = stod(w->Attribute("MUR"));
445 
446  // skip off-diagonals: one > nominal, one < nominal
447  if ((muf > nominal && mur < nominal) ||
448  (muf < nominal && mur > nominal))
449  {
450  continue;
451  }
452 
453  // skip the central nominal point
454  if (muf == nominal && mur == nominal)
455  continue;
456 
457  // build exactly the same variation names you want:
458  if (muf == nominal) {
459  variations.emplace_back(
460  mur > nominal
461  ? "RenormalisationScaleUp"
462  : "RenormalisationScaleDown"
463  );
464  }
465  else if (mur == nominal) {
466  variations.emplace_back(
467  muf > nominal
468  ? "FactorisationScaleUp"
469  : "FactorisationScaleDown"
470  );
471  }
472  else {
473  // both varied → only keep diagonal
474  if (muf > nominal && mur > nominal)
475  variations.emplace_back("BothScaleUp");
476  else if (muf < nominal && mur < nominal)
477  variations.emplace_back("BothScaleDown");
478  }
479  }
480 
481  // once we've processed the "Central scale variation" group, no need
482  // to look at any further weightgroup elements:
483  break;
484  }
485 
486  if (variations.empty()) {
487  throw cms::Exception("Ntupliser") << "No valid envelope variations found for scale choice: " << scaleChoice;
488  }
489 
490  return variations;
491 }

◆ JetID()

bool JetID ( const pat::Jet &  jet)

Testing tight ID lepton veto definition for jets (official from JetMET)

The values for Run 2 correspond to UL and are not expected to change. Instead, the values for Run 3 are only preliminary and are subject to changes.

Note
The formulae in blue from the original TWiki have been copied and their format adapted.
100 {
101  const auto eta = jet.eta();
102 
103  auto NHF = jet.neutralHadronEnergyFraction();
104  auto NEMF = jet.photonEnergyFraction();
105  auto MUF = jet.muonEnergyFraction();
106  auto NumConst = jet.neutralMultiplicity() + jet.chargedMultiplicity();
107 
108  auto CHF = jet.chargedHadronEnergyFraction();
109  auto CHM = jet.chargedHadronMultiplicity();
110  auto CEMF = jet.chargedEmEnergyFraction();
111 
112  auto NumNeutralParticle = jet.neutralMultiplicity();
113 
114  switch (p.year) {
115  case 2016:
116  return (abs(eta)<=2.4 && CEMF<0.8 && CHM>0 && CHF>0 && NumConst>1 && NEMF<0.9 && MUF <0.8 && NHF < 0.9)
117  || (p.CHS && abs(eta)>2.4 && abs(eta)<=2.7 && NEMF<0.99 && NHF < 0.9)
118  || (p.CHS && NEMF>0.0 && NEMF<0.99 && NHF<0.9 && NumNeutralParticle>1 && abs(eta)>2.7 && abs(eta)<=3.0)
119  || (p.CHS && NEMF<0.90 && NHF>0.2 && NumNeutralParticle>10 && abs(eta)>3.0)
120  || (p.PUPPI && abs(eta)>2.4 && abs(eta)<=2.7 && NEMF<0.99 && NHF < 0.98)
121  || (p.PUPPI && NumNeutralParticle>=1 && abs(eta)>2.7 && abs(eta)<=3.0)
122  || (p.PUPPI && NEMF<0.90 && NumNeutralParticle>2 && abs(eta)>3.0);
123 
124  case 2017:
125  case 2018:
126  return (abs(eta)<=2.6 && CEMF<0.8 && CHM>0 && CHF>0 && NumConst>1 && NEMF<0.9 && MUF <0.8 && NHF < 0.9)
127  || (p.CHS && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && CHM>0 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
128  || (p.CHS && NEMF>0.01 && NEMF<0.99 && NumNeutralParticle>1 && abs(eta)>2.7 && abs(eta)<=3.0)
129  || (p.CHS && NEMF<0.90 && NHF>0.2 && NumNeutralParticle>10 && abs(eta)>3.0)
130  || (p.PUPPI && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
131  || (p.PUPPI && NHF<0.9999 && abs(eta)>2.7 && abs(eta)<=3.0)
132  || (p.PUPPI && NEMF<0.90 && NumNeutralParticle>2 && abs(eta)>3.0);
133  case 2022:
134  case 2023:
135  case 2024:
136  return (abs(eta)<=2.6 && CEMF<0.8 && CHM>0 && CHF>0.01 && NumConst>1 && NEMF<0.9 && MUF <0.8 && NHF < 0.99)
137  || (p.PUPPI && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
138  || (p.PUPPI && NHF<0.99 && abs(eta)>2.7 && abs(eta)<=3.0)
139  || (p.PUPPI &&NEMF<0.40 && NumNeutralParticle>=2 && abs(eta)>3.0)
140  || (p.CHS && abs(eta)>2.6 && abs(eta)<=2.7 && CEMF<0.8 && CHM>0 && NEMF<0.99 && MUF <0.8 && NHF < 0.9)
141  || (p.CHS && NEMF<0.99 && NHF<0.99 && NumNeutralParticle>1 && abs(eta)>2.7 && abs(eta)<=3.0)
142  || (p.CHS && NEMF<0.40 && NumNeutralParticle>10 && abs(eta)>3.0);
143  default:
144  auto err_msg = "\x1B[31m\x1B[1mThe JetID has not yet been imlemented in DAS for "s
145  + to_string(p.year) + "\x1B[0m"s;
146  throw cms::Exception("Ntupliser") << err_msg;
147  }
148 }

Member Data Documentation

◆ p


The documentation for this struct was generated from the following files:
DAS::GenJet::partonFlavour
int partonFlavour
Parton flavour (PDG ID)
Definition: Jet.h:15
DYToLL_M-50_13TeV_pythia8_cff_GEN_SIM_RECOBEFMIX_DIGI_L1_DIGI2RAW_L1Reco_RECO.name
name
Definition: DYToLL_M-50_13TeV_pythia8_cff_GEN_SIM_RECOBEFMIX_DIGI_L1_DIGI2RAW_L1Reco_RECO.py:48
Ntupliser_cfg.cerr
cerr
Definition: Ntupliser_cfg.py:105
Step::eps
static const auto eps
Definition: Step.h:38
DAS::RecPhoton::PixelSeedVeto
@ PixelSeedVeto
Pixel seed veto.
Definition: Photon.h:55
DAS::Helper::GetGenJet
DAS::GenJet GetGenJet(const reco::JetFlavourInfoMatching &ijet)
Helper to get DAS::GenJet from MiniAOD with flavour.
Definition: helper.cc:30
DAS::RecPhoton::CutBasedMedium
@ CutBasedMedium
Medium cut-based ID.
Definition: Photon.h:50
DAS::RecPhoton::scEta
float scEta
Super cluster eta, used to veto the barrel/endcap transition region.
Definition: Photon.h:59
DAS::PhysicsObject::p4
FourVector p4
raw four-momentum directly after reconstruction
Definition: PhysicsObject.h:50
DAS::RecMuon::Dxy
float Dxy
transverse distance to PV
Definition: Lepton.h:31
DAS::RecPhoton::sigmaIEtaIEta
float sigmaIEtaIEta
Width of the ECAL deposit along the eta axis.
Definition: Photon.h:60
DAS::Helper::p
DAS::Parameters & p
Definition: helper.h:33
DAS::GenJet::nBHadrons
int nBHadrons
Number of B hadrons (0, 1 or 2+)
Definition: Jet.h:13
DAS::RecPhoton::photonIsolation
float photonIsolation
Recomputed isolation from other photons.
Definition: Photon.h:64
DAS::RecPhoton::CutBasedLoose
@ CutBasedLoose
Loose cut-based ID.
Definition: Photon.h:49
DAS::RecJet::Tagger::probc
float probc
Probability for the jet to contain at least one D hadron.
Definition: Jet.h:49
DAS::RecPhoton::MVAWorkingPoint80
@ MVAWorkingPoint80
80% efficiency working point of the MVA ID
Definition: Photon.h:52
DAS::RecJet::Tagger::probb
float probb
Probability for the jet to contain exactly one B hadron decaying hadronically.
Definition: Jet.h:50
DAS::RecMuon::nTkHits
int nTkHits
number of hits in tracker
Definition: Lepton.h:34
DAS::RecMuon::Dz
float Dz
longitudinal distance to PV
Definition: Lepton.h:32
DAS::RecJet
Definition: Jet.h:37
DAS::PhysicsObject::scales
std::vector< float > scales
energy scale corrections and variations
Definition: PhysicsObject.h:51
DAS::Parameters::year
const int year
20xx
Definition: Parameters.h:57
DAS::RecPhoton::selectors
std::uint32_t selectors
Identification cuts satisfied by the photon.
Definition: Photon.h:74
DAS::Parameters::PUPPI
const bool PUPPI
Definition: Parameters.h:62
DAS::RecMuon
class RecMuon
Definition: Lepton.h:25
DAS::RecJet::Tagger::probbb
float probbb
Probability for the jet to contain at least two B hadrons.
Definition: Jet.h:51
DAS::GenPhoton
class GenPhoton
Definition: Photon.h:13
DAS::RecJet::DeepJet
struct DAS::RecJet::Tagger DeepJet
Reference
DAS::RecJet::Tagger::problepb
float problepb
Probability for the jet to contain exactly one B hadron decaying leptonically.
Definition: Jet.h:52
DAS::GenMuon
class GenMuon
Definition: Lepton.h:9
DAS::GenJet
class GenJet
Definition: Jet.h:9
DAS::GenPhoton::prompt
bool prompt
Originates directly from the matrix element.
Definition: Photon.h:18
DAS::Parameters::CHS
const bool CHS
Definition: Parameters.h:62
DAS::GenJet::nCHadrons
int nCHadrons
Number of D hadrons (0, 1+ in 2017; 0, 1, 2+ in 2016)
Definition: Jet.h:14
DAS::RecPhoton::worstChargedIsolation
float worstChargedIsolation
Recomputed charged isolation with the vertex chosen to maximize this value used for the ID.
Definition: Photon.h:65
DAS::Uncertainties::nominal
const Variation nominal
Definition: Variation.h:55
DAS::RecPhoton::hOverE
float hOverE
Ratio of HCAL to ECAL energy.
Definition: Photon.h:61
DAS::RecMuon::selectors
unsigned int selectors
muon ID & PF isolation
Definition: Lepton.h:29
DAS::RecJet::area
float area
Jet area (should be peaked at pi*R^2), used for the JES corrections.
Definition: Jet.h:42
DAS::RecPhoton::ecalEnergyErrPostCorr
float ecalEnergyErrPostCorr
Energy scale and smearing variations, indexed with the EnergyVariation enum.
Definition: Photon.h:72
DAS::RecJet::Tagger::probuds
float probuds
Probability for the jet to be a quark jet with no HF hadron.
Definition: Jet.h:53
DAS::RecPhoton::CutBasedTight
@ CutBasedTight
Tight cut-based ID.
Definition: Photon.h:51
DAS::Parameters::flavour
const bool flavour
Definition: Parameters.h:72
DAS::RecPhoton::r9
float r9
R9 of the supercluster, calculated with full 5x5 region.
Definition: Photon.h:58
DAS::GenPhoton::zAncestor
bool zAncestor
Z boson among the particle mothers.
Definition: Photon.h:17
DAS::Parameters::PUjetID
const bool PUjetID
Definition: Parameters.h:72
DAS::FourVector
ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiM4D< float > > FourVector
Definition: PhysicsObject.h:15
DAS::RecPhoton::neutralHadronIsolation
float neutralHadronIsolation
Recomputed isolation from neutral hadrons.
Definition: Photon.h:63
DAS::GenMuon::Q
int Q
+/- 1
Definition: Lepton.h:13
DAS::RecJet::Tagger::probg
float probg
Probability for the jet to be a gluon jet with no HF hadron.
Definition: Jet.h:54
DAS::RecPhoton::seedCrystalGain
int seedCrystalGain
Amplifier gain of the ECAL crystal used to seed the supercluster.
Definition: Photon.h:68
DAS::RecPhoton::MVAWorkingPoint90
@ MVAWorkingPoint90
90% efficiency working point of the MVA ID
Definition: Photon.h:53
DAS::RecPhoton::chargedIsolation
float chargedIsolation
Recomputed isolation from charged particles.
Definition: Photon.h:62
jmarExample.eta
eta
DeepAK8/ParticleNet tagging.
Definition: jmarExample.py:19
DAS::RecPhoton
class RecPhoton
Definition: Photon.h:27
DAS::RecPhoton::ConversionSafeElectronVeto
@ ConversionSafeElectronVeto
Electron veto.
Definition: Photon.h:54
DAS::RecJet::puID
float puID
pile-up jet ID
Definition: Jet.h:43