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
	Define the map type since it's long.

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.
float	compute_ptconv (const xAOD::Photon *ph)
	This ptconv is the old one used by MVACalib.
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.
std::unique_ptr< funcMap_t >	initializeUnconvertedPhotonFuncs (bool useLayerCorrected)
	A function to build the map for uncoverted photons.
std::unique_ptr< funcMap_t >	initializeConvertedPhotonFuncs (bool useLayerCorrected)
	A function to build the map for converted photons.
std::unique_ptr< funcMap_t >	initializeForwardElectronFuncs (bool useLayerCorrected)
	NEW: A function to build the map for forward electrons.
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

• egammaMVAFunctions::initializeElectronFuncs
• egammaMVAFunctions::initializeUnconvertedPhotonFuncs
• egammaMVAFunctions::initializeConvertedPhotonFuncs the will return an unordered map with key a string, corresponding to the variable to be computed and as a value the function, with signature float(const xAOD::Egamma*).

Typedef Documentation

funcMap_t

using egammaMVAFunctions::funcMap_t

Initial value:

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 310 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 144 of file egammaMVAFunctions.h.

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

compute_calibHitsShowerDepth()

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

inline

Definition at line 102 of file egammaMVAFunctions.h.

  {
    const float denominator = cl[0] + cl[1] + cl[2] + cl[3];
    if (denominator == 0) return 0.;
 
    const std::array<float, 4> radius(get_MVAradius(eta));
 
    // loop unrolling
    return (radius[0] * cl[0]
          + radius[1] * cl[1]
          + radius[2] * cl[2]
          + radius[3] * cl[3]) / denominator;
  }

compute_cellIndex_EMEC()

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

inline

Definition at line 189 of file egammaMVAFunctions.h.

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

compute_cellIndex_FCAL()

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

inline

Definition at line 183 of file egammaMVAFunctions.h.

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

compute_cl_centerLambda()

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

inline

Definition at line 161 of file egammaMVAFunctions.h.

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

{ return cluster.e(); }

compute_cl_eta()

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

inline

Definition at line 49 of file egammaMVAFunctions.h.

{ return cluster.eta(); }

compute_cl_etaCalo()

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

inline

Definition at line 52 of file egammaMVAFunctions.h.

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

compute_cl_etas1()

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

inline

Definition at line 66 of file egammaMVAFunctions.h.

{ return cluster.etaBE(1); }

compute_cl_etas2()

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

inline

Definition at line 67 of file egammaMVAFunctions.h.

{ return cluster.etaBE(2); }

compute_cl_fracMax()

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

inline

Definition at line 158 of file egammaMVAFunctions.h.

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

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

compute_cl_longitudinal()

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

inline

Definition at line 157 of file egammaMVAFunctions.h.

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

compute_cl_phi()

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

inline

Definition at line 50 of file egammaMVAFunctions.h.

{ return cluster.phi(); }

compute_cl_phiCalo()

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

inline

Definition at line 59 of file egammaMVAFunctions.h.

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

compute_cl_secondDensity()

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

inline

Definition at line 162 of file egammaMVAFunctions.h.

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

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

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

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

compute_cl_significance()

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

inline

Definition at line 154 of file egammaMVAFunctions.h.

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

compute_cl_x()

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

inline

Definition at line 163 of file egammaMVAFunctions.h.

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

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

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

compute_convtrk1nPixHits()

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

inline

Definition at line 301 of file egammaMVAFunctions.h.

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

compute_convtrk1nSCTHits()

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

inline

Definition at line 303 of file egammaMVAFunctions.h.

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

compute_convtrk2nPixHits()

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

inline

Definition at line 302 of file egammaMVAFunctions.h.

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

compute_convtrk2nSCTHits()

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

inline

Definition at line 304 of file egammaMVAFunctions.h.

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

                                                        {
      const auto vx = ph->vertex();
      if (!vx) return 0.;
 
      if (vx->trackParticle(0)) {
        uint8_t hits;
        if (vx->trackParticle(itrack)->summaryValue(hits, summary)) {
          return hits;
        }
      }
      return 0.;
  }

compute_correctedcl_calibHitsShowerDepth()

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

inline

