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_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...
 
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 242 of file egammaMVAFunctions.h.

Function Documentation

◆ 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_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_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_convtrk1nPixHits()

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

Definition at line 233 of file egammaMVAFunctions.h.

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

◆ compute_convtrk1nSCTHits()

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

Definition at line 235 of file egammaMVAFunctions.h.

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

◆ compute_convtrk2nPixHits()

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

Definition at line 234 of file egammaMVAFunctions.h.

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

◆ compute_convtrk2nSCTHits()

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

Definition at line 236 of file egammaMVAFunctions.h.

236 { 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 220 of file egammaMVAFunctions.h.

220  {
221  const auto vx = ph->vertex();
222  if (!vx) return 0.;
223 
224  if (vx->trackParticle(0)) {
225  uint8_t hits;
226  if (vx->trackParticle(itrack)->summaryValue(hits, summary)) {
227  return hits;
228  }
229  }
230  return 0.;
231  }

◆ 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 141 of file egammaMVAFunctions.h.

141  {
142  static const SG::ConstAccessor<unsigned short int> acc ("author");
143  return acc (el);
144  }

◆ compute_el_charge()

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

Definition at line 136 of file egammaMVAFunctions.h.

136 { return el.charge(); }

◆ compute_el_refittedTrack_qoverp()

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

Definition at line 140 of file egammaMVAFunctions.h.

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

◆ compute_el_tracketa()

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

Definition at line 137 of file egammaMVAFunctions.h.

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

◆ compute_el_trackpt()

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

Definition at line 138 of file egammaMVAFunctions.h.

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

◆ compute_el_trackz0()

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

Definition at line 139 of file egammaMVAFunctions.h.

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

◆ compute_ph_convFlag()

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

Definition at line 148 of file egammaMVAFunctions.h.

148  {
149  const auto original = xAOD::EgammaHelpers::conversionType(&ph);
150  if (original == 3) return 2;
151  else if (original != 0) return 1;
152  else return original;
153  }

◆ compute_pt1conv()

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

Definition at line 191 of file egammaMVAFunctions.h.

192  {
193  static const SG::AuxElement::Accessor<float> accPt1("pt1");
194 
195  const xAOD::Vertex* vx = ph->vertex();
196  if (!vx) return 0.0;
197  if (accPt1.isAvailable(*vx)) {
198  return accPt1(*vx);
199  } else {
200  return getPtAtFirstMeasurement(vx->trackParticle(0));
201  }
202  }

◆ compute_pt2conv()

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

Definition at line 204 of file egammaMVAFunctions.h.

205  {
206  static const SG::AuxElement::Accessor<float> accPt2("pt2");
207 
208  const xAOD::Vertex* vx = ph->vertex();
209  if (!vx) return 0.0;
210  if (accPt2.isAvailable(*vx)) {
211  return accPt2(*vx);
212  } else {
213  return getPtAtFirstMeasurement(vx->trackParticle(1));
214  }
215  }

◆ compute_ptconv()

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

This ptconv is the old one used by MVACalib.

Definition at line 180 of file egammaMVAFunctions.h.

181  {
182  auto vx = ph->vertex();
183  if (!vx) return 0.0;
184 
185  TLorentzVector sum;
186  if (vx->trackParticle(0)) sum += vx->trackParticle(0)->p4();
187  if (vx->trackParticle(1)) sum += vx->trackParticle(1)->p4();
188  return sum.Perp();
189  }

◆ compute_ptconv_decor()

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

This ptconv function uses the vertex decorations.

Definition at line 170 of file egammaMVAFunctions.h.

171  {
172  static const SG::AuxElement::Accessor<float> accPx("px");
173  static const SG::AuxElement::Accessor<float> accPy("py");
174 
175  auto vx = ph->vertex();
176  return vx ? std::hypot(accPx(*vx), accPy(*vx)) : 0.0;
177  }

◆ 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 156 of file egammaMVAFunctions.h.

157  {
158  if (!tp) return 0;
159  for (unsigned int i = 0; i < tp->numberOfParameters(); ++i) {
160  if (tp->parameterPosition(i) == xAOD::FirstMeasurement) {
161  return hypot(tp->parameterPX(i), tp->parameterPY(i));
162  }
163  }
164  return tp->pt();
165  }

◆ initializeClusterFuncs()

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

Definition at line 143 of file egammaMVAFunctions.cxx.

146  {
147 
148  funcLibrary[prefix + "_cl_eta"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
149  { return compute_cl_eta(*cl); };
150  funcLibrary[prefix + "_cl_phi"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
151  { return compute_cl_phi(*cl); };
152  funcLibrary[prefix + "_cl_E"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
153  { return compute_cl_e(*cl); };
154  funcLibrary[prefix + "_cl_etaCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
155  { return compute_cl_etaCalo(*cl); };
156  funcLibrary[prefix + "_cl_phiCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
157  { return compute_cl_phiCalo(*cl); };
158  funcLibrary[prefix + "_cl_E_TileGap3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
159  { return cl->eSample(CaloSampling::TileGap3); };
160 
161  funcLibrary[prefix + "_cellIndexCalo"] = funcLibrary["cellIndexCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
162  { return std::floor(std::abs(compute_cl_etaCalo(*cl))/0.025); };
163  funcLibrary[prefix + "_phiModCalo"] = funcLibrary["phiModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
164  { return ((abs(compute_cl_eta(*cl)) < 1.425) ?
165  std::fmod(compute_cl_phiCalo(*cl), TMath::Pi() / 512) :
166  std::fmod(compute_cl_phiCalo(*cl), TMath::Pi() / 384));
167  };
168 
169  // improved version of phiModCalo, proposed by G. Unal, studied by L. Nasella
170  // see https://its.cern.ch/jira/browse/ATLASEG-325
171  // see https://indico.cern.ch/event/1364593/contributions/5843081/
172  funcLibrary[prefix + "_phiModCalo1"] = funcLibrary["phiModCalo1"] =
173  [](const xAOD::Egamma*, const xAOD::CaloCluster* cl) {
174  using std::numbers::pi;
175  const double eta = compute_cl_eta(*cl);
176  const double phi = compute_cl_phiCalo(*cl);
177  const double pi_divisor = std::abs(eta) < 1.425 ? 512. : 384.;
178 
179  if (eta > 0.) {
180  if (phi > 0.) return std::fmod(phi, pi / pi_divisor);
181  else return std::fmod((2 * pi + phi), pi / pi_divisor);
182  }
183  else return std::fmod((pi - phi), pi / pi_divisor);
184  };
185 
186  funcLibrary[prefix + "_phiModCell"] = funcLibrary["phiModCell"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
187  { return std::fmod(std::abs(compute_cl_phiCalo(*cl)), TMath::Pi() / 128); };
188  funcLibrary[prefix + "_etaModCalo"] = funcLibrary["etaModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
189  { return std::fmod(std::abs(compute_cl_etaCalo(*cl)), 0.025); };
190  funcLibrary["abs(" + prefix + "_cl_eta)"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
191  { return std::abs(compute_cl_eta(*cl)); };
192  funcLibrary[prefix + "_dPhiTG3"] = funcLibrary["dPhiTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
193  { return std::fmod(2.*TMath::Pi()+compute_cl_phi(*cl),TMath::Pi()/32.)-TMath::Pi()/64.0; };
194 
195  if (useLayerCorrected) {
196  funcLibrary[prefix + "_rawcl_Es0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
197  { return compute_correctedcl_Es0(*cl); };
198  funcLibrary[prefix + "_rawcl_Es1"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
199  { return compute_correctedcl_Es1(*cl); };
200  funcLibrary[prefix + "_rawcl_Es2"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
201  { return compute_correctedcl_Es2(*cl); };
202  funcLibrary[prefix + "_rawcl_Es3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
203  { return compute_correctedcl_Es3(*cl); };
204  funcLibrary[prefix + "_rawcl_Eacc"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
205  { return compute_correctedcl_Eacc(*cl); };
206  funcLibrary[prefix + "_rawcl_f0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
207  { return compute_correctedcl_f0(*cl); };
208  funcLibrary[prefix + "_rawcl_calibHitsShowerDepth"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
209  { return compute_correctedcl_calibHitsShowerDepth(*cl); };
210  funcLibrary[prefix + "_R12"] = funcLibrary["R12"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
211  { return compute_correctedcl_Es1(*cl)/compute_correctedcl_Es2(*cl); };
212  funcLibrary[prefix + "_fTG3"] = funcLibrary["fTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
213  { return cl->eSample(CaloSampling::TileGap3)/compute_correctedcl_Eacc(*cl); };
214  } else {
215  funcLibrary[prefix + "_rawcl_Es0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
216  { return compute_rawcl_Es0(*cl); };
217  funcLibrary[prefix + "_rawcl_Es1"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
218  { return compute_rawcl_Es1(*cl); };
219  funcLibrary[prefix + "_rawcl_Es2"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
220  { return compute_rawcl_Es2(*cl); };
221  funcLibrary[prefix + "_rawcl_Es3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
222  { return compute_rawcl_Es3(*cl); };
223  funcLibrary[prefix + "_rawcl_Eacc"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
224  { return compute_rawcl_Eacc(*cl); };
225  funcLibrary[prefix + "_rawcl_f0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
226  { return compute_rawcl_f0(*cl); };
227  funcLibrary[prefix + "_rawcl_calibHitsShowerDepth"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
228  { return compute_rawcl_calibHitsShowerDepth(*cl); };
229  funcLibrary[prefix + "_R12"] = funcLibrary["R12"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
230  { return compute_rawcl_Es1(*cl)/compute_rawcl_Es2(*cl); };
231  funcLibrary[prefix + "_fTG3"] = funcLibrary["fTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
232  { return cl->eSample(CaloSampling::TileGap3)/compute_rawcl_Eacc(*cl); };
233  }
234  }

◆ 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  { return static_cast<const xAOD::Photon*>(eg)->vertex()->position().z(); };
95  funcLibrary["ph_pt1conv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
96  { return compute_pt1conv(static_cast<const xAOD::Photon*>(eg)); };
97  funcLibrary["ph_pt2conv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
98  { return compute_pt2conv(static_cast<const xAOD::Photon*>(eg)); };
99  funcLibrary["ph_ptconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
100  { return compute_ptconv(static_cast<const xAOD::Photon*>(eg)); };
101 
102  funcLibrary["ph_convPtRatio"] = funcLibrary["convPtRatio"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
103  {
104  const auto *ph = static_cast<const xAOD::Photon*>(eg);
105  if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
106  auto pt1 = compute_pt1conv(ph);
107  auto pt2 = compute_pt2conv(ph);
108  return std::max(pt1, pt2)/(pt1+pt2);
109  }
110  return 1.0f;
111  };
112 
113  if (useLayerCorrected) {
114  funcLibrary["ph_convEtOverPt"] = funcLibrary["convEtOverPt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*cl)->float
115  {
116  const auto *ph = static_cast<const xAOD::Photon*>(eg);
117 
118  float rv = 0.0;
119  if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
120  rv = std::max(0.0f, compute_correctedcl_Eacc(*cl)/(std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph)));
121  }
122  return std::min(rv, 2.0f);
123  };
124  } else {
125  funcLibrary["ph_convEtOverPt"] = funcLibrary["convEtOverPt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*cl)->float
126  {
127  const auto *ph = static_cast<const xAOD::Photon*>(eg);
128 
129  float rv = 0.0;
130  if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
131  rv = std::max(0.0f, compute_rawcl_Eacc(*cl)/(std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph)));
132  }
133  return std::min(rv, 2.0f);
134  };
135  }
136 
137  return funcLibraryPtr;
138  }

◆ initializeEgammaFuncs()

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

Definition at line 238 of file egammaMVAFunctions.cxx.

241  {
242  funcLibrary[prefix + "_e011"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
243  { return eg->showerShapeValue(xAOD::EgammaParameters::e011); };
244  funcLibrary[prefix + "_e033"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
245  { return eg->showerShapeValue(xAOD::EgammaParameters::e033); };
246  funcLibrary[prefix + "_e132"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
247  { return eg->showerShapeValue(xAOD::EgammaParameters::e132); };
248  funcLibrary[prefix + "_e1152"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
249  { return eg->showerShapeValue(xAOD::EgammaParameters::e1152); };
250  funcLibrary[prefix + "_ethad1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
251  { return eg->showerShapeValue(xAOD::EgammaParameters::ethad1); };
252  funcLibrary[prefix + "_ethad"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
253  { return eg->showerShapeValue(xAOD::EgammaParameters::ethad); };
254  funcLibrary[prefix + "_f1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
255  { return eg->showerShapeValue(xAOD::EgammaParameters::f1); };
256  funcLibrary[prefix + "_f3"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
257  { return eg->showerShapeValue(xAOD::EgammaParameters::f3); };
258  funcLibrary[prefix + "_f1core"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
259  { return eg->showerShapeValue(xAOD::EgammaParameters::f1core); };
260  funcLibrary[prefix + "_f3core"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
261  { return eg->showerShapeValue(xAOD::EgammaParameters::f3core); };
262  funcLibrary[prefix + "_e233"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
263  { return eg->showerShapeValue(xAOD::EgammaParameters::e233); };
264  funcLibrary[prefix + "_e235"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
265  { return eg->showerShapeValue(xAOD::EgammaParameters::e235); };
266  funcLibrary[prefix + "_e255"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
267  { return eg->showerShapeValue(xAOD::EgammaParameters::e255); };
268  funcLibrary[prefix + "_e237"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
269  { return eg->showerShapeValue(xAOD::EgammaParameters::e237); };
270  funcLibrary[prefix + "_e277"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
271  { return eg->showerShapeValue(xAOD::EgammaParameters::e277); };
272  funcLibrary[prefix + "_e333"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
273  { return eg->showerShapeValue(xAOD::EgammaParameters::e333); };
274  funcLibrary[prefix + "_e335"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
275  { return eg->showerShapeValue(xAOD::EgammaParameters::e335); };
276  funcLibrary[prefix + "_e337"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
277  { return eg->showerShapeValue(xAOD::EgammaParameters::e337); };
278  funcLibrary[prefix + "_e377"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
279  { return eg->showerShapeValue(xAOD::EgammaParameters::e377); };
280  funcLibrary[prefix + "_weta1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
281  { return eg->showerShapeValue(xAOD::EgammaParameters::weta1); };
282  funcLibrary[prefix + "_weta2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
283  { return eg->showerShapeValue(xAOD::EgammaParameters::weta2); };
284  funcLibrary[prefix + "_e2ts1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
285  { return eg->showerShapeValue(xAOD::EgammaParameters::e2ts1); };
286  funcLibrary[prefix + "_e2tsts1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
287  { return eg->showerShapeValue(xAOD::EgammaParameters::e2tsts1); };
288  funcLibrary[prefix + "_fracs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
289  { return eg->showerShapeValue(xAOD::EgammaParameters::fracs1); };
290  funcLibrary[prefix + "_widths1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
291  { return eg->showerShapeValue(xAOD::EgammaParameters::widths1); };
292  funcLibrary[prefix + "_widths2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
293  { return eg->showerShapeValue(xAOD::EgammaParameters::widths2); };
294  funcLibrary[prefix + "_poscs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
295  { return eg->showerShapeValue(xAOD::EgammaParameters::poscs1); };
296  funcLibrary[prefix + "_poscs2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
297  { return eg->showerShapeValue(xAOD::EgammaParameters::poscs2); };
298  funcLibrary[prefix + "_asy1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
299  { return eg->showerShapeValue(xAOD::EgammaParameters::asy1); };
300  funcLibrary[prefix + "_pos"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
301  { return eg->showerShapeValue(xAOD::EgammaParameters::pos); };
302  funcLibrary[prefix + "_pos7"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
303  { return eg->showerShapeValue(xAOD::EgammaParameters::pos7); };
304  funcLibrary[prefix + "_barys1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
305  { return eg->showerShapeValue(xAOD::EgammaParameters::barys1); };
306  funcLibrary[prefix + "_wtots1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
307  { return eg->showerShapeValue(xAOD::EgammaParameters::wtots1); };
308  funcLibrary[prefix + "_emins1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
309  { return eg->showerShapeValue(xAOD::EgammaParameters::emins1); };
310  funcLibrary[prefix + "_emaxs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
311  { return eg->showerShapeValue(xAOD::EgammaParameters::emaxs1); };
312  funcLibrary[prefix + "_r33over37allcalo"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
313  { return eg->showerShapeValue(xAOD::EgammaParameters::r33over37allcalo); };
314  funcLibrary[prefix + "_ecore"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
315  { return eg->showerShapeValue(xAOD::EgammaParameters::ecore); };
316  funcLibrary[prefix + "_Reta"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
317  { return eg->showerShapeValue(xAOD::EgammaParameters::Reta); };
318  funcLibrary[prefix + "_Rphi"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
319  { return eg->showerShapeValue(xAOD::EgammaParameters::Rphi); };
320  funcLibrary[prefix + "_Eratio"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
321  { return eg->showerShapeValue(xAOD::EgammaParameters::Eratio); };
322  funcLibrary[prefix + "_Rhad"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
323  { return eg->showerShapeValue(xAOD::EgammaParameters::Rhad); };
324  funcLibrary[prefix + "_Rhad1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
325  { return eg->showerShapeValue(xAOD::EgammaParameters::Rhad1); };
326  funcLibrary[prefix + "_DeltaE"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
327  { return eg->showerShapeValue(xAOD::EgammaParameters::DeltaE); };
328 
329  }

◆ 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  }

◆ 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  }
egammaMVAFunctions::compute_el_trackz0
float compute_el_trackz0(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:139
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:68
python.CaloRecoConfig.f
f
Definition: CaloRecoConfig.py:127
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:243
xAOD::EgammaParameters::e033
@ e033
uncalibrated energy (sum of cells) in presampler in a 3x3 window in cells in eta X phi
Definition: EgammaEnums.h:33
max
#define max(a, b)
Definition: cfImp.cxx:41
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
ParticleTest.eg
eg
Definition: ParticleTest.py:29
xAOD::EgammaParameters::Reta
@ Reta
e237/e277
Definition: EgammaEnums.h:154
xAOD::EgammaParameters::e2ts1
@ e2ts1
2nd max in strips calc by summing 3 strips
Definition: EgammaEnums.h:105
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
xAOD::EgammaParameters::asy1
@ asy1
uncorr asymmetry in 3 strips in the 1st sampling
Definition: EgammaEnums.h:123
xAOD::EgammaParameters::e235
@ e235
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x5
Definition: EgammaEnums.h:71
egammaMVAFunctions::compute_cl_e
float compute_cl_e(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:50
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:152
egammaMVAFunctions::compute_ptconv
float compute_ptconv(const xAOD::Photon *ph)
This ptconv is the old one used by MVACalib.
Definition: egammaMVAFunctions.h:180
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:42
egammaMVAFunctions::compute_el_trackpt
float compute_el_trackpt(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:138
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
SG::ConstAccessor< double >
xAOD::EgammaParameters::Rphi
@ Rphi
e233/e237
Definition: EgammaEnums.h:156
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:60
egammaMVAFunctions::getPtAtFirstMeasurement
float getPtAtFirstMeasurement(const xAOD::TrackParticle *tp)
Definition: egammaMVAFunctions.h:156
xAOD::EgammaParameters::wtots1
@ wtots1
shower width is determined in a window detaxdphi = 0,0625 ×~0,2, corresponding typically to 20 strips...
Definition: EgammaEnums.h:140
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
egammaMVAFunctions::compute_correctedcl_Es0
float compute_correctedcl_Es0(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:77
pi
#define pi
Definition: TileMuonFitter.cxx:65
xAOD::EgammaParameters::e333
@ e333
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x3
Definition: EgammaEnums.h:83
xAOD::EgammaParameters::f3
@ f3
fraction of energy reconstructed in 3rd sampling
Definition: EgammaEnums.h:54
xAOD::CaloCluster_v1::etaBE
float etaBE(const unsigned layer) const
Get the eta in one layer of the EM Calo.
Definition: CaloCluster_v1.cxx:644
xAOD::EgammaParameters::e1152
@ e1152
uncalibrated energy (sum of cells) in strips in a 15x2 window in cells in eta X phi
Definition: EgammaEnums.h:39
xAOD::EgammaParameters::ethad
@ ethad
ET leakage into hadronic calorimeter with exclusion of energy in CaloSampling::TileGap3.
Definition: EgammaEnums.h:45
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
xAOD::EgammaHelpers::numberOfSiTracks
std::size_t numberOfSiTracks(const xAOD::Photon *eg)
return the number of Si tracks in the conversion
Definition: PhotonxAODHelpers.cxx:57
egammaMVAFunctions::compute_pt2conv
float compute_pt2conv(const xAOD::Photon *ph)
Definition: egammaMVAFunctions.h:204
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:137
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:52
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:92
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:213
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:133
xAOD::EgammaParameters::emins1
@ emins1
energy reconstructed in the strip with the minimal value between the first and second maximum
Definition: EgammaEnums.h:143
xAOD::EgammaParameters::poscs2
@ poscs2
relative position in eta within cell in 2nd sampling
Definition: EgammaEnums.h:121
egammaMVAFunctions::initializeClusterFuncs
void initializeClusterFuncs(funcMap_t &funcLibrary, const std::string &prefix, bool useLayerCorrected)
Definition: egammaMVAFunctions.cxx:143
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
xAOD::EgammaParameters::e011
@ e011
uncalibrated energy (sum of cells) in presampler in a 1x1 window in cells in eta X phi
Definition: EgammaEnums.h:30
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
egammaMVAFunctions::compute_el_refittedTrack_qoverp
float compute_el_refittedTrack_qoverp(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:140
AthenaPoolTestRead.acc
acc
Definition: AthenaPoolTestRead.py:16
xAOD::CaloCluster_v1::retrieveMoment
bool retrieveMoment(MomentType type, double &value) const
Retrieve individual moment.
Definition: CaloCluster_v1.cxx:738
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
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:162
min
#define min(a, b)
Definition: cfImp.cxx:40
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:92
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:119
xAOD::EgammaHelpers::conversionRadius
float conversionRadius(const xAOD::Vertex *vx)
return the conversion radius or 9999.
Definition: PhotonxAODHelpers.cxx:76
xAOD::EgammaParameters::barys1
@ barys1
barycentre in sampling 1 calculated in 3 strips
Definition: EgammaEnums.h:135
xAOD::Electron_v1
Definition: Electron_v1.h:34
dq_make_web_display.rv
def rv
Definition: dq_make_web_display.py:219
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:188
ParticleGun_SamplingFraction.radius
radius
Definition: ParticleGun_SamplingFraction.py:96
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
egammaMVAFunctions::compute_cl_phi
float compute_cl_phi(const xAOD::CaloCluster &cluster)
Definition: egammaMVAFunctions.h:49
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:238
xAOD::Photon_v1
Definition: Photon_v1.h:37
xAOD::EgammaParameters::e255
@ e255
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 5x5
Definition: EgammaEnums.h:74
xAOD::EgammaParameters::e337
@ e337
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x7
Definition: EgammaEnums.h:89
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:149
egammaMVAFunctions::compute_pt1conv
float compute_pt1conv(const xAOD::Photon *ph)
Definition: egammaMVAFunctions.h:191
xAOD::EgammaHelpers::conversionType
xAOD::EgammaParameters::ConversionType conversionType(const xAOD::Photon *ph)
return the photon conversion type (see EgammaEnums)
Definition: PhotonxAODHelpers.cxx:26
egammaMVAFunctions::compute_correctedcl_Es3
float compute_correctedcl_Es3(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:89
xAOD::EgammaParameters::e277
@ e277
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 7x7
Definition: EgammaEnums.h:80
xAOD::EgammaParameters::widths1
@ widths1
same as egammaParameters::weta1 but without corrections on particle impact point inside the cell
Definition: EgammaEnums.h:114
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:97
xAOD::EgammaParameters::e132
@ e132
uncalibrated energy (sum of cells) in strips in a 3x2 window in cells in eta X phi
Definition: EgammaEnums.h:36
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:158
xAOD::EgammaParameters::e237
@ e237
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x7
Definition: EgammaEnums.h:77
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:65
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:108
xAOD::EgammaParameters::Rhad
@ Rhad
ethad/et
Definition: EgammaEnums.h:160
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:187
xAOD::EgammaParameters::widths2
@ widths2
same as egammaParameters::weta2 but without corrections on particle impact point inside the cell
Definition: EgammaEnums.h:117
xAOD::EgammaParameters::DeltaE
@ DeltaE
e2tsts1-emins1
Definition: EgammaEnums.h:164
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:86
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
dq_make_web_display.cl
cl
print [x.__class__ for x in toList(dqregion.getSubRegions()) ]
Definition: dq_make_web_display.py:26
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:145
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
VP1PartSpect::Pi
@ Pi
Definition: VP1PartSpectFlags.h:27
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:111
xAOD::EgammaParameters::pos
@ pos
difference between shower cell and predicted track in +/- 1 cells
Definition: EgammaEnums.h:125
egammaMVAFunctions::compute_el_charge
float compute_el_charge(const xAOD::Electron &el)
Definition: egammaMVAFunctions.h:136
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:103
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Sun Jun 30 2024 22:16:01 for ATLAS Offline Software by   doxygen 1.8.18