ATLAS Offline Software
Classes | Typedefs | Functions
egammaMVAFunctions Namespace Reference

These functions are for calculating variables used by the MVA calibration. More...

Classes

struct  ConversionHelper
 The ConversionHelper struct is stll used by egammaMVATree in PhysicsAnalysis but not the functions in the dictionaries above. More...
 

Typedefs

using funcMap_t = std::unordered_map< std::string, std::function< float(const xAOD::Egamma *, const xAOD::CaloCluster *)> >
 Define the map type since it's long. More...
 

Functions

float compute_cl_eta (const xAOD::CaloCluster &cluster)
 
float compute_cl_phi (const xAOD::CaloCluster &cluster)
 
float compute_cl_e (const xAOD::CaloCluster &cluster)
 
float compute_cl_etaCalo (const xAOD::CaloCluster &cluster)
 
float compute_cl_phiCalo (const xAOD::CaloCluster &cluster)
 
float compute_cl_etas1 (const xAOD::CaloCluster &cluster)
 
float compute_cl_etas2 (const xAOD::CaloCluster &cluster)
 
float compute_rawcl_Es0 (const xAOD::CaloCluster &cl)
 
float compute_rawcl_Es1 (const xAOD::CaloCluster &cl)
 
float compute_rawcl_Es2 (const xAOD::CaloCluster &cl)
 