Definition at line 125 of file egammaMVAFunctions.h.

                                                                                   {
    const std::array<float, 4> cluster_array {{ compute_correctedcl_Es0(cl),
                                                compute_correctedcl_Es1(cl),
                                                compute_correctedcl_Es2(cl),
                                                compute_correctedcl_Es3(cl) }};
    return compute_calibHitsShowerDepth(cluster_array, compute_cl_eta(cl));
  }

compute_correctedcl_Eacc()

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

inline

Definition at line 98 of file egammaMVAFunctions.h.

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

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

compute_correctedcl_Es1()

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

inline

Definition at line 82 of file egammaMVAFunctions.h.

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

compute_correctedcl_Es2()

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

inline

Definition at line 86 of file egammaMVAFunctions.h.

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

compute_correctedcl_Es3()

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

inline

Definition at line 90 of file egammaMVAFunctions.h.

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

compute_correctedcl_f0()

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

inline

Definition at line 99 of file egammaMVAFunctions.h.

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

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

compute_el_charge()

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

inline

Definition at line 205 of file egammaMVAFunctions.h.

{ return el.charge(); }

compute_el_refittedTrack_qoverp()

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

inline

Definition at line 209 of file egammaMVAFunctions.h.

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

compute_el_tracketa()

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

inline

Definition at line 206 of file egammaMVAFunctions.h.

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

compute_el_trackpt()

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

inline

Definition at line 207 of file egammaMVAFunctions.h.

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

compute_el_trackz0()

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

inline

Definition at line 208 of file egammaMVAFunctions.h.

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

compute_et()

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

inline

Definition at line 137 of file egammaMVAFunctions.h.

                                                     {
    const float e   = cl.e();
    const float eta = cl.eta();
    const float c   = std::cosh(eta);
    return (c != 0.f) ? (e / c) : 0.f;
  }

compute_eta_FCAL()

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

inline

Definition at line 173 of file egammaMVAFunctions.h.

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

compute_etaMod_EMEC()

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

inline

Definition at line 186 of file egammaMVAFunctions.h.

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

compute_etaMod_FCAL()

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

inline

Definition at line 180 of file egammaMVAFunctions.h.

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

compute_ph_convFlag()

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

inline

Definition at line 216 of file egammaMVAFunctions.h.

                                                       {
    const auto original = xAOD::EgammaHelpers::conversionType(&ph);
    if (original == 3) return 2;
    else if (original != 0) return 1;
    else return original;
  }

compute_phiMod_EMEC()

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

inline

Definition at line 192 of file egammaMVAFunctions.h.

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

compute_pt1conv()

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

inline

Definition at line 259 of file egammaMVAFunctions.h.

  {
    static const SG::AuxElement::Accessor<float> accPt1("pt1");
    
    const xAOD::Vertex* vx = ph->vertex();
    if (!vx) return 0.0;
    if (accPt1.isAvailable(*vx)) {
      return accPt1(*vx);
    } else {
      return getPtAtFirstMeasurement(vx->trackParticle(0));
    }
  }

compute_pt2conv()

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

inline

Definition at line 272 of file egammaMVAFunctions.h.

  {
    static const SG::AuxElement::Accessor<float> accPt2("pt2");
    
    const xAOD::Vertex* vx = ph->vertex();
    if (!vx) return 0.0;
    if (accPt2.isAvailable(*vx)) {
      return accPt2(*vx);
    } else {
      return getPtAtFirstMeasurement(vx->trackParticle(1));
    }
  }

compute_ptconv()

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

inline

This ptconv is the old one used by MVACalib.

Definition at line 248 of file egammaMVAFunctions.h.

  {
    auto vx = ph->vertex();
    if (!vx) return 0.0;
 
    TLorentzVector sum;
    if (vx->trackParticle(0)) sum += vx->trackParticle(0)->p4();
    if (vx->trackParticle(1)) sum += vx->trackParticle(1)->p4();
    return sum.Perp();
  }

compute_ptconv_decor()

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

inline

This ptconv function uses the vertex decorations.

Definition at line 238 of file egammaMVAFunctions.h.

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

compute_R12_EMEC()

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

inline

