DerivationFramework::GainDecorator Class Reference

#include <GainDecorator.h>

Inheritance diagram for DerivationFramework::GainDecorator:

Collaboration diagram for DerivationFramework::GainDecorator:

Classes
struct	calculation

Public Member Functions
	GainDecorator (const std::string &t, const std::string &n, const IInterface *p)
	~GainDecorator ()
StatusCode	initialize ()
StatusCode	finalize ()
virtual StatusCode	addBranches () const

Static Public Member Functions
static int	getLayer (const CaloCell *cell)

Private Member Functions
calculation	decorateObject (const xAOD::Egamma *&egamma) const

Private Attributes
SG::ReadHandleKey< xAOD::EgammaContainer >	m_SGKey_photons { this, "SGKey_photons", "", "SG key of photon container" }
SG::ReadHandleKey< xAOD::EgammaContainer >	m_SGKey_electrons
std::string	m_decorationPattern
std::map< int, std::string >	m_gainNames
std::vector< unsigned int >	m_layers
std::map< std::pair< int, int >, std::string >	m_names_E
std::map< std::pair< int, int >, std::string >	m_names_rnoW
std::map< std::pair< int, int >, std::string >	m_names_nCells
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer >	m_SGKey_photons_decorations
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer >	m_SGKey_electrons_decorations

Detailed Description

Definition at line 27 of file GainDecorator.h.

Constructor & Destructor Documentation

GainDecorator()

DerivationFramework::GainDecorator::GainDecorator	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p
	)

Definition at line 22 of file GainDecorator.cxx.

  : base_class(t, n, p)
{
  declareProperty("decoration_pattern",
                  m_decorationPattern = "{info}_Lr{layer}_{gain}G");
  declareProperty("gain_names",
                  m_gainNames = { { CaloGain::LARHIGHGAIN, "Hi" },
                                  { CaloGain::LARMEDIUMGAIN, "Med" },
                                  { CaloGain::LARLOWGAIN, "Low" } });
  declareProperty("layers", m_layers = { 0, 1, 2, 3 });
 
  // Define the names for the decorations
  for (const auto& kv : m_gainNames)
    for (const auto layer : m_layers) {
      std::string name = m_decorationPattern;
      name.replace(name.find("{layer}"),
                   std::string("{layer}").size(),
                   std::to_string(layer));
      name.replace(
        name.find("{gain}"), std::string("{gain}").size(), kv.second);
      std::string name_E(name), name_rnoW(name), name_nCells(name);
      name_E.replace(name_E.find("{info}"), std::string("{info}").size(), "E");
      name_rnoW.replace(name_rnoW.find("{info}"), std::string("{info}").size(), "rnoW");
      name_nCells.replace(
        name_nCells.find("{info}"), std::string("{info}").size(), "nCells");
 
      std::pair<int, int> key(kv.first, layer);
      m_names_E[key] = name_E;
      m_names_rnoW[key] = name_rnoW;
      m_names_nCells[key] = name_nCells;
    }
 
  for (const auto& kv : m_names_E) {
    ATH_MSG_DEBUG("Decorating (layer, gain): " << kv.first << " " << kv.second);
  }
  for (const auto& kv : m_names_nCells) {
    ATH_MSG_DEBUG("Decorating (layer, gain): " << kv.first << " " << kv.second);
  }
}

~GainDecorator()

DerivationFramework::GainDecorator::~GainDecorator ( )

default

Member Function Documentation

addBranches()

StatusCode DerivationFramework::GainDecorator::addBranches ( ) const

virtual

