BasicConstantGPUDataExporter Class Reference

Standard tool to export calorimeter geometry and cell noise to GPU. More...

#include <BasicConstantGPUDataExporter.h>

Inheritance diagram for BasicConstantGPUDataExporter:

Collaboration diagram for BasicConstantGPUDataExporter:

Public Member Functions
	BasicConstantGPUDataExporter (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	convert (CaloRecGPU::ConstantDataHolder &constant_data, const bool override_keep_CPU_info) const override
virtual StatusCode	convert (const EventContext &ctx, CaloRecGPU::ConstantDataHolder &constant_data, const bool override_keep_CPU_info) const override
virtual StatusCode	finalize () override
virtual	~BasicConstantGPUDataExporter ()=default

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. 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 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_keepCPUData {this, "KeepCPUData", true, "Keep CPU version of GPU data format"}
	If true, do not delete the CPU version of the GPU-friendly data representation. More...
SG::ReadCondHandleKey< CaloNoise >	m_noiseCDOKey {this, "CaloNoiseKey", "totalNoise", "SG Key of CaloNoise data object"}
	Key of the CaloNoise Conditions data object. More...
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
	Key for the CaloDetDescrManager in the Condition Store. More...
bool	m_hasBeenInitialized

Detailed Description

Standard tool to export calorimeter geometry and cell noise to GPU.

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

29 May 2022 For the time being, this must be run on first event, so that the noise tool exists and so on. Hopefully we can find a way around this in the future.

Definition at line 28 of file BasicConstantGPUDataExporter.h.

Constructor & Destructor Documentation

BasicConstantGPUDataExporter()

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

Definition at line 25 of file BasicConstantGPUDataExporter.cxx.

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

~BasicConstantGPUDataExporter()

virtual BasicConstantGPUDataExporter::~BasicConstantGPUDataExporter ( )

virtualdefault

Member Function Documentation

convert() [1/2]

StatusCode BasicConstantGPUDataExporter::convert ( CaloRecGPU::ConstantDataHolder &  constant_data, const bool  override_keep_CPU_info  ) const

overridevirtual

Definition at line 49 of file BasicConstantGPUDataExporter.cxx.

{
  ATH_MSG_ERROR("BasicConstantGPUDataExporter (" << this->name() << ") must be used with the "
                "GPU data preparation happening on the first event.");
 
  return StatusCode::FAILURE;
}

convert() [2/2]

StatusCode BasicConstantGPUDataExporter::convert ( const EventContext &  ctx, CaloRecGPU::ConstantDataHolder &  constant_data, const bool  override_keep_CPU_info  ) const

overridevirtual

Definition at line 57 of file BasicConstantGPUDataExporter.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();
  };
 
  auto start = clock_type::now();
 
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
  const CaloDetDescrManager * calo_dd_man = *caloMgrHandle;
 
  cd.m_geometry.allocate();
 
  const CaloCell_ID * calo_id = calo_dd_man->getCaloCell_ID();
 
  float min_eta_pos[NumSamplings], max_eta_pos[NumSamplings],
        min_eta_neg[NumSamplings], max_eta_neg[NumSamplings],
        min_phi_pos[NumSamplings], max_phi_pos[NumSamplings],
        min_phi_neg[NumSamplings], max_phi_neg[NumSamplings],
        min_deta   [NumSamplings], min_dphi   [NumSamplings];
 
  for (int i = 0; i < NumSamplings; ++i)
    {
      min_eta_pos[i] = std::numeric_limits<float>::max();
      max_eta_pos[i] = std::numeric_limits<float>::lowest();
      min_eta_neg[i] = std::numeric_limits<float>::max();
      max_eta_neg[i] = std::numeric_limits<float>::lowest();
      min_phi_pos[i] = std::numeric_limits<float>::max();
      max_phi_pos[i] = std::numeric_limits<float>::lowest();
      min_phi_neg[i] = std::numeric_limits<float>::max();
      max_phi_neg[i] = std::numeric_limits<float>::lowest();
      min_deta   [i] = std::numeric_limits<float>::max();
      min_dphi   [i] = std::numeric_limits<float>::max();
    }
 
  for (int cell = 0; cell < NCaloCells; ++cell)
    {
      const CaloDetDescrElement * caloElement = calo_dd_man->get_element((IdentifierHash) cell);
 
      const Identifier cell_identifier = calo_id->cell_id((IdentifierHash) cell);
 
      const int  sampling            = calo_id->calo_sample(cell_identifier);
      const int  intra_calo_sampling = calo_id->sampling(cell_identifier);
      const int  subcalo             = caloElement->getSubCalo();
      const int  region              = calo_id->region(cell_identifier);
      
      const bool is_PS               =   (subcalo == CaloCell_ID::LAREM   && intra_calo_sampling == 0);
      
      const bool is_HECIW_or_FCAL    = ( (subcalo == CaloCell_ID::LARHEC  && region              == 1 ) ||
                                         (subcalo == CaloCell_ID::LARFCAL && intra_calo_sampling >  1 )    );
      
      cd.m_geometry->otherCellInfo[cell] = OtherCellInfo(sampling,
                                                         ConstantEnumConversion::from_intra_calorimeter_sampling_enum(intra_calo_sampling),
                                                         ConstantEnumConversion::from_subcalo_enum(subcalo),
                                                         ConstantEnumConversion::from_region_enum(region),
                                                         is_PS,
                                                         is_HECIW_or_FCAL);
      cd.m_geometry->x[cell] = caloElement->x();
      cd.m_geometry->y[cell] = caloElement->y();
      cd.m_geometry->z[cell] = caloElement->z();
      cd.m_geometry->r[cell] = caloElement->r();
      cd.m_geometry->eta[cell] = caloElement->eta();
      cd.m_geometry->phi[cell] = caloElement->phi();
 
      cd.m_geometry->dx[cell] = caloElement->dx();
      cd.m_geometry->dy[cell] = caloElement->dy();
      cd.m_geometry->dz[cell] = caloElement->dz();
      cd.m_geometry->dr[cell] = caloElement->dr();
      cd.m_geometry->deta[cell] = caloElement->deta();
      cd.m_geometry->dphi[cell] = caloElement->dphi();
 
      cd.m_geometry->volume[cell] = caloElement->volume();
      cd.m_geometry->neighbours.offsets[cell] = 0;
 
      if (caloElement->eta() >= 0)
        {
          min_eta_pos[sampling] = std::min(min_eta_pos[sampling], caloElement->eta() - caloElement->deta() / 2);
          min_phi_pos[sampling] = std::min(min_phi_pos[sampling], caloElement->phi() - caloElement->dphi() / 2);
          max_eta_pos[sampling] = std::max(max_eta_pos[sampling], caloElement->eta() + caloElement->deta() / 2);
          max_phi_pos[sampling] = std::max(max_phi_pos[sampling], caloElement->phi() + caloElement->dphi() / 2);
        }
      else
        {
          min_eta_neg[sampling] = std::min(min_eta_neg[sampling], caloElement->eta() - caloElement->deta() / 2);
          min_phi_neg[sampling] = std::min(min_phi_neg[sampling], caloElement->phi() - caloElement->dphi() / 2);
          max_eta_neg[sampling] = std::max(max_eta_neg[sampling], caloElement->eta() + caloElement->deta() / 2);
          max_phi_neg[sampling] = std::max(max_phi_neg[sampling], caloElement->phi() + caloElement->dphi() / 2);
        }
      min_deta[sampling] = std::min(min_deta[sampling], caloElement->deta());
      min_dphi[sampling] = std::min(min_dphi[sampling], caloElement->dphi());
 
    }
 
  for (int i = 0; i < NumSamplings; ++i)
    {
      constexpr float corrective_factor = 0.99f;
      cd.m_geometry->etaPhiToCell.initialize(i, min_eta_neg[i], min_phi_neg[i], max_eta_neg[i], max_phi_neg[i],
                                             min_eta_pos[i], min_phi_pos[i], max_eta_pos[i], max_phi_pos[i],
                                             min_deta[i]*corrective_factor, min_dphi[i]*corrective_factor);
    }
 
  cd.m_geometry->fill_eta_phi_map();
 
  std::vector<IdentifierHash> neighbour_vector, full_neighs, prev_neighs;
 
  for (int cell = 0; cell < NCaloCells; ++cell)
    {
      for (int neigh_bit_set = 0; neigh_bit_set < NumNeighOptions; ++neigh_bit_set)
        {
          const unsigned int curr_neigh_opt = (1U << neigh_bit_set);
 
          if (curr_neigh_opt == LArNeighbours::corners2D || curr_neigh_opt == LArNeighbours::corners3D)
            //Scanning the ATLAS codebase, neighbour handling has special cases
            //for all2D (LarFCAL_Base_ID.cxx, LArMiniFCAL_ID.cxx, Tile_Base_ID.cxx)
            //and all3DwithCorners (Tile_Base_ID.cxx), which include
            //neighbours not returned when just the constituent bits are set separately.
            //As an imperfect workaround, we stuff them in the immediately previous option
            //(corners, for both 2D and 3D).
            {
              if (curr_neigh_opt == LArNeighbours::corners2D)
                {
                  calo_id->get_neighbours((IdentifierHash) cell,
                                          (LArNeighbours::neighbourOption) LArNeighbours::all2D,
                                          full_neighs);
                }
              else /*if (curr_neigh_opt == LArNeighbours::corners3D)*/
                {
                  calo_id->get_neighbours((IdentifierHash) cell,
                                          (LArNeighbours::neighbourOption) LArNeighbours::all3DwithCorners,
                                          prev_neighs);
                  calo_id->get_neighbours((IdentifierHash) cell,
                                          (LArNeighbours::neighbourOption) LArNeighbours::super3D,
                                          neighbour_vector);
                  //We will exclude the cells that could come from later options
                  //(it seems,  from Tile_Base_ID.cxx, all3DwithCorners will give more than super3D),
                  //which... might make some sense, but seems unexpected.
 
 
                  std::sort(neighbour_vector.begin(), neighbour_vector.end());
                  std::sort(prev_neighs.begin(), prev_neighs.end());
 
                  full_neighs.clear();
 
                  std::set_difference( prev_neighs.begin(), prev_neighs.end(),
                                       neighbour_vector.begin(), neighbour_vector.end(),
                                       std::back_inserter(full_neighs)    );
 
                }
 
              prev_neighs.resize(cd.m_geometry->neighbours.get_total_number_of_neighbours(cell));
              //We want to add just the neighbours that are not part of this.
 
              for (size_t neigh = 0; neigh < prev_neighs.size(); ++neigh)
                {
                  prev_neighs[neigh] = cd.m_geometry->neighbours.get_neighbour(cell, neigh);
                }
 
              std::sort(full_neighs.begin(), full_neighs.end());
              std::sort(prev_neighs.begin(), prev_neighs.end());
 
              neighbour_vector.clear();
 
              std::set_difference( full_neighs.begin(), full_neighs.end(),
                                   prev_neighs.begin(), prev_neighs.end(),
                                   std::back_inserter(neighbour_vector)    );
            }
          else
            {
              calo_id->get_neighbours((IdentifierHash) cell, (LArNeighbours::neighbourOption) curr_neigh_opt, neighbour_vector);
            }
 
          std::sort(neighbour_vector.begin(), neighbour_vector.end());
 
          const int neighs_start = cd.m_geometry->neighbours.get_total_number_of_neighbours(cell);
 
          for (size_t neigh_num = 0; neigh_num < neighbour_vector.size(); ++neigh_num)
            {
              cd.m_geometry->neighbours.set_neighbour(cell, neighs_start + neigh_num, neighbour_vector[neigh_num]);
            }
 
          cd.m_geometry->neighbours.offsets[cell] += NeighOffset::offset_delta(neigh_bit_set) * neighbour_vector.size();
 
        }
    }
 