Definition at line 198 of file egammaMVAFunctions.h.

                                                          {
    double es1 = cl.energy_max(CaloSampling::EME2);
    double es2 = cl.energy_max(CaloSampling::EME3);
    return es2 != 0 ? float(es1/es2) : -1;
  }

compute_rawcl_calibHitsShowerDepth()

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

inline

Definition at line 116 of file egammaMVAFunctions.h.

  {
      const std::array<float, 4> cluster_array {{ compute_rawcl_Es0(cl),
                                                  compute_rawcl_Es1(cl),
                                                  compute_rawcl_Es2(cl),
                                                  compute_rawcl_Es3(cl) }};
      return compute_calibHitsShowerDepth(cluster_array, compute_cl_eta(cl));
  }

compute_rawcl_Eacc()

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

inline

Definition at line 95 of file egammaMVAFunctions.h.

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

{ return cl.energyBE(0); }

compute_rawcl_Es1()

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

inline

Definition at line 74 of file egammaMVAFunctions.h.

{ return cl.energyBE(1); }

compute_rawcl_Es2()

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

inline

Definition at line 75 of file egammaMVAFunctions.h.

{ return cl.energyBE(2); }

compute_rawcl_Es3()

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

inline

Definition at line 76 of file egammaMVAFunctions.h.

{ return cl.energyBE(3); }

compute_rawcl_f0()

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

inline

Definition at line 96 of file egammaMVAFunctions.h.

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

  {
    if (!tp) return 0;
    for (unsigned int i = 0; i < tp->numberOfParameters(); ++i) {
      if (tp->parameterPosition(i) == xAOD::FirstMeasurement) {
        return hypot(tp->parameterPX(i), tp->parameterPY(i));
      }
    }
    return tp->pt();
  }

initializeClusterFuncs()

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

