CaloPerformancePropertiesOutput Class Reference

Tool that outputs certain cell and cluster properties with implications for performance to a text file. More...

#include <CaloPerformancePropertiesOutput.h>

Inheritance diagram for CaloPerformancePropertiesOutput:

Collaboration diagram for CaloPerformancePropertiesOutput:

Classes
struct	EventPerformanceInfo

Public Member Functions
	CaloPerformancePropertiesOutput (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *cluster_collection) const override
virtual StatusCode	finalize () override
virtual	~CaloPerformancePropertiesOutput ()=default

Private Attributes
Gaudi::Property< std::string >	m_fileName {this, "FileName", "event_properties.txt", "File to save the performance-related info."}
	The path specifying the folder to which the files should be saved.
SG::ReadHandleKey< CaloCellContainer >	m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}
	vector of names of the cell containers to use as input.
SG::ReadCondHandleKey< CaloNoise >	m_noiseCDOKey {this, "CaloNoiseKey", "totalNoise", "SG Key of CaloNoise data object"}
	Key of the CaloNoise Conditions data object.
Gaudi::Property< bool >	m_twoGaussianNoise {this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"}
	if set to true use 2-gaussian noise description for TileCal
Gaudi::Property< float >	m_seedThreshold {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"}
	Value to consider for the seed threshold.
Gaudi::Property< float >	m_growThreshold {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"}
	Value to consider for the seed threshold.
Gaudi::Property< float >	m_cellThreshold {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"}
	Value to consider for the seed threshold.
Gaudi::Property< bool >	m_seedCutsInAbsE {this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"}
	if set to true seed cuts are on \(|E|\) and \(|E|_\perp\).
Gaudi::Property< bool >	m_neighborCutsInAbsE {this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"}
	if set to true neighbor cuts are on \(|E|\) and \(|E|_\perp\).
Gaudi::Property< bool >	m_cellCutsInAbsE {this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"}
	if set to true cell cuts are on \(|E|\) and \(|E|_\perp\).
Gaudi::Property< std::string >	m_growNeighborOptionString
	type of neighbor relations to use for cluster growing.
LArNeighbours::neighbourOption	m_growNeighborOption
Gaudi::Property< std::string >	m_splitNeighborOptionString
	type of neighbor relations to use for cluster splitting.
LArNeighbours::neighbourOption	m_splitNeighborOption
Gaudi::Property< bool >	m_growRestrictHECIWandFCalNeighbors
	if set to true limit the neighbors in HEC IW and FCal2&3 during growing.
Gaudi::Property< bool >	m_splitRestrictHECIWandFCalNeighbors
	if set to true limit the neighbors in HEC IW and FCal2&3 during splitting.
Gaudi::Property< bool >	m_growRestrictPSNeighbors
	if set to true limit the neighbors in presampler Barrel and Endcap during growing.
Gaudi::Property< bool >	m_splitRestrictPSNeighbors
	if set to true limit the neighbors in presampler Barrel and Endcap during splitting.
const CaloCell_ID *	m_calo_id {nullptr}
	Pointer to Calo ID Helper.
std::mutex	m_mutex
	Mutex that is locked when recording info.
std::vector< EventPerformanceInfo > m_eventInfo	ATLAS_THREAD_SAFE
	Vector to hold the information.
std::vector< size_t > m_eventNumbers	ATLAS_THREAD_SAFE
	Vector to hold the event numbers to be recorded if necessary.

Detailed Description

Tool that outputs certain cell and cluster properties with implications for performance to a text file.

Author

Nuno Fernandes nuno..nosp@m.dos..nosp@m.santo.nosp@m.s.fe.nosp@m.rnand.nosp@m.es@c.nosp@m.ern.c.nosp@m.h

Date

17 September 2025

Definition at line 33 of file CaloPerformancePropertiesOutput.h.

Constructor & Destructor Documentation

CaloPerformancePropertiesOutput()

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

Definition at line 19 of file CaloPerformancePropertiesOutput.cxx.

                                                                                                                                         :
  base_class(type, name, parent)
{
}

~CaloPerformancePropertiesOutput()

virtual CaloPerformancePropertiesOutput::~CaloPerformancePropertiesOutput ( )

virtualdefault

Member Function Documentation

execute()

StatusCode CaloPerformancePropertiesOutput::execute ( const EventContext & ctx, xAOD::CaloClusterContainer * cluster_collection ) const

overridevirtual

Definition at line 85 of file CaloPerformancePropertiesOutput.cxx.

{
  SG::ReadHandle<CaloCellContainer> cell_collection(m_cellsKey, ctx);
  if ( !cell_collection.isValid() )
    {
      ATH_MSG_ERROR( " Cannot retrieve CaloCellContainer: " << cell_collection.name()  );
      return StatusCode::FAILURE;
    }
 
  SG::ReadCondHandle<CaloNoise> noise_handle(m_noiseCDOKey, ctx);
  const CaloNoise * noise_tool = *noise_handle;
 
  std::vector<unsigned char> cell_classification(NCaloCells, 0);
  //0 for invalid, 1 for terminal, 2 for growing, 3 for seed...
 
 
  EventPerformanceInfo ev_perf_info;
 
  ev_perf_info.num_clusters = cluster_collection->size();
 
  for (const auto & cell_ptr : *cell_collection)
    {
      const float energy = cell_ptr->energy();
      const float noise  = m_twoGaussianNoise ?
                           noise_tool->getEffectiveSigma(cell_ptr->ID(), cell_ptr->gain(), energy) :
                           noise_tool->getNoise(cell_ptr->ID(), cell_ptr->gain());
      const float s_n_r = (noise > 0 ? energy / noise : 0.00001f);
      const float abs_s_n_r = fabsf(s_n_r);
 
      const int this_hash_ID = cell_ptr->caloDDE()->calo_hash();
 
      if (s_n_r >= m_seedThreshold || (m_seedCutsInAbsE && abs_s_n_r >= m_seedThreshold))
        {
          cell_classification[this_hash_ID] = 3;
          ++ev_perf_info.total_seed;
        }
      else if (s_n_r >= m_growThreshold || (m_neighborCutsInAbsE && abs_s_n_r >= m_growThreshold))
        {
          cell_classification[this_hash_ID] = 2;
          ++ev_perf_info.total_grow;
        }
      else if (s_n_r >= m_cellThreshold || (m_cellCutsInAbsE && abs_s_n_r >= m_cellThreshold))
        {
          cell_classification[this_hash_ID] = 1;
          ++ev_perf_info.total_term;
        }
      else
        {
          cell_classification[this_hash_ID] = 0;
          ++ev_perf_info.total_invalid;
        }
    }
 
  auto accumulate_stats = [&](EventPerformanceInfo::Stats & s, const double v)
  {
    s.min = std::min(s.min, v);
    s.max = std::max(s.max, v);
    s.avg += v;
    s.stddev += v * v;
  };
 
  int cluster_count = 0;
 
  std::vector<int> cluster_assignment(NCaloCells, -1);
 
  constexpr int check_seed_flag = 0x40000000;
  constexpr int check_first_flag = 0x20000000;
  //Since we only have 187652 cells, this works...
 
  constexpr int check_mask = ~(check_seed_flag | check_first_flag);
 
  std::vector<int> cells_to_check;
  std::vector<int> new_cells_to_check;
  std::vector<IdentifierHash> neighs;
  
  auto check_for_restrict = [&] (const auto & hash_ID, const bool restrict_HECIWandFCal, const bool restrict_PS)
  {
    const Identifier cell_identifier = m_calo_id->cell_id(hash_ID);
 
    const auto sub_calo            = m_calo_id->sub_calo(cell_identifier);
    const auto region              = m_calo_id->region(cell_identifier);
    const auto intra_calo_sampling = m_calo_id->sampling(cell_identifier);
 
    const bool is_PS               =   (sub_calo == CaloCell_ID::LAREM   && intra_calo_sampling == 0);
 
    const bool is_HECIW_or_FCAL    = ( (sub_calo == CaloCell_ID::LARHEC  && region              == 1 ) ||
                                       (sub_calo == CaloCell_ID::LARFCAL && intra_calo_sampling >  1 )    );
              
    return (is_HECIW_or_FCAL && restrict_HECIWandFCal) || (is_PS && restrict_PS);
  };
 
  for (const auto & cluster_ptr : *cluster_collection)
    {
      int this_seed = 0, this_grow = 0, this_term = 0;
 
      cells_to_check.clear();
      
      bool first = true;
 
      for (const CaloCell * cell_ptr : *cluster_ptr)
        {
          const int this_hash_ID = cell_ptr->caloDDE()->calo_hash();
 
          cluster_assignment[this_hash_ID] = cluster_count | check_seed_flag | (first ? 0 : check_first_flag);
 
          const unsigned char this_classification = cell_classification[this_hash_ID];
 
          switch (this_classification)
            {
              case 3:
                ++this_seed;
                cluster_assignment[this_hash_ID] = cluster_count | (first ? 0 : check_first_flag);
                cells_to_check.push_back(this_hash_ID);
                break;
              case 2:
                ++this_grow;
                break;
              case 1:
                ++this_term;
                break;
              default:
                ATH_MSG_WARNING("Invalid cell " << this_hash_ID << " in cluster " << cluster_count << ".");
                break;
            }
 
          first = false;
        }
 
      ev_perf_info.seed_in_cluster += this_seed;
      ev_perf_info.grow_in_cluster += this_grow;
      ev_perf_info.term_in_cluster += this_term;
 
      accumulate_stats(ev_perf_info.cluster_size, cluster_ptr->size());
      accumulate_stats(ev_perf_info.cluster_num_seed, this_seed);
      accumulate_stats(ev_perf_info.cluster_num_grow, this_grow);
      accumulate_stats(ev_perf_info.cluster_num_term, this_term);
 
      //Now for the complicated part: the radius...
 
 
      int min_radius = -1, radius = -1;
 
      while (cells_to_check.size() > 0)
        {
          ++radius;
 
          new_cells_to_check.clear();
 
          for (const auto & hash_ID : cells_to_check)
            {
              if (min_radius < 0 && cell_classification[hash_ID] <= 1)
                {
                  min_radius = radius;
                  //We have reached a terminal cell: this is the minimum radius.
                }
              
              const bool restrict = check_for_restrict(hash_ID,
                                                       m_growRestrictHECIWandFCalNeighbors, 
                                                       m_growRestrictPSNeighbors);
 
              neighs.clear();
 
              if (restrict && (m_growNeighborOption & LArNeighbours::nextInSamp))
                {
                  m_calo_id->get_neighbours(hash_ID, LArNeighbours::nextInSamp, neighs);
                }
              else
                {
                  m_calo_id->get_neighbours(hash_ID, m_growNeighborOption, neighs);
                }
 
              for (const auto & neigh_hash : neighs)
                {
                  int & neigh_assignment = cluster_assignment[neigh_hash];
                  if ((neigh_assignment & check_seed_flag) && ((neigh_assignment & check_mask) == cluster_count))
                    {
                      new_cells_to_check.push_back(neigh_hash) ;
                      neigh_assignment = (neigh_assignment & ~check_seed_flag);
                    }
                }
            }
 
          cells_to_check.swap(new_cells_to_check);
        }
 
      accumulate_stats(ev_perf_info.cluster_seed_min_radius, min_radius);
      accumulate_stats(ev_perf_info.cluster_seed_max_radius, radius);
 
      //And now the radius from the first cell
      //(for split clusters)
 
      if (cluster_ptr->size() > 0)
        {
          cells_to_check.clear();
          cells_to_check.push_back(cluster_ptr->begin()->caloDDE()->calo_hash());
 
          radius = -1;
          min_radius = -1;
 
          while (cells_to_check.size() > 0)
            {
              ++radius;
 
              new_cells_to_check.clear();
 
              for (const auto & hash_ID : cells_to_check)
                {
              const bool restrict = check_for_restrict(hash_ID,
                                                       m_splitRestrictHECIWandFCalNeighbors, 
                                                       m_splitRestrictPSNeighbors);
                                                       
 
                  neighs.clear();
 
                  if (restrict && (m_splitNeighborOption & LArNeighbours::nextInSamp))
                    {
                      m_calo_id->get_neighbours(hash_ID, LArNeighbours::nextInSamp, neighs);
                    }
                  else
                    {
                      m_calo_id->get_neighbours(hash_ID, m_splitNeighborOption, neighs);
                    }
 
                  for (const auto & neigh_hash : neighs)
                    {
                      int & neigh_assignment = cluster_assignment[neigh_hash];
                      if ((neigh_assignment & check_first_flag) && ((neigh_assignment & check_mask) == cluster_count))
                        {
                          new_cells_to_check.push_back(neigh_hash) ;
                          neigh_assignment = (neigh_assignment & ~check_first_flag);
                        }
                    }
                }
 
              cells_to_check.swap(new_cells_to_check);
            }
            
            accumulate_stats(ev_perf_info.cluster_first_max_radius, radius);
        }
 
      ++cluster_count;
    }
 
 
  auto finalize_stats = [&](EventPerformanceInfo::Stats & s)
  {
    s.avg /= cluster_collection->size();
    s.stddev /= cluster_collection->size();
    s.stddev -= s.avg * s.avg;
    //Sure, floating point accuracy issues may ensue,
    //but not the most relevant anyway...
  };
 
  finalize_stats(ev_perf_info.cluster_size);
  finalize_stats(ev_perf_info.cluster_num_seed);
  finalize_stats(ev_perf_info.cluster_num_grow);
  finalize_stats(ev_perf_info.cluster_num_term);
  finalize_stats(ev_perf_info.cluster_seed_min_radius);
  finalize_stats(ev_perf_info.cluster_seed_max_radius);
  finalize_stats(ev_perf_info.cluster_first_max_radius);
 
  {
    std::lock_guard<std::mutex> lock_guard(m_mutex);
 
    m_eventInfo.push_back(ev_perf_info);
    m_eventNumbers.push_back(ctx.evt());
  }
 
  return StatusCode::SUCCESS;
}

finalize()

StatusCode CaloPerformancePropertiesOutput::finalize ( )

overridevirtual

Definition at line 357 of file CaloPerformancePropertiesOutput.cxx.

{
  if (m_fileName.size() > 0)
    {
      std::ofstream out(m_fileName);
 
      std::vector<size_t> indices(m_eventNumbers.size());
 
      std::iota(indices.begin(), indices.end(), 0);
      std::sort(indices.begin(), indices.end(), [&](size_t a, size_t b)
      {
        return m_eventNumbers[a] < m_eventNumbers[b];
      }
               );
 
      out << "Event_Number Number_Clusters "
          << "Total_Seed Total_Grow Total_Term Total_Invalid "
          << "Seed_In_Cluster Term_In_Cluster";
 
      auto print_stat_name = [&](const auto & name)
      {
        out << " " << name << "_Min " << name << "_Max " << name << "_Avg " << name << "_Stddev";
      };
 
      print_stat_name("Size");
      print_stat_name("Num_Seed");
      print_stat_name("Num_Grow");
      print_stat_name("Num_Term");
      print_stat_name("Radius_Seed_Min");
      print_stat_name("Radius_Seed_Max");
      print_stat_name("Radius_First");
 
      out << "\n";
 
      auto print_stat = [&](const EventPerformanceInfo::Stats & s)
      {
        out << " " << s.min << " " << s.max << " " << s.avg << " " << s.stddev;
      };
 
      for (const auto & idx : indices)
        {
          out << m_eventNumbers[idx] << " ";
 
          const auto & info = m_eventInfo[idx];
 
          out << info.num_clusters << " " << info.total_seed << " " << info.total_grow << " "
              << info.total_term << " " << info.total_invalid << " " << info.seed_in_cluster << " "
              << info.grow_in_cluster << " " << info.term_in_cluster;
 
          print_stat(info.cluster_size);
          print_stat(info.cluster_num_seed);
          print_stat(info.cluster_num_grow);
          print_stat(info.cluster_num_term);
          print_stat(info.cluster_seed_min_radius);
          print_stat(info.cluster_seed_max_radius);
          print_stat(info.cluster_first_max_radius);
 
          out << "\n";
        }
 
      out << std::endl;
 
      out.close();
 
    }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode CaloPerformancePropertiesOutput::initialize ( )

overridevirtual

Definition at line 25 of file CaloPerformancePropertiesOutput.cxx.

{
  ATH_CHECK( m_cellsKey.initialize() );
 
  ATH_CHECK( m_noiseCDOKey.initialize() );
 
  ATH_CHECK( detStore()->retrieve(m_calo_id, "CaloCell_ID") );
 
  auto get_neighbour_option_from_string = [](const std::string & str, bool & failed)
  {
    failed = false;
    //cppcheck-suppress syntaxError
    CRGPU_RECURSIVE_MACRO(
            CRGPU_CHEAP_STRING_TO_ENUM( str, LArNeighbours,
                                        prevInPhi,
                                        nextInPhi,
                                        prevInEta,
                                        nextInEta,
                                        faces2D,
                                        corners2D,
                                        all2D,
                                        prevInSamp,
                                        nextInSamp,
                                        upAndDown,
                                        prevSubDet,
                                        nextSubDet,
                                        all3D,
                                        corners3D,
                                        all3DwithCorners,
                                        prevSuperCalo,
                                        nextSuperCalo,
                                        super3D
                                      )
    )
    else
      {
        failed = true;
        return LArNeighbours::super3D;
      }
  };
 
  bool neigh_failed = false;
  m_growNeighborOption = get_neighbour_option_from_string(m_growNeighborOptionString, neigh_failed);
 
  if (neigh_failed)
    {
      ATH_MSG_ERROR("Invalid Grow Neighbour Option: " << m_growNeighborOptionString);
    }
 
  neigh_failed = false;
  m_growNeighborOption = get_neighbour_option_from_string(m_splitNeighborOptionString, neigh_failed);
 
  if (neigh_failed)
    {
      ATH_MSG_ERROR("Invalid Split Neighbour Option: " << m_splitNeighborOption);
    }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

std::vector<size_t> m_eventNumbers CaloPerformancePropertiesOutput::ATLAS_THREAD_SAFE

mutableprivate

Vector to hold the event numbers to be recorded if necessary.

Definition at line 262 of file CaloPerformancePropertiesOutput.h.

ATLAS_THREAD_SAFE [2/2]

std::vector<EventPerformanceInfo> m_eventInfo CaloPerformancePropertiesOutput::ATLAS_THREAD_SAFE

mutableprivate

Vector to hold the information.

Definition at line 257 of file CaloPerformancePropertiesOutput.h.

m_calo_id

const CaloCell_ID* CaloPerformancePropertiesOutput::m_calo_id {nullptr}

private

Pointer to Calo ID Helper.

Definition at line 219 of file CaloPerformancePropertiesOutput.h.

{nullptr};

m_cellCutsInAbsE

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_cellCutsInAbsE {this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"}

private

if set to true cell cuts are on \(|E|\) and \(|E|_\perp\).

The cell cuts will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 113 of file CaloPerformancePropertiesOutput.h.

{this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"};

m_cellsKey

SG::ReadHandleKey<CaloCellContainer> CaloPerformancePropertiesOutput::m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}

private

vector of names of the cell containers to use as input.

Definition at line 61 of file CaloPerformancePropertiesOutput.h.

{this, "CellsName", "", "Name(s) of Cell Containers"};

m_cellThreshold

Gaudi::Property<float> CaloPerformancePropertiesOutput::m_cellThreshold {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"}

private

Value to consider for the seed threshold.

Should be consistent with the one used in Topological Clustering to ensure cell classification is correct.

Definition at line 87 of file CaloPerformancePropertiesOutput.h.

{this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"};

m_fileName

Gaudi::Property<std::string> CaloPerformancePropertiesOutput::m_fileName {this, "FileName", "event_properties.txt", "File to save the performance-related info."}

private

The path specifying the folder to which the files should be saved.

Default "event_properties.txt"

Definition at line 56 of file CaloPerformancePropertiesOutput.h.

{this, "FileName", "event_properties.txt", "File to save the performance-related info."};

m_growNeighborOption

LArNeighbours::neighbourOption CaloPerformancePropertiesOutput::m_growNeighborOption

private

Definition at line 141 of file CaloPerformancePropertiesOutput.h.

m_growNeighborOptionString

Gaudi::Property<std::string> CaloPerformancePropertiesOutput::m_growNeighborOptionString

private

Initial value:

{this, "GrowingNeighborOption", "super3D",
                                                           "Neighbor option to be used for cell neighborhood relations during growing"}

type of neighbor relations to use for cluster growing.

The CaloIdentifier package defines different types of neighbors for the calorimeter cells. Currently supported neighbor relations for topological clustering are:

• "all2D" for all cells in the same layer (sampling or module) of one calorimeter subsystem. Note that endcap and barrel will be unconnected in this case even for the LAREM.

• "all3D" for all cells in the same calorimeter. This means all the "all2D" neighbors for each cell plus the cells in adjacent samplings overlapping at least partially in \(\eta\) and \(\phi\) with the cell. Note that endcap and barrel will be connected in this case for the LAREM.

• "super3D" for all cells. This means all the "all3D" neighbors for each cell plus the cells in adjacent samplings from other subsystems overlapping at least partially in \(\eta\) and \(\phi\) with the cell. All calorimeters are connected in this case.

The default setting is "super3D".

Definition at line 139 of file CaloPerformancePropertiesOutput.h.

                                                      {this, "GrowingNeighborOption", "super3D",
                                                           "Neighbor option to be used for cell neighborhood relations during growing"};

m_growRestrictHECIWandFCalNeighbors

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_growRestrictHECIWandFCalNeighbors

private

Initial value:

{this, "GrowingRestrictHECIWandFCalNeighbors",
    false, "Limit the neighbors in HEC IW and FCal2&3 for growing"}

if set to true limit the neighbors in HEC IW and FCal2&3 during growing.

The cells in HEC IW and FCal2&3 get very large in terms of eta and phi. Since this might pose problems on certain jet algorithms one might need to avoid expansion in eta and phi for those cells. If this property is set to true the 2d neighbors of these cells are not used - only the next sampling neighbors are probed.

Definition at line 180 of file CaloPerformancePropertiesOutput.h.

                                                          {this, "GrowingRestrictHECIWandFCalNeighbors",
    false, "Limit the neighbors in HEC IW and FCal2&3 for growing"};

m_growRestrictPSNeighbors

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_growRestrictPSNeighbors

private

Initial value:

{this, "GrowingRestrictPSNeighbors",
    false, "Limit the neighbors in presampler Barrel and Endcap for growing"}

if set to true limit the neighbors in presampler Barrel and Endcap during growing.

The presampler cells add a lot of PileUp in the Hilum samples. With this option set to true the presampler cells do not expand the cluster in the presampler layer. Only the next sampling is used as valid neighbor source.

Definition at line 202 of file CaloPerformancePropertiesOutput.h.

                                                {this, "GrowingRestrictPSNeighbors",
    false, "Limit the neighbors in presampler Barrel and Endcap for growing"};

m_growThreshold

Gaudi::Property<float> CaloPerformancePropertiesOutput::m_growThreshold {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"}

private

Value to consider for the seed threshold.

Should be consistent with the one used in Topological Clustering to ensure cell classification is correct.

Definition at line 82 of file CaloPerformancePropertiesOutput.h.

{this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"};

m_mutex

std::mutex CaloPerformancePropertiesOutput::m_mutex

mutableprivate

Mutex that is locked when recording info.

Definition at line 253 of file CaloPerformancePropertiesOutput.h.

m_neighborCutsInAbsE

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_neighborCutsInAbsE {this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"}

private

if set to true neighbor cuts are on \(|E|\) and \(|E|_\perp\).

The neighbor cuts will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 105 of file CaloPerformancePropertiesOutput.h.

{this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"};

m_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> CaloPerformancePropertiesOutput::m_noiseCDOKey {this, "CaloNoiseKey", "totalNoise", "SG Key of CaloNoise data object"}

private

Key of the CaloNoise Conditions data object.

Typical values are '"electronicNoise', 'pileupNoise', or '"totalNoise' (default)

Definition at line 66 of file CaloPerformancePropertiesOutput.h.

{this, "CaloNoiseKey", "totalNoise", "SG Key of CaloNoise data object"};

m_seedCutsInAbsE

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_seedCutsInAbsE {this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"}

private

if set to true seed cuts are on \(|E|\) and \(|E|_\perp\).

The seed cuts and the \(E_\perp\) cut on the final clusters before insertion to the CaloClusterContainer will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 97 of file CaloPerformancePropertiesOutput.h.

{this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"};

m_seedThreshold

Gaudi::Property<float> CaloPerformancePropertiesOutput::m_seedThreshold {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"}

private

Value to consider for the seed threshold.

Should be consistent with the one used in Topological Clustering to ensure cell classification is correct.

Definition at line 77 of file CaloPerformancePropertiesOutput.h.

{this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"};

m_splitNeighborOption

LArNeighbours::neighbourOption CaloPerformancePropertiesOutput::m_splitNeighborOption

private

Definition at line 169 of file CaloPerformancePropertiesOutput.h.

m_splitNeighborOptionString

Gaudi::Property<std::string> CaloPerformancePropertiesOutput::m_splitNeighborOptionString

private

Initial value:

{this, "SplittingNeighborOption", "super3D",
    "Neighbor option to be used for cell neighborhood relations during splitting"}

type of neighbor relations to use for cluster splitting.

The CaloIdentifier package defines different types of neighbors for the calorimeter cells. Currently supported neighbor relations for topological clustering are:

• "all2D" for all cells in the same layer (sampling or module) of one calorimeter subsystem. Note that endcap and barrel will be unconnected in this case even for the LAREM.

• "all3D" for all cells in the same calorimeter. This means all the "all2D" neighbors for each cell plus the cells in adjacent samplings overlapping at least partially in \(\eta\) and \(\phi\) with the cell. Note that endcap and barrel will be connected in this case for the LAREM.

• "super3D" for all cells. This means all the "all3D" neighbors for each cell plus the cells in adjacent samplings from other subsystems overlapping at least partially in \(\eta\) and \(\phi\) with the cell. All calorimeters are connected in this case.

The default setting is "super3D".

Definition at line 167 of file CaloPerformancePropertiesOutput.h.

                                                       {this, "SplittingNeighborOption", "super3D",
    "Neighbor option to be used for cell neighborhood relations during splitting"};

m_splitRestrictHECIWandFCalNeighbors

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_splitRestrictHECIWandFCalNeighbors

private

Initial value:

{this, "SplittingRestrictHECIWandFCalNeighbors",
    false, "Limit the neighbors in HEC IW and FCal2&3 for splitting"}

if set to true limit the neighbors in HEC IW and FCal2&3 during splitting.

The cells in HEC IW and FCal2&3 get very large in terms of eta and phi. Since this might pose problems on certain jet algorithms one might need to avoid expansion in eta and phi for those cells. If this property is set to true the 2d neighbors of these cells are not used - only the next sampling neighbors are probed.

Definition at line 192 of file CaloPerformancePropertiesOutput.h.

                                                           {this, "SplittingRestrictHECIWandFCalNeighbors",
    false, "Limit the neighbors in HEC IW and FCal2&3 for splitting"};

m_splitRestrictPSNeighbors

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_splitRestrictPSNeighbors

private

Initial value:

{this, "SplittingRestrictPSNeighbors",
    false, "Limit the neighbors in presampler Barrel and Endcap for splitting"}

if set to true limit the neighbors in presampler Barrel and Endcap during splitting.

The presampler cells add a lot of PileUp in the Hilum samples. With this option set to true the presampler cells do not expand the cluster in the presampler layer. Only the next sampling is used as valid neighbor source.

Definition at line 212 of file CaloPerformancePropertiesOutput.h.

                                                 {this, "SplittingRestrictPSNeighbors",
    false, "Limit the neighbors in presampler Barrel and Endcap for splitting"};

m_twoGaussianNoise

Gaudi::Property<bool> CaloPerformancePropertiesOutput::m_twoGaussianNoise {this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"}

private

if set to true use 2-gaussian noise description for TileCal

Definition at line 71 of file CaloPerformancePropertiesOutput.h.

{this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"};

---

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

• CaloPerformancePropertiesOutput.h
• CaloPerformancePropertiesOutput.cxx