#if CALORECGPU_ADD_FULL_PAIRS_LIST_TO_CONSTANT_INFORMATION
 
//Note: the commented out code is used to output the hard-coded numbers
//in NeighPairsArr. For the time being, it should remain here until
//a more definitive solution for the geometry is found.
 
    {
      int num_pairs = 0;
 
      auto add_neighbours = [&](const int cell, const unsigned int curr_neigh_opt)
      {
        int neighbours[NMaxNeighbours];
 
        const int num_neighs = cd.m_geometry->neighbours.get_neighbours(curr_neigh_opt, cell, neighbours);
 
        for (int neigh = 0; neigh < num_neighs; ++neigh)
          {
            cd.m_geometry->neighPairs.cell_A[num_pairs] = cell;
            cd.m_geometry->neighPairs.cell_B[num_pairs] = neighbours[neigh];
            ++num_pairs;
          }
      };
 
      for (int neigh_bit_set = 0; neigh_bit_set < NumNeighOptions; ++neigh_bit_set)
        {
          const unsigned int curr_neigh_opt = (1U << neigh_bit_set);
 
          for (int cell = 0; cell < NCaloCells; ++cell)
            {
              if (cd.m_geometry->is_PS(cell) || cd.m_geometry->is_HECIW_or_FCal(cell))
                {
                  continue;
                }
 
              add_neighbours(cell, curr_neigh_opt);
            }
 
          //const int PS_start = num_pairs;
 
          for (int cell = 0; cell < NCaloCells; ++cell)
            {
              if (!cd.m_geometry->is_PS(cell))
                {
                  continue;
                }
 
              add_neighbours(cell, curr_neigh_opt);
            }
 
          //const int HECIW_FCal_start = num_pairs;
 
          for (int cell = 0; cell < NCaloCells; ++cell)
            {
              if (!cd.m_geometry->is_HECIW_or_FCal(cell))
                {
                  continue;
                }
 
              add_neighbours(cell, curr_neigh_opt);
            }
 
          //std::cout << neigh_bit_set << " " << num_pairs << " " << PS_start << " " << HECIW_FCal_start << std::endl;
        }
    }
