DerivationFramework::EGPhotonBDTToolWrapper Class Reference

#include <EGPhotonBDTToolWrapper.h>

Inheritance diagram for DerivationFramework::EGPhotonBDTToolWrapper:

Collaboration diagram for DerivationFramework::EGPhotonBDTToolWrapper:

Public Member Functions
virtual StatusCode	initialize () override final
virtual StatusCode	addBranches (const EventContext &ctx) const override final

Private Attributes
ToolHandle< IAsgEGammaIsEMSelector >	m_selectorTool {this, "PhotonBDTSelectionTool", "", "Selector tool",}
ToolHandle< IPhotonObservableTool >	m_observableTool {this, "PhotonObservableTool", "", "Observable tool",}
ToolHandle< IElectronPhotonShowerShapeFudgeTool >	m_fudgeMCTool { this, "EGammaFudgeMCTool", "", "Fudging tool" }
SG::ReadHandleKey< xAOD::EgammaContainer >	m_ContainerName { this, "ContainerName", "", "Input" }
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_decoratorPass
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_decoratorIsEM
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_decoratorScore
Gaudi::Property< std::string >	m_cut { this, "CutType", "", "cut type" }

Detailed Description

Definition at line 25 of file EGPhotonBDTToolWrapper.h.

Member Function Documentation

addBranches()

StatusCode DerivationFramework::EGPhotonBDTToolWrapper::addBranches ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 35 of file EGPhotonBDTToolWrapper.cxx.

