egammaMVASvc Class Reference

#include <egammaMVASvc.h>

Inheritance diagram for egammaMVASvc:

Collaboration diagram for egammaMVASvc:

Public Member Functions
virtual	~egammaMVASvc () override
virtual StatusCode	initialize () override
StatusCode	getEnergy (const xAOD::CaloCluster &cluster, const xAOD::Egamma &eg, double &mvaE, const egammaMVACalib::GlobalEventInfo &gei=egammaMVACalib::GlobalEventInfo()) const override final
	Compute the calibrated energy.
StatusCode	getEnergy (const xAOD::CaloCluster &cluster, const xAOD::EgammaParameters::EgammaType egType, double &mvaE, const egammaMVACalib::GlobalEventInfo &gei=egammaMVACalib::GlobalEventInfo()) const override final
	Compute the calibrated energy when the full egamma object is not available.
StatusCode	execute (xAOD::CaloCluster &cluster, const xAOD::Egamma &eg, const egammaMVACalib::GlobalEventInfo &gei=egammaMVACalib::GlobalEventInfo()) const override final
	Main execute.
StatusCode	execute (xAOD::CaloCluster &cluster, const xAOD::EgammaParameters::EgammaType egType, const egammaMVACalib::GlobalEventInfo &gei=egammaMVACalib::GlobalEventInfo()) const override final
	Calibrate the cluster, when the full egamma object is not available.

Private Member Functions
bool	isConvCalib (const xAOD::Photon &ph) const
	Decide if the photon is converted or not.
StatusCode	resolve_flags ()

Private Attributes
ToolHandle< IegammaMVACalibTool >	m_mvaElectron
	MVA tool for electron.
ToolHandle< IegammaMVACalibTool >	m_mvaFwdElectron
	MVA tool for forward electron.
ToolHandle< IegammaMVACalibTool >	m_mvaUnconvertedPhoton
	MVA tool for unconverted photon.
ToolHandle< IegammaMVACalibTool >	m_mvaConvertedPhoton
	MVA tool for converted photon.
Gaudi::Property< float >	m_maxConvR
Gaudi::Property< int >	m_removeTRTConvBarrel
Gaudi::Property< std::string >	m_folder

Detailed Description

Definition at line 23 of file egammaMVASvc.h.

Constructor & Destructor Documentation

~egammaMVASvc()

virtual egammaMVASvc::~egammaMVASvc ( )

inlineoverridevirtual

Definition at line 28 of file egammaMVASvc.h.

{};

Member Function Documentation

execute() [1/2]

StatusCode egammaMVASvc::execute ( xAOD::CaloCluster & cluster, const xAOD::Egamma & eg, const egammaMVACalib::GlobalEventInfo & gei = egammaMVACalib::GlobalEventInfo() ) const

finaloverride

Main execute.

We need to calibrate the cluster. Use full egamma object instead of Type As we employ further variables than the ones present in the cluster This method needs to be valid also for reconstruction

Definition at line 202 of file egammaMVASvc.cxx.

{
  double mvaE = 0.;
 
  ATH_CHECK(getEnergy(cluster, eg, mvaE, gei));
 
  if (mvaE > eg.m()) {
    cluster.setCalE(mvaE);
  }
  else {
    ATH_MSG_DEBUG("MVA energy (" << mvaE << ") < particle mass ("
                  << eg.m() << "), setting e = cluster energy (" << cluster.e() << ")");
    cluster.setCalE(cluster.e());
  }
  return StatusCode::SUCCESS;
}

execute() [2/2]

StatusCode egammaMVASvc::execute ( xAOD::CaloCluster & cluster, const xAOD::EgammaParameters::EgammaType egType, const egammaMVACalib::GlobalEventInfo & gei = egammaMVACalib::GlobalEventInfo() ) const

finaloverride

Calibrate the cluster, when the full egamma object is not available.

Only variables related to the cluster are used (e.g. no conversion are used here) If the full egamma object use the other version.

Definition at line 221 of file egammaMVASvc.cxx.