#endif
 
  auto after_geo = clock_type::now();
 
  /*
    //Useful output for debugging and studying regularities in calorimeter geometry...
    
    std::cout << "ID\tCaloSample\tSampling\tRegion\tSubCalo";
    for (int j = 0; j < NumNeighOptions; ++j)
      {
        std::cout << "\tn_" << j;
      }
    std::cout << "\tn_total\tOffset" << std::endl;
 
    for (int cell = 0; cell < NCaloCells; ++cell)
    {
 
        const CaloDetDescrElement * caloElement = calo_dd_man->get_element((IdentifierHash) cell);
        std::cout << cell                                                                << "\t"
                  << (int) calo_id->calo_sample(calo_id->cell_id((IdentifierHash) cell)) << "\t"
                  << (int) calo_id->sampling(calo_id->cell_id((IdentifierHash) cell))    << "\t"
                  << (int) calo_id->region(calo_id->cell_id((IdentifierHash) cell))      << "\t"
                  << (int) caloElement->getSubCalo();
 
        const NeighOffset n_off = cd.m_geometry->neighbours.offsets[cell];
 
        for (int j = 0; j < NumNeighOptions; ++j)
          {
            std::cout << "\t" << n_off.get_num_cells(j);
          }
 
        std::cout << "\t" << n_off.get_total_number() << "\t" << n_off << std::endl;
    }
  // */
 
  SG::ReadCondHandle<CaloNoise> noise_handle(m_noiseCDOKey, ctx);
  const CaloNoise * noise_tool = *noise_handle;
 
  IdentifierHash t_start, t_end;
  calo_id->calo_cell_hash_range(CaloCell_ID::TILE, t_start, t_end);
 
  if (t_start != TileCellStart)
    {
      ATH_MSG_WARNING("Tile start (" << t_start << ") differs from assumed constant value (" << TileCellStart << ")!");
    }
  if (t_end != TileCellAfterEnd)
    {
      ATH_MSG_WARNING("Tile end (" << t_end << ") differs from assumed constant value (" << TileCellAfterEnd << ")!");
    }
 
  const CaloCondBlobFlt * blob = noise_tool->getTileBlob();
 
  cd.m_cell_noise.allocate();
 
  if (!blob)
    {
      cd.m_cell_noise->noise_properties = CellNoiseProperties::invalid_value();
    }
  else
    {
      cd.m_cell_noise->noise_properties = CellNoiseProperties(blob->getObjVersion(), noise_tool->getNoiseType());
    }
 
  cd.m_cell_noise->luminosity = noise_tool->getLumi();
 
  for (int cell = 0; cell < int(t_start); ++cell)
    {
      for (int gain_state = 0; gain_state < CaloRecGPU::NumGainStates; ++gain_state)
        {
          cd.m_cell_noise->noise[cell][gain_state] = noise_tool->larStorage()[(gain_state > 2 ? 0 : gain_state)][cell];
        }
    }
  for (int cell = t_start; cell < int(t_end); ++cell)
    {
      for (int gain_state = 0; gain_state < CaloRecGPU::NumGainStates; ++gain_state)
        {
          cd.m_cell_noise->noise[cell][gain_state] = noise_tool->tileStorage()[gain_state][cell - t_start];
          cd.m_cell_noise->double_gaussian_constants[0][cell - t_start][gain_state] = blob->getData(cell - t_start, gain_state, 2);
          cd.m_cell_noise->double_gaussian_constants[1][cell - t_start][gain_state] = blob->getData(cell - t_start, gain_state, 3);
          cd.m_cell_noise->double_gaussian_constants[2][cell - t_start][gain_state] = blob->getData(cell - t_start, gain_state, 4);
          cd.m_cell_noise->double_gaussian_constants[3][cell - t_start][gain_state] = blob->getData(cell - t_start, gain_state, 1);
        }
    }
  for (int cell = t_end; cell < NCaloCells; ++cell)
    {
      for (int gain_state = 0; gain_state < CaloRecGPU::NumGainStates; ++gain_state)
        {
          cd.m_cell_noise->noise[cell][gain_state] = 0;
        }
    }
 
  auto after_noise = clock_type::now();
 
  cd.sendToGPU(!(m_keepCPUData || keep_CPU_info));
 
 
  auto after_send = clock_type::now();
 
  if (m_measureTimes)
    {
      record_times(ctx.evt(), time_cast(start, after_geo),
                   time_cast(after_geo, after_noise),
                   time_cast(after_noise, after_send)
                  );
    }
 
  return StatusCode::SUCCESS;
 
}

