DerivationFramework::EGElectronLikelihoodToolWrapper Class Reference

#include <EGElectronLikelihoodToolWrapper.h>

Inheritance diagram for DerivationFramework::EGElectronLikelihoodToolWrapper:

Collaboration diagram for DerivationFramework::EGElectronLikelihoodToolWrapper:

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

Private Attributes
ToolHandle< IAsgElectronLikelihoodTool >	m_tool
ToolHandle< IElectronPhotonShowerShapeFudgeTool >	m_fudgeMCTool { this, "EGammaFudgeMCTool", "", "Fudging tool" }
SG::ReadHandleKey< xAOD::EgammaContainer >	m_ContainerName
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_decoratorPass { this, "decoratorPass", m_ContainerName, "", "" }
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_decoratorIsEM { this, "decoratorIsEM", m_ContainerName, "", "" }
SG::WriteDecorHandleKey< xAOD::EgammaContainer >	m_decoratorResult { this, "decoratorResult", m_ContainerName, "", "" }
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer, float >	m_decoratorMultipleOutputs {this, "decoratorMultipleOutputs", m_ContainerName, {}, ""}
Gaudi::Property< std::string >	m_cut {this, "CutType", ""}
Gaudi::Property< bool >	m_storeTResult {this, "StoreTResult", false}
Gaudi::Property< bool >	m_storeMultipleOutputs {this, "StoreMultipleOutputs", false}

Detailed Description

Definition at line 33 of file EGElectronLikelihoodToolWrapper.h.

Member Function Documentation

addBranches()

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

finaloverridevirtual

