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

Function Documentation

cl_getMoment()

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

inline

Definition at line 143 of file egammaMVAFunctions.h.

                                              {
    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 101 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 188 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 182 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 160 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 50 of file egammaMVAFunctions.h.

{ return cluster.e(); }

compute_cl_eta()

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

inline

Definition at line 48 of file egammaMVAFunctions.h.

{ return cluster.eta(); }

compute_cl_etaCalo()

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

inline

Definition at line 51 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 65 of file egammaMVAFunctions.h.

{ 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.

{ return cluster.etaBE(2); }

compute_cl_fracMax()

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

inline

Definition at line 157 of file egammaMVAFunctions.h.

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

compute_cl_lateral()

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

inline

Definition at line 155 of file egammaMVAFunctions.h.

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

compute_cl_longitudinal()

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

inline

Definition at line 156 of file egammaMVAFunctions.h.

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

compute_cl_phi()

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

inline

Definition at line 49 of file egammaMVAFunctions.h.

{ return cluster.phi(); }

compute_cl_phiCalo()

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

inline

Definition at line 58 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 161 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 154 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 159 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 166 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 153 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 162 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 163 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 164 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 298 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 300 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 299 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 301 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 285 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 124 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 97 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 77 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 81 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 85 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 89 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 98 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 207 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 202 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 206 of file egammaMVAFunctions.h.

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

compute_el_tracketa()

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

inline

Definition at line 203 of file egammaMVAFunctions.h.

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

compute_el_trackpt()

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

inline

Definition at line 204 of file egammaMVAFunctions.h.

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

compute_el_trackz0()

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

inline

Definition at line 205 of file egammaMVAFunctions.h.

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

compute_et()

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

inline

Definition at line 136 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 172 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 185 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 179 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 213 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 191 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 256 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 269 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 245 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 235 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 197 of file egammaMVAFunctions.h.

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

compute_rawcl_calibHitsShowerDepth()

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

inline

Definition at line 115 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 94 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 67 of file egammaMVAFunctions.h.

{ 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.

{ 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.

{ 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.

{ 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.

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

getPtAtFirstMeasurement()

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

inline

Definition at line 221 of file egammaMVAFunctions.h.

  {
    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 185 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 72 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);
          return std::max(pt1, pt2)/(pt1+pt2);
        }
          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) {
            rv = std::max(0.0f, compute_correctedcl_Eacc(*cl)/(std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph)));
          }
          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) {
            rv = std::max(0.0f, compute_rawcl_Eacc(*cl)/(std::cosh(compute_cl_eta(*cl))*compute_ptconv(ph)));
          }
          return std::min(rv, 2.0f);
        };
    }
 
    return funcLibraryPtr;
  }

initializeEgammaFuncs()

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

Definition at line 280 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 34 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 143 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 59 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;
  }