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.
virtual StatusCode	initialize_CUDA () override
	Initialization that invokes CUDA functions.
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

Protected Member Functions
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.
std::vector< size_t > m_times	ATLAS_THREAD_SAFE
	Vector to hold execution times to be recorded if necessary.
std::vector< size_t > m_eventNumbers	ATLAS_THREAD_SAFE
	Vector to hold the event numbers to be recorded if necessary.
Gaudi::Property< bool >	m_measureTimes
	If true, times are recorded to the file given by m_timeFileName.
Gaudi::Property< std::string >	m_timeFileName
	File to which times should be saved.

Private Member Functions
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< 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.
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
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
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
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
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.
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
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).
ClusterMomentsCalculator::CMCOptionsHolder	m_options
	Options for the algorithm, held in a GPU-friendly way.
ServiceHandle< IGPUKernelSizeOptimizerSvc >	m_kernelSizeOptimizer { this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." }
	Handle to the CUDA kernel block and grid size optimization service.

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 33 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),
  CaloGPUTimed(this)
{
}

~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 47 of file GPUClusterInfoAndMomentsCalculator.cxx.

{
  size_t times[num_time_measurements];
  
  calculateClusterPropertiesAndMoments(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), times, m_measureTimes);
  
  if (m_measureTimes)
    {
      record_times(ctx.evt(),
                   times[ 0],
                   times[ 1],
                   times[ 2],
                   times[ 3],
                   times[ 4],
                   times[ 5],
                   times[ 6],
                   times[ 7],
                   times[ 8],
                   times[ 9],
                   times[10]
                   );
    }
    
  return StatusCode::SUCCESS;
}

finalize()

StatusCode GPUClusterInfoAndMomentsCalculator::finalize ( )

overridevirtual

Definition at line 74 of file GPUClusterInfoAndMomentsCalculator.cxx.

{
  if (m_measureTimes)
    {
      print_times("Isolation_Clusters Isolation_Cells Zeroth_Clusters "
                  "First_Cells First_Clusters Second_Cells Shower_Axis Second_Clusters "
                  "Third_Cells Third_Clusters Finalize_Clusters", num_time_measurements);
    }
  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 40 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 39 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 20 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;
}

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)), ...);
  }

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_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 94 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "WeightingOfNegClusters", false, "If set to true use abs E value of cells to calculate cluster moments"};

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 98 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "EMECAbsEtaWheelTransition", 2.52, "Transition from outer to inner wheel in EME2"};

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 115 of file GPUClusterInfoAndMomentsCalculator.h.

{ this, "KernelSizeOptimizer", "GPUKernelSizeOptimizerSvc", "CUDA kernel size optimization service." };

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 63 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "MaxAxisAngle", 20 * CLHEP::deg, "The maximal allowed deviation from the IP-to-ClusterCenter-axis"};

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_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 89 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "MinBadLArQuality", 4000, "The minimal cell quality in the LAr for declaring a cell bad"};

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 81 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "MinLLongitudinal", 10 * CLHEP::cm, "The minimal lambda in the definition of the Longitudinal moment"};

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 71 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "MinRLateral", 4 * CLHEP::cm, "The minimal r in the definition of the Lateral moment"};  

m_options

ClusterMomentsCalculator::CMCOptionsHolder GPUClusterInfoAndMomentsCalculator::m_options

private

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

Definition at line 112 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 108 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "SkipInvalidClusters", true, "Check for and skip invalid clusters during moments calculation."};

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_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 103 of file GPUClusterInfoAndMomentsCalculator.h.

{this, "TwoGaussianNoise", false, "If set to true use 2-gaussian noise description for TileCal"};

---

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

• GPUClusterInfoAndMomentsCalculator.h
• GPUClusterInfoAndMomentsCalculator.cxx