{
  // retrieve container
  SG::ReadHandle<xAOD::EgammaContainer> particles{ m_ContainerName, ctx };
 
  // Decorators
  SG::WriteDecorHandle<xAOD::EgammaContainer, char> decoratorPass{
    m_decoratorPass, ctx
  };
  SG::WriteDecorHandle<xAOD::EgammaContainer, unsigned int> decoratorIsEM{
    m_decoratorIsEM, ctx
  };
  SG::WriteDecorHandle<xAOD::EgammaContainer, float> decoratorScore{
    m_decoratorScore, ctx
  };
 
  // If we're applying corrections, the correction tools will give us
  // copies that we need to keep track of.  (We want to do all the copies
  // before we start writing decorations, to avoid warnings about having
  // unlocked decorations in a copy).
  // The copies we get back from the tool will have standalone aux stores.
  // We'll put them in a DataVector to get them deleted, but we don't
  // need to copy the aux data to the container, so construct it with
  // @c NEVER_TRACK_INDICES.
  xAOD::EgammaContainer pCopies (SG::OWN_ELEMENTS, SG::NEVER_TRACK_INDICES);
  if (!m_fudgeMCTool.empty()) {
    pCopies.reserve (particles->size());
    for (const xAOD::Egamma* par : *particles) {
      xAOD::Type::ObjectType type = par->type();
      // apply the shower shape corrections
      CP::CorrectionCode correctionCode = CP::CorrectionCode::Ok;
      xAOD::Egamma* pCopy = nullptr;
      if (type == xAOD::Type::Electron) {
        const xAOD::Electron* eg = static_cast<const xAOD::Electron*>(par);
        xAOD::Electron* el = nullptr;
        correctionCode = m_fudgeMCTool->correctedCopy(*eg, el);
        pCopy = el;
      } else {
        const xAOD::Photon* eg = static_cast<const xAOD::Photon*>(par);
        xAOD::Photon* ph = nullptr;
        correctionCode = m_fudgeMCTool->correctedCopy(*eg, ph);
        pCopy = ph;
      }
      if (correctionCode == CP::CorrectionCode::Ok) {
        // all OK
      } else if (correctionCode == CP::CorrectionCode::OutOfValidityRange) {
        Warning(
          "addBranches()",
          "Current photon has no valid fudge factors due to out-of-range");
      } else {
        Warning(
          "addBranches()",
          "Unknown correction code %d from ElectronPhotonShowerShapeFudgeTool",
          (int)correctionCode);
      }
      pCopies.push_back (pCopy);
    }
  }
  else {
    pCopies.resize (particles->size());
  }
 
  // Write mask for each element and record to SG for subsequent selection
  for (size_t ipar = 0; ipar < particles->size(); ipar++) {
    const xAOD::Egamma* par = particles->at(ipar);
    const xAOD::Egamma* pCopy = pCopies[ipar];
    if (!pCopy) pCopy = par;
 
    // compute the output of the selector
    asg::AcceptData theAccept(m_selectorTool->accept(ctx, pCopy));
    // compute the is EM word
    unsigned int isEM = 0;
    ATH_CHECK(m_selectorTool->execute(ctx, pCopy, isEM));
    // compute the BDT score
    const float score = m_observableTool->evaluate(pCopy);
    
    // decorate the original object
    if (m_cut.empty()) {
      decoratorPass(*par) = static_cast<bool>(theAccept) ? 1 : 0;  
    } else {
      decoratorPass(*par) = theAccept.getCutResult(m_cut) ? 1 : 0;
    }
    decoratorIsEM(*par) = isEM;
    decoratorScore(*par) = score;
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::EGPhotonBDTToolWrapper::initialize ( )

finaloverridevirtual

Definition at line 15 of file EGPhotonBDTToolWrapper.cxx.

{
  ATH_CHECK(m_selectorTool.retrieve());
  ATH_CHECK(m_observableTool.retrieve());
 
  if (!(m_fudgeMCTool.name().empty())) {
    ATH_CHECK(m_fudgeMCTool.retrieve());
  } else {
    m_fudgeMCTool.disable();
  }
 
  ATH_CHECK(m_ContainerName.initialize());
  ATH_CHECK(m_decoratorPass.initialize());
  ATH_CHECK(m_decoratorIsEM.initialize());
  ATH_CHECK(m_decoratorScore.initialize());
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_ContainerName

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::EGPhotonBDTToolWrapper::m_ContainerName { this, "ContainerName", "", "Input" }

private

Definition at line 42 of file EGPhotonBDTToolWrapper.h.

{ this, "ContainerName", "", "Input" };

m_cut

Gaudi::Property<std::string> DerivationFramework::EGPhotonBDTToolWrapper::m_cut { this, "CutType", "", "cut type" }

private

Definition at line 52 of file EGPhotonBDTToolWrapper.h.

{ this, "CutType", "", "cut type" };

m_decoratorIsEM

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGPhotonBDTToolWrapper::m_decoratorIsEM

private

Initial value:

{ this,
      "decoratorIsEM", m_ContainerName, "", "" }

Definition at line 48 of file EGPhotonBDTToolWrapper.h.

                                                              { this,
      "decoratorIsEM", m_ContainerName, "", "" };

m_decoratorPass

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGPhotonBDTToolWrapper::m_decoratorPass

private

Initial value:

{ this,
      "decoratorPass", m_ContainerName, "", "" }

Definition at line 46 of file EGPhotonBDTToolWrapper.h.

                                                              { this,
      "decoratorPass", m_ContainerName, "", "" };

m_decoratorScore

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGPhotonBDTToolWrapper::m_decoratorScore

private

Initial value:

{ this,
      "decoratorScore", m_ContainerName, "", "" }

Definition at line 50 of file EGPhotonBDTToolWrapper.h.

                                                               { this,
      "decoratorScore", m_ContainerName, "", "" };

m_fudgeMCTool

ToolHandle<IElectronPhotonShowerShapeFudgeTool> DerivationFramework::EGPhotonBDTToolWrapper::m_fudgeMCTool { this, "EGammaFudgeMCTool", "", "Fudging tool" }

private

Definition at line 40 of file EGPhotonBDTToolWrapper.h.

{ this, "EGammaFudgeMCTool", "", "Fudging tool" };

m_observableTool

ToolHandle<IPhotonObservableTool> DerivationFramework::EGPhotonBDTToolWrapper::m_observableTool {this, "PhotonObservableTool", "", "Observable tool",}

private

Definition at line 38 of file EGPhotonBDTToolWrapper.h.

{this, "PhotonObservableTool", "", "Observable tool",};

m_selectorTool

ToolHandle<IAsgEGammaIsEMSelector> DerivationFramework::EGPhotonBDTToolWrapper::m_selectorTool {this, "PhotonBDTSelectionTool", "", "Selector tool",}

private

Definition at line 36 of file EGPhotonBDTToolWrapper.h.

{this, "PhotonBDTSelectionTool", "", "Selector tool",};

---

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

• EGPhotonBDTToolWrapper.h
• EGPhotonBDTToolWrapper.cxx