DerivationFramework::EGammaCookieCutClusterTool Class Reference

#include <EGammaCookieCutClusterTool.h>

Inheritance diagram for DerivationFramework::EGammaCookieCutClusterTool:

Collaboration diagram for DerivationFramework::EGammaCookieCutClusterTool:

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

Private Attributes
SG::WriteHandleKey< xAOD::CaloClusterContainer >	m_outClusterContainerKey
	Output cluster container. More...
SG::WriteHandleKey< CaloClusterCellLinkContainer >	m_outClusterContainerCellLinkKey
	Output cluster container cell links: should match output containter name. More...
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey
	Calorimeter description. More...
SG::ReadHandleKey< xAOD::EgammaContainer >	m_SGKey_electrons
SG::WriteDecorHandleKeyArray< xAOD::EgammaContainer >	m_SGKey_electrons_decorations
Gaudi::Property< int >	m_maxDelEtaCells
	Size of maximum search window in eta. More...
Gaudi::Property< int >	m_maxDelPhiCells
	Size of maximum search window in phi. More...
Gaudi::Property< float >	m_maxDelR
	Size of cone to cookie cut on FCal. More...
Gaudi::Property< bool >	m_storeOrigMom
	Decide whether or not to store input cluster moments. More...
Gaudi::Property< bool >	m_storeCookMom
	Decide whether or not to store cooked cluster moments. More...
egammaClusterCookieCut::CookieCutPars	m_CookieCutPars {}
std::once_flag	m_Seen
unsigned short	m_nDecor = 0
const std::vector< xAOD::CaloCluster::MomentType >	m_vecM
const std::vector< std::string >	m_vecMName
ToolHandleArray< CaloClusterCollectionProcessor >	m_clusterCorrectionTools

Detailed Description

Definition at line 21 of file EGammaCookieCutClusterTool.h.

Member Function Documentation

addBranches()

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

finaloverridevirtual

Definition at line 57 of file EGammaCookieCutClusterTool.cxx.