Definition at line 192 of file egammaMVAFunctions.cxx.

  {
 
    funcLibrary[prefix + "_cl_eta"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_eta(*cl); };
    funcLibrary[prefix + "_cl_phi"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_phi(*cl); };
    funcLibrary[prefix + "_cl_E"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_e(*cl); };
    funcLibrary[prefix + "_cl_etaCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_etaCalo(*cl); };
    funcLibrary[prefix + "_cl_phiCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_phiCalo(*cl); };
    funcLibrary[prefix + "_cl_E_TileGap3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return cl->eSample(CaloSampling::TileGap3); };
 
    funcLibrary[prefix + "_cellIndexCalo"] = funcLibrary["cellIndexCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return std::floor(std::abs(compute_cl_etaCalo(*cl))/0.025); };
    funcLibrary[prefix + "_phiModCalo"] = funcLibrary["phiModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return ((abs(compute_cl_eta(*cl)) < 1.425) ?
                  std::fmod(compute_cl_phiCalo(*cl), TMath::Pi() / 512) :
                  std::fmod(compute_cl_phiCalo(*cl), TMath::Pi() / 384));
      };
 
    // improved version of phiModCalo, proposed by G. Unal, studied by L. Nasella
    // see https://its.cern.ch/jira/browse/ATLASEG-325
    // see https://indico.cern.ch/event/1364593/contributions/5843081/
    funcLibrary[prefix + "_phiModCalo1"] = funcLibrary["phiModCalo1"] =
        [](const xAOD::Egamma*, const xAOD::CaloCluster* cl) {
          using std::numbers::pi;
          const double eta = compute_cl_eta(*cl);
          const double phi = compute_cl_phiCalo(*cl);
          const double pi_divisor = std::abs(eta) < 1.425 ? 512. : 384.;
 
          if (eta > 0.) {
            if (phi > 0.) return std::fmod(phi, pi / pi_divisor);
            else return std::fmod((2 * pi + phi), pi / pi_divisor);
          }
          else return std::fmod((pi - phi), pi / pi_divisor);
        };
 
    funcLibrary[prefix + "_phiModCell"] = funcLibrary["phiModCell"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return std::fmod(std::abs(compute_cl_phiCalo(*cl)), TMath::Pi() / 128); };
    funcLibrary[prefix + "_etaModCalo"] = funcLibrary["etaModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return std::fmod(std::abs(compute_cl_etaCalo(*cl)), 0.025); };
    funcLibrary["abs(" + prefix + "_cl_eta)"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return std::abs(compute_cl_eta(*cl)); };
    funcLibrary[prefix + "_dPhiTG3"] = funcLibrary["dPhiTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return std::fmod(2.*TMath::Pi()+compute_cl_phi(*cl),TMath::Pi()/32.)-TMath::Pi()/64.0; };
 
    if (useLayerCorrected) {
      funcLibrary[prefix + "_rawcl_Es0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_Es0(*cl); };
      funcLibrary[prefix + "_rawcl_Es1"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_Es1(*cl); };
      funcLibrary[prefix + "_rawcl_Es2"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_Es2(*cl); };
      funcLibrary[prefix + "_rawcl_Es3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_Es3(*cl); };
      funcLibrary[prefix + "_rawcl_Eacc"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_Eacc(*cl); };
      funcLibrary[prefix + "_rawcl_f0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_f0(*cl); };
      funcLibrary[prefix + "_rawcl_calibHitsShowerDepth"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_calibHitsShowerDepth(*cl); };
      funcLibrary[prefix + "_R12"] = funcLibrary["R12"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_correctedcl_Es1(*cl)/compute_correctedcl_Es2(*cl); };
      funcLibrary[prefix + "_fTG3"] = funcLibrary["fTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return cl->eSample(CaloSampling::TileGap3)/compute_correctedcl_Eacc(*cl); };
    } else {
      funcLibrary[prefix + "_rawcl_Es0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_Es0(*cl); };
      funcLibrary[prefix + "_rawcl_Es1"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_Es1(*cl); };
      funcLibrary[prefix + "_rawcl_Es2"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_Es2(*cl); };
      funcLibrary[prefix + "_rawcl_Es3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_Es3(*cl); };
      funcLibrary[prefix + "_rawcl_Eacc"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_Eacc(*cl); };
      funcLibrary[prefix + "_rawcl_f0"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_f0(*cl); };
      funcLibrary[prefix + "_rawcl_calibHitsShowerDepth"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_calibHitsShowerDepth(*cl); };
      funcLibrary[prefix + "_R12"] = funcLibrary["R12"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_rawcl_Es1(*cl)/compute_rawcl_Es2(*cl); };
      funcLibrary[prefix + "_fTG3"] = funcLibrary["fTG3"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return cl->eSample(CaloSampling::TileGap3)/compute_rawcl_Eacc(*cl); };
    }
  }

initializeConvertedPhotonFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeConvertedPhotonFuncs

(

bool

useLayerCorrected

)

A function to build the map for converted photons.

Definition at line 73 of file egammaMVAFunctions.cxx.

  {
    auto funcLibraryPtr = std::make_unique<funcMap_t>();
    funcMap_t& funcLibrary = *funcLibraryPtr;
 
    initializeClusterFuncs(funcLibrary, "ph", useLayerCorrected);
    initializeEgammaFuncs(funcLibrary, "ph", useLayerCorrected);
 
 
    funcLibrary["ph_Rconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
      { return xAOD::EgammaHelpers::conversionRadius(static_cast<const xAOD::Photon*>(eg)); };
 
    funcLibrary["ph_convR"] = funcLibrary["convR"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
      {
        const auto *ph = static_cast<const xAOD::Photon*>(eg);
        if (compute_ptconv(ph) > 3*GeV) {
          return xAOD::EgammaHelpers::conversionRadius(ph);
        }
        return 799.0;
 
      };
    funcLibrary["ph_zconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      {
    const auto *vertex = static_cast<const xAOD::Photon*>(eg)->vertex();
    return vertex ? vertex->position().z() : 9999;
      };
    funcLibrary["ph_pt1conv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
      { return compute_pt1conv(static_cast<const xAOD::Photon*>(eg)); };
    funcLibrary["ph_pt2conv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
      { return compute_pt2conv(static_cast<const xAOD::Photon*>(eg)); };
    funcLibrary["ph_ptconv"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return compute_ptconv(static_cast<const xAOD::Photon*>(eg)); };
 
    funcLibrary["ph_convPtRatio"] = funcLibrary["convPtRatio"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)->float
      {
        const auto *ph = static_cast<const xAOD::Photon*>(eg);
        if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
          auto pt1 = compute_pt1conv(ph);
          auto pt2 = compute_pt2conv(ph);
          auto denom = pt1+pt2;
          if (denom == 0.)[[unlikely]] return std::numeric_limits<float>::max();
          return std::max(pt1, pt2)/denom;
        }
          return 1.0f;
      };
 
    if (useLayerCorrected) {
      funcLibrary["ph_convEtOverPt"] = funcLibrary["convEtOverPt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*cl)->float
        {
          const auto *ph = static_cast<const xAOD::Photon*>(eg);
 
          float rv = 0.0;
          if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
            auto denom = std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph);
            if (denom == 0.f)[[unlikely]] rv = std::numeric_limits<float>::max();
            else rv = std::max(0.0f, compute_correctedcl_Eacc(*cl)/denom);
          }
          return std::min(rv, 2.0f);
        };
    } else {
      funcLibrary["ph_convEtOverPt"] = funcLibrary["convEtOverPt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*cl)->float
        {
          const auto *ph = static_cast<const xAOD::Photon*>(eg);
 
          float rv = 0.0;
          if (xAOD::EgammaHelpers::numberOfSiTracks(ph) == 2) {
            auto denom = (std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph));
            if (denom == 0.f)[[unlikely]] rv = std::numeric_limits<float>::max();
            else rv = std::max(0.0f, compute_rawcl_Eacc(*cl)/denom);
          }
          return std::min(rv, 2.0f);
        };
    }
 
    return funcLibraryPtr;
  }

initializeEgammaFuncs()

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

Definition at line 287 of file egammaMVAFunctions.cxx.

  {
    funcLibrary[prefix + "_e011"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e011); };
    funcLibrary[prefix + "_e033"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e033); };
    funcLibrary[prefix + "_e132"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e132); };
    funcLibrary[prefix + "_e1152"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e1152); };
    funcLibrary[prefix + "_ethad1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::ethad1); };
    funcLibrary[prefix + "_ethad"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::ethad); };
    funcLibrary[prefix + "_f1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::f1); };
    funcLibrary[prefix + "_f3"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::f3); };
    funcLibrary[prefix + "_f1core"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::f1core); };
    funcLibrary[prefix + "_f3core"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::f3core); };
    funcLibrary[prefix + "_e233"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e233); };
    funcLibrary[prefix + "_e235"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e235); };
    funcLibrary[prefix + "_e255"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e255); };
    funcLibrary[prefix + "_e237"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e237); };
    funcLibrary[prefix + "_e277"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e277); };
    funcLibrary[prefix + "_e333"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e333); };
    funcLibrary[prefix + "_e335"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e335); };
    funcLibrary[prefix + "_e337"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e337); };
    funcLibrary[prefix + "_e377"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e377); };
    funcLibrary[prefix + "_weta1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::weta1); };
    funcLibrary[prefix + "_weta2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::weta2); };
    funcLibrary[prefix + "_e2ts1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e2ts1); };
    funcLibrary[prefix + "_e2tsts1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::e2tsts1); };
    funcLibrary[prefix + "_fracs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::fracs1); };
    funcLibrary[prefix + "_widths1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::widths1); };
    funcLibrary[prefix + "_widths2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::widths2); };
    funcLibrary[prefix + "_poscs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::poscs1); };
    funcLibrary[prefix + "_poscs2"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::poscs2); };
    funcLibrary[prefix + "_asy1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::asy1); };
    funcLibrary[prefix + "_pos"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::pos); };
    funcLibrary[prefix + "_pos7"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::pos7); };
    funcLibrary[prefix + "_barys1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::barys1); };
    funcLibrary[prefix + "_wtots1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::wtots1); };
    funcLibrary[prefix + "_emins1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::emins1); };
    funcLibrary[prefix + "_emaxs1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::emaxs1); };
    funcLibrary[prefix + "_r33over37allcalo"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::r33over37allcalo); };
    funcLibrary[prefix + "_ecore"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::ecore); };
    funcLibrary[prefix + "_Reta"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::Reta); };
    funcLibrary[prefix + "_Rphi"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::Rphi); };
    funcLibrary[prefix + "_Eratio"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::Eratio); };
    funcLibrary[prefix + "_Rhad"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::Rhad); };
    funcLibrary[prefix + "_Rhad1"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::Rhad1); };
    funcLibrary[prefix + "_DeltaE"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return eg->showerShapeValue(xAOD::EgammaParameters::DeltaE); };
 
  }

initializeElectronFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeElectronFuncs

(

bool

useLayerCorrected

)

A function to build the map for electrons.

Definition at line 35 of file egammaMVAFunctions.cxx.

  {
    // rel21 uses a naming version of some variables without prefix, keep both for compatibility
    auto funcLibraryPtr = std::make_unique<funcMap_t>();
    funcMap_t& funcLibrary = *funcLibraryPtr;
 
    initializeClusterFuncs(funcLibrary, "el", useLayerCorrected);
    initializeEgammaFuncs(funcLibrary, "el", useLayerCorrected);
 
    // specific functions only for electrons
    funcLibrary["el_charge"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return compute_el_charge(*(static_cast<const xAOD::Electron*>(eg))); };
    funcLibrary["el_tracketa"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return compute_el_tracketa(*(static_cast<const xAOD::Electron*>(eg))); };
    funcLibrary["el_trackpt"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return compute_el_trackpt(*(static_cast<const xAOD::Electron*>(eg))); };
    funcLibrary["el_trackz0"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return compute_el_trackz0(*(static_cast<const xAOD::Electron*>(eg))); };
    funcLibrary["el_refittedTrack_qoverp"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
      { return compute_el_refittedTrack_qoverp(*(static_cast<const xAOD::Electron*>(eg))); };
 
    return funcLibraryPtr;
  }

initializeForwardElectronFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeForwardElectronFuncs

(

bool

useLayerCorrected

)

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

Definition at line 150 of file egammaMVAFunctions.cxx.

                                                                                  {
    auto funcLibraryPtr = std::make_unique<funcMap_t>();
    funcMap_t& funcLibrary = *funcLibraryPtr;
 
    funcLibrary["el_cl_e"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_e(*cl); };
    funcLibrary["abs_el_cl_eta"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return std::abs(compute_cl_eta(*cl));  };
    funcLibrary["etaModCalo"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return (std::abs(cl->eta()) < 3.15 ? compute_etaMod_EMEC(*cl) : compute_etaMod_FCAL(*cl)); };
    funcLibrary["cellIndex"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return (std::abs(cl->eta()) < 3.15 ? compute_cellIndex_EMEC(*cl) : compute_cellIndex_FCAL(*cl)); };
    funcLibrary["el_cl_phi"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_phi(*cl); };
    funcLibrary["phiMod2pi32"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_phiMod_EMEC(*cl); };
    if (useLayerCorrected) {
      funcLibrary["el_cl_secondR"] = [](const xAOD::Egamma* eg, const xAOD::CaloCluster*)
    { return compute_cl_secondR_fudge(*eg); };
    } else {
      funcLibrary["el_cl_secondR"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
    { return compute_cl_secondR(*cl); };
    }
    funcLibrary["Es1Es2Ratio"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_R12_EMEC(*cl); };
    funcLibrary["el_cl_centerX"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_x(*cl); };
    funcLibrary["el_cl_centerY"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_y(*cl); };
    funcLibrary["abs_el_cl_centerZ"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      {  return std::abs(compute_cl_z(*cl)); };
    funcLibrary["el_cl_centerLambda"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_centerLambda(*cl); };
    funcLibrary["el_cl_secondMoment"] = [](const xAOD::Egamma*, const xAOD::CaloCluster* cl)
      { return compute_cl_secondDensity(*cl); };
    
    return funcLibraryPtr;
  }

initializeUnconvertedPhotonFuncs()

std::unique_ptr< funcMap_t > egammaMVAFunctions::initializeUnconvertedPhotonFuncs

(

bool

useLayerCorrected

)

A function to build the map for uncoverted photons.

Definition at line 60 of file egammaMVAFunctions.cxx.

  {
    auto funcLibraryPtr = std::make_unique<funcMap_t>();
    funcMap_t& funcLibrary = *funcLibraryPtr;
 
    initializeClusterFuncs(funcLibrary, "ph", useLayerCorrected);
    initializeEgammaFuncs(funcLibrary, "ph", useLayerCorrected);
 
    return funcLibraryPtr;
  }