DerivationFramework::EGammaCookieCutClusterTool Class Reference

#include <EGammaCookieCutClusterTool.h>

Inheritance diagram for DerivationFramework::EGammaCookieCutClusterTool:

Collaboration diagram for DerivationFramework::EGammaCookieCutClusterTool:

Public Member Functions
	EGammaCookieCutClusterTool (const std::string &t, const std::string &n, const IInterface *p)
StatusCode	initialize () override final
virtual StatusCode	addBranches () 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: name taken from 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 25 of file EGammaCookieCutClusterTool.h.

Constructor & Destructor Documentation

EGammaCookieCutClusterTool()

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

Definition at line 21 of file EGammaCookieCutClusterTool.cxx.

  : base_class(t, n, p)
{
}

Member Function Documentation

addBranches()

StatusCode DerivationFramework::EGammaCookieCutClusterTool::addBranches ( ) const

finaloverridevirtual

Definition at line 86 of file EGammaCookieCutClusterTool.cxx.

{
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // 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 ( )

finaloverride

Definition at line 32 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());
  m_outClusterContainerCellLinkKey = m_outClusterContainerKey.key() + "_links";
  ATH_CHECK(m_outClusterContainerCellLinkKey.initialize());
 
  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& e : m_vecMName) {
    std::string key;
    if (m_storeCookMom) {
      key = containerKey + ".cookiecut" + e;
      m_SGKey_electrons_decorations.emplace_back(key);
    }
    if (m_storeOrigMom) {
      key = containerKey + ".original" + e;
      m_SGKey_electrons_decorations.emplace_back(key);
    }
  }
  m_SGKey_electrons_decorations.emplace_back(
     containerKey + ".cookiecutClusterLink");
  // 
  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 " << containerKey);
    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 49 of file EGammaCookieCutClusterTool.h.

m_clusterCorrectionTools

ToolHandleArray<CaloClusterCollectionProcessor> DerivationFramework::EGammaCookieCutClusterTool::m_clusterCorrectionTools

private

Initial value:

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

Definition at line 136 of file EGammaCookieCutClusterTool.h.

m_CookieCutPars

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

private

Definition at line 111 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 72 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 80 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 88 of file EGammaCookieCutClusterTool.h.

m_nDecor

unsigned short DerivationFramework::EGammaCookieCutClusterTool::m_nDecor = 0

private

Definition at line 114 of file EGammaCookieCutClusterTool.h.

m_outClusterContainerCellLinkKey

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

private

Output cluster container cell links: name taken from containter name.

Definition at line 46 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 38 of file EGammaCookieCutClusterTool.h.

m_Seen

std::once_flag DerivationFramework::EGammaCookieCutClusterTool::m_Seen

mutableprivate

Definition at line 113 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 56 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_noConf",
    {},
    "SG keys for electrons decorations not really configurable"
        }

Definition at line 64 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 104 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 96 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 115 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 125 of file EGammaCookieCutClusterTool.h.

---

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

• EGammaCookieCutClusterTool.h
• EGammaCookieCutClusterTool.cxx