{
 
  // For debug
  static const std::vector<CaloSampling::CaloSample> s_sam
    { CaloSampling::PreSamplerB, CaloSampling::EMB1,
      CaloSampling::EMB2, CaloSampling::EMB3,
      CaloSampling::PreSamplerE, CaloSampling::EME1,
      CaloSampling::EME2, CaloSampling::EME3,
      CaloSampling::TileBar0, CaloSampling::TileBar1, CaloSampling::TileBar2,
      CaloSampling::TileExt0, CaloSampling::TileExt1, CaloSampling::TileExt2,
      CaloSampling::TileGap1, CaloSampling::TileGap2, CaloSampling::TileGap3,
      CaloSampling::HEC0, CaloSampling::HEC1,
      CaloSampling::HEC2, CaloSampling::HEC3,
      CaloSampling::FCAL0, CaloSampling::FCAL1, CaloSampling::FCAL2 };
 
  // Create the relevant cluster output and register it.
  SG::WriteHandle<xAOD::CaloClusterContainer> outClusterContainer(
                                                                  m_outClusterContainerKey,
                                                                  ctx
                                                                  );
  ATH_CHECK(CaloClusterStoreHelper::AddContainerWriteHandle(outClusterContainer));
 
  SG::WriteHandle<CaloClusterCellLinkContainer> outClusterContainerCellLink(
                                                                            m_outClusterContainerCellLinkKey,
                                                                            ctx
                                                                            );
  ATH_CHECK(outClusterContainerCellLink.record(
                                               std::make_unique<CaloClusterCellLinkContainer>())
            );
 
  // Retrieve electron container
  SG::ReadHandle<xAOD::EgammaContainer> electronContainer(m_SGKey_electrons,
                                                          ctx);
  const std::size_t nF = electronContainer.ptr()->size();
  if (nF == 0) {
    return StatusCode::SUCCESS;
  }
 
  std::vector<SG::WriteDecorHandle<xAOD::EgammaContainer, float>> decoM;
  decoM.reserve(m_nDecor);
  for (int i = 0; i < m_nDecor - 1; i++) {
    decoM.emplace_back(m_SGKey_electrons_decorations[i], ctx);
  }
 
  if (msgLevel(MSG::DEBUG)) {
    std::call_once(m_Seen, [this,&decoM]() {
      for (int i = 0; i < m_nDecor - 1; i++) {
        ATH_MSG_DEBUG("Decor " << i << " out of " << m_nDecor
                      << " " << m_SGKey_electrons_decorations[i].key()
                      << " " << decoM[i].decorKey());
      }
    });
  }
  SG::WriteDecorHandle<xAOD::EgammaContainer,
                       ElementLink<xAOD::CaloClusterContainer>>
    decoEl(m_SGKey_electrons_decorations[m_nDecor-1],ctx);
 
  // Calorimeter description.
  SG::ReadCondHandle<CaloDetDescrManager> caloDetDescrMgrHandle{
    m_caloDetDescrMgrKey, ctx
  };
  ATH_CHECK(caloDetDescrMgrHandle.isValid());
  const CaloDetDescrManager* calodetdescrmgr = *caloDetDescrMgrHandle;
 
  // Decorate electrons
  int iel = 0;
  std::vector<bool> success(nF,true);
  ATH_MSG_VERBOSE("Will analyze " << nF << " forward electrons");
  for (const auto* electron : *electronContainer.ptr()) {
 
    const xAOD::CaloCluster *cluster = electron->caloCluster();
    ATH_MSG_DEBUG("Electron " << electron->index() << " cluster"
                  << " pT = " << cluster->pt()
                  << " eta = " << cluster->eta());
 
    const DataLink<CaloCellContainer>& cellCont =
      cluster->getCellLinks()->getCellContainerLink();
 
    std::unique_ptr<xAOD::CaloCluster> newCluster =
      egammaClusterCookieCut::cookieCut(*cluster, *calodetdescrmgr,
                                        cellCont, m_CookieCutPars);
 
    if (!newCluster || newCluster->getCellLinks()->size() == 0) {
      ATH_MSG_DEBUG("No able to build a new cluster for electron "
                    << electron->index()
                    << " pT = " << electron->pt()
                    << " eta = " << electron->eta()
                    << " original cluster " << cluster->index()
                    << " pT = " << cluster->pt()
                    << " eta = " << cluster->eta()
                    << " has EME2 or FCAL0"
                    << " " << cluster->hasSampling(CaloSampling::EME2)
                    << " " << cluster->hasSampling(CaloSampling::FCAL0)
                    << " reason : "
                    << (newCluster ? " no cells in cluster" : " no cluster"));
      if (!newCluster) {
        ATH_MSG_VERBOSE("Energies in various samplings :");
        for (auto s : s_sam)
          ATH_MSG_VERBOSE("Sampling " << s << " E = " << cluster->eSample(s));
      }
      decoEl(*electron) = ElementLink<xAOD::CaloClusterContainer>();
      success[iel] = false;
    }
 
    if (success[iel]) {
      if (newCluster) {
        ATH_MSG_DEBUG("Cookie cut cluster"
                      << " pT = " << newCluster->pt()
                      << " eta = " << newCluster->eta());
      }
      outClusterContainer->push_back(std::move(newCluster));
      size_t index = outClusterContainer->size() - 1;
      ElementLink<xAOD::CaloClusterContainer>
        clusterLink(*outClusterContainer, index, ctx);
      // Now decorate the electron with the link to cookie cut cluster
      decoEl(*electron) = clusterLink;
    }
 
    // Eventually decorate the electron with the original moment
    if (m_storeOrigMom) {
      for (size_t i = 0; i < m_vecM.size(); i++) {
        int indexDecor = m_storeCookMom ? 2*i+1 : i;
        double m = 0.;
        bool gotM = cluster->retrieveMoment(m_vecM.at(i), m);
        if (!gotM) {
          ATH_MSG_VERBOSE(m_vecMName[i]
                          << " does not exist for the original cluster");
        }
        decoM[indexDecor](*electron) = float(m);
        ATH_MSG_VERBOSE("Decorated electron " << electron->index()
                        << " with original moment "
                        << i << " " << m_vecMName[i]
                        << " = " << m << " (decoration index =" << indexDecor
                        << " key = " << decoM[indexDecor].decorKey() << ")");
      }
    }
    iel++;
  }
 
  if (!m_clusterCorrectionTools.empty()) {
    ToolHandleArray<CaloClusterCollectionProcessor>::const_iterator
      toolIt = m_clusterCorrectionTools.begin(),
      toolIt_e = m_clusterCorrectionTools.end();
    for (; toolIt != toolIt_e; ++toolIt) {
      ATH_CHECK((*toolIt)->execute(ctx, outClusterContainer.ptr()));
    }
 
    if (m_storeCookMom) {
      static const SG::AuxElement::Accessor<
        ElementLink< xAOD::CaloClusterContainer > >
        cookClusLinkAcc( "cookiecutClusterLink" );
      iel = 0;
      for (const auto* electron : *electronContainer.ptr()) {
        const xAOD::CaloCluster *cluster = nullptr;
        if (success[iel] && cookClusLinkAcc.isAvailable(*electron)) {
          const ElementLink< xAOD::CaloClusterContainer >& link =
            cookClusLinkAcc(*electron);
          if (link.isValid()) {
            cluster = *link;
          }
        }
        if (success[iel] && cluster == nullptr) {
          ATH_MSG_WARNING("CookieCut cluster was build successfully, but"
                          "could not be retrieved");
        }
 
        for (size_t i = 0; i < m_vecM.size(); i++) {
          int indexDecor = m_storeOrigMom ? 2*i : i;
          double m = 0.;
          if (cluster) {
            bool gotM = cluster->retrieveMoment(m_vecM.at(i), m);
            if (!gotM) {
              ATH_MSG_VERBOSE(m_vecMName[i]
                              << " does not exist for the new cluster");
            }
          }
          decoM[indexDecor](*electron) = float(m);
          ATH_MSG_VERBOSE("Decorated electron " << electron->index()
                          << " with new moment "
                          << i << " " << m_vecMName[i]
                          << " = " << m << " (decoration index = " << indexDecor
                          << " key = " << decoM[indexDecor].decorKey() << ")");
        }
      }
    }
  }
 
  CaloClusterStoreHelper::finalizeClusters(
                                           ctx,
                                           outClusterContainer,
                                           outClusterContainerCellLink);
 
  ATH_MSG_DEBUG("Built " << outClusterContainer.ptr()->size()
                << " cookie cut clusters");
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode DerivationFramework::EGammaCookieCutClusterTool::initialize ( )

finaloverridevirtual

Definition at line 19 of file EGammaCookieCutClusterTool.cxx.

{
  ATH_MSG_VERBOSE("initialize() ...");
 
  ATH_CHECK(m_caloDetDescrMgrKey.initialize());
 
  ATH_MSG_DEBUG("Will store cookie cut clusters in this container "
                << m_outClusterContainerKey.key());
  ATH_CHECK(m_outClusterContainerKey.initialize());
  ATH_CHECK(m_outClusterContainerCellLinkKey.initialize());
 
  ATH_MSG_DEBUG("Using " << m_SGKey_electrons << " for electrons");
  ATH_CHECK(m_SGKey_electrons.initialize());
 
  m_nDecor = m_SGKey_electrons_decorations.size();
  ATH_MSG_DEBUG("Initialize nDecor = " << m_nDecor);
  ATH_CHECK(m_SGKey_electrons_decorations.initialize());
  if (msgLvl(MSG::DEBUG)) {
    ATH_MSG_DEBUG("Decorations for " << m_SGKey_electrons.key());
    for (const auto& s : m_SGKey_electrons_decorations)
      { ATH_MSG_DEBUG(s.key()); }
  }
 
  m_CookieCutPars.maxDelEta = m_maxDelEtaCells * cellEtaSize * 0.5;
  m_CookieCutPars.maxDelPhi = m_maxDelPhiCells * cellPhiSize * 0.5;
  m_CookieCutPars.maxDelR2  = m_maxDelR * m_maxDelR;
 
  // Retrieve cluster moment maker in case we cookie cut and want to recompute
  if (!m_clusterCorrectionTools.empty()) {
    ATH_CHECK(m_clusterCorrectionTools.retrieve());
    m_CookieCutPars.recomputeMoments = true;
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> DerivationFramework::EGammaCookieCutClusterTool::m_caloDetDescrMgrKey

private

Initial value:

{
      this,
      "CaloDetDescrManager",
      "CaloDetDescrManager",
      "SG Key for CaloDetDescrManager in the Condition Store"
    }

Calorimeter description.

Definition at line 50 of file EGammaCookieCutClusterTool.h.

m_clusterCorrectionTools

ToolHandleArray<CaloClusterCollectionProcessor> DerivationFramework::EGammaCookieCutClusterTool::m_clusterCorrectionTools

private

Initial value:

{
      this,
      "ClusterMomentMaker",
      {},
      "The moment maker"
    }

Definition at line 137 of file EGammaCookieCutClusterTool.h.

m_CookieCutPars

egammaClusterCookieCut::CookieCutPars DerivationFramework::EGammaCookieCutClusterTool::m_CookieCutPars {}

private

Definition at line 112 of file EGammaCookieCutClusterTool.h.

m_maxDelEtaCells

Gaudi::Property<int> DerivationFramework::EGammaCookieCutClusterTool::m_maxDelEtaCells

private

Initial value:

{
      this,
      "MaxWindowDelEtaCells",
      3,
      "Size of maximum search window in eta"
    }

Size of maximum search window in eta.

Definition at line 73 of file EGammaCookieCutClusterTool.h.

m_maxDelPhiCells

Gaudi::Property<int> DerivationFramework::EGammaCookieCutClusterTool::m_maxDelPhiCells

private

Initial value:

{
      this,
      "MaxWindowDelPhiCells",
      3,
      "Size of maximum search window in phi"
    }

Size of maximum search window in phi.

Definition at line 81 of file EGammaCookieCutClusterTool.h.

m_maxDelR

Gaudi::Property<float> DerivationFramework::EGammaCookieCutClusterTool::m_maxDelR

private

Initial value:

{
      this,
      "MaxWindowDelR",
      0.3,
      "Cone size to collect cells around hottest-cell FCAL"
    }

Size of cone to cookie cut on FCal.

Definition at line 89 of file EGammaCookieCutClusterTool.h.

m_nDecor

unsigned short DerivationFramework::EGammaCookieCutClusterTool::m_nDecor = 0

private

Definition at line 115 of file EGammaCookieCutClusterTool.h.

m_outClusterContainerCellLinkKey

SG::WriteHandleKey<CaloClusterCellLinkContainer> DerivationFramework::EGammaCookieCutClusterTool::m_outClusterContainerCellLinkKey

private

Initial value:

{
      this,
        "ClusterContainerLinksName",
        "ForwardElectronCookieCutClusters_links",
        "Name of the output cluster container cell links container"
        }

Output cluster container cell links: should match output containter name.

Definition at line 42 of file EGammaCookieCutClusterTool.h.

m_outClusterContainerKey

SG::WriteHandleKey<xAOD::CaloClusterContainer> DerivationFramework::EGammaCookieCutClusterTool::m_outClusterContainerKey

private

Initial value:

{
      this,
        "ClusterContainerName",
        "ForwardElectronCookieCutClusters",
        "Name of the output cookie cut cluster container"
        }

Output cluster container.

Definition at line 34 of file EGammaCookieCutClusterTool.h.

m_Seen

std::once_flag DerivationFramework::EGammaCookieCutClusterTool::m_Seen

mutableprivate

Definition at line 114 of file EGammaCookieCutClusterTool.h.

m_SGKey_electrons

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

private

Initial value:

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

Definition at line 57 of file EGammaCookieCutClusterTool.h.

m_SGKey_electrons_decorations

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

private

Initial value:

{
      this,
      "SGKey_electrons_decorations",
      m_SGKey_electrons, {},
      "SG keys for electrons decorations"
    }

Definition at line 65 of file EGammaCookieCutClusterTool.h.

m_storeCookMom

Gaudi::Property<bool> DerivationFramework::EGammaCookieCutClusterTool::m_storeCookMom

private

Initial value:

{
      this,
      "StoreCookedMoments",
      false,
      "Decorate also with the moments from the cookie-cut cluster"
    }

Decide whether or not to store cooked cluster moments.

Definition at line 105 of file EGammaCookieCutClusterTool.h.

m_storeOrigMom

Gaudi::Property<bool> DerivationFramework::EGammaCookieCutClusterTool::m_storeOrigMom

private

Initial value:

{
      this,
      "StoreInputMoments",
      false,
      "Decorate also with the moments from the original cluster"
    }

Decide whether or not to store input cluster moments.

Definition at line 97 of file EGammaCookieCutClusterTool.h.

m_vecM

const std::vector<xAOD::CaloCluster::MomentType> DerivationFramework::EGammaCookieCutClusterTool::m_vecM

private

Initial value:

{
      xAOD::CaloCluster::SECOND_LAMBDA,
      xAOD::CaloCluster::LATERAL,
      xAOD::CaloCluster::LONGITUDINAL,
      xAOD::CaloCluster::ENG_FRAC_MAX,
      xAOD::CaloCluster::SECOND_R,
      xAOD::CaloCluster::CENTER_LAMBDA,
      xAOD::CaloCluster::SECOND_ENG_DENS,
      xAOD::CaloCluster::SIGNIFICANCE
    }

Definition at line 116 of file EGammaCookieCutClusterTool.h.

m_vecMName

const std::vector<std::string> DerivationFramework::EGammaCookieCutClusterTool::m_vecMName

private

Initial value:

{
      "SECOND_LAMBDA",
      "LATERAL",
      "LONGITUDINAL",
      "ENG_FRAC_MAX",
      "SECOND_R",
      "CENTER_LAMBDA",
      "SECOND_ENG_DENS",
      "SIGNIFICANCE"
    }

Definition at line 126 of file EGammaCookieCutClusterTool.h.

---

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

• EGammaCookieCutClusterTool.h
• EGammaCookieCutClusterTool.cxx