Definition at line 41 of file EGElectronLikelihoodToolWrapper.cxx.

  {
    // retrieve container
    SG::ReadHandle<xAOD::EgammaContainer> particles{ m_ContainerName, 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::Error) {
          Error("addBranches()",
                "Error applying fudge factors to current photon");
        } else if (correctionCode == CP::CorrectionCode::OutOfValidityRange) {
          Warning(
                  "addBranches()",
                  "Current object 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());
    }
 
    // Decorators
    SG::WriteDecorHandle<xAOD::EgammaContainer, char> decoratorPass{
      m_decoratorPass, ctx
    };
    SG::WriteDecorHandle<xAOD::EgammaContainer, unsigned int> decoratorIsEM{
      m_decoratorIsEM, ctx
    };
 
    std::unique_ptr<SG::WriteDecorHandle<xAOD::EgammaContainer, float>>
      decoratorResult = nullptr;
    if (m_storeTResult) {
      decoratorResult =
        std::make_unique<SG::WriteDecorHandle<xAOD::EgammaContainer, float>>(
                                                                             m_decoratorResult, ctx);
    }
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, float>> decoratorMultipleOutputs{};
    if (m_storeMultipleOutputs) {
      decoratorMultipleOutputs = m_decoratorMultipleOutputs.makeHandles(ctx);
    }
 
    // Write mask for each element and record to SG for subsequent selection
    for (size_t ipar = 0; const xAOD::Egamma* par : *particles) {
      const xAOD::Egamma* pCopy = pCopies[ipar++];
      if (!pCopy) pCopy = par;
      // compute the output of the selector
      asg::AcceptData theAccept(m_tool->accept(ctx, pCopy));
      const unsigned int isEM =
        (unsigned int)theAccept.getCutResultInvertedBitSet()
        .to_ulong(); // this should work for both the
      // cut-based and the LH selectors
 
      // decorate the original object
      if (m_cut.empty()) {
        const bool pass_selection = (bool)theAccept;
        if (pass_selection) {
          decoratorPass(*par) = 1;
        } else {
          decoratorPass(*par) = 0;
        }
        decoratorIsEM(*par) = isEM;
        if (decoratorResult) {
          (*decoratorResult)(*par) =
            static_cast<float>(m_tool->calculate(ctx, pCopy));
        }
        if (m_storeMultipleOutputs) {
          // calculateMultipleOutputs only supports xAOD::Electron as input
          const xAOD::Electron *eCopy = static_cast<const xAOD::Electron *>(pCopy);
          std::vector<float> toolOutput = m_tool->calculateMultipleOutputs(ctx, eCopy);
          for (size_t i = 0; i < toolOutput.size(); i++){
            decoratorMultipleOutputs.at(i)(*par) = toolOutput.at(i);
          }
        }
      } else {
        if (theAccept.getCutResult(m_cut)) {
          decoratorPass(*par) = 1;
        } else {
          decoratorPass(*par) = 0;
        }
        decoratorIsEM(*par) = isEM;
        if (decoratorResult) {
          (*decoratorResult)(*par) =
            static_cast<float>(m_tool->calculate(ctx, pCopy));
        }
        if (m_storeMultipleOutputs) {
          // calculateMultipleOutputs only supports xAOD::Electron as input
          const xAOD::Electron* eCopy = static_cast<const xAOD::Electron*>(pCopy);
          std::vector<float> toolOutput = m_tool->calculateMultipleOutputs(ctx, eCopy);
          for (size_t i = 0; i < toolOutput.size(); i++){
            decoratorMultipleOutputs.at(i)(*par) = toolOutput.at(i);
          }
        }
      }
    }
 
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode DerivationFramework::EGElectronLikelihoodToolWrapper::initialize ( )

finaloverridevirtual

Definition at line 20 of file EGElectronLikelihoodToolWrapper.cxx.

  {
    ATH_CHECK(m_tool.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_decoratorResult.initialize(m_storeTResult));
    ATH_CHECK(m_decoratorMultipleOutputs.initialize(m_storeMultipleOutputs));
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_ContainerName

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::EGElectronLikelihoodToolWrapper::m_ContainerName

private

Initial value:

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

Definition at line 52 of file EGElectronLikelihoodToolWrapper.h.

m_cut

Gaudi::Property<std::string> DerivationFramework::EGElectronLikelihoodToolWrapper::m_cut {this, "CutType", ""}

private

Definition at line 66 of file EGElectronLikelihoodToolWrapper.h.

m_decoratorIsEM

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGElectronLikelihoodToolWrapper::m_decoratorIsEM { this, "decoratorIsEM", m_ContainerName, "", "" }

private

Definition at line 61 of file EGElectronLikelihoodToolWrapper.h.

m_decoratorMultipleOutputs

SG::WriteDecorHandleKeyArray<xAOD::EgammaContainer, float> DerivationFramework::EGElectronLikelihoodToolWrapper::m_decoratorMultipleOutputs {this, "decoratorMultipleOutputs", m_ContainerName, {}, ""}

private

Definition at line 65 of file EGElectronLikelihoodToolWrapper.h.

m_decoratorPass

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGElectronLikelihoodToolWrapper::m_decoratorPass { this, "decoratorPass", m_ContainerName, "", "" }

private

Definition at line 59 of file EGElectronLikelihoodToolWrapper.h.

m_decoratorResult

SG::WriteDecorHandleKey<xAOD::EgammaContainer> DerivationFramework::EGElectronLikelihoodToolWrapper::m_decoratorResult { this, "decoratorResult", m_ContainerName, "", "" }

private

Definition at line 63 of file EGElectronLikelihoodToolWrapper.h.

m_fudgeMCTool

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

private

Definition at line 50 of file EGElectronLikelihoodToolWrapper.h.

m_storeMultipleOutputs

Gaudi::Property<bool> DerivationFramework::EGElectronLikelihoodToolWrapper::m_storeMultipleOutputs {this, "StoreMultipleOutputs", false}

private

Definition at line 68 of file EGElectronLikelihoodToolWrapper.h.

m_storeTResult

Gaudi::Property<bool> DerivationFramework::EGElectronLikelihoodToolWrapper::m_storeTResult {this, "StoreTResult", false}

private

Definition at line 67 of file EGElectronLikelihoodToolWrapper.h.

m_tool

ToolHandle<IAsgElectronLikelihoodTool> DerivationFramework::EGElectronLikelihoodToolWrapper::m_tool

private

Initial value:

{
      this,
        "EGammaElectronLikelihoodTool",
        "",
        "Electron  Likelihood Selector"
        }

Definition at line 43 of file EGElectronLikelihoodToolWrapper.h.

---

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

• EGElectronLikelihoodToolWrapper.h
• EGElectronLikelihoodToolWrapper.cxx