Definition at line 129 of file GainDecorator.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // Photon decorations
 
  if (!m_SGKey_photons.key().empty()) {
 
    // Retrieve photon container
    SG::ReadHandle<xAOD::EgammaContainer> photonContainer(m_SGKey_photons, ctx);
    const xAOD::EgammaContainer* importedPhotons = photonContainer.ptr();
 
    // Setup vectors of photon decorations
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, float>>
      decorations_E;
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, float>>
      decorations_rnoW;
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, char>>
      decorations_nCells;
    int i(0);
    for (const auto& kv : m_gainNames) {
      for (const auto layer : m_layers) {
        std::pair<int, int> key(kv.first, layer);
        decorations_E.emplace_back(
          
            m_SGKey_photons_decorations[i * 3], ctx);
        decorations_rnoW.emplace_back(
          
            m_SGKey_photons_decorations[i * 3 + 1], ctx);
        decorations_nCells.emplace_back(
          
            m_SGKey_photons_decorations[i * 3 + 2], ctx);
        i++;
      }
    }
 
    // Decorate photons
    for (const auto* photon : *importedPhotons) {
      DerivationFramework::GainDecorator::calculation res =
        decorateObject(photon);
      i = 0;
      for (const auto& kv : m_gainNames) {
        for (const auto layer : m_layers) {
          std::pair<int, int> key(kv.first, layer);
          decorations_E[i](*photon) = res.E[key];
          decorations_rnoW[i](*photon) =
        res.EnoW[key] != 0 ? res.E[key]/res.EnoW[key] : 1;
          decorations_nCells[i](*photon) = res.nCells[key];
          i++;
        }
      }
    }
  }
 
  // Electron decorations
 
  if (!m_SGKey_electrons.key().empty()) {
 
    // Retrieve electron container
    SG::ReadHandle<xAOD::EgammaContainer> electronContainer(m_SGKey_electrons,
                                                            ctx);
    const xAOD::EgammaContainer* importedElectrons = electronContainer.ptr();
 
    // Setup vectors of electron decorations
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, float>>
      decorations_E;
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, float>>
      decorations_rnoW;
    std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, char>>
      decorations_nCells;
    int i(0);
    for (const auto& kv : m_gainNames) {
      for (const auto layer : m_layers) {
        std::pair<int, int> key(kv.first, layer);
        decorations_E.emplace_back(
          
            m_SGKey_electrons_decorations[i * 3], ctx);
        decorations_rnoW.emplace_back(
          
            m_SGKey_electrons_decorations[i * 3 + 1], ctx);
        decorations_nCells.emplace_back(
          
            m_SGKey_electrons_decorations[i * 3 + 2], ctx);
        i++;
      }
    }
 
    // Decorate electrons
    for (const auto* electron : *importedElectrons) {
      DerivationFramework::GainDecorator::calculation res =
        decorateObject(electron);
      i = 0;
      for (const auto& kv : m_gainNames) {
        for (const auto layer : m_layers) {
          std::pair<int, int> key(kv.first, layer);
          decorations_E[i](*electron) = res.E[key];
          decorations_rnoW[i](*electron) =
        res.EnoW[key] != 0 ? res.E[key]/res.EnoW[key] : 1;
          decorations_nCells[i](*electron) = res.nCells[key];
          i++;
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

decorateObject()

DerivationFramework::GainDecorator::calculation DerivationFramework::GainDecorator::decorateObject ( const xAOD::Egamma *&  egamma ) const

private

Definition at line 238 of file GainDecorator.cxx.

{
 
  // Compute energy and number of cells per gain per layer
  // Set the initial values to 0 (needed?)
  DerivationFramework::GainDecorator::calculation result;
  for (const auto& kv : m_names_E) {
    result.E[kv.first] = 0.;
    result.EnoW[kv.first] = 0.;
    result.nCells[kv.first] = 0;
  }
 
  // Skip the computation for missing cell links (like topo-seeded photons)
  // but decorate anyway
  const CaloClusterCellLink* cellLinks =
    egamma->caloCluster() ? egamma->caloCluster()->getCellLinks() : nullptr;
  if (cellLinks) {
    CaloClusterCellLink::const_iterator it = cellLinks->begin(),
      itE = cellLinks->end();
    for (; it != itE; ++it) {
      const CaloCell *cell = *it;
      if (!cell)
        continue;
      std::pair<int, int> key(static_cast<int>(cell->gain()), getLayer(cell));
      // Increment the corresponding entry (not important if it is not
      // initialised)
      double weight = it.weight();
      result.E[key] += cell->energy()*weight;
      result.EnoW[key] += cell->energy();
      result.nCells[key]++;
    }
  }
 
  return result;
}

finalize()

StatusCode DerivationFramework::GainDecorator::finalize

(

)

Definition at line 121 of file GainDecorator.cxx.

{
 
  return StatusCode::SUCCESS;
}

getLayer()

int DerivationFramework::GainDecorator::getLayer ( const CaloCell *  cell )

static

Definition at line 276 of file GainDecorator.cxx.

{
  int sampling =
    (cell && cell->caloDDE() ? cell->caloDDE()->getSampling() : -1);
  if (sampling == CaloSampling::PreSamplerB ||
      sampling == CaloSampling::PreSamplerE)
    return 0;
  if (sampling == CaloSampling::EMB1 || sampling == CaloSampling::EME1)
    return 1;
  if (sampling == CaloSampling::EMB2 || sampling == CaloSampling::EME2)
    return 2;
  if (sampling == CaloSampling::EMB3 || sampling == CaloSampling::EME3)
    return 3;
  return -1;
}

initialize()

StatusCode DerivationFramework::GainDecorator::initialize

(

)

Definition at line 69 of file GainDecorator.cxx.

{
  ATH_MSG_VERBOSE("initialize() ...");
 
  if (m_SGKey_photons.key().empty() && m_SGKey_electrons.key().empty()) {
    ATH_MSG_FATAL("No e-gamma collection provided for thinning. At least one "
                  "egamma collection (photons/electrons) must be provided!");
    return StatusCode::FAILURE;
  }
 
  if (!m_SGKey_electrons.key().empty()) {
    ATH_MSG_DEBUG("Using " << m_SGKey_electrons << " for electrons");
    ATH_CHECK(m_SGKey_electrons.initialize());
 
    const std::string containerKey = m_SGKey_electrons.key();
    for (const auto& kv : m_gainNames) {
      for (const auto layer : m_layers) {
        std::pair<int, int> key(kv.first, layer);
        m_SGKey_electrons_decorations.emplace_back(containerKey + "." +
                                                   m_names_E[key]);
        m_SGKey_electrons_decorations.emplace_back(containerKey + "." +
                                                   m_names_rnoW[key]);
        m_SGKey_electrons_decorations.emplace_back(containerKey + "." +
                                                   m_names_nCells[key]);
      }
    }
    ATH_CHECK(m_SGKey_electrons_decorations.initialize());
  }
 
  if (!m_SGKey_photons.key().empty()) {
    ATH_MSG_DEBUG("Using " << m_SGKey_photons << " for photons");
    ATH_CHECK(m_SGKey_photons.initialize());
 
    const std::string containerKey = m_SGKey_photons.key();
    for (const auto& kv : m_gainNames) {
      for (const auto layer : m_layers) {
        std::pair<int, int> key(kv.first, layer);
        m_SGKey_photons_decorations.emplace_back(containerKey + "." +
                                                 m_names_E[key]);
        m_SGKey_photons_decorations.emplace_back(containerKey + "." +
                                                 m_names_rnoW[key]);
        m_SGKey_photons_decorations.emplace_back(containerKey + "." +
                                                 m_names_nCells[key]);
      }
    }
    ATH_CHECK(m_SGKey_photons_decorations.initialize());
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_decorationPattern

std::string DerivationFramework::GainDecorator::m_decorationPattern

private

Definition at line 57 of file GainDecorator.h.

m_gainNames

std::map<int, std::string> DerivationFramework::GainDecorator::m_gainNames

private

Definition at line 58 of file GainDecorator.h.

m_layers

std::vector<unsigned int> DerivationFramework::GainDecorator::m_layers

private

Definition at line 59 of file GainDecorator.h.

m_names_E

std::map<std::pair<int, int>, std::string> DerivationFramework::GainDecorator::m_names_E

private

Definition at line 62 of file GainDecorator.h.

m_names_nCells

std::map<std::pair<int, int>, std::string> DerivationFramework::GainDecorator::m_names_nCells

private

Definition at line 64 of file GainDecorator.h.

m_names_rnoW

std::map<std::pair<int, int>, std::string> DerivationFramework::GainDecorator::m_names_rnoW

private

Definition at line 63 of file GainDecorator.h.

m_SGKey_electrons

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::GainDecorator::m_SGKey_electrons

private

Initial value:

{
    this,
    "SGKey_electrons",
    "",
    "SG key of electron container"
  }

Definition at line 50 of file GainDecorator.h.

m_SGKey_electrons_decorations

SG::WriteDecorHandleKeyArray<xAOD::EgammaContainer> DerivationFramework::GainDecorator::m_SGKey_electrons_decorations

private

Initial value:

{
      this,
      "SGKey_electrons_decorations_noConf",
      {},
      "SG keys for electrons decorations not really configurable"
    }

Definition at line 75 of file GainDecorator.h.

m_SGKey_photons

SG::ReadHandleKey<xAOD::EgammaContainer> DerivationFramework::GainDecorator::m_SGKey_photons { this, "SGKey_photons", "", "SG key of photon container" }

private

Definition at line 48 of file GainDecorator.h.

m_SGKey_photons_decorations

SG::WriteDecorHandleKeyArray<xAOD::EgammaContainer> DerivationFramework::GainDecorator::m_SGKey_photons_decorations

private

Initial value:

{
      this,
      "SGKey_photons_decorations_noConf",
      {},
      "SG keys for photon decorations not really configurable"
    }

Definition at line 67 of file GainDecorator.h.

---

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

• GainDecorator.h
• GainDecorator.cxx