egammaCaloClusterSelector Class Reference

A tool which specifies whether a cluster passes a selection. More...

#include <egammaCaloClusterSelector.h>

Inheritance diagram for egammaCaloClusterSelector:

Collaboration diagram for egammaCaloClusterSelector:

Public Member Functions
	egammaCaloClusterSelector (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override final
virtual StatusCode	finalize () override final
bool	passSelection (const xAOD::CaloCluster *cluster, const CaloDetDescrManager &cmgr) const override final
	pass the selection described in the class egammaCaloClusterSelector More...

Private Attributes
SG::ReadHandleKey< CaloCellContainer >	m_cellsKey
	Name of the cluster intput collection. More...
ToolHandle< IegammaCheckEnergyDepositTool >	m_egammaCheckEnergyDepositTool
	Pointer to the egammaCheckEnergyDepositTool. More...
ToolHandle< IegammaIso >	m_HadronicLeakageTool
	Tool for hadronic leakage calculation; onlud used if cuts needing are defined. More...
Gaudi::Property< double >	m_ClusterEtCut
Gaudi::Property< double >	m_EMEtCut
Gaudi::Property< double >	m_EMEtSplittingFraction
Gaudi::Property< double >	m_EMFCut
Gaudi::Property< double >	m_RetaCut
Gaudi::Property< double >	m_HadLeakCut
bool	m_doReta {false}
bool	m_doHadLeak {false}

Static Private Attributes
static constexpr double	RETA_DEFAULT_NO_CUT = 0.0
static constexpr double	HAD_LEAK_DEFAULT_NO_CUT = 999.

Detailed Description

A tool which specifies whether a cluster passes a selection.

The tool implements the IegammaCaloClusterSelector interface which provides the passSelection method. It selects xAOD::CaloCluster based on their properties in this order:

• minimum et
• cut on the fraction of the energy in the layers, by default using egammaCheckEnergyDepositTool (e.g. minimum energy fraction in 2nd layer, maximum fraction in PS, ...)
• having a second sampling (CaloSampling::EMB2 or CaloSampling::EME2)
• |eta| in the second layer not above 10
• energy in the second layer not below 50 MeV
• minimum transverse EM energy (considering rescaling, EM energy -> EM energy / EMEtSplittingFraction, for cluster in the crack; usually the rescaling increase the EM energy so loosing the cut, see ATLASRECTS-4772)
• minimum EM fraction
• maximum Reta
• maximum hadronic fraction: ethad / EMEt (ethad1 is used outside 0.8-1.37 eta2)

Several selection can be disabled. The cut on Reta and hadronic fraction are done if cut values are specified. The cut on the fraction of the energy is done only if egammaCheckEnergyDepositTool is spefified. See ATLASRECTS-5765.

The tool is generic, but it is used in egamma reconstruction by CaloClusterROI_Selector and egammaSelectedTrackCopy

Definition at line 47 of file egammaCaloClusterSelector.h.

Constructor & Destructor Documentation

egammaCaloClusterSelector()

egammaCaloClusterSelector::egammaCaloClusterSelector	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 15 of file egammaCaloClusterSelector.cxx.

                                                                               :
  base_class(type, name, parent)
{
}

Member Function Documentation

finalize()

StatusCode egammaCaloClusterSelector::finalize ( )

finaloverridevirtual

Definition at line 45 of file egammaCaloClusterSelector.cxx.

{
  return StatusCode::SUCCESS;
}

initialize()

StatusCode egammaCaloClusterSelector::initialize ( )

finaloverridevirtual

Definition at line 22 of file egammaCaloClusterSelector.cxx.

{
  if (!m_egammaCheckEnergyDepositTool.empty()) {
    ATH_CHECK( m_egammaCheckEnergyDepositTool.retrieve() );
  } else {
    m_egammaCheckEnergyDepositTool.disable();
  }
 
  //Shower Shape tools
  //Initialize tools when non-default values are given
  m_doReta = (m_RetaCut != RETA_DEFAULT_NO_CUT);
  m_doHadLeak = (m_HadLeakCut != HAD_LEAK_DEFAULT_NO_CUT);
  ATH_CHECK(m_cellsKey.initialize(m_doReta||m_doHadLeak));
 
  if (m_doHadLeak) {
    ATH_CHECK(m_HadronicLeakageTool.retrieve());
  } else {
    m_HadronicLeakageTool.disable();
  }
 
  return StatusCode::SUCCESS;
}

passSelection()

bool egammaCaloClusterSelector::passSelection ( const xAOD::CaloCluster *  cluster, const CaloDetDescrManager &  cmgr  ) const

finaloverride

pass the selection described in the class egammaCaloClusterSelector

Definition at line 50 of file egammaCaloClusterSelector.cxx.

                                                                           {
 
  // Minimum Cluster energy
  if (cluster->et() < m_ClusterEtCut) {
    ATH_MSG_DEBUG("Cluster failed Energy Cut: dont make ROI");
    return false;
  }
 
  // Accept all clusters in the FCAL
  if (xAOD::EgammaHelpers::isFCAL(cluster)){
    return true;
  }
  
  // Sanity check to catch extreme eta values
  const double eta2 = std::abs(cluster->etaBE(2));
  if (eta2 > 10) {
    return false;
  }
 
  // Check energy deposit if requested
  if (!m_egammaCheckEnergyDepositTool.empty() &&
      !m_egammaCheckEnergyDepositTool->checkFractioninSamplingCluster(cluster)) {
    ATH_MSG_DEBUG("Cluster failed sample check: dont make ROI");
    return false;
  }
 
  // Check second sampling is present
  if (!cluster->hasSampling(CaloSampling::EMB2) && !cluster->hasSampling(CaloSampling::EME2)){
      return false;
  }
  // minimum energy reconstructed in 2nd sampling
  constexpr double EM2ENERGY_CUT = 50 * MeV;
  if (cluster->energyBE(2) < EM2ENERGY_CUT){
      return false;
  }
  // use the egamma definition of EMFrac
  // (includes presampler and TileGap3/E4, helps with eff in the crack)
  static const SG::AuxElement::ConstAccessor<float> acc("EMFraction");
  const double emFrac = acc.isAvailable(*cluster) ? acc(*cluster) : 0.;
  const double EMEnergy = cluster->e() * emFrac;
  double EMEt = EMEnergy / std::cosh(eta2);
  // cluster is in crack region
  // if at least one clustered cell in EMB and EMEC
  if (cluster->inBarrel() && cluster->inEndcap()) {
    EMEt /= m_EMEtSplittingFraction;  // rescale EMEt for clusters in the crack
  }
 
  // EMEt cut
  if (EMEt < m_EMEtCut) {
    ATH_MSG_DEBUG("Cluster failed EMEt cut: don't make ROI");
    return false;
  }
 
  // EM fraction cut
  if (emFrac < m_EMFCut) {
    ATH_MSG_DEBUG("Cluster failed EM Fraction cut: don't make ROI");
    return false;
  }
 
  // Reta and Rhad cuts
  if (m_doReta || m_doHadLeak) {
    // retrieve the cell containers
    SG::ReadHandle<CaloCellContainer> cellcoll(m_cellsKey);
    if (m_doReta) {
      egammaMiddleShape::Info info;
      StatusCode sc =
        egammaMiddleShape::execute(*cluster, cmgr, *cellcoll, info, true);
      if (sc.isFailure()) {
        ATH_MSG_WARNING("call to Middle shape returns failure for execute");
        return false;
      }
      if (info.e277<0 || info.e237<0) {
        ATH_MSG_DEBUG("Negative e277 or e237: dont make ROI");
        return false;
      }
      if (info.e277 != 0. && info.e237/info.e277 < m_RetaCut) {
        ATH_MSG_DEBUG("Cluster failed Reta test: dont make ROI");
        return false;
      }
    }
 
    if (m_doHadLeak) {
      // calculate information concerning just the hadronic leakage
      IegammaIso::Info info;
      StatusCode sc = m_HadronicLeakageTool->execute(*cluster, cmgr, *cellcoll, info);
      if ( sc.isFailure() ) {
        ATH_MSG_WARNING("call to Iso returns failure for execute");
        return false;
      }
      const double ethad1 = info.ethad1;
      const double ethad = info.ethad;
      const double raphad1 = EMEt != 0. ? ethad1 / EMEt : 0.;
      const double raphad = EMEt != 0. ? ethad / EMEt : 0.;
      if (eta2 >= 0.8 && eta2 < 1.37) {
        if (raphad > m_HadLeakCut) {
          ATH_MSG_DEBUG("Cluster failed Hadronic Leakage test: dont make ROI");
          return false;
        }
      }
      else if (raphad1 > m_HadLeakCut){
        ATH_MSG_DEBUG("Cluster failed Hadronic Leakage test: dont make ROI");
        return false;
      }
    }
  }
 
  return true;
}

Member Data Documentation

HAD_LEAK_DEFAULT_NO_CUT

constexpr double egammaCaloClusterSelector::HAD_LEAK_DEFAULT_NO_CUT = 999.

staticconstexprprivate

Definition at line 90 of file egammaCaloClusterSelector.h.

m_cellsKey

SG::ReadHandleKey<CaloCellContainer> egammaCaloClusterSelector::m_cellsKey

private

Initial value:

{this,
      "CellContainerName", "AllCalo", 
      "Names of containers which contain cells"}

Name of the cluster intput collection.

Definition at line 60 of file egammaCaloClusterSelector.h.

m_ClusterEtCut

Gaudi::Property<double> egammaCaloClusterSelector::m_ClusterEtCut

private

Initial value:

{this,
      "ClusterEtCut", 0.0, "Cut on cluster EM+Had Et"}

Definition at line 74 of file egammaCaloClusterSelector.h.

m_doHadLeak

bool egammaCaloClusterSelector::m_doHadLeak {false}

private

Definition at line 96 of file egammaCaloClusterSelector.h.

m_doReta

bool egammaCaloClusterSelector::m_doReta {false}

private

Definition at line 95 of file egammaCaloClusterSelector.h.

m_egammaCheckEnergyDepositTool

ToolHandle<IegammaCheckEnergyDepositTool> egammaCaloClusterSelector::m_egammaCheckEnergyDepositTool

private

Initial value:

{this, 
      "egammaCheckEnergyDepositTool", "",
      "Optional tool that performs basic checks of viability of cluster"}

Pointer to the egammaCheckEnergyDepositTool.

Definition at line 65 of file egammaCaloClusterSelector.h.

m_EMEtCut

Gaudi::Property<double> egammaCaloClusterSelector::m_EMEtCut

private

Initial value:

{this,
      "EMEtCut", 0.0, "EM Et cut"}

Definition at line 77 of file egammaCaloClusterSelector.h.

m_EMEtSplittingFraction

Gaudi::Property<double> egammaCaloClusterSelector::m_EMEtSplittingFraction

private

Initial value:

{this,
      "EMEtSplittingFraction", 1.0, "Apply only fraction of EMEt cut for crack region"}

Definition at line 80 of file egammaCaloClusterSelector.h.

m_EMFCut

Gaudi::Property<double> egammaCaloClusterSelector::m_EMFCut

private

Initial value:

{this,
      "EMFCut", 0.0, "Cut on cluster EM fraction"}

Definition at line 83 of file egammaCaloClusterSelector.h.

m_HadLeakCut

Gaudi::Property<double> egammaCaloClusterSelector::m_HadLeakCut

private

Initial value:

{this,
      "HadLeakCut", HAD_LEAK_DEFAULT_NO_CUT, "Cut on cluster Hadronic Leakage"}

Definition at line 91 of file egammaCaloClusterSelector.h.

m_HadronicLeakageTool

ToolHandle<IegammaIso> egammaCaloClusterSelector::m_HadronicLeakageTool

private

Initial value:

{this,
    "HadronicLeakageTool", "egammaIso", 
    "Handle of the EMCaloIsolationTool for Hadronic leakage"}

Tool for hadronic leakage calculation; onlud used if cuts needing are defined.

Definition at line 70 of file egammaCaloClusterSelector.h.

m_RetaCut

Gaudi::Property<double> egammaCaloClusterSelector::m_RetaCut

private

Initial value:

{this,
      "RetaCut", RETA_DEFAULT_NO_CUT, "Cut on cluster Reta"}

Definition at line 87 of file egammaCaloClusterSelector.h.

RETA_DEFAULT_NO_CUT

constexpr double egammaCaloClusterSelector::RETA_DEFAULT_NO_CUT = 0.0

staticconstexprprivate

Definition at line 86 of file egammaCaloClusterSelector.h.

---

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

• egammaCaloClusterSelector.h
• egammaCaloClusterSelector.cxx