ATLAS Offline Software
TopoAutomatonClustering.cxx
Go to the documentation of this file.
1 //
2 // Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 //
4 // Dear emacs, this is -*- c++ -*-
5 //
6 
9 
10 
11 #include <string>
12 #include <climits> //For CHAR_BIT... though it's a slightly inefficient way of saying 8.
13 
15 
16 #include "boost/chrono/chrono.hpp"
17 #include "boost/chrono/thread_clock.hpp"
18 
19 #include "MacroHelpers.h"
20 
21 using namespace CaloRecGPU;
22 using namespace TAGrowing;
23 
24 TopoAutomatonClustering::TopoAutomatonClustering(const std::string & type, const std::string & name, const IInterface * parent):
26  CaloGPUTimed(this)
27 {
28  declareInterface<CaloClusterGPUProcessor> (this);
29 }
30 
32 {
33 
35 
36 
37  using PackType = decltype(m_options.m_options->valid_sampling_seed);
38 
39  static_assert(CaloCell_ID::getNumberOfSamplings() <= sizeof(PackType) * CHAR_BIT, "We are assuming that we have fewer samplings that bits per int!");
40 
41  //Possibly more elegant alternative: compile-time packed bool vector (std::bitset?) with CUDA compat.
42  //Been there, done that, overkill since number of samplings shouldn't change unexpectedly overnight
43  //and it doesn't seem that likely to me that it'll reach anything that a 64-bit int wouldn't cover
44  //(at least without implying such a major overhaul that the code will need a deeper redesign anyway...)
45 
46  auto get_sampling_from_string = [](const std::string & str, bool & failed)
47  {
48  failed = false;
50  CRGPU_CHEAP_STRING_TO_ENUM( str, CaloCell_ID,
52  EMB1,
53  EMB2,
54  EMB3,
56  EME1,
57  EME2,
58  EME3,
59  HEC0,
60  HEC1,
61  HEC2,
62  HEC3,
63  TileBar0,
64  TileBar1,
65  TileBar2,
66  TileGap1,
67  TileGap2,
68  TileGap3,
69  TileExt0,
70  TileExt1,
71  TileExt2,
72  FCAL0,
73  FCAL1,
74  FCAL2
75  )
76  )
77  else
78  {
79  failed = true;
80  return CaloCell_ID::Unknown;
81  }
82  };
83 
84 
85  PackType & seed_samplings = m_options.m_options->valid_sampling_seed;
86 
87  seed_samplings = 0;
88 
89  for (const std::string & samp_name : m_samplingNames)
90  {
91  bool failed = false;
92  const PackType sampling = (PackType) get_sampling_from_string(samp_name, failed);
93 
94  if (failed)
95  {
96  ATH_MSG_ERROR( "Calorimeter sampling" << samp_name
97  << " is not a valid Calorimeter sampling name and will be ignored! "
98  << "Valid names are: "
99  << "PreSamplerB, EMB1, EMB2, EMB3, "
100  << "PreSamplerE, EME1, EME2, EME3, "
101  << "HEC0, HEC1, HEC2, HEC3, "
102  << "TileBar0, TileBar1, TileBar2, "
103  << "TileGap1, TileGap2, TileGap3, "
104  << "TileExt0, TileExt1, TileExt2, "
105  << "FCAL0, FCAL1, FCAL2." );
106  }
107  else
108  {
109  seed_samplings |= ((PackType) 1) << sampling;
110  }
111  }
112 
113  auto get_calo_from_string = [](const std::string & str, bool & failed)
114  {
115  failed = false;
117  CRGPU_CHEAP_STRING_TO_ENUM( str, CaloCell_ID,
118  LAREM, LARHEC,
119  LARFCAL, TILE,
121  )
122  )
123  else
124  {
125  failed = true;
126  return CaloCell_ID::NOT_VALID;
127  }
128  };
129 
130 
131  auto calo_to_sampling_mask = [](const CaloCell_ID::SUBCALO sc) -> PackType
132  {
133  switch (sc)
134  {
135  case CaloCell_ID::LAREM:
136  return 0xFFU;
137  //PreSamplerB=0, EMB1, EMB2, EMB3,
138  //PreSamplerE, EME1, EME2, EME3=7,
139  case CaloCell_ID::LARHEC:
140  return 0xF00U;
141  //HEC0=8, HEC1, HEC2, HEC3=11,
142  case CaloCell_ID::TILE:
143  return 0x1FF000U;
144  //TileBar0=12, TileBar1, TileBar2,
145  //TileGap1, TileGap2, TileGap3,
146  //TileExt0, TileExt1, TileExt2=20,
148  return 0xE00000U;
149  //FCAL0=21, FCAL1, FCAL2=23
151  return 0xF000000U;
152  //MINIFCAL0=24, MINIFCAL1, MINIFCAL2, MINIFCAL3=27,
153  default:
154  return 0;
155  }
156  };
157 
158  PackType & calo_samplings = m_options.m_options->valid_calorimeter_by_sampling;
159 
160  calo_samplings = 0;
161 
162  for (const std::string & calo_name : m_caloNames)
163  {
164  bool failed = false;
165  const PackType sample_mask = calo_to_sampling_mask(get_calo_from_string(calo_name, failed));
166 
167  if (failed)
168  {
169  ATH_MSG_ERROR( "Calorimeter " << calo_name
170  << " is not a valid Calorimeter name and will be ignored! "
171  << "Valid names are: LAREM, LARHEC, LARFCAL, and TILE." );
172  }
173  else
174  {
175  calo_samplings |= sample_mask;
176  }
177  }
178 
179  auto get_neighbour_option_from_string = [](const std::string & str, bool & failed)
180  {
181  failed = false;
184  prevInPhi,
185  nextInPhi,
186  prevInEta,
187  nextInEta,
188  faces2D,
189  corners2D,
190  all2D,
191  prevInSamp,
192  nextInSamp,
193  upAndDown,
194  prevSubDet,
195  nextSubDet,
196  all3D,
197  corners3D,
201  super3D
202  )
203  )
204  else
205  {
206  failed = true;
207  return LArNeighbours::super3D;
208  }
209  };
210 
211  bool neigh_failed = false;
212  m_options.m_options->neighbour_options = (unsigned int) get_neighbour_option_from_string(m_neighborOptionString, neigh_failed);
213 
214  if (neigh_failed)
215  {
216  ATH_MSG_ERROR("Invalid Neighbour Option: " << m_neighborOptionString);
217  }
218 
224  m_options.m_options->abs_terminal = m_cellCutsInAbsE;
225  m_options.m_options->use_two_gaussian = m_twoGaussianNoise;
226 
227  m_options.m_options->treat_L1_predicted_as_good = m_treatL1PredictedCellsAsGood;
228  m_options.m_options->use_time_cut = m_cutCellsInTime;
229  m_options.m_options->keep_significant_cells = m_keepSignificantCells;
230  m_options.m_options->completely_exclude_cut_seeds = m_excludeCutSeedsFromClustering;
231  m_options.m_options->time_threshold = m_timeThreshold;
232  m_options.m_options->snr_threshold_for_keeping_cells = m_thresholdForKeeping;
233 
234  m_options.m_options->limit_HECIW_and_FCal_neighs = m_restrictHECIWandFCalNeighbors;
235  m_options.m_options->limit_PS_neighs = m_restrictPSNeighbors;
236 
237  m_options.m_options->use_crosstalk = m_xtalkEM2;
238  m_options.m_options->crosstalk_delta = m_xtalkDeltaT;
239 
240  ATH_CHECK( m_kernelSizeOptimizer.retrieve() );
241 
242  return StatusCode::SUCCESS;
243 }
244 
246 {
249 
250  return StatusCode::SUCCESS;
251 }
252 
253 
254 
255 StatusCode TopoAutomatonClustering::execute(const EventContext & ctx, const ConstantDataHolder & constant_data,
256  EventDataHolder & event_data, void * /*temporary_buffer*/ ) const
257 {
258 
259  using clock_type = boost::chrono::thread_clock;
260  auto time_cast = [](const auto & before, const auto & after)
261  {
262  return boost::chrono::duration_cast<boost::chrono::microseconds>(after - before).count();
263  };
264 
265  static_assert(sizeof(TopoAutomatonGrowingTemporaries) <= sizeof(ClusterMomentsArr), "We store the temporaries in the cluster moments, so the sizes must be compatible!");
266 
267  const auto start = clock_type::now();
268 
269  const auto before_snr = clock_type::now();
270 
271  signalToNoise(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
272 
273  const auto before_pairs = clock_type::now();
274 
275  cellPairs(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
276 
277  const auto before_growing = clock_type::now();
278 
279  clusterGrowing(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
280 
281  const auto end = clock_type::now();
282 
283 
284  if (m_measureTimes)
285  {
286  record_times(ctx.evt(),
287  time_cast(start, before_snr),
288  time_cast(before_snr, before_pairs),
289  time_cast(before_pairs, before_growing),
290  time_cast(before_growing, end)
291  );
292  }
293 
294  return StatusCode::SUCCESS;
295 
296 
297 }
298 
299 
301 {
302  if (m_measureTimes)
303  {
304  print_times("Preprocessing Signal-to-Noise_Ratio Cell_Pair_Creation Cluster_Growing", 4);
305  }
306  return StatusCode::SUCCESS;
307 }
308 
TopoAutomatonClustering::m_cutCellsInTime
Gaudi::Property< bool > m_cutCellsInTime
if set to true, time cut is applied to seed cells, no cut otherwise
Definition: TopoAutomatonClustering.h:155
TopoAutomatonClustering::m_restrictHECIWandFCalNeighbors
Gaudi::Property< bool > m_restrictHECIWandFCalNeighbors
if set to true limit the neighbors in HEC IW and FCal2&3.
Definition: TopoAutomatonClustering.h:226
TopoAutomatonClustering::m_caloNames
Gaudi::Property< std::vector< std::string > > m_caloNames
vector of names of the calorimeters to consider.
Definition: TopoAutomatonClustering.h:72
LArNeighbours::nextSuperCalo
@ nextSuperCalo
Definition: LArNeighbours.h:28
GetLCDefs::Unknown
@ Unknown
Definition: GetLCDefs.h:21
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition: CaloCell_Base_ID.h:46
LArNeighbours::corners3D
@ corners3D
Definition: LArNeighbours.h:25
TopoAutomatonClustering::m_cellCutsInAbsE
Gaudi::Property< bool > m_cellCutsInAbsE
if set to true cell cuts are on and .
Definition: TopoAutomatonClustering.h:150
LArNeighbours::upAndDown
@ upAndDown
Definition: LArNeighbours.h:21
CaloCell_ID_FCS::TileExt2
@ TileExt2
Definition: FastCaloSim_CaloCell_ID.h:39
constants.EMB1
int EMB1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:53
TopoAutomatonClustering::initialize_non_CUDA
virtual StatusCode initialize_non_CUDA() override
Initialization that does not invoke CUDA functions.
Definition: TopoAutomatonClustering.cxx:31
TopoAutomatonClustering::m_xtalkDeltaT
Gaudi::Property< float > m_xtalkDeltaT
Additional maximum delta t added to the upper limit time window in case crosstalk in EM2 should be ac...
Definition: TopoAutomatonClustering.h:250
TAGrowing::cellPairs
void cellPairs(CaloRecGPU::EventDataHolder &holder, const CaloRecGPU::ConstantDataHolder &instance_data, const TACOptionsHolder &options, const IGPUKernelSizeOptimizer &optimizer, const bool synchronize=false, CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder stream_to_use={})
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
LArNeighbours::corners2D
@ corners2D
Definition: LArNeighbours.h:17
TAGrowing::TACOptionsHolder::m_options
CaloRecGPU::Helpers::CPU_object< TopoAutomatonOptions > m_options
Definition: TopoAutomatonClusteringImpl.h:278
CaloCell_ID_FCS::TileExt0
@ TileExt0
Definition: FastCaloSim_CaloCell_ID.h:37
CaloCell_ID_FCS::TileBar1
@ TileBar1
Definition: FastCaloSim_CaloCell_ID.h:32
CaloCell_Base_ID::LARMINIFCAL
@ LARMINIFCAL
Definition: CaloCell_Base_ID.h:46
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:14
LArNeighbours::faces2D
@ faces2D
Definition: LArNeighbours.h:16
LArNeighbours::nextSubDet
@ nextSubDet
Definition: LArNeighbours.h:23
CaloCell_ID_FCS::FCAL1
@ FCAL1
Definition: FastCaloSim_CaloCell_ID.h:41
TAGrowing::TACOptionsHolder::allocate
void allocate()
Definition: TopoAutomatonClusteringImpl.h:282
CaloCell_Base_ID::LARHEC
@ LARHEC
Definition: CaloCell_Base_ID.h:46
CaloCell_ID_FCS::HEC2
@ HEC2
Definition: FastCaloSim_CaloCell_ID.h:29
LArNeighbours::prevInPhi
@ prevInPhi
Definition: LArNeighbours.h:12
TopoAutomatonClusteringImpl.h
CaloCell_ID_FCS::TileGap3
@ TileGap3
Definition: FastCaloSim_CaloCell_ID.h:36
CaloGPUTimed
Base class to provide some basic common infrastructure for timing measurements...
Definition: CaloGPUTimed.h:25
TopoAutomatonClustering.h
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
CaloCell_ID.h
TAGrowing::clusterGrowing
void clusterGrowing(CaloRecGPU::EventDataHolder &holder, const CaloRecGPU::ConstantDataHolder &instance_data, const TACOptionsHolder &options, const IGPUKernelSizeOptimizer &optimizer, const bool synchronize=false, CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder stream_to_use={})
TopoAutomatonClustering::m_seedCutsInAbsE
Gaudi::Property< bool > m_seedCutsInAbsE
if set to true seed cuts are on and .
Definition: TopoAutomatonClustering.h:134
CRGPU_CHEAP_STRING_TO_ENUM
#define CRGPU_CHEAP_STRING_TO_ENUM(VAR, PREFIX, ONE,...)
Checks a string variable, VAR, for matching enum identifiers (ONE and the remaining variadic argument...
Definition: MacroHelpers.h:148
LArNeighbours::nextInSamp
@ nextInSamp
Definition: LArNeighbours.h:20
TopoAutomatonClustering::m_seedThresholdOnEorAbsEinSigma
Gaudi::Property< float > m_seedThresholdOnEorAbsEinSigma
cells with start a cluster
Definition: TopoAutomatonClustering.h:123
LArNeighbours::nextInPhi
@ nextInPhi
Definition: LArNeighbours.h:13
TopoAutomatonClustering::m_restrictPSNeighbors
Gaudi::Property< bool > m_restrictPSNeighbors
if set to true limit the neighbors in presampler Barrel and Endcap.
Definition: TopoAutomatonClustering.h:236
python.handimod.now
now
Definition: handimod.py:675
CaloRecGPU::EventDataHolder
Definition: DataHolders.h:35
CaloCell_ID_FCS::HEC1
@ HEC1
Definition: FastCaloSim_CaloCell_ID.h:28
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
constants.EMB2
int EMB2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:54
TAGrowing::signalToNoise
void signalToNoise(CaloRecGPU::EventDataHolder &holder, const CaloRecGPU::ConstantDataHolder &instance_data, const TACOptionsHolder &options, const IGPUKernelSizeOptimizer &optimizer, const bool synchronize=false, CaloRecGPU::CUDA_Helpers::CUDAStreamPtrHolder stream_to_use={})
TopoAutomatonClustering::finalize
virtual StatusCode finalize() override
Definition: TopoAutomatonClustering.cxx:300
CaloCell_ID_FCS::TileBar0
@ TileBar0
Definition: FastCaloSim_CaloCell_ID.h:31
LArNeighbours::all3DwithCorners
@ all3DwithCorners
Definition: LArNeighbours.h:26
TopoAutomatonClustering::m_excludeCutSeedsFromClustering
Gaudi::Property< bool > m_excludeCutSeedsFromClustering
if set to true, seed cells failing the time cut are also excluded from cluster at all
Definition: TopoAutomatonClustering.h:174
CRGPU_RECURSIVE_MACRO
#define CRGPU_RECURSIVE_MACRO(...)
Expands recursive macros.
Definition: MacroHelpers.h:70
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
CaloCell_ID_FCS::TileGap2
@ TileGap2
Definition: FastCaloSim_CaloCell_ID.h:35
TopoAutomatonClustering::m_samplingNames
Gaudi::Property< std::vector< std::string > > m_samplingNames
vector of names of the calorimeter samplings to consider for seeds.
Definition: TopoAutomatonClustering.h:84
TopoAutomatonClustering::m_kernelSizeOptimizer
ServiceHandle< IGPUKernelSizeOptimizerSvc > m_kernelSizeOptimizer
Handle to the CUDA kernel block and grid size optimization service.
Definition: TopoAutomatonClustering.h:259
CaloCell_Base_ID::SUBCALO
SUBCALO
enumeration of sub calorimeters
Definition: CaloCell_Base_ID.h:46
CaloGPUTimed::print_times
void print_times(const std::string &header, const size_t time_size) const
Definition: CaloGPUTimed.h:143
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TopoAutomatonClustering::m_thresholdForKeeping
Gaudi::Property< float > m_thresholdForKeeping
upper limit on the energy significance, for applying the cell time cut
Definition: TopoAutomatonClustering.h:163
TopoAutomatonClustering::m_cellThresholdOnEorAbsEinSigma
Gaudi::Property< float > m_cellThresholdOnEorAbsEinSigma
all cells have to satisfy
Definition: TopoAutomatonClustering.h:102
constants.EME1
int EME1
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:55
TAGrowing::TopoAutomatonGrowingTemporaries
Definition: TopoAutomatonClusteringImpl.h:212
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LArNeighbours::prevSuperCalo
@ prevSuperCalo
Definition: LArNeighbours.h:27
LArNeighbours::prevSubDet
@ prevSubDet
Definition: LArNeighbours.h:22
python.SUBCALO.LARMINIFCAL
int LARMINIFCAL
Definition: SUBCALO.py:12
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:46
TopoAutomatonClustering::m_xtalkEM2
Gaudi::Property< bool > m_xtalkEM2
If set to true, the time window is softened in the EMB2 and EME2_OW due to crosstalk from direct neig...
Definition: TopoAutomatonClustering.h:244
python.SUBCALO.LARHEC
int LARHEC
Definition: SUBCALO.py:9
CaloCell_ID_FCS::TileGap1
@ TileGap1
Definition: FastCaloSim_CaloCell_ID.h:34
LArNeighbours::prevInSamp
@ prevInSamp
Definition: LArNeighbours.h:19
LArNeighbours::super3D
@ super3D
Definition: LArNeighbours.h:29
TopoAutomatonClustering::m_options
TAGrowing::TACOptionsHolder m_options
Options for the algorithm, held in a GPU-friendly way.
Definition: TopoAutomatonClustering.h:256
MacroHelpers.h
TopoAutomatonClustering::execute
virtual StatusCode execute(const EventContext &ctx, const CaloRecGPU::ConstantDataHolder &constant_data, CaloRecGPU::EventDataHolder &event_data, void *temporary_buffer) const override
Process the clusters on GPU.
Definition: TopoAutomatonClustering.cxx:255
TAGrowing::TACOptionsHolder::sendToGPU
void sendToGPU(const bool clear_CPU=false)
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CaloCell_ID_FCS::TileExt1
@ TileExt1
Definition: FastCaloSim_CaloCell_ID.h:38
CaloCell_ID_FCS::EME3
@ EME3
Definition: FastCaloSim_CaloCell_ID.h:26
CaloRecGPU::ClusterMomentsArr
Definition: EventInfoDefinitions.h:342
TopoAutomatonClustering::m_timeThreshold
Gaudi::Property< float > m_timeThreshold
threshold used for timing cut on seed cells.
Definition: TopoAutomatonClustering.h:159
CaloSampling::getNumberOfSamplings
static constexpr unsigned int getNumberOfSamplings()
Get number of available samplings.
Definition: Calorimeter/CaloGeoHelpers/CaloGeoHelpers/CaloSampling.h:30
TILE
@ TILE
Definition: RegSelEnums.h:30
CaloCell_ID_FCS::HEC0
@ HEC0
Definition: FastCaloSim_CaloCell_ID.h:27
TopoAutomatonClustering::m_neighborOptionString
Gaudi::Property< std::string > m_neighborOptionString
type of neighbor relations to use.
Definition: TopoAutomatonClustering.h:214
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
CaloGPUTimed::record_times
void record_times(const size_t event_num, const std::vector< size_t > &times) const
Definition: CaloGPUTimed.h:86
CaloGPUTimed::m_measureTimes
Gaudi::Property< bool > m_measureTimes
If true, times are recorded to the file given by m_timeFileName.
Definition: CaloGPUTimed.h:46
CaloCell_ID_FCS::PreSamplerE
@ PreSamplerE
Definition: FastCaloSim_CaloCell_ID.h:23
CaloCell_ID_FCS::PreSamplerB
@ PreSamplerB
Definition: FastCaloSim_CaloCell_ID.h:19
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
LArNeighbours::nextInEta
@ nextInEta
Definition: LArNeighbours.h:15
BasicClusterInfoCalculator::register_kernels
void register_kernels(IGPUKernelSizeOptimizer &optimizer)
TopoAutomatonClustering::initialize_CUDA
virtual StatusCode initialize_CUDA() override
Initialization that invokes CUDA functions.
Definition: TopoAutomatonClustering.cxx:245
TopoAutomatonClustering::m_neighborCutsInAbsE
Gaudi::Property< bool > m_neighborCutsInAbsE
if set to true neighbor cuts are on and .
Definition: TopoAutomatonClustering.h:142
CaloRecGPU::ConstantDataHolder
Definition: DataHolders.h:19
TopoAutomatonClustering::m_keepSignificantCells
Gaudi::Property< bool > m_keepSignificantCells
if set to true, the time cut is not applied on cell of large significance
Definition: TopoAutomatonClustering.h:179
LArNeighbours
Definition: LArNeighbours.h:11
CaloCell_ID_FCS::FCAL2
@ FCAL2
Definition: FastCaloSim_CaloCell_ID.h:42
TopoAutomatonClustering::TopoAutomatonClustering
TopoAutomatonClustering(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TopoAutomatonClustering.cxx:24
LArNeighbours::all3D
@ all3D
Definition: LArNeighbours.h:24
LArNeighbours::prevInEta
@ prevInEta
Definition: LArNeighbours.h:14
str
Definition: BTagTrackIpAccessor.cxx:11
python.SUBCALO.LARFCAL
int LARFCAL
Definition: SUBCALO.py:10
TopoAutomatonClustering::m_treatL1PredictedCellsAsGood
Gaudi::Property< bool > m_treatL1PredictedCellsAsGood
if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead ...
Definition: TopoAutomatonClustering.h:169
AthAlgTool
Definition: AthAlgTool.h:26
CaloCell_ID_FCS::HEC3
@ HEC3
Definition: FastCaloSim_CaloCell_ID.h:30
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:46
CaloCell_Base_ID::NOT_VALID
@ NOT_VALID
Definition: CaloCell_Base_ID.h:46
CaloRecGPU
Definition: BaseDefinitions.h:11
CaloCell_ID_FCS::FCAL0
@ FCAL0
Definition: FastCaloSim_CaloCell_ID.h:40
CaloCell_ID_FCS::EMB3
@ EMB3
Definition: FastCaloSim_CaloCell_ID.h:22
CaloCell_ID_FCS::TileBar2
@ TileBar2
Definition: FastCaloSim_CaloCell_ID.h:33
TAGrowing
Definition: TopoAutomatonClusteringImpl.h:18
TopoAutomatonClustering::m_twoGaussianNoise
Gaudi::Property< bool > m_twoGaussianNoise
if set to true use 2-gaussian noise description for TileCal
Definition: TopoAutomatonClustering.h:187
LArNeighbours::all2D
@ all2D
Definition: LArNeighbours.h:18
constants.EME2
int EME2
Definition: Calorimeter/CaloClusterCorrection/python/constants.py:56
python.SUBCALO.LAREM
int LAREM
Definition: SUBCALO.py:8
TopoAutomatonClustering::m_neighborThresholdOnEorAbsEinSigma
Gaudi::Property< float > m_neighborThresholdOnEorAbsEinSigma
cells with extend the cluster
Definition: TopoAutomatonClustering.h:113