Standard tool to calculate cluster info (energy, transverse energy, pseudo-rapidity and azimuthal angle) and apply E/ET cuts on clusters if desired. More...

#include <BasicGPUClusterInfoCalculator.h>

Inheritance diagram for BasicGPUClusterInfoCalculator:

Collaboration diagram for BasicGPUClusterInfoCalculator:

Public Member Functions
	BasicGPUClusterInfoCalculator (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	~BasicGPUClusterInfoCalculator ()=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< bool >	m_cutClustersInAbsE {this, "ClusterCutsInAbsEt", true, "Do cluster cuts in Abs Et instead of Et"}
	if set to `true` cluster cuts are on \(\|E\|_\perp\), if `false` on \(E_\perp\).
Gaudi::Property< float >	m_clusterETThreshold {this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"}
	\(E_\perp\) cut on the clusters.
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) and apply E/ET cuts on clusters if desired.

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: 11 August 2022

Definition at line 34 of file BasicGPUClusterInfoCalculator.h.

Constructor & Destructor Documentation

◆ BasicGPUClusterInfoCalculator()

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

Definition at line 16 of file BasicGPUClusterInfoCalculator.cxx.

                                                                                                                                     :
  base_class(type, name, parent),
  CaloGPUTimed(this)
{
}

◆ ~BasicGPUClusterInfoCalculator()

virtual BasicGPUClusterInfoCalculator::~BasicGPUClusterInfoCalculator ( )

virtualdefault

Member Function Documentation

◆ execute()

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

overridevirtual

Definition at line 34 of file BasicGPUClusterInfoCalculator.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();
  };
 
  const auto start = clock_type::now();
 
  const auto before_seed_properties = clock_type::now();
 
  updateSeedCellProperties(event_data, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes);
 
  const auto before_calculating = clock_type::now();
 
  calculateClusterProperties(event_data, constant_data, *(m_kernelSizeOptimizer.get()), m_measureTimes, m_cutClustersInAbsE, m_clusterETThreshold);
 
  const auto end = clock_type::now();
 
 
  if (m_measureTimes)
    {
      record_times(ctx.evt(),
                   time_cast(start, before_seed_properties),
                   time_cast(before_seed_properties, before_calculating),
                   time_cast(before_calculating, end)
                  );
    }
 
 
  return StatusCode::SUCCESS;
 
}

◆ finalize()

StatusCode BasicGPUClusterInfoCalculator::finalize ( )

overridevirtual

Definition at line 71 of file BasicGPUClusterInfoCalculator.cxx.

{
  if (m_measureTimes)
    {
      print_times("Preprocessing Seed_Cell_Properties_Updating Cluster_Properties_Calculation", 3);
    }
  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 BasicGPUClusterInfoCalculator::initialize ( )

inlineoverridevirtual

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 41 of file BasicGPUClusterInfoCalculator.h.

  {
    return CaloGPUCUDAInitialization::initialize();
  }

◆ initialize_CUDA()

StatusCode BasicGPUClusterInfoCalculator::initialize_CUDA ( )

overridevirtual

Initialization that invokes CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 28 of file BasicGPUClusterInfoCalculator.cxx.

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

◆ initialize_non_CUDA()

StatusCode BasicGPUClusterInfoCalculator::initialize_non_CUDA ( )

overridevirtual

Initialization that does not invoke CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 22 of file BasicGPUClusterInfoCalculator.cxx.

{ 
  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_clusterETThreshold

Gaudi::Property<float> BasicGPUClusterInfoCalculator::m_clusterETThreshold {this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"}

private

\(E_\perp\) cut on the clusters.

The clusters have to pass this cut (which is on \(E_\perp\) or \(|E|_\perp\) of the cluster depending on the above switch) in order to be inserted into the CaloClusterContainer.

Definition at line 74 of file BasicGPUClusterInfoCalculator.h.

74{this, "ClusterEtorAbsEtCut", 0.*CLHEP::MeV, "Cluster E_t or Abs E_t cut"};

◆ m_cutClustersInAbsE

Gaudi::Property<bool> BasicGPUClusterInfoCalculator::m_cutClustersInAbsE {this, "ClusterCutsInAbsEt", true, "Do cluster cuts in Abs Et instead of Et"}

private

if set to true cluster cuts are on \(|E|_\perp\), if false on \(E_\perp\).

Default is true.

Definition at line 65 of file BasicGPUClusterInfoCalculator.h.

65{this, "ClusterCutsInAbsEt", true, "Do cluster cuts in Abs Et instead of Et"};

◆ m_kernelSizeOptimizer

ServiceHandle<IGPUKernelSizeOptimizerSvc> BasicGPUClusterInfoCalculator::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 77 of file BasicGPUClusterInfoCalculator.h.

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

◆ 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_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.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BasicGPUClusterInfoCalculator()

◆ ~BasicGPUClusterInfoCalculator()

Member Function Documentation

◆ execute()

◆ finalize()

◆ handle()

◆ initialize()

◆ initialize_CUDA()

◆ initialize_non_CUDA()

◆ 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]

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

◆ ATLAS_THREAD_SAFE [2/2]

◆ m_clusterETThreshold

◆ m_cutClustersInAbsE

◆ m_kernelSizeOptimizer

◆ m_measureTimes

◆ m_timeFileName

◆ m_timeMutex