finalize()

StatusCode BasicConstantGPUDataExporter::finalize ( )

overridevirtual

Definition at line 418 of file BasicConstantGPUDataExporter.cxx.

{
 
  if (m_measureTimes)
    {
      print_times("Geometry Geometry_Correction Noise Transfer_to_GPU", 3 /*4*/);
    }
  return StatusCode::SUCCESS;
}

initialize()

StatusCode BasicConstantGPUDataExporter::initialize ( )

overridevirtual

Definition at line 32 of file BasicConstantGPUDataExporter.cxx.

{
  if (m_hasBeenInitialized)
    {
      ATH_MSG_INFO("Initializing data tool again...");
      return StatusCode::SUCCESS;
    }
 
  ATH_CHECK(m_noiseCDOKey.initialize());
 
  ATH_CHECK(m_caloMgrKey.initialize());
 
  m_hasBeenInitialized = true;
 
  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_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> BasicConstantGPUDataExporter::m_caloMgrKey

private

Initial value:

{this, "CaloDetDescrManager", "CaloDetDescrManager",
                                                          "SG Key for CaloDetDescrManager in the Condition Store"}

Key for the CaloDetDescrManager in the Condition Store.

Definition at line 62 of file BasicConstantGPUDataExporter.h.

m_hasBeenInitialized

bool BasicConstantGPUDataExporter::m_hasBeenInitialized

private

Definition at line 66 of file BasicConstantGPUDataExporter.h.

m_keepCPUData

Gaudi::Property<bool> BasicConstantGPUDataExporter::m_keepCPUData {this, "KeepCPUData", true, "Keep CPU version of GPU data format"}

private

If true, do not delete the CPU version of the GPU-friendly data representation.

Defaults to false.

Definition at line 52 of file BasicConstantGPUDataExporter.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_noiseCDOKey

SG::ReadCondHandleKey<CaloNoise> BasicConstantGPUDataExporter::m_noiseCDOKey {this, "CaloNoiseKey", "totalNoise", "SG Key of CaloNoise data object"}

private

Key of the CaloNoise Conditions data object.

Typical values are '"electronicNoise', 'pileupNoise', or '"totalNoise' (default)

Definition at line 57 of file BasicConstantGPUDataExporter.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:

• BasicConstantGPUDataExporter.h
• BasicConstantGPUDataExporter.cxx