float compute_rawcl_Es3 (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_Es0 (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_Es1 (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_Es2 (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_Es3 (const xAOD::CaloCluster &cl)
 
float compute_rawcl_Eacc (const xAOD::CaloCluster &cl)
 
float compute_rawcl_f0 (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_Eacc (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_f0 (const xAOD::CaloCluster &cl)
 
float compute_calibHitsShowerDepth (const std::array< float, 4 > &cl, float eta)
 
float compute_rawcl_calibHitsShowerDepth (const xAOD::CaloCluster &cl)
 
float compute_correctedcl_calibHitsShowerDepth (const xAOD::CaloCluster &cl)
 
float compute_et (const xAOD::CaloCluster &cl)
 
float cl_getMoment (const xAOD::CaloCluster &cl, xAOD::CaloCluster::MomentType m, const char *name)
 
float compute_cl_significance (const xAOD::CaloCluster &cl)
 
float compute_cl_secondLambda (const xAOD::CaloCluster &cl)
 
float compute_cl_lateral (const xAOD::CaloCluster &cl)
 
float compute_cl_longitudinal (const xAOD::CaloCluster &cl)
 
float compute_cl_fracMax (const xAOD::CaloCluster &cl)
 
float compute_cl_secondR (const xAOD::CaloCluster &cl)
 
float compute_cl_centerLambda (const xAOD::CaloCluster &cl)
 
float compute_cl_secondDensity (const xAOD::CaloCluster &cl)
 
float compute_cl_x (const xAOD::CaloCluster &cl)
 
float compute_cl_y (const xAOD::CaloCluster &cl)
 
float compute_cl_z (const xAOD::CaloCluster &cl)
 
float compute_cl_secondR_fudge (const xAOD::Egamma &eg)
 
float compute_eta_FCAL (const xAOD::CaloCluster &cl)
 
float compute_etaMod_FCAL (const xAOD::CaloCluster &cl)
 
float compute_cellIndex_FCAL (const xAOD::CaloCluster &cl)
 
float compute_etaMod_EMEC (const xAOD::CaloCluster &cl)
 
float compute_cellIndex_EMEC (const xAOD::CaloCluster &cl)
 
float compute_phiMod_EMEC (const xAOD::CaloCluster &cl)
 
float compute_R12_EMEC (const xAOD::CaloCluster &cl)
 
float compute_el_charge (const xAOD::Electron &el)
 
float compute_el_tracketa (const xAOD::Electron &el)
 
float compute_el_trackpt (const xAOD::Electron &el)
 
float compute_el_trackz0 (const xAOD::Electron &el)
 
float compute_el_refittedTrack_qoverp (const xAOD::Electron &el)
 
int compute_el_author (const xAOD::Electron &el)
 
int compute_ph_convFlag (const xAOD::Photon &ph)
 
float getPtAtFirstMeasurement (const xAOD::TrackParticle *tp)
 
float compute_ptconv_decor (const xAOD::Photon *ph)
 This ptconv function uses the vertex decorations. More...
 
float compute_ptconv (const xAOD::Photon *ph)
 This ptconv is the old one used by MVACalib. More...
 
float compute_pt1conv (const xAOD::Photon *ph)
 
float compute_pt2conv (const xAOD::Photon *ph)
 
template<int itrack, xAOD::SummaryType summary>
int compute_convtrkXhits (const xAOD::Photon *ph)
 
int compute_convtrk1nPixHits (const xAOD::Photon *ph)
 
int compute_convtrk2nPixHits (const xAOD::Photon *ph)
 
int compute_convtrk1nSCTHits (const xAOD::Photon *ph)
 
int compute_convtrk2nSCTHits (const xAOD::Photon *ph)
 
std::unique_ptr< funcMap_t > initializeElectronFuncs (bool useLayerCorrected)
 A function to build the map for electrons. More...
 
std::unique_ptr< funcMap_t > initializeUnconvertedPhotonFuncs (bool useLayerCorrected)
 A function to build the map for uncoverted photons. More...
 
std::unique_ptr< funcMap_t > initializeConvertedPhotonFuncs (bool useLayerCorrected)
 A function to build the map for converted photons. More...
 
std::unique_ptr< funcMap_t > initializeForwardElectronFuncs (bool useLayerCorrected)
 NEW: A function to build the map for forward electrons. More...
 
void initializeClusterFuncs (funcMap_t &funcLibrary, const std::string &prefix, bool useLayerCorrected)
 
void initializeEgammaFuncs (funcMap_t &funcLibrary, const std::string &prefix, bool useLayerCorrected)
 

Detailed Description

These functions are for calculating variables used by the MVA calibration.

These functions are for building the maps of functions.

The user can use the functions

Typedef Documentation

◆ funcMap_t

using egammaMVAFunctions::funcMap_t = typedef std::unordered_map<std::string, std::function<float(const xAOD::Egamma*, const xAOD::CaloCluster*)> >

Define the map type since it's long.

Definition at line 307 of file egammaMVAFunctions.h.

Function Documentation

◆ cl_getMoment()

float egammaMVAFunctions::cl_getMoment ( const xAOD::CaloCluster &  cl,
xAOD::CaloCluster::MomentType  m,
const char *  name 
)
inline

Definition at line 143 of file egammaMVAFunctions.h.

145  {
146  double tmp = 0.;
147  if (!cl.retrieveMoment(m, tmp)) {
148  throw std::runtime_error(std::string("Forward-electron missing moment: ") + name);
149  }
150  return static_cast<float>(tmp);
151  }

◆ compute_calibHitsShowerDepth()

float egammaMVAFunctions::compute_calibHitsShowerDepth ( const std::array< float, 4 > &  cl,
float  eta 
)
inline

Definition at line 101 of file egammaMVAFunctions.h.

102  {
103  const float denominator = cl[0] + cl[1] + cl[2] + cl[3];
104  if (denominator == 0) return 0.;
105 
106  const std::array<float, 4> radius(get_MVAradius(eta));
107 
108  // loop unrolling
109  return (radius[0] * cl[0]
110  + radius[1] * cl[1]
111  + radius[2] * cl[2]
112  + radius[3] * cl[3]) / denominator;
113  }

◆ compute_cellIndex_EMEC()

float egammaMVAFunctions::compute_cellIndex_EMEC ( const xAOD::CaloCluster &  cl)
inline

Definition at line 188 of file egammaMVAFunctions.h.

188  {
189  return std::floor(std::abs(cl.eta())/0.1);
190  }

◆ compute_cellIndex_FCAL()

float egammaMVAFunctions::compute_cellIndex_FCAL ( const xAOD::CaloCluster &  cl)
inline

Definition at line 182 of file egammaMVAFunctions.h.

182  {
183  return std::floor(std::abs(compute_eta_FCAL(cl))/0.15);
184  }

◆ compute_cl_centerLambda()

float egammaMVAFunctions::compute_cl_centerLambda ( const xAOD::CaloCluster &  cl)
inline

Definition at line 160 of file egammaMVAFunctions.h.

160 { return cl_getMoment(cl, xAOD::CaloCluster::CENTER_LAMBDA , "CENTER_LAMBDA"); }

◆ compute_cl_e()

float egammaMVAFunctions::compute_cl_e ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 50 of file egammaMVAFunctions.h.

50 { return cluster.e(); }

◆ compute_cl_eta()

float egammaMVAFunctions::compute_cl_eta ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 48 of file egammaMVAFunctions.h.

48 { return cluster.eta(); }

◆ compute_cl_etaCalo()

float egammaMVAFunctions::compute_cl_etaCalo ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 51 of file egammaMVAFunctions.h.

51  {
52  double tmp = 0.;
53  if(! (cluster.retrieveMoment(xAOD::CaloCluster::ETACALOFRAME, tmp))) {
54  throw std::runtime_error("etaCalo not found in CaloCluster object");
55  }
56  return tmp;
57  }

◆ compute_cl_etas1()

float egammaMVAFunctions::compute_cl_etas1 ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 65 of file egammaMVAFunctions.h.

65 { return cluster.etaBE(1); }

◆ compute_cl_etas2()

float egammaMVAFunctions::compute_cl_etas2 ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 66 of file egammaMVAFunctions.h.

66 { return cluster.etaBE(2); }

◆ compute_cl_fracMax()

float egammaMVAFunctions::compute_cl_fracMax ( const xAOD::CaloCluster &  cl)
inline

Definition at line 157 of file egammaMVAFunctions.h.

157 { return cl_getMoment(cl, xAOD::CaloCluster::ENG_FRAC_MAX , "ENG_FRAC_MAX"); }

◆ compute_cl_lateral()

float egammaMVAFunctions::compute_cl_lateral ( const xAOD::CaloCluster &  cl)
inline

Definition at line 155 of file egammaMVAFunctions.h.

155 { return cl_getMoment(cl, xAOD::CaloCluster::LATERAL , "LATERAL"); }

◆ compute_cl_longitudinal()

float egammaMVAFunctions::compute_cl_longitudinal ( const xAOD::CaloCluster &  cl)
inline

Definition at line 156 of file egammaMVAFunctions.h.

156 { return cl_getMoment(cl, xAOD::CaloCluster::LONGITUDINAL , "LONGITUDINAL"); }

◆ compute_cl_phi()

float egammaMVAFunctions::compute_cl_phi ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 49 of file egammaMVAFunctions.h.

49 { return cluster.phi(); }

◆ compute_cl_phiCalo()

float egammaMVAFunctions::compute_cl_phiCalo ( const xAOD::CaloCluster &  cluster)
inline

Definition at line 58 of file egammaMVAFunctions.h.

58  {
59  double tmp = 0.;
60  if(! (cluster.retrieveMoment(xAOD::CaloCluster::PHICALOFRAME, tmp))) {
61  throw std::runtime_error("phiCalo not found in CaloCluster object");
62  }
63  return tmp;
64  }

◆ compute_cl_secondDensity()

float egammaMVAFunctions::compute_cl_secondDensity ( const xAOD::CaloCluster &  cl)
inline

Definition at line 161 of file egammaMVAFunctions.h.

161 { return cl_getMoment(cl, xAOD::CaloCluster::SECOND_ENG_DENS,"SECOND_ENG_DENS"); }

◆ compute_cl_secondLambda()

float egammaMVAFunctions::compute_cl_secondLambda ( const xAOD::CaloCluster &  cl)
inline

Definition at line 154 of file egammaMVAFunctions.h.

154 { return cl_getMoment(cl, xAOD::CaloCluster::SECOND_LAMBDA , "SECOND_LAMBDA"); }

◆ compute_cl_secondR()

float egammaMVAFunctions::compute_cl_secondR ( const xAOD::CaloCluster &  cl)
inline

Definition at line 159 of file egammaMVAFunctions.h.

159 { return cl_getMoment(cl, xAOD::CaloCluster::SECOND_R , "SECOND_R"); }

◆ compute_cl_secondR_fudge()

float egammaMVAFunctions::compute_cl_secondR_fudge ( const xAOD::Egamma &  eg)
inline

Definition at line 166 of file egammaMVAFunctions.h.

166  {
167  static const SG::AuxElement::Accessor<float> accR2("SECOND_R");
168  if (accR2.isAvailable(eg)) { return accR2(eg); }
169  return -1.;
170  }

◆ compute_cl_significance()

float egammaMVAFunctions::compute_cl_significance ( const xAOD::CaloCluster &  cl)
inline

Definition at line 153 of file egammaMVAFunctions.h.

153 { return cl_getMoment(cl, xAOD::CaloCluster::SIGNIFICANCE , "SIGNIFICANCE"); }

◆ compute_cl_x()

float egammaMVAFunctions::compute_cl_x ( const xAOD::CaloCluster &  cl)
inline

Definition at line 162 of file egammaMVAFunctions.h.

162 { return cl_getMoment(cl, xAOD::CaloCluster::CENTER_X , "CENTER_X"); }

◆ compute_cl_y()

float egammaMVAFunctions::compute_cl_y ( const xAOD::CaloCluster &  cl)
inline

Definition at line 163 of file egammaMVAFunctions.h.

163 { return cl_getMoment(cl, xAOD::CaloCluster::CENTER_Y , "CENTER_Y"); }

◆ compute_cl_z()

float egammaMVAFunctions::compute_cl_z ( const xAOD::CaloCluster &  cl)
inline

Definition at line 164 of file egammaMVAFunctions.h.

164 { return cl_getMoment(cl, xAOD::CaloCluster::CENTER_Z , "CENTER_Z"); }

◆ compute_convtrk1nPixHits()

int egammaMVAFunctions::compute_convtrk1nPixHits ( const xAOD::Photon *  ph)
inline

Definition at line 298 of file egammaMVAFunctions.h.

298 { return compute_convtrkXhits<0, xAOD::numberOfPixelHits>(ph); }

◆ compute_convtrk1nSCTHits()

int egammaMVAFunctions::compute_convtrk1nSCTHits ( const xAOD::Photon *  ph)
inline

Definition at line 300 of file egammaMVAFunctions.h.

300 { return compute_convtrkXhits<0, xAOD::numberOfSCTHits>(ph); }

◆ compute_convtrk2nPixHits()

int egammaMVAFunctions::compute_convtrk2nPixHits ( const xAOD::Photon *  ph)
inline

Definition at line 299 of file egammaMVAFunctions.h.

299 { return compute_convtrkXhits<1, xAOD::numberOfPixelHits>(ph); }

◆ compute_convtrk2nSCTHits()

int egammaMVAFunctions::compute_convtrk2nSCTHits ( const xAOD::Photon *  ph)
inline

Definition at line 301 of file egammaMVAFunctions.h.

301 { return compute_convtrkXhits<1, xAOD::numberOfSCTHits>(ph); }

◆ compute_convtrkXhits()

template<int itrack, xAOD::SummaryType summary>
int egammaMVAFunctions::compute_convtrkXhits ( const xAOD::Photon *  ph)
inline

Definition at line 285 of file egammaMVAFunctions.h.

285  {
286  const auto vx = ph->vertex();
287  if (!vx) return 0.;
288 
289  if (vx->trackParticle(0)) {
290  uint8_t hits;
291  if (vx->trackParticle(itrack)->summaryValue(hits, summary)) {
292  return hits;
293  }
294  }
295  return 0.;
296  }

◆ compute_correctedcl_calibHitsShowerDepth()

float egammaMVAFunctions::compute_correctedcl_calibHitsShowerDepth ( const xAOD::CaloCluster &  cl)
inline

Definition at line 124 of file egammaMVAFunctions.h.

124  {
125  const std::array<float, 4> cluster_array {{ compute_correctedcl_Es0(cl),
126  compute_correctedcl_Es1(cl),
127  compute_correctedcl_Es2(cl),
128  compute_correctedcl_Es3(cl) }};
129  return compute_calibHitsShowerDepth(cluster_array, compute_cl_eta(cl));
130  }

◆ compute_correctedcl_Eacc()

float egammaMVAFunctions::compute_correctedcl_Eacc ( const xAOD::CaloCluster &  cl)
inline

Definition at line 97 of file egammaMVAFunctions.h.

97 { return compute_correctedcl_Es1(cl) + compute_correctedcl_Es2(cl) + compute_correctedcl_Es3(cl); }

◆ compute_correctedcl_Es0()

float egammaMVAFunctions::compute_correctedcl_Es0 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 77 of file egammaMVAFunctions.h.

77  {
78  static const SG::ConstAccessor<double> acc ("correctedcl_Es0");
79  return acc.isAvailable(cl) ? acc(cl) : cl.energyBE(0);
80  }

◆ compute_correctedcl_Es1()

float egammaMVAFunctions::compute_correctedcl_Es1 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 81 of file egammaMVAFunctions.h.

81  {
82  static const SG::ConstAccessor<double> acc ("correctedcl_Es1");
83  return acc.isAvailable(cl) ? acc(cl) : cl.energyBE(1);
84  }

◆ compute_correctedcl_Es2()

float egammaMVAFunctions::compute_correctedcl_Es2 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 85 of file egammaMVAFunctions.h.

85  {
86  static const SG::ConstAccessor<double> acc ("correctedcl_Es2");
87  return acc.isAvailable(cl) ? acc(cl) : cl.energyBE(2);
88  }

◆ compute_correctedcl_Es3()

float egammaMVAFunctions::compute_correctedcl_Es3 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 89 of file egammaMVAFunctions.h.

89  {
90  static const SG::ConstAccessor<double> acc ("correctedcl_Es3");
91  return acc.isAvailable(cl) ? acc(cl) : cl.energyBE(3);
92  }

◆ compute_correctedcl_f0()

float egammaMVAFunctions::compute_correctedcl_f0 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 98 of file egammaMVAFunctions.h.

98 { return compute_correctedcl_Es0(cl) / (compute_correctedcl_Eacc(cl)); }

◆ compute_el_author()

int egammaMVAFunctions::compute_el_author ( const xAOD::Electron &  el)
inline

Definition at line 207 of file egammaMVAFunctions.h.

207  {
208  static const SG::ConstAccessor<unsigned short int> acc ("author");
209  return acc (el);
210  }

◆ compute_el_charge()

float egammaMVAFunctions::compute_el_charge ( const xAOD::Electron &  el)
inline

Definition at line 202 of file egammaMVAFunctions.h.

202 { return el.charge(); }

◆ compute_el_refittedTrack_qoverp()

float egammaMVAFunctions::compute_el_refittedTrack_qoverp ( const xAOD::Electron &  el)
inline

Definition at line 206 of file egammaMVAFunctions.h.

206 { return el.trackParticle()->qOverP(); }

◆ compute_el_tracketa()

float egammaMVAFunctions::compute_el_tracketa ( const xAOD::Electron &  el)
inline

Definition at line 203 of file egammaMVAFunctions.h.

203 { return el.trackParticle()->eta(); }

◆ compute_el_trackpt()

float egammaMVAFunctions::compute_el_trackpt ( const xAOD::Electron &  el)
inline

Definition at line 204 of file egammaMVAFunctions.h.

204 { return el.trackParticle()->pt(); }

◆ compute_el_trackz0()

float egammaMVAFunctions::compute_el_trackz0 ( const xAOD::Electron &  el)
inline

Definition at line 205 of file egammaMVAFunctions.h.

205 { return el.trackParticle()->z0(); }

◆ compute_et()

float egammaMVAFunctions::compute_et ( const xAOD::CaloCluster &  cl)
inline

Definition at line 136 of file egammaMVAFunctions.h.

136  {
137  const float e = cl.e();
138  const float eta = cl.eta();
139  const float c = std::cosh(eta);
140  return (c != 0.f) ? (e / c) : 0.f;
141  }

◆ compute_eta_FCAL()

float egammaMVAFunctions::compute_eta_FCAL ( const xAOD::CaloCluster &  cl)
inline

Definition at line 172 of file egammaMVAFunctions.h.

172  {
173  float x = compute_cl_x(cl);
174  float y = compute_cl_y(cl);
175  float z = compute_cl_z(cl);
176  float theta = std::acos(z/std::sqrt(x*x+y*y+z*z));
177  return -std::log(std::tan(theta/2.));
178  }

◆ compute_etaMod_EMEC()

float egammaMVAFunctions::compute_etaMod_EMEC ( const xAOD::CaloCluster &  cl)
inline

Definition at line 185 of file egammaMVAFunctions.h.

185  {
186  return std::fmod(std::abs(cl.eta()),0.1);
187  }

◆ compute_etaMod_FCAL()

float egammaMVAFunctions::compute_etaMod_FCAL ( const xAOD::CaloCluster &  cl)
inline

Definition at line 179 of file egammaMVAFunctions.h.

179  {
180  return std::fmod(std::abs(compute_eta_FCAL(cl)),0.15);
181  }

◆ compute_ph_convFlag()

int egammaMVAFunctions::compute_ph_convFlag ( const xAOD::Photon &  ph)
inline

Definition at line 213 of file egammaMVAFunctions.h.

213  {
214  const auto original = xAOD::EgammaHelpers::conversionType(&ph);
215  if (original == 3) return 2;
216  else if (original != 0) return 1;
217  else return original;
218  }

◆ compute_phiMod_EMEC()

float egammaMVAFunctions::compute_phiMod_EMEC ( const xAOD::CaloCluster &  cl)
inline

Definition at line 191 of file egammaMVAFunctions.h.

191  {
192  static const float cz = std::numbers::pi/16.;
193  float phi_mod = std::fmod(cl.phi(), cz);
194  if (phi_mod < 0) phi_mod += cz;
195  return phi_mod;
196  }

◆ compute_pt1conv()

float egammaMVAFunctions::compute_pt1conv ( const xAOD::Photon *  ph)
inline

Definition at line 256 of file egammaMVAFunctions.h.

257  {
258  static const SG::AuxElement::Accessor<float> accPt1("pt1");
259 
260  const xAOD::Vertex* vx = ph->vertex();
261  if (!vx) return 0.0;
262  if (accPt1.isAvailable(*vx)) {
263  return accPt1(*vx);
264  } else {
265  return getPtAtFirstMeasurement(vx->trackParticle(0));
266  }
267  }

◆ compute_pt2conv()

float egammaMVAFunctions::compute_pt2conv ( const xAOD::Photon *  ph)
inline

Definition at line 269 of file egammaMVAFunctions.h.

270  {
271  static const SG::AuxElement::Accessor<float> accPt2("pt2");
272 
273  const xAOD::Vertex* vx = ph->vertex();
274  if (!vx) return 0.0;
275  if (accPt2.isAvailable(*vx)) {
276  return accPt2(*vx);
277  } else {
278  return getPtAtFirstMeasurement(vx->trackParticle(1));
279  }
280  }

◆ compute_ptconv()

float egammaMVAFunctions::compute_ptconv ( const xAOD::Photon *  ph)
inline

This ptconv is the old one used by MVACalib.

Definition at line 245 of file egammaMVAFunctions.h.

246  {
247  auto vx = ph->vertex();
248  if (!vx) return 0.0;
249 
250  TLorentzVector sum;
251  if (vx->trackParticle(0)) sum += vx->trackParticle(0)->p4();
252  if (vx->trackParticle(1)) sum += vx->trackParticle(1)->p4();
253  return sum.Perp();
254  }

◆ compute_ptconv_decor()

float egammaMVAFunctions::compute_ptconv_decor ( const xAOD::Photon *  ph)
inline

This ptconv function uses the vertex decorations.

Definition at line 235 of file egammaMVAFunctions.h.

236  {
237  static const SG::AuxElement::Accessor<float> accPx("px");
238  static const SG::AuxElement::Accessor<float> accPy("py");
239 
240  auto vx = ph->vertex();
241  return vx ? std::hypot(accPx(*vx), accPy(*vx)) : 0.0;
242  }

◆ compute_R12_EMEC()

float egammaMVAFunctions::compute_R12_EMEC ( const xAOD::CaloCluster &  cl)
inline

Definition at line 197 of file egammaMVAFunctions.h.

197  {
198  return float(cl.energy_max(CaloSampling::EME1)/cl.energy_max(CaloSampling::EME2));
199  }

◆ compute_rawcl_calibHitsShowerDepth()

float egammaMVAFunctions::compute_rawcl_calibHitsShowerDepth ( const xAOD::CaloCluster &  cl)
inline

Definition at line 115 of file egammaMVAFunctions.h.

116  {
117  const std::array<float, 4> cluster_array {{ compute_rawcl_Es0(cl),
118  compute_rawcl_Es1(cl),
119  compute_rawcl_Es2(cl),
120  compute_rawcl_Es3(cl) }};
121  return compute_calibHitsShowerDepth(cluster_array, compute_cl_eta(cl));
122  }

◆ compute_rawcl_Eacc()

float egammaMVAFunctions::compute_rawcl_Eacc ( const xAOD::CaloCluster &  cl)
inline

Definition at line 94 of file egammaMVAFunctions.h.

94 { return cl.energyBE(1) + cl.energyBE(2) + cl.energyBE(3); }

◆ compute_rawcl_Es0()

float egammaMVAFunctions::compute_rawcl_Es0 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 67 of file egammaMVAFunctions.h.

67 { return cl.energyBE(0); }

◆ compute_rawcl_Es1()

float egammaMVAFunctions::compute_rawcl_Es1 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 73 of file egammaMVAFunctions.h.

73 { return cl.energyBE(1); }

◆ compute_rawcl_Es2()

float egammaMVAFunctions::compute_rawcl_Es2 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 74 of file egammaMVAFunctions.h.

74 { return cl.energyBE(2); }

◆ compute_rawcl_Es3()

float egammaMVAFunctions::compute_rawcl_Es3 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 75 of file egammaMVAFunctions.h.

75 { return cl.energyBE(3); }

◆ compute_rawcl_f0()

float egammaMVAFunctions::compute_rawcl_f0 ( const xAOD::CaloCluster &  cl)
inline

Definition at line 95 of file egammaMVAFunctions.h.

95 { return cl.energyBE(0) / (cl.energyBE(1) + cl.energyBE(2) + cl.energyBE(3)); }

◆ getPtAtFirstMeasurement()

float egammaMVAFunctions::getPtAtFirstMeasurement ( const xAOD::TrackParticle *  tp)
inline

Definition at line 221 of file egammaMVAFunctions.h.

222  {
223  if (!tp) return 0;
224  for (unsigned int i = 0; i < tp->numberOfParameters(); ++i) {
225  if (tp->parameterPosition(i) == xAOD::FirstMeasurement) {
226  return hypot(tp->parameterPX(i), tp->parameterPY(i));
227  }
228  }
229  return tp->pt();
230  }

◆ initializeClusterFuncs()

void egammaMVAFunctions::initializeClusterFuncs ( funcMap_t &  funcLibrary,
const std::string &  prefix,
bool  useLayerCorrected 
)

Definition at line 185 of file egammaMVAFunctions.cxx.

188  {
189 
190  funcLibrary[prefix + "_cl_eta"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
191  { return compute_cl_eta(*cl); };
192  funcLibrary[prefix + "_cl_phi"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
193  { return compute_cl_phi(*cl); };
194  funcLibrary[prefix + "_cl_E"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
195  { return compute_cl_e(*cl); };
196  funcLibrary[prefix + "_cl_etaCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
197  { return compute_cl_etaCalo(*cl); };
198  funcLibrary[prefix + "_cl_phiCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
199  { return compute_cl_phiCalo(*cl); };
200  funcLibrary[prefix + "_cl_E_TileGap3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
201  { return cl->eSample(CaloSampling::TileGap3); };
202 
203  funcLibrary[prefix + "_cellIndexCalo"] = funcLibrary["cellIndexCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
204  { return std::floor(std::abs(compute_cl_etaCalo(*cl))/0.025); };
205  funcLibrary[prefix + "_phiModCalo"] = funcLibrary["phiModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
206  { return ((abs(compute_cl_eta(*cl)) < 1.425) ?
207  std::fmod(compute_cl_phiCalo(*cl), TMath::Pi() / 512) :
208  std::fmod(compute_cl_phiCalo(*cl), TMath::Pi() / 384));
209  };
210 
211  // improved version of phiModCalo, proposed by G. Unal, studied by L. Nasella
212  // see https://its.cern.ch/jira/browse/ATLASEG-325
213  // see https://indico.cern.ch/event/1364593/contributions/5843081/
214  funcLibrary[prefix + "_phiModCalo1"] = funcLibrary["phiModCalo1"] =
215  [](const xAOD::Egamma*, const xAOD::CaloCluster* cl) {
216  using std::numbers::pi;
217  const double eta = compute_cl_eta(*cl);
218  const double phi = compute_cl_phiCalo(*cl);
219  const double pi_divisor = std::abs(eta) < 1.425 ? 512. : 384.;
220 
221  if (eta > 0.) {
222  if (phi > 0.) return std::fmod(phi, pi / pi_divisor);
223  else return std::fmod((2 * pi + phi), pi / pi_divisor);
224  }
225  else return std::fmod((pi - phi), pi / pi_divisor);
226  };
227 
228  funcLibrary[prefix + "_phiModCell"] = funcLibrary["phiModCell"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
229  { return std::fmod(std::abs(compute_cl_phiCalo(*cl)), TMath::Pi() / 128); };
230  funcLibrary[prefix + "_etaModCalo"] = funcLibrary["etaModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
231  { return std::fmod(std::abs(compute_cl_etaCalo(*cl)), 0.025); };
232  funcLibrary["abs(" + prefix + "_cl_eta)"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
233  { return std::abs(compute_cl_eta(*cl)); };
234  funcLibrary[prefix + "_dPhiTG3"] = funcLibrary["dPhiTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
235  { return std::fmod(2.*TMath::Pi()+compute_cl_phi(*cl),TMath::Pi()/32.)-TMath::Pi()/64.0; };
236 
237  if (useLayerCorrected) {
238  funcLibrary[prefix + "_rawcl_Es0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
239  { return compute_correctedcl_Es0(*cl); };
240  funcLibrary[prefix + "_rawcl_Es1"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
241  { return compute_correctedcl_Es1(*cl); };
242  funcLibrary[prefix + "_rawcl_Es2"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
243  { return compute_correctedcl_Es2(*cl); };
244  funcLibrary[prefix + "_rawcl_Es3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
245  { return compute_correctedcl_Es3(*cl); };
246  funcLibrary[prefix + "_rawcl_Eacc"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
247  { return compute_correctedcl_Eacc(*cl); };
248  funcLibrary[prefix + "_rawcl_f0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
249  { return compute_correctedcl_f0(*cl); };
250  funcLibrary[prefix + "_rawcl_calibHitsShowerDepth"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
251  { return compute_correctedcl_calibHitsShowerDepth(*cl); };
252  funcLibrary[prefix + "_R12"] = funcLibrary["R12"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
253  { return compute_correctedcl_Es1(*cl)/compute_correctedcl_Es2(*cl); };
254  funcLibrary[prefix + "_fTG3"] = funcLibrary["fTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
255  { return cl->eSample(CaloSampling::TileGap3)/compute_correctedcl_Eacc(*cl); };
256  } else {
257  funcLibrary[prefix + "_rawcl_Es0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
258  { return compute_rawcl_Es0(*cl); };
259  funcLibrary[prefix + "_rawcl_Es1"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
260  { return compute_rawcl_Es1(*cl); };
261  funcLibrary[prefix + "_rawcl_Es2"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
262  { return compute_rawcl_Es2(*cl); };
263  funcLibrary[prefix + "_rawcl_Es3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
264  { return compute_rawcl_Es3(*cl); };
265  funcLibrary[prefix + "_rawcl_Eacc"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
266  { return compute_rawcl_Eacc(*cl); };
267  funcLibrary[prefix + "_rawcl_f0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
268  { return compute_rawcl_f0(*cl); };
269  funcLibrary[prefix + "_rawcl_calibHitsShowerDepth"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
270  { return compute_rawcl_calibHitsShowerDepth(*cl); };
271  funcLibrary[prefix + "_R12"] = funcLibrary["R12"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
272  { return compute_rawcl_Es1(*cl)/compute_rawcl_Es2(*cl); };
273  funcLibrary[prefix + "_fTG3"] = funcLibrary["fTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
274  { return cl->eSample(CaloSampling::TileGap3)/compute_rawcl_Eacc(*cl); };
275  }
276  }

◆ initializeConvertedPhotonFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeConvertedPhotonFuncs ( bool  useLayerCorrected)

A function to build the map for converted photons.

Definition at line 72 of file egammaMVAFunctions.cxx.

73  {
74  auto funcLibraryPtr = std::make_unique<funcMap_t>();
75  funcMap_t& funcLibrary = *funcLibraryPtr;
76 
77  initializeClusterFuncs(funcLibrary, "ph", useLayerCorrected);
78  initializeEgammaFuncs(funcLibrary, "ph", useLayerCorrected);
79 
80 
81  funcLibrary["ph_Rconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
82  { return xAOD::EgammaHelpers::conversionRadius(static_cast<const xAOD::Photon*>(eg)); };
83 
84  funcLibrary["ph_convR"] = funcLibrary["convR"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
85  {
86  const auto *ph = static_cast<const xAOD::Photon*>(eg);
87  if (compute_ptconv(ph) > 3*GeV) {
88  return xAOD::EgammaHelpers::conversionRadius(ph);
89  }
90  return 799.0;
91 
92  };
93  funcLibrary["ph_zconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
94  {
95  const auto *vertex = static_cast<const xAOD::Photon*>(eg)->vertex();
96  return vertex ? vertex->position().z() : 9999;
97  };
98  funcLibrary["ph_pt1conv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
99  { return compute_pt1conv(static_cast<const xAOD::Photon*>(eg)); };
100  funcLibrary["ph_pt2conv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
101  { return compute_pt2conv(static_cast<const xAOD::Photon*>(eg)); };
102  funcLibrary["ph_ptconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
103  { return compute_ptconv(static_cast<const xAOD::Photon*>(eg)); };
104 
105  funcLibrary["ph_convPtRatio"] = funcLibrary["convPtRatio"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
106  {
107  const auto *ph = static_cast<const xAOD::Photon*>(eg);
108  if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
109  auto pt1 = compute_pt1conv(ph);
110  auto pt2 = compute_pt2conv(ph);
111  return std::max(pt1, pt2)/(pt1+pt2);
112  }
113  return 1.0f;
114  };
115 
116  if (useLayerCorrected) {
117  funcLibrary["ph_convEtOverPt"] = funcLibrary["convEtOverPt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*cl)->float
118  {
119  const auto *ph = static_cast<const xAOD::Photon*>(eg);
120 
121  float rv = 0.0;
122  if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
123  rv = std::max(0.0f, compute_correctedcl_Eacc(*cl)/(std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph)));
124  }
125  return std::min(rv, 2.0f);
126  };
127  } else {
128  funcLibrary["ph_convEtOverPt"] = funcLibrary["convEtOverPt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*cl)->float
129  {
130  const auto *ph = static_cast<const xAOD::Photon*>(eg);
131 
132  float rv = 0.0;
133  if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
134  rv = std::max(0.0f, compute_rawcl_Eacc(*cl)/(std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph)));
135  }
136  return std::min(rv, 2.0f);
137  };
138  }
139 
140  return funcLibraryPtr;
141  }

◆ initializeEgammaFuncs()

void egammaMVAFunctions::initializeEgammaFuncs ( funcMap_t &  funcLibrary,
const std::string &  prefix,
bool  useLayerCorrected 
)

Definition at line 280 of file egammaMVAFunctions.cxx.

283  {
284  funcLibrary[prefix + "_e011"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
285  { return eg->showerShapeValue(xAOD::EgammaParameters::e011); };
286  funcLibrary[prefix + "_e033"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
287  { return eg->showerShapeValue(xAOD::EgammaParameters::e033); };
288  funcLibrary[prefix + "_e132"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
289  { return eg->showerShapeValue(xAOD::EgammaParameters::e132); };
290  funcLibrary[prefix + "_e1152"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
291  { return eg->showerShapeValue(xAOD::EgammaParameters::e1152); };
292  funcLibrary[prefix + "_ethad1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
293  { return eg->showerShapeValue(xAOD::EgammaParameters::ethad1); };
294  funcLibrary[prefix + "_ethad"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
295  { return eg->showerShapeValue(xAOD::EgammaParameters::ethad); };
296  funcLibrary[prefix + "_f1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
297  { return eg->showerShapeValue(xAOD::EgammaParameters::f1); };
298  funcLibrary[prefix + "_f3"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
299  { return eg->showerShapeValue(xAOD::EgammaParameters::f3); };
300  funcLibrary[prefix + "_f1core"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
301  { return eg->showerShapeValue(xAOD::EgammaParameters::f1core); };
302  funcLibrary[prefix + "_f3core"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
303  { return eg->showerShapeValue(xAOD::EgammaParameters::f3core); };
304  funcLibrary[prefix + "_e233"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
305  { return eg->showerShapeValue(xAOD::EgammaParameters::e233); };
306  funcLibrary[prefix + "_e235"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
307  { return eg->showerShapeValue(xAOD::EgammaParameters::e235); };
308  funcLibrary[prefix + "_e255"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
309  { return eg->showerShapeValue(xAOD::EgammaParameters::e255); };
310  funcLibrary[prefix + "_e237"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
311  { return eg->showerShapeValue(xAOD::EgammaParameters::e237); };
312  funcLibrary[prefix + "_e277"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
313  { return eg->showerShapeValue(xAOD::EgammaParameters::e277); };
314  funcLibrary[prefix + "_e333"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
315  { return eg->showerShapeValue(xAOD::EgammaParameters::e333); };
316  funcLibrary[prefix + "_e335"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
317  { return eg->showerShapeValue(xAOD::EgammaParameters::e335); };
318  funcLibrary[prefix + "_e337"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
319  { return eg->showerShapeValue(xAOD::EgammaParameters::e337); };
320  funcLibrary[prefix + "_e377"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
321  { return eg->showerShapeValue(xAOD::EgammaParameters::e377); };
322  funcLibrary[prefix + "_weta1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
323  { return eg->showerShapeValue(xAOD::EgammaParameters::weta1); };
324  funcLibrary[prefix + "_weta2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
325  { return eg->showerShapeValue(xAOD::EgammaParameters::weta2); };
326  funcLibrary[prefix + "_e2ts1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
327  { return eg->showerShapeValue(xAOD::EgammaParameters::e2ts1); };
328  funcLibrary[prefix + "_e2tsts1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
329  { return eg->showerShapeValue(xAOD::EgammaParameters::e2tsts1); };
330  funcLibrary[prefix + "_fracs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
331  { return eg->showerShapeValue(xAOD::EgammaParameters::fracs1); };
332  funcLibrary[prefix + "_widths1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
333  { return eg->showerShapeValue(xAOD::EgammaParameters::widths1); };
334  funcLibrary[prefix + "_widths2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
335  { return eg->showerShapeValue(xAOD::EgammaParameters::widths2); };
336  funcLibrary[prefix + "_poscs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
337  { return eg->showerShapeValue(xAOD::EgammaParameters::poscs1); };
338  funcLibrary[prefix + "_poscs2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
339  { return eg->showerShapeValue(xAOD::EgammaParameters::poscs2); };
340  funcLibrary[prefix + "_asy1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
341  { return eg->showerShapeValue(xAOD::EgammaParameters::asy1); };
342  funcLibrary[prefix + "_pos"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
343  { return eg->showerShapeValue(xAOD::EgammaParameters::pos); };
344  funcLibrary[prefix + "_pos7"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
345  { return eg->showerShapeValue(xAOD::EgammaParameters::pos7); };
346  funcLibrary[prefix + "_barys1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
347  { return eg->showerShapeValue(xAOD::EgammaParameters::barys1); };
348  funcLibrary[prefix + "_wtots1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
349  { return eg->showerShapeValue(xAOD::EgammaParameters::wtots1); };
350  funcLibrary[prefix + "_emins1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
351  { return eg->showerShapeValue(xAOD::EgammaParameters::emins1); };
352  funcLibrary[prefix + "_emaxs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
353  { return eg->showerShapeValue(xAOD::EgammaParameters::emaxs1); };
354  funcLibrary[prefix + "_r33over37allcalo"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
355  { return eg->showerShapeValue(xAOD::EgammaParameters::r33over37allcalo); };
356  funcLibrary[prefix + "_ecore"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
357  { return eg->showerShapeValue(xAOD::EgammaParameters::ecore); };
358  funcLibrary[prefix + "_Reta"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
359  { return eg->showerShapeValue(xAOD::EgammaParameters::Reta); };
360  funcLibrary[prefix + "_Rphi"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
361  { return eg->showerShapeValue(xAOD::EgammaParameters::Rphi); };
362  funcLibrary[prefix + "_Eratio"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
363  { return eg->showerShapeValue(xAOD::EgammaParameters::Eratio); };
364  funcLibrary[prefix + "_Rhad"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
365  { return eg->showerShapeValue(xAOD::EgammaParameters::Rhad); };
366  funcLibrary[prefix + "_Rhad1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
367  { return eg->showerShapeValue(xAOD::EgammaParameters::Rhad1); };
368  funcLibrary[prefix + "_DeltaE"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
369  { return eg->showerShapeValue(xAOD::EgammaParameters::DeltaE); };
370 
371  }

◆ initializeElectronFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeElectronFuncs ( bool  useLayerCorrected)

A function to build the map for electrons.

Definition at line 34 of file egammaMVAFunctions.cxx.

35  {
36  // rel21 uses a naming version of some variables without prefix, keep both for compatibility
37  auto funcLibraryPtr = std::make_unique<funcMap_t>();
38  funcMap_t& funcLibrary = *funcLibraryPtr;
39 
40  initializeClusterFuncs(funcLibrary, "el", useLayerCorrected);
41  initializeEgammaFuncs(funcLibrary, "el", useLayerCorrected);
42 
43  // specific functions only for electrons
44  funcLibrary["el_charge"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
45  { return compute_el_charge(*(static_cast<const xAOD::Electron*>(eg))); };
46  funcLibrary["el_tracketa"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
47  { return compute_el_tracketa(*(static_cast<const xAOD::Electron*>(eg))); };
48  funcLibrary["el_trackpt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
49  { return compute_el_trackpt(*(static_cast<const xAOD::Electron*>(eg))); };
50  funcLibrary["el_trackz0"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
51  { return compute_el_trackz0(*(static_cast<const xAOD::Electron*>(eg))); };
52  funcLibrary["el_refittedTrack_qoverp"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
53  { return compute_el_refittedTrack_qoverp(*(static_cast<const xAOD::Electron*>(eg))); };
54 
55  return funcLibraryPtr;
56  }

◆ initializeForwardElectronFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeForwardElectronFuncs ( bool  useLayerCorrected)

NEW: A function to build the map for forward electrons.

Definition at line 143 of file egammaMVAFunctions.cxx.

143  {
144  auto funcLibraryPtr = std::make_unique<funcMap_t>();
145  funcMap_t& funcLibrary = *funcLibraryPtr;
146 
147  funcLibrary["el_cl_e"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
148  { return compute_cl_e(*cl); };
149  funcLibrary["abs_el_cl_eta"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
150  { return std::abs(compute_cl_eta(*cl)); };
151  funcLibrary["etaModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
152  { return (std::abs(cl->eta()) < 3.15 ? compute_etaMod_EMEC(*cl) : compute_etaMod_FCAL(*cl)); };
153  funcLibrary["cellIndex"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
154  { return (std::abs(cl->eta()) < 3.15 ? compute_cellIndex_EMEC(*cl) : compute_cellIndex_FCAL(*cl)); };
155  funcLibrary["el_cl_phi"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
156  { return compute_cl_phi(*cl); };
157  funcLibrary["phiMod2pi32"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
158  { return compute_phiMod_EMEC(*cl); };
159  if (useLayerCorrected) {
160  funcLibrary["el_cl_secondR"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
161  { return compute_cl_secondR_fudge(*eg); };
162  } else {
163  funcLibrary["el_cl_secondR"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
164  { return compute_cl_secondR(*cl); };
165  }
166  funcLibrary["Es1Es2Ratio"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
167  { return compute_R12_EMEC(*cl); };
168  funcLibrary["el_cl_centerX"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
169  { return compute_cl_x(*cl); };
170  funcLibrary["el_cl_centerY"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
171  { return compute_cl_y(*cl); };
172  funcLibrary["abs_el_cl_centerZ"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
173  { return std::abs(compute_cl_z(*cl)); };
174  funcLibrary["el_cl_centerLambda"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
175  { return compute_cl_centerLambda(*cl); };
176  funcLibrary["el_cl_secondMoment"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
177  { return compute_cl_secondDensity(*cl); };
178 
179  return funcLibraryPtr;
180  }

◆ initializeUnconvertedPhotonFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeUnconvertedPhotonFuncs ( bool  useLayerCorrected)

A function to build the map for uncoverted photons.

Definition at line 59 of file egammaMVAFunctions.cxx.

60  {
61  auto funcLibraryPtr = std::make_unique<funcMap_t>();
62  funcMap_t& funcLibrary = *funcLibraryPtr;
63 
64  initializeClusterFuncs(funcLibrary, "ph", useLayerCorrected);
65  initializeEgammaFuncs(funcLibrary, "ph", useLayerCorrected);
66 
67  return funcLibraryPtr;
68  }
xAOD::CaloCluster_v1::SECOND_R
@ SECOND_R
Second Moment in .
Definition: CaloCluster_v1.h:126
egammaMVAFunctions::compute_el_trackz0
float compute_el_trackz0(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:205
egammaMVAFunctions::compute_cl_secondR_fudge
float compute_cl_secondR_fudge(const xAOD::Egamma &eg)
Definition: egammaMVAFunctions.h:166
egammaMVAFunctions::compute_rawcl_Eacc
float compute_rawcl_Eacc(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:94
egammaMVAFunctions::compute_cl_phiCalo
float compute_cl_phiCalo(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:58
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
xAOD::EgammaParameters::e233
@ e233
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x3 (in cell units e...
Definition: EgammaEnums.h:69
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
egammaMVAFunctions::compute_cl_centerLambda
float compute_cl_centerLambda(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:160
egammaMVAFunctions::funcMap_t
std::unordered_map< std::string, std::function< float(const xAOD::Egamma *, const xAOD::CaloCluster *)> > funcMap_t
Define the map type since it's long.
Definition: egammaMVAFunctions.h:308
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
xAOD::EgammaParameters::e033
@ e033
uncalibrated energy (sum of cells) in presampler in a 3x3 window in cells in eta X phi
Definition: EgammaEnums.h:34
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:553
ParticleTest.eg
eg
Definition: ParticleTest.py:29
xAOD::EgammaParameters::Reta
@ Reta
e237/e277
Definition: EgammaEnums.h:155
egammaMVAFunctions::compute_cl_z
float compute_cl_z(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:164
xAOD::EgammaParameters::e2ts1
@ e2ts1
2nd max in strips calc by summing 3 strips
Definition: EgammaEnums.h:106
egammaMVAFunctions::compute_phiMod_EMEC
float compute_phiMod_EMEC(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:191
xAOD::CaloCluster_v1::CENTER_X
@ CENTER_X
Cluster Centroid ( )
Definition: CaloCluster_v1.h:134
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:68
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
xAOD::EgammaParameters::asy1
@ asy1
uncorr asymmetry in 3 strips in the 1st sampling
Definition: EgammaEnums.h:124
xAOD::EgammaParameters::e235
@ e235
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x5
Definition: EgammaEnums.h:72
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
egammaMVAFunctions::compute_cl_e
float compute_cl_e(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:50
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
egammaMVAFunctions::compute_correctedcl_calibHitsShowerDepth
float compute_correctedcl_calibHitsShowerDepth(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:124
xAOD::EgammaParameters::ecore
@ ecore
core energy in em calo E(core) = E0(3x3) + E1(15x2) + E2(5x5) + E3(3x5)
Definition: EgammaEnums.h:153
egammaMVAFunctions::compute_ptconv
float compute_ptconv(const xAOD::Photon *ph)
This ptconv is the old one used by MVACalib.
Definition: egammaMVAFunctions.h:245
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:75
egammaMVAFunctions::compute_cl_secondR
float compute_cl_secondR(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:159
ParticleTest.tp
tp
Definition: ParticleTest.py:25
xAOD::EgammaParameters::ethad1
@ ethad1
transverse energy in the first sampling of the hadronic calorimeters behind the cluster calculated fr...
Definition: EgammaEnums.h:43
xAOD::CaloCluster_v1::CENTER_LAMBDA
@ CENTER_LAMBDA
Shower depth at Cluster Centroid.
Definition: CaloCluster_v1.h:139
egammaMVAFunctions::compute_el_trackpt
float compute_el_trackpt(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:204
egammaMVAFunctions::compute_eta_FCAL
float compute_eta_FCAL(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:172
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
SG::ConstAccessor< double >
xAOD::EgammaParameters::Rphi
@ Rphi
e233/e237
Definition: EgammaEnums.h:157
xAOD::CaloClusterDetails::energyBE
float energyBE(const unsigned sample, const std::uint32_t samplingPattern, const std::span< const float > e_sampl)
Get the energy in one layer of the EM Calo.
Definition: CaloClusterDetails.h:87
egammaMVAFunctions::compute_cl_eta
float compute_cl_eta(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:48
xAOD::EgammaParameters::f1core
@ f1core
E1(3x1)/E = fraction of the energy reconstructed in the first longitudinal compartment of the electro...
Definition: EgammaEnums.h:61
egammaMVAFunctions::cl_getMoment
float cl_getMoment(const xAOD::CaloCluster &cl, xAOD::CaloCluster::MomentType m, const char *name)
Definition: egammaMVAFunctions.h:143
xAOD::CaloCluster_v1::ENG_FRAC_MAX
@ ENG_FRAC_MAX
Energy fraction of hottest cell.
Definition: CaloCluster_v1.h:143
egammaMVAFunctions::compute_cellIndex_FCAL
float compute_cellIndex_FCAL(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:182
egammaMVAFunctions::getPtAtFirstMeasurement
float getPtAtFirstMeasurement(const xAOD::TrackParticle *tp)
Definition: egammaMVAFunctions.h:221
egammaMVAFunctions::compute_cl_x
float compute_cl_x(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:162
x
#define x
xAOD::EgammaParameters::wtots1
@ wtots1
shower width is determined in a window detaxdphi = 0,0625 ×~0,2, corresponding typically to 20 strips...
Definition: EgammaEnums.h:141
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
egammaMVAFunctions::compute_cl_secondDensity
float compute_cl_secondDensity(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:161
egammaMVAFunctions::compute_correctedcl_Es0
float compute_correctedcl_Es0(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:77
pi
#define pi
Definition: TileMuonFitter.cxx:65
xAOD::CaloCluster_v1::SECOND_LAMBDA
@ SECOND_LAMBDA
Second Moment in .
Definition: CaloCluster_v1.h:127
xAOD::EgammaParameters::e333
@ e333
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x3
Definition: EgammaEnums.h:84
xAOD::CaloCluster_v1::CENTER_Z
@ CENTER_Z
Cluster Centroid ( )
Definition: CaloCluster_v1.h:136
xAOD::EgammaParameters::f3
@ f3
fraction of energy reconstructed in 3rd sampling
Definition: EgammaEnums.h:55
xAOD::CaloCluster_v1::etaBE
float etaBE(const unsigned layer) const
Get the eta in one layer of the EM Calo.
Definition: CaloCluster_v1.cxx:628
xAOD::EgammaParameters::e1152
@ e1152
uncalibrated energy (sum of cells) in strips in a 15x2 window in cells in eta X phi
Definition: EgammaEnums.h:40
xAOD::CaloCluster_v1::SECOND_ENG_DENS
@ SECOND_ENG_DENS
Second Moment in E/V.
Definition: CaloCluster_v1.h:147
xAOD::EgammaParameters::ethad
@ ethad
ET leakage into hadronic calorimeter with exclusion of energy in CaloSampling::TileGap3.
Definition: EgammaEnums.h:46
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:62
xAOD::EgammaHelpers::numberOfSiTracks
std::size_t numberOfSiTracks(const xAOD::Photon *eg)
return the number of Si tracks in the conversion
Definition: PhotonxAODHelpers.cxx:39
egammaMVAFunctions::compute_pt2conv
float compute_pt2conv(const xAOD::Photon *ph)
Definition: egammaMVAFunctions.h:269
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
egammaMVAFunctions::compute_calibHitsShowerDepth
float compute_calibHitsShowerDepth(const std::array< float, 4 > &cl, float eta)
Definition: egammaMVAFunctions.h:101
egammaMVAFunctions::compute_el_tracketa
float compute_el_tracketa(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:203
xAOD::EgammaParameters::f1
@ f1
E1/E = fraction of energy reconstructed in the first sampling, where E1 is energy in all strips belon...
Definition: EgammaEnums.h:53
egammaMVAFunctions::compute_correctedcl_Es2
float compute_correctedcl_Es2(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:85
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
lumiFormat.i
int i
Definition: lumiFormat.py:85
z
#define z
egammaMVAFunctions::compute_correctedcl_f0
float compute_correctedcl_f0(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:98
xAOD::FirstMeasurement
@ FirstMeasurement
Parameter defined at the position of the 1st measurement.
Definition: TrackingPrimitives.h:214
xAOD::EgammaParameters::pos7
@ pos7
Difference between the track and the shower positions: sum_{i=i_m-7}^{i=i_m+7}E_i x (i-i_m) / sum_{i=...
Definition: EgammaEnums.h:134
egammaMVAFunctions::compute_cl_y
float compute_cl_y(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:163
xAOD::EgammaParameters::emins1
@ emins1
energy reconstructed in the strip with the minimal value between the first and second maximum
Definition: EgammaEnums.h:144
xAOD::EgammaParameters::poscs2
@ poscs2
relative position in eta within cell in 2nd sampling
Definition: EgammaEnums.h:122
egammaMVAFunctions::initializeClusterFuncs
void initializeClusterFuncs(funcMap_t &funcLibrary, const std::string &prefix, bool useLayerCorrected)
Definition: egammaMVAFunctions.cxx:185
xAOD::EgammaParameters::e011
@ e011
uncalibrated energy (sum of cells) in presampler in a 1x1 window in cells in eta X phi
Definition: EgammaEnums.h:31
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
egammaMVAFunctions::compute_el_refittedTrack_qoverp
float compute_el_refittedTrack_qoverp(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:206
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
python.getProblemFolderFromLogs.el
dictionary el
Definition: getProblemFolderFromLogs.py:48
hist_file_dump.f
f
Definition: hist_file_dump.py:140
xAOD::CaloCluster_v1::retrieveMoment
bool retrieveMoment(MomentType type, double &value) const
Retrieve individual moment.
Definition: CaloCluster_v1.cxx:662
egammaMVAFunctions::compute_rawcl_Es1
float compute_rawcl_Es1(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:73
egammaMVAFunctions::compute_rawcl_f0
float compute_rawcl_f0(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:95
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
xAOD::Vertex_v1::trackParticle
const TrackParticle * trackParticle(size_t i) const
Get the pointer to a given track that was used in vertex reco.
Definition: Vertex_v1.cxx:249
egammaMVAFunctions::compute_cl_etaCalo
float compute_cl_etaCalo(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:51
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
ReadTripsProbsFromCool.denominator
denominator
Definition: ReadTripsProbsFromCool.py:96
get_MVAradius
std::array< float, 4 > get_MVAradius(float eta)
helper function to compute shower depth
Definition: egammaMVALayerDepth.cxx:10
xAOD::EgammaParameters::Rhad1
@ Rhad1
ethad1/et
Definition: EgammaEnums.h:163
egammaMVAFunctions::compute_correctedcl_Eacc
float compute_correctedcl_Eacc(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:97
xAOD::EgammaParameters::e377
@ e377
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 7x7
Definition: EgammaEnums.h:93
egammaMVAFunctions::compute_etaMod_FCAL
float compute_etaMod_FCAL(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:179
egammaMVAFunctions::compute_rawcl_calibHitsShowerDepth
float compute_rawcl_calibHitsShowerDepth(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:115
xAOD::EgammaParameters::poscs1
@ poscs1
relative position in eta within cell in 1st sampling
Definition: EgammaEnums.h:120
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
xAOD::EgammaHelpers::conversionRadius
float conversionRadius(const xAOD::Vertex *vx)
return the conversion radius or 9999.
Definition: PhotonxAODHelpers.cxx:58
xAOD::EgammaParameters::barys1
@ barys1
barycentre in sampling 1 calculated in 3 strips
Definition: EgammaEnums.h:136
xAOD::Electron_v1
Definition: Electron_v1.h:34
dq_make_web_display.rv
def rv
Definition: dq_make_web_display.py:218
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:191
ParticleGun_SamplingFraction.radius
radius
Definition: ParticleGun_SamplingFraction.py:96
egammaMVAFunctions::compute_R12_EMEC
float compute_R12_EMEC(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:197
egammaMVAFunctions::compute_cellIndex_EMEC
float compute_cellIndex_EMEC(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:188
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
egammaMVAFunctions::compute_cl_phi
float compute_cl_phi(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:49
y
#define y
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
egammaMVAFunctions::initializeEgammaFuncs
void initializeEgammaFuncs(funcMap_t &funcLibrary, const std::string &prefix, bool useLayerCorrected)
Definition: egammaMVAFunctions.cxx:280
xAOD::Photon_v1
Definition: Photon_v1.h:37
xAOD::CaloCluster_v1::SIGNIFICANCE
@ SIGNIFICANCE
Cluster significance.
Definition: CaloCluster_v1.h:160
xAOD::EgammaParameters::e255
@ e255
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 5x5
Definition: EgammaEnums.h:75
xAOD::EgammaParameters::e337
@ e337
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x7
Definition: EgammaEnums.h:90
xAOD::EgammaParameters::r33over37allcalo
@ r33over37allcalo
1-ratio of energy in 3x3 over 3x7 cells; E(3x3) = E0(1x1) + E1(3x1) + E2(3x3) + E3(3x3); E(3x7) = E0(...
Definition: EgammaEnums.h:150
egammaMVAFunctions::compute_pt1conv
float compute_pt1conv(const xAOD::Photon *ph)
Definition: egammaMVAFunctions.h:256
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
egammaMVAFunctions::compute_etaMod_EMEC
float compute_etaMod_EMEC(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:185
xAOD::EgammaHelpers::conversionType
xAOD::EgammaParameters::ConversionType conversionType(const xAOD::Photon *ph)
return the photon conversion type (see EgammaEnums)
Definition: PhotonxAODHelpers.cxx:21
egammaMVAFunctions::compute_correctedcl_Es3
float compute_correctedcl_Es3(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:89
xAOD::CaloCluster_v1::LATERAL
@ LATERAL
Normalized lateral moment.
Definition: CaloCluster_v1.h:140
xAOD::EgammaParameters::e277
@ e277
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 7x7
Definition: EgammaEnums.h:81
xAOD::EgammaParameters::widths1
@ widths1
same as egammaParameters::weta1 but without corrections on particle impact point inside the cell
Definition: EgammaEnums.h:115
xAOD::EgammaParameters::weta1
@ weta1
shower width using +/-3 strips around the one with the maximal energy deposit: w3 strips = sqrt{sum(E...
Definition: EgammaEnums.h:98
xAOD::EgammaParameters::e132
@ e132
uncalibrated energy (sum of cells) in strips in a 3x2 window in cells in eta X phi
Definition: EgammaEnums.h:37
egammaMVAFunctions::compute_correctedcl_Es1
float compute_correctedcl_Es1(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:81
xAOD::EgammaParameters::Eratio
@ Eratio
(emaxs1-e2tsts1)/(emaxs1+e2tsts1)
Definition: EgammaEnums.h:159
xAOD::EgammaParameters::e237
@ e237
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x7
Definition: EgammaEnums.h:78
egammaMVAFunctions::compute_rawcl_Es2
float compute_rawcl_Es2(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:74
xAOD::EgammaParameters::f3core
@ f3core
E3(3x3)/E fraction of the energy reconstructed in the third compartment of the electromagnetic calori...
Definition: EgammaEnums.h:66
egammaMVAFunctions::compute_rawcl_Es3
float compute_rawcl_Es3(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:75
xAOD::EgammaParameters::e2tsts1
@ e2tsts1
energy of the cell corresponding to second energy maximum in the first sampling
Definition: EgammaEnums.h:109
xAOD::EgammaParameters::Rhad
@ Rhad
ethad/et
Definition: EgammaEnums.h:161
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:190
xAOD::EgammaParameters::widths2
@ widths2
same as egammaParameters::weta2 but without corrections on particle impact point inside the cell
Definition: EgammaEnums.h:118
xAOD::EgammaParameters::DeltaE
@ DeltaE
e2tsts1-emins1
Definition: EgammaEnums.h:165
xAOD::CaloCluster_v1::LONGITUDINAL
@ LONGITUDINAL
Normalized longitudinal moment.
Definition: CaloCluster_v1.h:141
egammaMVAFunctions::compute_rawcl_Es0
float compute_rawcl_Es0(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:67
xAOD::EgammaParameters::e335
@ e335
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x5
Definition: EgammaEnums.h:87
python.compressB64.c
def c
Definition: compressB64.py:93
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:25
xAOD::Photon_v1::vertex
const xAOD::Vertex * vertex(size_t index=0) const
Pointer to the xAOD::Vertex/es that match the photon candidate.
Definition: Photon_v1.cxx:46
xAOD::EgammaParameters::emaxs1
@ emaxs1
energy of strip with maximal energy deposit
Definition: EgammaEnums.h:146
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
xAOD::CaloCluster_v1::CENTER_Y
@ CENTER_Y
Cluster Centroid ( )
Definition: CaloCluster_v1.h:135
VP1PartSpect::Pi
@ Pi
Definition: VP1PartSpectFlags.h:27
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
xAOD::EgammaParameters::fracs1
@ fracs1
shower shape in the shower core : [E(+/-3)-E(+/-1)]/E(+/-1), where E(+/-n) is the energy in ± n strip...
Definition: EgammaEnums.h:112
xAOD::EgammaParameters::pos
@ pos
difference between shower cell and predicted track in +/- 1 cells
Definition: EgammaEnums.h:126
python.SystemOfUnits.m
float m
Definition: SystemOfUnits.py:106
egammaMVAFunctions::compute_el_charge
float compute_el_charge(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:202
xAOD::EgammaParameters::weta2
@ weta2
the lateral width is calculated with a window of 3x5 cells using the energy weighted sum over all cel...
Definition: EgammaEnums.h:104
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Fri Nov 21 2025 21:56:57 for ATLAS Offline Software by   doxygen 1.8.18