GPUClusterInfoAndMomentsCalculator Class Reference

Standard tool to calculate cluster info (energy, transverse energy, pseudo-rapidity and azimuthal angle). More...

#include <GPUClusterInfoAndMomentsCalculator.h>

Inheritance diagram for GPUClusterInfoAndMomentsCalculator:

Collaboration diagram for GPUClusterInfoAndMomentsCalculator:

Public Member Functions
	GPUClusterInfoAndMomentsCalculator (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
virtual StatusCode	finalize () override
virtual	~GPUClusterInfoAndMomentsCalculator ()=default
void	handle (const Incident &incident) override

Private Attributes
Gaudi::Property< double >	m_maxAxisAngle {this, "MaxAxisAngle", 20 * CLHEP::deg, "The maximal allowed deviation from the IP-to-ClusterCenter-axis"}
	the maximal allowed deviation from the IP-to-ClusterCenter-axis. More...
Gaudi::Property< double >	m_minRLateral {this, "MinRLateral", 4 * CLHEP::cm, "The minimal r in the definition of the Lateral moment"}
	the minimal \(r\) in the definition of the Lateral moment More...
Gaudi::Property< double >	m_minLLongitudinal {this, "MinLLongitudinal", 10 * CLHEP::cm, "The minimal lambda in the definition of the Longitudinal moment"}
	the minimal \(\lambda\) in the definition of the Longitudinal moment More...
Gaudi::Property< double >	m_minBadLArQuality {this, "MinBadLArQuality", 4000, "The minimal cell quality in the LAr for declaring a cell bad"}
	the minimal cell quality in the LAr for declaring a cell bad More...
Gaudi::Property< bool >	m_absOpt {this, "WeightingOfNegClusters", false, "If set to true use abs E value of cells to calculate cluster moments"}
	if set to true use abs E value of cells to calculate cluster moments More...
Gaudi::Property< double >	m_etaInnerWheel {this, "EMECAbsEtaWheelTransition", 2.52, "Transition from outer to inner wheel in EME2"}
	Transition from outer to inner wheel in EME2. More...
Gaudi::Property< bool >	m_twoGaussianNoise {this, "TwoGaussianNoise", false, "If set to true use 2-gaussian noise description for TileCal"}
	if set to true use 2-gaussian noise description for TileCal More...
Gaudi::Property< bool >	m_skipInvalidClusters {this, "SkipInvalidClusters", true, "Check for and skip invalid clusters during moments calculation."}
	If false, do the moment calculation even for invalid clusters (which may waste computation). More...
ClusterMomentsCalculator::CMCOptionsHolder	m_options
	Options for the algorithm, held in a GPU-friendly way. More...
Gaudi::Property< bool >	m_measureTimes {this, "MeasureTimes", false, "Synchronize for time measurements"}
	If true, synchronize the kernel calls to ensure accurate per-step/per-tool time measurements. 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...

Detailed Description

Standard tool to calculate cluster info (energy, transverse energy, pseudo-rapidity and azimuthal angle).

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

01 March 2023

Definition at line 32 of file GPUClusterInfoAndMomentsCalculator.h.

Constructor & Destructor Documentation

GPUClusterInfoAndMomentsCalculator()

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

Definition at line 14 of file GPUClusterInfoAndMomentsCalculator.cxx.

                                                                                                                                               :
  base_class(type, name, parent)
{
}

~GPUClusterInfoAndMomentsCalculator()

virtual GPUClusterInfoAndMomentsCalculator::~GPUClusterInfoAndMomentsCalculator ( )

virtualdefault

Member Function Documentation

execute()

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

overridevirtual

Definition at line 46 of file GPUClusterInfoAndMomentsCalculator.cxx.

{
  calculateClusterPropertiesAndMoments(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
  return StatusCode::SUCCESS;
 
}

finalize()

StatusCode GPUClusterInfoAndMomentsCalculator::finalize ( )

overridevirtual

Definition at line 54 of file GPUClusterInfoAndMomentsCalculator.cxx.

{
  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 GPUClusterInfoAndMomentsCalculator::initialize ( )

inlineoverridevirtual

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 39 of file GPUClusterInfoAndMomentsCalculator.h.

  {
    return CaloGPUCUDAInitialization::initialize();
  }

initialize_CUDA()

StatusCode GPUClusterInfoAndMomentsCalculator::initialize_CUDA ( )

overridevirtual

Initialization that invokes CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 38 of file GPUClusterInfoAndMomentsCalculator.cxx.

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

initialize_non_CUDA()

StatusCode GPUClusterInfoAndMomentsCalculator::initialize_non_CUDA ( )

overridevirtual

Initialization that does not invoke CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 19 of file GPUClusterInfoAndMomentsCalculator.cxx.

{
  m_options.allocate();
    
  m_options.m_options->use_abs_energy         = m_absOpt;
  m_options.m_options->use_two_gaussian_noise = m_twoGaussianNoise;
  m_options.m_options->skip_invalid_clusters  = m_skipInvalidClusters;
  m_options.m_options->min_LAr_quality        = m_minBadLArQuality;
  m_options.m_options->max_axis_angle         = m_maxAxisAngle;
  m_options.m_options->eta_inner_wheel        = m_etaInnerWheel;
  m_options.m_options->min_l_longitudinal     = m_minLLongitudinal;
  m_options.m_options->min_r_lateral          = m_minRLateral;
  
  
  ATH_CHECK( m_kernelSizeOptimizer.retrieve() );
  
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_absOpt

Gaudi::Property<bool> GPUClusterInfoAndMomentsCalculator::m_absOpt {this, "WeightingOfNegClusters", false, "If set to true use abs E value of cells to calculate cluster moments"}

private

if set to true use abs E value of cells to calculate cluster moments

Definition at line 93 of file GPUClusterInfoAndMomentsCalculator.h.

m_etaInnerWheel

Gaudi::Property<double> GPUClusterInfoAndMomentsCalculator::m_etaInnerWheel {this, "EMECAbsEtaWheelTransition", 2.52, "Transition from outer to inner wheel in EME2"}

private

Transition from outer to inner wheel in EME2.

Definition at line 97 of file GPUClusterInfoAndMomentsCalculator.h.

m_kernelSizeOptimizer

ServiceHandle<IGPUKernelSizeOptimizerSvc> GPUClusterInfoAndMomentsCalculator::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 120 of file GPUClusterInfoAndMomentsCalculator.h.

m_maxAxisAngle

Gaudi::Property<double> GPUClusterInfoAndMomentsCalculator::m_maxAxisAngle {this, "MaxAxisAngle", 20 * CLHEP::deg, "The maximal allowed deviation from the IP-to-ClusterCenter-axis"}

private

the maximal allowed deviation from the IP-to-ClusterCenter-axis.

Definition at line 62 of file GPUClusterInfoAndMomentsCalculator.h.

m_measureTimes

Gaudi::Property<bool> GPUClusterInfoAndMomentsCalculator::m_measureTimes {this, "MeasureTimes", false, "Synchronize for time measurements"}

private

If true, synchronize the kernel calls to ensure accurate per-step/per-tool time measurements.

Defaults to false.

Definition at line 117 of file GPUClusterInfoAndMomentsCalculator.h.

m_minBadLArQuality

Gaudi::Property<double> GPUClusterInfoAndMomentsCalculator::m_minBadLArQuality {this, "MinBadLArQuality", 4000, "The minimal cell quality in the LAr for declaring a cell bad"}

private

the minimal cell quality in the LAr for declaring a cell bad

This defines the minimal quality (large values mean worse shape) a cell needs to exceed in order to be considered as not compatible with a normal ionization signal.

Definition at line 88 of file GPUClusterInfoAndMomentsCalculator.h.

m_minLLongitudinal

Gaudi::Property<double> GPUClusterInfoAndMomentsCalculator::m_minLLongitudinal {this, "MinLLongitudinal", 10 * CLHEP::cm, "The minimal lambda in the definition of the Longitudinal moment"}

private

the minimal \(\lambda\) in the definition of the Longitudinal moment

This defines the minimal distance along the shower axis from the cluster center the two leading cells might have before this value is used instead of their real distance in the normalization of the LONGITUDINAL moment.

Definition at line 80 of file GPUClusterInfoAndMomentsCalculator.h.

m_minRLateral

Gaudi::Property<double> GPUClusterInfoAndMomentsCalculator::m_minRLateral {this, "MinRLateral", 4 * CLHEP::cm, "The minimal r in the definition of the Lateral moment"}

private

the minimal \(r\) in the definition of the Lateral moment

This defines the minimal distance the two leading cells might have before this value is used instead of their real distance in the normalization of the LATERAL moment.

Definition at line 70 of file GPUClusterInfoAndMomentsCalculator.h.

m_options

ClusterMomentsCalculator::CMCOptionsHolder GPUClusterInfoAndMomentsCalculator::m_options

private

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

Definition at line 111 of file GPUClusterInfoAndMomentsCalculator.h.

m_skipInvalidClusters

Gaudi::Property<bool> GPUClusterInfoAndMomentsCalculator::m_skipInvalidClusters {this, "SkipInvalidClusters", true, "Check for and skip invalid clusters during moments calculation."}

private

If false, do the moment calculation even for invalid clusters (which may waste computation).

Defaults to true.

Definition at line 107 of file GPUClusterInfoAndMomentsCalculator.h.

m_twoGaussianNoise

Gaudi::Property<bool> GPUClusterInfoAndMomentsCalculator::m_twoGaussianNoise {this, "TwoGaussianNoise", false, "If set to true use 2-gaussian noise description for TileCal"}

private

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

Definition at line 102 of file GPUClusterInfoAndMomentsCalculator.h.

---

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

• GPUClusterInfoAndMomentsCalculator.h
• GPUClusterInfoAndMomentsCalculator.cxx