{
 
  double mvaE = 0.;
 
  ATH_CHECK(getEnergy(cluster, egType, mvaE, gei));
 
  if (mvaE > 0) {
    cluster.setCalE(mvaE);
  }
  else {
    ATH_MSG_DEBUG("MVA energy (" << mvaE << ") < 0, setting e = cluster energy ("
          << cluster.e() << ")");
    cluster.setCalE(cluster.e());
  }
  return StatusCode::SUCCESS;
}

getEnergy() [1/2]

StatusCode egammaMVASvc::getEnergy ( const xAOD::CaloCluster & cluster, const xAOD::Egamma & eg, double & mvaE, const egammaMVACalib::GlobalEventInfo & gei = egammaMVACalib::GlobalEventInfo() ) const

finaloverride

Compute the calibrated energy.

Definition at line 105 of file egammaMVASvc.cxx.

{
 
  ATH_MSG_DEBUG("calling egammaMVASvc::getEnergy with cluster and eg");
 
  mvaE = 0.;
 
  if (xAOD::EgammaHelpers::isElectron(&eg)) {
    if (!m_mvaElectron.empty()) {
      mvaE = m_mvaElectron->getEnergy(cluster, &eg, gei);
    } else {
      ATH_MSG_FATAL("Trying to calibrate an electron, but disabled");
      return StatusCode::FAILURE;
    }
  } else if (xAOD::EgammaHelpers::isFwdElectron(&eg)) {
    if (!m_mvaFwdElectron.empty()) {
      mvaE = m_mvaFwdElectron->getEnergy(cluster, &eg, gei);
    } else {
      ATH_MSG_FATAL("Trying to calibrate a forward electron, but disabled");
      return StatusCode::FAILURE;
    }
  } else if (xAOD::EgammaHelpers::isPhoton(&eg)) {
    const xAOD::Photon* ph = static_cast<const xAOD::Photon*>(&eg);
    const bool is_conv_calib = isConvCalib(*ph);
    if (is_conv_calib) {
      if (!m_mvaConvertedPhoton.empty()) {
        mvaE = m_mvaConvertedPhoton->getEnergy(cluster, &eg, gei);
      } else {
        ATH_MSG_FATAL("Trying to calibrate a converted photon, but disabled");
        return StatusCode::FAILURE;
      }
    } else {
      if (!m_mvaUnconvertedPhoton.empty()) {
        mvaE = m_mvaUnconvertedPhoton->getEnergy(cluster, &eg, gei);
      } else {
        ATH_MSG_FATAL("Trying to calibrate an unconverted photon, but disabled");
        return StatusCode::FAILURE;
      }
    }
  } else {
    ATH_MSG_FATAL("Egamma object is of unsupported type");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG( "Calculated MVA calibrated energy = " << mvaE );
  return StatusCode::SUCCESS;
}

getEnergy() [2/2]

StatusCode egammaMVASvc::getEnergy ( const xAOD::CaloCluster & cluster, const xAOD::EgammaParameters::EgammaType egType, double & mvaE, const egammaMVACalib::GlobalEventInfo & gei = egammaMVACalib::GlobalEventInfo() ) const

finaloverride

Compute the calibrated energy when the full egamma object is not available.

Definition at line 156 of file egammaMVASvc.cxx.

{
 
  ATH_MSG_DEBUG("calling egammaMVASvc::getEnergy with cluster and egType (" << egType <<")");
 
  mvaE = 0.0;
  switch (egType) {
  case xAOD::EgammaParameters::electron:
    if (!m_mvaElectron.empty()) {
      mvaE = m_mvaElectron->getEnergy(cluster,nullptr, gei);
    } else {
      ATH_MSG_FATAL("Trying to calibrate an electron, but disabled");
      return StatusCode::FAILURE;
    }
    break;
  case xAOD::EgammaParameters::forwardelectron:
    if (!m_mvaFwdElectron.empty()) {
      mvaE = m_mvaFwdElectron->getEnergy(cluster,nullptr, gei);
    } else {
      ATH_MSG_FATAL("Trying to calibrate a forward electron, but disabled");
      return StatusCode::FAILURE;
    }
    break;
  case xAOD::EgammaParameters::convertedPhoton:
  case xAOD::EgammaParameters::unconvertedPhoton:
    // treat converted photons like unconverted photons since don't have access to vertex
    if (!m_mvaUnconvertedPhoton.empty()) {
      mvaE = m_mvaUnconvertedPhoton->getEnergy(cluster,nullptr, gei);
    } else {
      ATH_MSG_FATAL("Trying to calibrate an unconverted photon, but disabled");
      return StatusCode::FAILURE;
    }
    break;
  default:
    ATH_MSG_FATAL("Egamma object " << egType << " is of unsupported type");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG( "Calculated MVA calibrated energy = " << mvaE );
  return StatusCode::SUCCESS;
}

initialize()

StatusCode egammaMVASvc::initialize ( )

overridevirtual

Definition at line 18 of file egammaMVASvc.cxx.

{
  ATH_MSG_DEBUG("In initialize of " << name() << "..." );
 
  if (!m_mvaElectron.empty()) {
    ATH_MSG_DEBUG("Retrieving mvaElectron");
    ATH_CHECK(m_mvaElectron.retrieve());
  } else {
    ATH_MSG_DEBUG("Disabling mvaElectron");
    m_mvaElectron.disable();
  }
 
  if (!m_mvaFwdElectron.empty()) {
    ATH_MSG_DEBUG("Retrieving mvaFwdElectron");
    ATH_CHECK(m_mvaFwdElectron.retrieve());
  } else {
    ATH_MSG_DEBUG("Disabling mvaFwdElectron");
    m_mvaFwdElectron.disable();
  }
 
  if (!m_mvaUnconvertedPhoton.empty()) {
    ATH_MSG_DEBUG("Retrieving mvaUnconvertedPhoton");
    ATH_CHECK(m_mvaUnconvertedPhoton.retrieve());
  } else {
    ATH_MSG_DEBUG("Disabling mvaUnconvertedPhoton");
    m_mvaUnconvertedPhoton.disable();
  }
 
  if (!m_mvaConvertedPhoton.empty()) {
    ATH_MSG_DEBUG("Retrieving mvaConvertedPhoton");
    ATH_CHECK(m_mvaConvertedPhoton.retrieve());
  } else {
    ATH_MSG_DEBUG("Disabling mvaConvertedPhoton");
    m_mvaConvertedPhoton.disable();
  }
 
  ATH_CHECK(resolve_flags());
 
  ATH_MSG_INFO(m_maxConvR);
  ATH_MSG_INFO(m_removeTRTConvBarrel);
 
  return StatusCode::SUCCESS;
}

isConvCalib()

bool egammaMVASvc::isConvCalib ( const xAOD::Photon & ph ) const

private

Decide if the photon is converted or not.

Definition at line 94 of file egammaMVASvc.cxx.

{
  bool isConvCalib = xAOD::EgammaHelpers::isConvertedPhoton(&ph) && 
                     xAOD::EgammaHelpers::conversionRadius(&ph) < m_maxConvR;
  if (m_removeTRTConvBarrel) {
    // special case in Run3 to avoid TRT converted photons in the barrel
    isConvCalib = isConvCalib && xAOD::EgammaHelpers::isConvertedPhoton(&ph, true);
  }
  return isConvCalib;
}

resolve_flags()

StatusCode egammaMVASvc::resolve_flags ( )

private

Definition at line 62 of file egammaMVASvc.cxx.

{
  if (m_removeTRTConvBarrel == -1) {
    const bool removeTRTConvBarrelDefault = false;
    if (!m_mvaConvertedPhoton.empty() and !m_folder.empty()) {
      const std::string mva_filename = PathResolverFindCalibFile(m_folder + "/MVACalib_convertedPhoton.weights.root");
      std::unique_ptr<TFile> f(TFile::Open(mva_filename.c_str()));
      if (!f || f->IsZombie()) {
        ATH_MSG_ERROR("Could not open file: " << mva_filename);
        m_removeTRTConvBarrel = removeTRTConvBarrelDefault;
      }
      else {  // we have the MVA for converted photons
        TObjString* conversionDefinitionObj = nullptr;
        f->GetObject("conversionDefinition", conversionDefinitionObj);
        if (conversionDefinitionObj) {
          m_removeTRTConvBarrel = (conversionDefinitionObj->GetString() == "removeTRTConvBarrel");
        } else {
          // the conversion definition is not encoded in the file, this is true for the old ones
          m_removeTRTConvBarrel = removeTRTConvBarrelDefault;
        }
      }
    } else {  // we are running without converted
      m_removeTRTConvBarrel = removeTRTConvBarrelDefault;
    }
  }
  if (m_removeTRTConvBarrel == -1) {
    ATH_MSG_ERROR("Could not determine if TRT converted photons should be removed in the barrel");
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_folder

Gaudi::Property<std::string> egammaMVASvc::m_folder

private

Initial value:

{this,
      "folder", "", "folder for weight files"}

Definition at line 88 of file egammaMVASvc.h.

                                    {this,
      "folder", "", "folder for weight files"};

m_maxConvR

Gaudi::Property<float> egammaMVASvc::m_maxConvR

private

Initial value:

{this,
      "MaxConvRadius", 800.0,
      "The maximum conversion radius for a photon to be considered converted"}

Definition at line 80 of file egammaMVASvc.h.

                                  {this,
      "MaxConvRadius", 800.0,
      "The maximum conversion radius for a photon to be considered converted"};

m_mvaConvertedPhoton

ToolHandle<IegammaMVACalibTool> egammaMVASvc::m_mvaConvertedPhoton

private

Initial value:

{this,
      "ConvertedPhotonTool", "", "Tool to handle MVA trees for converted photons"}

MVA tool for converted photon.

Definition at line 77 of file egammaMVASvc.h.

                                                       {this,
      "ConvertedPhotonTool", "", "Tool to handle MVA trees for converted photons"};

m_mvaElectron

ToolHandle<IegammaMVACalibTool> egammaMVASvc::m_mvaElectron

private

Initial value:

{this,
      "ElectronTool", "", "Tool to handle MVA trees for electrons"}

MVA tool for electron.

Definition at line 65 of file egammaMVASvc.h.

                                                {this,
      "ElectronTool", "", "Tool to handle MVA trees for electrons"};

m_mvaFwdElectron

ToolHandle<IegammaMVACalibTool> egammaMVASvc::m_mvaFwdElectron

private

Initial value:

{this,
      "FwdElectronTool", "", "Tool to handle MVA trees for forward electrons"}

MVA tool for forward electron.

Definition at line 69 of file egammaMVASvc.h.

                                                   {this,
      "FwdElectronTool", "", "Tool to handle MVA trees for forward electrons"};

m_mvaUnconvertedPhoton

ToolHandle<IegammaMVACalibTool> egammaMVASvc::m_mvaUnconvertedPhoton

private

Initial value:

{this,
      "UnconvertedPhotonTool", "", "Tool to handle MVA trees for unconverted photons"}

MVA tool for unconverted photon.

Definition at line 73 of file egammaMVASvc.h.

                                                         {this,
      "UnconvertedPhotonTool", "", "Tool to handle MVA trees for unconverted photons"};

m_removeTRTConvBarrel

Gaudi::Property<int> egammaMVASvc::m_removeTRTConvBarrel

private

Initial value:

{this,
      "RemoveTRTConvBarrel", -1,
      "Remove TRT converted photons in the barrel: no=0, yes=1, automatic=-1"}

Definition at line 84 of file egammaMVASvc.h.

                                           {this,
      "RemoveTRTConvBarrel", -1,
      "Remove TRT converted photons in the barrel: no=0, yes=1, automatic=-1"};

---

The documentation for this class was generated from the following files:

• egammaMVASvc.h
• egammaMVASvc.cxx