Topological cluster maker algorithm to be run on GPUs. More...

#include <TopoAutomatonClustering.h>

Inheritance diagram for TopoAutomatonClustering:

Collaboration diagram for TopoAutomatonClustering:

Public Member Functions
	TopoAutomatonClustering (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	initialize () override

virtual StatusCode	initialize_non_CUDA () override
	Initialization that does not invoke CUDA functions. More...

virtual StatusCode	initialize_CUDA () override
	Initialization that invokes CUDA functions. More...

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. More...

virtual StatusCode	finalize () override

virtual	~TopoAutomatonClustering ()=default

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

virtual size_t	size_of_temporaries () const
	The size (in bytes) of the temporary object(s) that the algorithm will use. More...

	DeclareInterfaceID (CaloClusterGPUProcessor, 1, 0)

void	handle (const Incident &incident) override

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

void	record_times (const size_t event_num, const std::vector< size_t > &times) const

template<class ... Args>
void	record_times (const size_t event_num, const size_t &value) const

template<class ... Args>
void	record_times (const size_t event_num, const size_t &value, Args &&... args) const

void	print_times (const std::string &header, const size_t time_size) const

Protected Attributes
std::shared_mutex	m_timeMutex
	Mutex that is locked when recording times. More...

std::vector< size_t > m_times	ATLAS_THREAD_SAFE
	Vector to hold execution times to be recorded if necessary. More...

std::vector< size_t > m_eventNumbers	ATLAS_THREAD_SAFE
	Vector to hold the event numbers to be recorded if necessary. More...

Gaudi::Property< bool >	m_measureTimes
	If `true`, times are recorded to the file given by `m_timeFileName`. More...

Gaudi::Property< std::string >	m_timeFileName
	File to which times should be saved. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

void	record_times_helper (const size_t) const

template<class Arg >
void	record_times_helper (const size_t index, Arg &&arg) const

template<class ... Args>
void	record_times_helper (size_t index, Args &&... args) const

Private Attributes
Gaudi::Property< std::vector< std::string > >	m_caloNames {this, "CalorimeterNames", {}, "Name(s) of Calorimeters to use for clustering"}
	vector of names of the calorimeters to consider. More...

Gaudi::Property< std::vector< std::string > >	m_samplingNames {this, "SeedSamplingNames", {}, "Name(s) of Calorimeter Samplings to consider for seeds"}
	vector of names of the calorimeter samplings to consider for seeds. More...

Gaudi::Property< float >	m_cellThresholdOnEorAbsEinSigma {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"}
	all cells have to satisfy \(\|E\| > N_{\rm cell}\,\sigma\) More...

Gaudi::Property< float >	m_neighborThresholdOnEorAbsEinSigma {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"}
	cells with \(\|E\| > N_{\rm neighbor}\,\sigma\) extend the cluster More...

Gaudi::Property< float >	m_seedThresholdOnEorAbsEinSigma {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"}
	cells with \(\|E\| > N_{\rm seed}\,\sigma\) start a cluster More...

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\). More...

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\). More...

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\). More...

Gaudi::Property< bool >	m_cutCellsInTime {this, "SeedCutsInT", false, "Do seed cuts in time"}
	if set to true, time cut is applied to seed cells, no cut otherwise More...

Gaudi::Property< float >	m_timeThreshold {this, "SeedThresholdOnTAbs", 12.5 * CLHEP::ns, "Time thresholds (in abs. val.)"}
	threshold used for timing cut on seed cells. More...

Gaudi::Property< float >	m_thresholdForKeeping {this, "TimeCutUpperLimit", 20., "Significance upper limit for applying time cut"}
	upper limit on the energy significance, for applying the cell time cut More...

Gaudi::Property< bool >	m_treatL1PredictedCellsAsGood {this, "TreatL1PredictedCellsAsGood", true, "Treat bad cells with dead OTX if predicted from L1 as good"}
	if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead of bad cells More...

Gaudi::Property< bool >	m_excludeCutSeedsFromClustering {this, "CutOOTseed", true, "Exclude out-of-time seeds from neighbouring and cell stage"}
	if set to true, seed cells failing the time cut are also excluded from cluster at all More...

Gaudi::Property< bool >	m_keepSignificantCells {this, "UseTimeCutUpperLimit", false, "Do not apply time cut on cells of large significance"}
	if set to true, the time cut is not applied on cell of large significance More...

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 More...

Gaudi::Property< std::string >	m_neighborOptionString
	type of neighbor relations to use. More...

Gaudi::Property< bool >	m_restrictHECIWandFCalNeighbors
	if set to true limit the neighbors in HEC IW and FCal2&3. More...

Gaudi::Property< bool >	m_restrictPSNeighbors
	if set to true limit the neighbors in presampler Barrel and Endcap. More...

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 neighbour cells in phi. More...

Gaudi::Property< float >	m_xtalkDeltaT
	Additional maximum delta t added to the upper limit time window in case crosstalk in EM2 should be accounted for. More...

TAGrowing::TACOptionsHolder	m_options
	Options for the algorithm, held in a GPU-friendly way. More...

ServiceHandle< IGPUKernelSizeOptimizerSvc >	m_kernelSizeOptimizer { this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." }
	Handle to the CUDA kernel block and grid size optimization service. More...

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Topological cluster maker algorithm to be run on GPUs.

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: 31 May 2022

Definition at line 36 of file TopoAutomatonClustering.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TopoAutomatonClustering()

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

Definition at line 24 of file TopoAutomatonClustering.cxx.

                                                                                                                          :
   AthAlgTool(type, name, parent),
   CaloGPUTimed(this)
 {
   declareInterface<CaloClusterGPUProcessor> (this);
 }

◆ ~TopoAutomatonClustering()

virtual TopoAutomatonClustering::~TopoAutomatonClustering ( )

virtualdefault

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ DeclareInterfaceID()

CaloClusterGPUProcessor::DeclareInterfaceID	(	CaloClusterGPUProcessor	,
		1	,
		0
	)

inherited

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode TopoAutomatonClustering::execute	(	const EventContext &	ctx,
		const CaloRecGPU::ConstantDataHolder &	constant_data,
		CaloRecGPU::EventDataHolder &	event_data,
		void *	temporary_buffer
	)		const

overridevirtual

Process the clusters on GPU.

Parameters

ctx	The event context.
constant_data	Data held in GPU memory that is common to all events (cell noise and geometry).
event_data	Data held in GPU memory that is specific to this event (including the description of the clusters themselves).
temporary_buffer	A pointer to an \array in GPU memory that is at least as large as `size_of_temporaries()`, to hold temporary information for the algorithms. Given the way CUDA memory allocations work, casting this to a pointer (or a `CaloRecGPU::Helpers::CUDA_kernel_object`) to the intended type and then using it will be perfectly valid.

Implements CaloClusterGPUProcessor.

Definition at line 255 of file TopoAutomatonClustering.cxx.

 {
  
   using clock_type = boost::chrono::thread_clock;
   auto time_cast = [](const auto & before, const auto & after)
   {
     return boost::chrono::duration_cast<boost::chrono::microseconds>(after - before).count();
   };
  
   static_assert(sizeof(TopoAutomatonGrowingTemporaries) <= sizeof(ClusterMomentsArr), "We store the temporaries in the cluster moments, so the sizes must be compatible!");
   
   const auto start = clock_type::now();
   
   const auto before_snr = clock_type::now();
  
   signalToNoise(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  
   const auto before_pairs = clock_type::now();
  
   cellPairs(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  
   const auto before_growing = clock_type::now();
  
   clusterGrowing(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  
   const auto end = clock_type::now();
  
  
   if (m_measureTimes)
     {
       record_times(ctx.evt(),
                    time_cast(start, before_snr),
                    time_cast(before_snr, before_pairs),
                    time_cast(before_pairs, before_growing),
                    time_cast(before_growing, end)
                   );
     }
  
   return StatusCode::SUCCESS;
  
  
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize()

StatusCode TopoAutomatonClustering::finalize ( )

overridevirtual

Definition at line 300 of file TopoAutomatonClustering.cxx.

 {
   if (m_measureTimes)
     {
       print_times("Preprocessing Signal-to-Noise_Ratio Cell_Pair_Creation Cluster_Growing", 4);
     }
   return StatusCode::SUCCESS;
 }

◆ handle()

void CaloGPUCUDAInitialization::handle ( const Incident & incident )

inlineoverrideinherited

Definition at line 66 of file CaloGPUCUDAInitialization.h.

   {
     const bool is_multiprocess = (Gaudi::Concurrency::ConcurrencyFlags::numProcs() > 0);
     if (is_multiprocess && incident.type() == AthenaInterprocess::UpdateAfterFork::type())
       {
         if (!this->initialize_CUDA().isSuccess())
         {
           throw GaudiException("Failed to perform the CUDA initialization!",
                                "CaloGPUCUDAInitialization::handle",
                                StatusCode::FAILURE);
         }
       }
   }

◆ initialize()

virtual StatusCode TopoAutomatonClustering::initialize ( )

inlineoverridevirtual

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 43 of file TopoAutomatonClustering.h.

   {
     return CaloGPUCUDAInitialization::initialize();
   }

◆ initialize_CUDA()

StatusCode TopoAutomatonClustering::initialize_CUDA ( )

overridevirtual

Initialization that invokes CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 245 of file TopoAutomatonClustering.cxx.

 {
   m_options.sendToGPU();
   register_kernels( *(m_kernelSizeOptimizer.get()) );
   
   return StatusCode::SUCCESS;
 }

◆ initialize_non_CUDA()

StatusCode TopoAutomatonClustering::initialize_non_CUDA ( )

overridevirtual

Initialization that does not invoke CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 31 of file TopoAutomatonClustering.cxx.

 {
  
   m_options.allocate();
  
  
   using PackType = decltype(m_options.m_options->valid_sampling_seed);
  
   static_assert(CaloCell_ID::getNumberOfSamplings() <= sizeof(PackType) * CHAR_BIT,  "We are assuming that we have fewer samplings that bits per int!");
  
   //Possibly more elegant alternative: compile-time packed bool vector (std::bitset?) with CUDA compat.
   //Been there, done that, overkill since number of samplings shouldn't change unexpectedly overnight
   //and it doesn't seem that likely to me that it'll reach anything that a 64-bit int wouldn't cover
   //(at least without implying such a major overhaul that the code will need a deeper redesign anyway...)
  
   auto get_sampling_from_string = [](const std::string & str, bool & failed)
   {
     failed = false;
     CRGPU_RECURSIVE_MACRO(
             CRGPU_CHEAP_STRING_TO_ENUM( str, CaloCell_ID,
                                         PreSamplerB,
                                         EMB1,
                                         EMB2,
                                         EMB3,
                                         PreSamplerE,
                                         EME1,
                                         EME2,
                                         EME3,
                                         HEC0,
                                         HEC1,
                                         HEC2,
                                         HEC3,
                                         TileBar0,
                                         TileBar1,
                                         TileBar2,
                                         TileGap1,
                                         TileGap2,
                                         TileGap3,
                                         TileExt0,
                                         TileExt1,
                                         TileExt2,
                                         FCAL0,
                                         FCAL1,
                                         FCAL2
                                       )
     )
     else
       {
         failed = true;
         return CaloCell_ID::Unknown;
       }
   };
  
  
   PackType & seed_samplings = m_options.m_options->valid_sampling_seed;
  
   seed_samplings = 0;
   
   for (const std::string & samp_name : m_samplingNames)
     {
       bool failed = false;
       const PackType sampling = (PackType) get_sampling_from_string(samp_name, failed);
  
       if (failed)
         {
           ATH_MSG_ERROR( "Calorimeter sampling" << samp_name
                          << " is not a valid Calorimeter sampling name and will be ignored! "
                          << "Valid names are: "
                          << "PreSamplerB, EMB1, EMB2, EMB3, "
                          << "PreSamplerE, EME1, EME2, EME3, "
                          << "HEC0, HEC1, HEC2, HEC3, "
                          << "TileBar0, TileBar1, TileBar2, "
                          << "TileGap1, TileGap2, TileGap3, "
                          << "TileExt0, TileExt1, TileExt2, "
                          << "FCAL0, FCAL1, FCAL2."  );
         }
       else
         {
           seed_samplings |= ((PackType) 1) << sampling;
         }
     }
  
   auto get_calo_from_string = [](const std::string & str, bool & failed)
   {
     failed = false;
     CRGPU_RECURSIVE_MACRO(
             CRGPU_CHEAP_STRING_TO_ENUM( str, CaloCell_ID,
                                         LAREM, LARHEC,
                                         LARFCAL, TILE,
                                         LARMINIFCAL
                                       )
     )
     else
       {
         failed = true;
         return CaloCell_ID::NOT_VALID;
       }
   };
   
   
   auto calo_to_sampling_mask = [](const CaloCell_ID::SUBCALO sc) -> PackType
   {
     switch (sc)
       {
         case CaloCell_ID::LAREM:
           return 0xFFU;
         //PreSamplerB=0, EMB1, EMB2, EMB3,
         //PreSamplerE, EME1, EME2, EME3=7,
         case CaloCell_ID::LARHEC:
           return 0xF00U;
         //HEC0=8, HEC1, HEC2, HEC3=11,
         case CaloCell_ID::TILE:
           return 0x1FF000U;
         //TileBar0=12, TileBar1, TileBar2,
         //TileGap1, TileGap2, TileGap3,
         //TileExt0, TileExt1, TileExt2=20,
         case CaloCell_ID::LARFCAL:
           return 0xE00000U;
         //FCAL0=21, FCAL1, FCAL2=23
         case CaloCell_ID::LARMINIFCAL:
           return 0xF000000U;
         //MINIFCAL0=24, MINIFCAL1, MINIFCAL2, MINIFCAL3=27,
         default:
           return 0;
       }
   };
   
   PackType & calo_samplings = m_options.m_options->valid_calorimeter_by_sampling;
  
   calo_samplings = 0;
   
   for (const std::string & calo_name : m_caloNames)
     {
       bool failed = false;
       const PackType sample_mask = calo_to_sampling_mask(get_calo_from_string(calo_name, failed));
  
       if (failed)
         {
           ATH_MSG_ERROR( "Calorimeter " << calo_name
                          << " is not a valid Calorimeter name and will be ignored! "
                          << "Valid names are: LAREM, LARHEC, LARFCAL, and TILE."  );
         }
       else
         {
           calo_samplings |= sample_mask;
         }
     }
   
     auto get_neighbour_option_from_string = [](const std::string & str, bool & failed)
   {
     failed = false;
     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_options.m_options->neighbour_options = (unsigned int) get_neighbour_option_from_string(m_neighborOptionString, neigh_failed);
  
   if (neigh_failed)
     {
       ATH_MSG_ERROR("Invalid Neighbour Option: " << m_neighborOptionString);
     }
  
   m_options.m_options->seed_threshold = m_seedThresholdOnEorAbsEinSigma;
   m_options.m_options->grow_threshold = m_neighborThresholdOnEorAbsEinSigma;
   m_options.m_options->terminal_threshold = m_cellThresholdOnEorAbsEinSigma;
   m_options.m_options->abs_seed = m_seedCutsInAbsE;
   m_options.m_options->abs_grow = m_neighborCutsInAbsE;
   m_options.m_options->abs_terminal = m_cellCutsInAbsE;
   m_options.m_options->use_two_gaussian = m_twoGaussianNoise;
  
   m_options.m_options->treat_L1_predicted_as_good = m_treatL1PredictedCellsAsGood;
   m_options.m_options->use_time_cut = m_cutCellsInTime;
   m_options.m_options->keep_significant_cells = m_keepSignificantCells;
   m_options.m_options->completely_exclude_cut_seeds = m_excludeCutSeedsFromClustering;
   m_options.m_options->time_threshold = m_timeThreshold;
   m_options.m_options->snr_threshold_for_keeping_cells = m_thresholdForKeeping;
  
   m_options.m_options->limit_HECIW_and_FCal_neighs = m_restrictHECIWandFCalNeighbors;
   m_options.m_options->limit_PS_neighs = m_restrictPSNeighbors;
   
   m_options.m_options->use_crosstalk = m_xtalkEM2;
   m_options.m_options->crosstalk_delta = m_xtalkDeltaT;
  
   ATH_CHECK( m_kernelSizeOptimizer.retrieve() );
  
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( const MSG::Level lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ print_times()

void CaloGPUTimed::print_times	(	const std::string &	header,
		const size_t	time_size
	)		const

inlineprotectedinherited

Definition at line 143 of file CaloGPUTimed.h.

   {
     std::shared_lock<std::shared_mutex> lock(m_timeMutex);
     
     if (m_timeFileName.size() == 0)
       {
         return;
       }
     
     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];
     }
              );
     std::ofstream out(m_timeFileName);
  
     out << "Event_Number Total " << header << "\n";
  
     for (const size_t idx : indices)
       {
         out << m_eventNumbers[idx] << " ";
  
         size_t total = 0;
  
         for (size_t i = 0; i < time_size; ++i)
           {
             total += m_times[idx * time_size + i];
           }
  
         out << total << " ";
  
         for (size_t i = 0; i < time_size; ++i)
           {
             out << m_times[idx * time_size + i] << " ";
           }
         out << "\n";
       }
  
     out << std::endl;
  
     out.close();
   }

◆ record_times() [1/3]

template<class ... Args>

void CaloGPUTimed::record_times	(	const size_t	event_num,
		const size_t &	value
	)		const

inlineprotectedinherited

Definition at line 105 of file CaloGPUTimed.h.

   {
     const size_t time_size = 1;
  
     size_t old_size;
  
     {
       std::unique_lock<std::shared_mutex> lock(m_timeMutex);
       old_size = m_times.size();
       m_times.resize(old_size + time_size);
       m_eventNumbers.push_back(event_num);
     }
     {
       std::shared_lock<std::shared_mutex> lock(m_timeMutex);
       record_times_helper(old_size, value);
     }
   }

◆ record_times() [2/3]

template<class ... Args>

void CaloGPUTimed::record_times	(	const size_t	event_num,
		const size_t &	value,
		Args &&...	args
	)		const

inlineprotectedinherited

Definition at line 124 of file CaloGPUTimed.h.

   {
     const size_t time_size = sizeof...(args) + 1;
  
     size_t old_size;
  
     {
       std::unique_lock<std::shared_mutex> lock(m_timeMutex);
       old_size = m_times.size();
       m_times.resize(old_size + time_size);
       m_eventNumbers.push_back(event_num);
     }
     {
       std::shared_lock<std::shared_mutex> lock(m_timeMutex);
       record_times_helper(old_size, value, std::forward<Args>(args)...);
     }
  
   }

◆ record_times() [3/3]

void CaloGPUTimed::record_times	(	const size_t	event_num,
		const std::vector< size_t > &	times
	)		const

inlineprotectedinherited

Definition at line 86 of file CaloGPUTimed.h.

   {
     size_t old_size;
     {
       std::unique_lock<std::shared_mutex> lock(m_timeMutex);
       old_size = m_times.size();
       m_times.resize(old_size + times.size());
       m_eventNumbers.push_back(event_num);
     }
     {
       std::shared_lock<std::shared_mutex> lock(m_timeMutex);
       for (size_t i = 0; i < times.size(); ++i)
         {
           m_times[old_size + i] = times[i];
         }
     }
   }

◆ record_times_helper() [1/3]

template<class Arg >

void CaloGPUTimed::record_times_helper	(	const size_t	index,
		Arg &&	arg
	)		const

inlineprivateinherited

Definition at line 70 of file CaloGPUTimed.h.

   {
     // coverity[missing_lock]
     m_times[index] = std::forward<Arg>(arg);
     
     //This is called within a function that holds the lock itself.
   }

◆ record_times_helper() [2/3]

void CaloGPUTimed::record_times_helper ( const size_t ) const

inlineprivateinherited

Definition at line 64 of file CaloGPUTimed.h.

   {
     //Do nothing
   }

◆ record_times_helper() [3/3]

template<class ... Args>

void CaloGPUTimed::record_times_helper	(	size_t	index,
		Args &&...	args
	)		const

inlineprivateinherited

Definition at line 79 of file CaloGPUTimed.h.

   {
     (record_times_helper(index++, std::forward<Args>(args)), ...);
   }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

   {
     h.renounce();
     PBASE::renounce (h);
   }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ size_of_temporaries()

virtual size_t CaloClusterGPUProcessor::size_of_temporaries ( ) const

inlinevirtualinherited

The size (in bytes) of the temporary object(s) that the algorithm will use.

Reimplemented in BasicGPUClusterInfoCalculator.

Definition at line 48 of file CaloClusterGPUProcessor.h.

   {
     return 0;
   };

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

std::vector<size_t> m_times CaloGPUTimed::ATLAS_THREAD_SAFE

mutableprotectedinherited

Vector to hold execution times to be recorded if necessary.

Definition at line 35 of file CaloGPUTimed.h.

◆ ATLAS_THREAD_SAFE [2/2]

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

mutableprotectedinherited

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

Definition at line 40 of file CaloGPUTimed.h.

◆ m_caloNames

Gaudi::Property<std::vector<std::string> > TopoAutomatonClustering::m_caloNames {this, "CalorimeterNames", {}, "Name(s) of Calorimeters to use for clustering"}

private

vector of names of the calorimeters to consider.

The default is to use all calorimeters (i.e. LAREM, LARHEC, LARFCAL, TILE). Cells which belong to one of the input cell containers and to one of the calorimeters in this vector are used as input for the cluster maker. This property is used in order to ignore a certain subsystem (e.g. for LAREM only clusters specify only LAREM in the jobOptions).

Definition at line 72 of file TopoAutomatonClustering.h.

◆ m_cellCutsInAbsE

Gaudi::Property<bool> TopoAutomatonClustering::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 150 of file TopoAutomatonClustering.h.

◆ m_cellThresholdOnEorAbsEinSigma

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

private

all cells have to satisfy \(|E| > N_{\rm cell}\,\sigma\)

This cut determines how much the cluster will extend beyond the last cell passing the neighbor threshold. The smaller this cut is the more cells will be allowed in the tail of the cluster. It should be smaller or equal to the neighbor threshold. If a cell passing this cut is neighbor of two or more cells passing the neighbor cut it will be inserted in the cluster which has the neighbor cell that was asked first for its neighbors. Since the original list of seed cells is ordered in descending order of \(E/\sigma\) (or \(|E|/\sigma\)) the distance of the cell (in number of cell generations passing the neighbor cut until this cell will be reached) usually determines in which cluster the cell will end up in. The cell cut should be lower or equal to the neighbor cut.

Definition at line 102 of file TopoAutomatonClustering.h.

◆ m_cutCellsInTime

Gaudi::Property<bool> TopoAutomatonClustering::m_cutCellsInTime {this, "SeedCutsInT", false, "Do seed cuts in time"}

private

if set to true, time cut is applied to seed cells, no cut otherwise

Definition at line 155 of file TopoAutomatonClustering.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_excludeCutSeedsFromClustering

Gaudi::Property<bool> TopoAutomatonClustering::m_excludeCutSeedsFromClustering {this, "CutOOTseed", true, "Exclude out-of-time seeds from neighbouring and cell stage"}

private

if set to true, seed cells failing the time cut are also excluded from cluster at all

Definition at line 174 of file TopoAutomatonClustering.h.

◆ m_keepSignificantCells

Gaudi::Property<bool> TopoAutomatonClustering::m_keepSignificantCells {this, "UseTimeCutUpperLimit", false, "Do not apply time cut on cells of large significance"}

private

if set to true, the time cut is not applied on cell of large significance

Definition at line 179 of file TopoAutomatonClustering.h.

◆ m_kernelSizeOptimizer

ServiceHandle<IGPUKernelSizeOptimizerSvc> TopoAutomatonClustering::m_kernelSizeOptimizer { this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." }

private

Handle to the CUDA kernel block and grid size optimization service.

Definition at line 259 of file TopoAutomatonClustering.h.

◆ m_measureTimes

Gaudi::Property<bool> CaloGPUTimed::m_measureTimes

protectedinherited

If true, times are recorded to the file given by m_timeFileName.

Defaults to false.

Definition at line 46 of file CaloGPUTimed.h.

◆ m_neighborCutsInAbsE

Gaudi::Property<bool> TopoAutomatonClustering::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 142 of file TopoAutomatonClustering.h.

◆ m_neighborOptionString

Gaudi::Property<std::string> TopoAutomatonClustering::m_neighborOptionString

private

Initial value:

{this, "NeighborOption", "super3D",

"Neighbor option to be used for cell neighborhood relations"}

type of neighbor relations to use.

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 214 of file TopoAutomatonClustering.h.

◆ m_neighborThresholdOnEorAbsEinSigma

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

private

cells with \(|E| > N_{\rm neighbor}\,\sigma\) extend the cluster

This cut determines how many cells are asked for their neighbors to expand the cluster. The smaller this cut is the more cells will be asked for their neighbors. If a cell passing this cut is neighbor of two other cells passing this cut from different clusters, the two clusters are merged. The neighbor cut should be lower or equal to the seed cut.

Definition at line 113 of file TopoAutomatonClustering.h.

◆ m_options

TAGrowing::TACOptionsHolder TopoAutomatonClustering::m_options

private

Options for the algorithm, held in a GPU-friendly way.

Definition at line 256 of file TopoAutomatonClustering.h.

◆ m_restrictHECIWandFCalNeighbors

Gaudi::Property<bool> TopoAutomatonClustering::m_restrictHECIWandFCalNeighbors

private

Initial value:

{this, "RestrictHECIWandFCalNeighbors",

false, "Limit the neighbors in HEC IW and FCal2&3"}

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

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 226 of file TopoAutomatonClustering.h.

◆ m_restrictPSNeighbors

Gaudi::Property<bool> TopoAutomatonClustering::m_restrictPSNeighbors

private

Initial value:

{this, "RestrictPSNeighbors",

false, "Limit the neighbors in presampler Barrel and Endcap"}

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

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 236 of file TopoAutomatonClustering.h.

◆ m_samplingNames

Gaudi::Property<std::vector<std::string> > TopoAutomatonClustering::m_samplingNames {this, "SeedSamplingNames", {}, "Name(s) of Calorimeter Samplings to consider for seeds"}

private

vector of names of the calorimeter samplings to consider for seeds.

The default is to use all calorimeter samplings. Excluding a sampling from this vector prevents the definition of a seed cell in this sampling. Cells in those samplings are still used and incorporated in the topo clusters (both on the neighbor and the cell level) they can therefore even expand a cluster but not seed one ...

Definition at line 84 of file TopoAutomatonClustering.h.

◆ m_seedCutsInAbsE

Gaudi::Property<bool> TopoAutomatonClustering::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 134 of file TopoAutomatonClustering.h.

◆ m_seedThresholdOnEorAbsEinSigma

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

private

cells with \(|E| > N_{\rm seed}\,\sigma\) start a cluster

This cut determines how many clusters are formed initially. The smaller this cut is the more clusters will be created. During the accumulation of cells inside the clusters it can happen that clusters are merged if a cell passing the neighbor threshold would be included in both clusters.

Definition at line 123 of file TopoAutomatonClustering.h.

◆ m_thresholdForKeeping

Gaudi::Property<float> TopoAutomatonClustering::m_thresholdForKeeping {this, "TimeCutUpperLimit", 20., "Significance upper limit for applying time cut"}

private

upper limit on the energy significance, for applying the cell time cut

Definition at line 163 of file TopoAutomatonClustering.h.

◆ m_timeFileName

Gaudi::Property<std::string> CaloGPUTimed::m_timeFileName

protectedinherited

File to which times should be saved.

Definition at line 50 of file CaloGPUTimed.h.

◆ m_timeMutex

std::shared_mutex CaloGPUTimed::m_timeMutex

mutableprotectedinherited

Mutex that is locked when recording times.

Definition at line 32 of file CaloGPUTimed.h.

◆ m_timeThreshold

Gaudi::Property<float> TopoAutomatonClustering::m_timeThreshold {this, "SeedThresholdOnTAbs", 12.5 * CLHEP::ns, "Time thresholds (in abs. val.)"}

private

threshold used for timing cut on seed cells.

Implemented as |seed_cell_time|<m_timeThreshold. No such cut on neighbouring cells.

Definition at line 159 of file TopoAutomatonClustering.h.

◆ m_treatL1PredictedCellsAsGood

Gaudi::Property<bool> TopoAutomatonClustering::m_treatL1PredictedCellsAsGood {this, "TreatL1PredictedCellsAsGood", true, "Treat bad cells with dead OTX if predicted from L1 as good"}

private

if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead of bad cells

Definition at line 169 of file TopoAutomatonClustering.h.

◆ m_twoGaussianNoise

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

private

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

Warning: Currently unsupported on the GPU side!

Definition at line 187 of file TopoAutomatonClustering.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_xtalkDeltaT

Gaudi::Property<float> TopoAutomatonClustering::m_xtalkDeltaT

private

Initial value:

{this, "XTalkDeltaT",

15 * CLHEP::ns, "Delta T to add to upper time threshold for EM2 cells affected by xtalk."}

Additional maximum delta t added to the upper limit time window in case crosstalk in EM2 should be accounted for.

Definition at line 250 of file TopoAutomatonClustering.h.

◆ m_xtalkEM2

Gaudi::Property<bool> TopoAutomatonClustering::m_xtalkEM2

private

Initial value:

{this, "XTalkEM2",

false, "Relax time window (if timing is used) in EM2 when xTalk is present"}

If set to true, the time window is softened in the EMB2 and EME2_OW due to crosstalk from direct neighbour cells in phi.

Definition at line 244 of file TopoAutomatonClustering.h.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ TopoAutomatonClustering()

◆ ~TopoAutomatonClustering()

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ DeclareInterfaceID()

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ finalize()

◆ handle()

◆ initialize()

◆ initialize_CUDA()

◆ initialize_non_CUDA()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ print_times()

◆ record_times() [1/3]

◆ record_times() [2/3]

◆ record_times() [3/3]

◆ record_times_helper() [1/3]

◆ record_times_helper() [2/3]

◆ record_times_helper() [3/3]

◆ renounce()

◆ renounceArray()

◆ size_of_temporaries()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

◆ ATLAS_THREAD_SAFE [2/2]

◆ m_caloNames

◆ m_cellCutsInAbsE

◆ m_cellThresholdOnEorAbsEinSigma

◆ m_cutCellsInTime

◆ m_detStore

◆ m_evtStore

◆ m_excludeCutSeedsFromClustering

◆ m_keepSignificantCells

◆ m_kernelSizeOptimizer

◆ m_measureTimes

◆ m_neighborCutsInAbsE

◆ m_neighborOptionString

◆ m_neighborThresholdOnEorAbsEinSigma

◆ m_options

◆ m_restrictHECIWandFCalNeighbors

◆ m_restrictPSNeighbors

◆ m_samplingNames

◆ m_seedCutsInAbsE

◆ m_seedThresholdOnEorAbsEinSigma

◆ m_thresholdForKeeping

◆ m_timeFileName

◆ m_timeMutex

◆ m_timeThreshold

◆ m_treatL1PredictedCellsAsGood

◆ m_twoGaussianNoise