Tool to convert the GPU data representation back to CPU, with selected moments too. More...

#include <GPUToAthenaImporterWithMoments.h>

Inheritance diagram for GPUToAthenaImporterWithMoments:

Collaboration diagram for GPUToAthenaImporterWithMoments:

Public Member Functions
	GPUToAthenaImporterWithMoments (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual StatusCode	convert (const EventContext &ctx, const CaloRecGPU::ConstantDataHolder &constant_data, CaloRecGPU::EventDataHolder &event_data, xAOD::CaloClusterContainer *cluster_collection) const override
virtual StatusCode	finalize () override
virtual	~GPUToAthenaImporterWithMoments ()=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.
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_keepGPUData {this, "KeepGPUData", true, "Keep GPU allocated data"}
	If `true`, do not delete the GPU data representation.
SG::ReadHandleKey< CaloCellContainer >	m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}
	vector of names of the cell containers to use as input.
Gaudi::Property< std::string >	m_clusterSizeString {this, "ClusterSize", "Topo_420", "The size/type of the clusters"}
	Cluster size. Should be set accordingly to the threshold.
xAOD::CaloCluster::ClusterSize	m_clusterSize
const CaloCell_ID *	m_calo_id {nullptr}
	Pointer to Calo ID Helper.
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
	Key for the CaloDetDescrManager in the Condition Store.
Gaudi::Property< bool >	m_fillHVMoments {this, "FillHVMoments", false, "Fill the HV-related moments using the respective tools."}
	if set to true, fill the HV-related moments using the respective tools.
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_HVCablingKey {this, "LArCablingKey","LArOnOffIdMap","SG Key of LAr Cabling object"}
	Cabling for the CPU-based HV moments calculation.
SG::ReadCondHandleKey< ILArHVScaleCorr >	m_HVScaleKey {this,"HVScaleCorrKey","LArHVScaleCorr","SG key of HVScaleCorr conditions object"}
	HV corrections for the CPU-based HV moments.
Gaudi::Property< float >	m_HVthreshold {this,"HVThreshold",0.2,"Threshold to consider a cell 'affected' by HV issues"}
	Threshold above which a cell contributes to the HV moments.
Gaudi::Property< std::vector< int > >	m_missingCellsToFill {this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."}
	Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells).
Gaudi::Property< bool >	m_saveUncalibrated {this, "SaveUncalibratedSignalState", true, "Use CaloClusterKineHelper::calculateKine instead of GPU-calculated cluster properties"}
	if set to true, the uncalibrated state is saved when importing the clusters.
Gaudi::Property< std::vector< std::string > >	m_momentsNames {this, "MomentsNames", {}, "List of names of moments to calculate"}
	vector holding the input list of names of moments to calculate.
CaloRecGPU::MomentsOptionsArray	m_momentsToDo
	Holds (in a linearized way) the moments and whether to add them to the clusters.
bool	m_doHVMoments
	To abbreviate checks of `m_momentsToDo`...

Detailed Description

Tool to convert the GPU data representation back to CPU, with selected moments too.

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

Definition at line 34 of file GPUToAthenaImporterWithMoments.h.

Constructor & Destructor Documentation

◆ GPUToAthenaImporterWithMoments()

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

Definition at line 25 of file GPUToAthenaImporterWithMoments.cxx.

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

◆ ~GPUToAthenaImporterWithMoments()

virtual GPUToAthenaImporterWithMoments::~GPUToAthenaImporterWithMoments ( )

virtualdefault

Member Function Documentation

◆ convert()

StatusCode GPUToAthenaImporterWithMoments::convert	(	const EventContext &	ctx,
		const CaloRecGPU::ConstantDataHolder &	constant_data,
		CaloRecGPU::EventDataHolder &	event_data,
		xAOD::CaloClusterContainer *	cluster_collection ) const

overridevirtual

Definition at line 221 of file GPUToAthenaImporterWithMoments.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();
  };
 
  cluster_container->clear();
 
  const auto start = clock_type::now();
 
  SG::ReadHandle<CaloCellContainer> cell_collection(m_cellsKey, ctx);
  
  if ( !cell_collection.isValid() )
    {
      ATH_MSG_ERROR( " Cannot retrieve CaloCellContainer: " << cell_collection.name()  );
      return StatusCode::FAILURE;
    }
  const DataLink<CaloCellContainer> cell_collection_link (cell_collection.name(), ctx);
 
  size_t extra_times[6];
 
  const auto before_export = clock_type::now();
 
  ed.returnAndExportClusters(cluster_container,
                             &cell_collection_link,
                             m_momentsToDo,
                             false,
                             m_saveUncalibrated,
                             false,
                             m_missingCellsToFill,
                             m_measureTimes ? extra_times : nullptr);
 
  const auto after_export = clock_type::now();
 
  for (size_t i = 0; i < cluster_container->size(); ++i)
    {
      (*cluster_container)[i]->setClusterSize(m_clusterSize);
    }
 
  const auto after_size = clock_type::now();
 
  if (m_doHVMoments)
    {
      SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl(m_HVCablingKey, ctx);
      SG::ReadCondHandle<ILArHVScaleCorr> hvScaleHdl(m_HVScaleKey, ctx);
      const LArOnOffIdMapping * cabling = *cablingHdl;
      const ILArHVScaleCorr * hvcorr = *hvScaleHdl;
 
      std::vector<double> HV_energies(ed.m_clusters->number, 0.);
      std::vector<int>    HV_numbers(ed.m_clusters->number, 0.);
 
      for (int i = 0; i < ed.m_clusters->number_cells; ++i)
        {
          const int this_cluster = ed.m_clusters->clusterIndices[i];
            
          const int this_cell_index = ed.m_clusters->cells.indices[i];
          const int this_hash_ID = ed.m_cell_info->get_hash_ID(this_cell_index, ed.m_cell_info->complete);
 
          if (GeometryArr::is_tile(this_hash_ID))
            {
              continue;
            }
          
          HWIdentifier hwid = cabling->createSignalChannelIDFromHash(this_hash_ID);
          const float corr = hvcorr->HVScaleCorr(hwid);
 
          if (corr > 0.f && corr < 100.f && fabsf(corr - 1.f) > m_HVthreshold)
            {
              HV_energies[this_cluster] += fabsf(ed.m_cell_info->energy[this_cell_index]);
              ++HV_numbers[this_cluster];
            }
        }
 
      for (int i = 0; i < ed.m_clusters->number; ++i)
        {
          xAOD::CaloCluster * cluster = (*cluster_container)[i];
          if (m_momentsToDo[xAOD::CaloCluster::ENG_BAD_HV_CELLS])
            {
              cluster->insertMoment(xAOD::CaloCluster::ENG_BAD_HV_CELLS, HV_energies[i]);
            }
          if (m_momentsToDo[xAOD::CaloCluster::N_BAD_HV_CELLS])
            {
              cluster->insertMoment(xAOD::CaloCluster::N_BAD_HV_CELLS, HV_numbers[i]);
            }
        }
    }
  
  if (!m_keepGPUData)
    {
      ed.clear_GPU();
    }
  
  const auto after_HV = clock_type::now();
 
  if (m_measureTimes)
    {
      record_times(ctx.evt(),
                   time_cast(start, before_export),
                   extra_times[0],
                   extra_times[1],
                   extra_times[2],
                   extra_times[3],
                   extra_times[4],
                   extra_times[5],
                   time_cast(after_export, after_size),
                   time_cast(after_size, after_HV)
                  );
    }
 
  return StatusCode::SUCCESS;
 
}

◆ finalize()

StatusCode GPUToAthenaImporterWithMoments::finalize ( )

overridevirtual

Definition at line 341 of file GPUToAthenaImporterWithMoments.cxx.

{
  if (m_measureTimes)
    {
      print_times("Preprocessing Number_and_State Link_Creation Cell_Processing Sorting Basic_Info Moments Cluster_Size HV_Moments", 9);
    }
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode GPUToAthenaImporterWithMoments::initialize ( )

overridevirtual

Definition at line 34 of file GPUToAthenaImporterWithMoments.cxx.

{
  ATH_CHECK( m_cellsKey.initialize() );
 
  ATH_CHECK( detStore()->retrieve(m_calo_id, "CaloCell_ID") );
 
  ATH_CHECK(m_caloMgrKey.initialize());
 
  ATH_CHECK(m_HVCablingKey.initialize(m_fillHVMoments));
  ATH_CHECK(m_HVScaleKey.initialize(m_fillHVMoments));
 
  auto get_cluster_size_from_string = [](const std::string & str, bool & failed)
  {
    failed = false;
    //cppcheck-suppress syntaxError
    CRGPU_RECURSIVE_MACRO(
            CRGPU_CHEAP_STRING_TO_ENUM( str, xAOD::CaloCluster,
                                        SW_55ele,
                                        SW_35ele,
                                        SW_37ele,
                                        SW_55gam,
                                        SW_35gam,
                                        SW_37gam,
                                        SW_55Econv,
                                        SW_35Econv,
                                        SW_37Econv,
                                        SW_softe,
                                        Topo_420,
                                        Topo_633,
                                        SW_7_11,
                                        SuperCluster,
                                        Tower_01_01,
                                        Tower_005_005,
                                        Tower_fixed_area
                                      )
    )
    //I know Topological Clustering only supports a subset of those,
    //but this is supposed to be a general data exporting tool...
    else
      {
        //failed = true;
        return xAOD::CaloCluster::CSize_Unknown;
      }
  };
 
  bool size_failed = false;
  m_clusterSize = get_cluster_size_from_string(m_clusterSizeString, size_failed);
 
  if (m_clusterSize == xAOD::CaloCluster::CSize_Unknown)
    {
      ATH_MSG_ERROR("Invalid Cluster Size: " << m_clusterSizeString);
    }
 
  if (size_failed)
    {
      return StatusCode::FAILURE;
    }
 
 
  auto get_moment_from_string = [](const std::string & str, bool & failed)
  {
    failed = false;
    CRGPU_RECURSIVE_MACRO(
            CRGPU_CHEAP_STRING_TO_ENUM( str, xAOD::CaloCluster,
                                        FIRST_PHI,
                                        FIRST_ETA,
                                        SECOND_R,
                                        SECOND_LAMBDA,
                                        DELTA_PHI,
                                        DELTA_THETA,
                                        DELTA_ALPHA,
                                        CENTER_X,
                                        CENTER_Y,
                                        CENTER_Z,
                                        CENTER_MAG,
                                        CENTER_LAMBDA,
                                        LATERAL,
                                        LONGITUDINAL,
                                        ENG_FRAC_EM,
                                        ENG_FRAC_MAX,
                                        ENG_FRAC_CORE,
                                        FIRST_ENG_DENS,
                                        SECOND_ENG_DENS,
                                        ISOLATION,
                                        ENG_BAD_CELLS,
                                        N_BAD_CELLS,
                                        N_BAD_CELLS_CORR,
                                        BAD_CELLS_CORR_E,
                                        BADLARQ_FRAC,
                                        ENG_POS,
                                        SIGNIFICANCE,
                                        CELL_SIGNIFICANCE,
                                        CELL_SIG_SAMPLING,
                                        AVG_LAR_Q,
                                        AVG_TILE_Q,
                                        ENG_BAD_HV_CELLS,
                                        N_BAD_HV_CELLS,
                                        PTD,
                                        MASS,
                                        EM_PROBABILITY,
                                        HAD_WEIGHT,
                                        OOC_WEIGHT,
                                        DM_WEIGHT,
                                        TILE_CONFIDENCE_LEVEL,
                                        SECOND_TIME,
                                        NCELL_SAMPLING,
                                        VERTEX_FRACTION,
                                        NVERTEX_FRACTION,
                                        ETACALOFRAME,
                                        PHICALOFRAME,
                                        ETA1CALOFRAME,
                                        PHI1CALOFRAME,
                                        ETA2CALOFRAME,
                                        PHI2CALOFRAME,
                                        ENG_CALIB_TOT,
                                        ENG_CALIB_OUT_L,
                                        ENG_CALIB_OUT_M,
                                        ENG_CALIB_OUT_T,
                                        ENG_CALIB_DEAD_L,
                                        ENG_CALIB_DEAD_M,
                                        ENG_CALIB_DEAD_T,
                                        ENG_CALIB_EMB0,
                                        ENG_CALIB_EME0,
                                        ENG_CALIB_TILEG3,
                                        ENG_CALIB_DEAD_TOT,
                                        ENG_CALIB_DEAD_EMB0,
                                        ENG_CALIB_DEAD_TILE0,
                                        ENG_CALIB_DEAD_TILEG3,
                                        ENG_CALIB_DEAD_EME0,
                                        ENG_CALIB_DEAD_HEC0,
                                        ENG_CALIB_DEAD_FCAL,
                                        ENG_CALIB_DEAD_LEAKAGE,
                                        ENG_CALIB_DEAD_UNCLASS,
                                        ENG_CALIB_FRAC_EM,
                                        ENG_CALIB_FRAC_HAD,
                                        ENG_CALIB_FRAC_REST)
    )
    else
      {
        failed = true;
        return xAOD::CaloCluster::ENERGY_DigiHSTruth;
      }
  };
 
 
  auto process_moments = [&](const std::vector<std::string> & moment_names, std::string & invalid_names)
  {
    for (const std::string & mom_name : moment_names)
      {
        bool failed = false;
        const int linear_num = MomentsOptionsArray::moment_to_linear(get_moment_from_string(mom_name, failed));
 
        failed = failed || linear_num >= MomentsOptionsArray::num_moments;
 
        if (failed)
          {
            if (invalid_names.size() == 0)
              {
                invalid_names = "'" + mom_name + "'";
              }
            else
              {
                invalid_names += ", '" + mom_name + "'";
              }
          }
        else
          {
            m_momentsToDo.array[linear_num] = true;
          }
      }
  };
 
  std::string invalid_names;
 
  process_moments(m_momentsNames, invalid_names);
 
  if (invalid_names.size() > 0)
    {
      ATH_MSG_ERROR( "Moments " << invalid_names
                     << " are not valid moments and will be ignored!" );
    }
 
  m_doHVMoments = (m_momentsToDo[xAOD::CaloCluster::ENG_BAD_HV_CELLS] || m_momentsToDo[xAOD::CaloCluster::N_BAD_HV_CELLS]) && m_fillHVMoments;
  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_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.

◆ ATLAS_THREAD_SAFE [2/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.

◆ m_calo_id

const CaloCell_ID* GPUToAthenaImporterWithMoments::m_calo_id {nullptr}

private

Pointer to Calo ID Helper.

Definition at line 71 of file GPUToAthenaImporterWithMoments.h.

71{nullptr};

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> GPUToAthenaImporterWithMoments::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 76 of file GPUToAthenaImporterWithMoments.h.

76 {this, "CaloDetDescrManager", "CaloDetDescrManager",

77 "SG Key for CaloDetDescrManager in the Condition Store"};

◆ m_cellsKey

SG::ReadHandleKey<CaloCellContainer> GPUToAthenaImporterWithMoments::m_cellsKey {this, "CellsName", "", "Name(s) of Cell Containers"}

private

vector of names of the cell containers to use as input.

Definition at line 61 of file GPUToAthenaImporterWithMoments.h.

61{this, "CellsName", "", "Name(s) of Cell Containers"};

◆ m_clusterSize

xAOD::CaloCluster::ClusterSize GPUToAthenaImporterWithMoments::m_clusterSize

private

Definition at line 66 of file GPUToAthenaImporterWithMoments.h.

◆ m_clusterSizeString

Gaudi::Property<std::string> GPUToAthenaImporterWithMoments::m_clusterSizeString {this, "ClusterSize", "Topo_420", "The size/type of the clusters"}

private

Cluster size. Should be set accordingly to the threshold.

Definition at line 64 of file GPUToAthenaImporterWithMoments.h.

64{this, "ClusterSize", "Topo_420", "The size/type of the clusters"};

◆ m_doHVMoments

bool GPUToAthenaImporterWithMoments::m_doHVMoments

private

To abbreviate checks of m_momentsToDo...

Definition at line 120 of file GPUToAthenaImporterWithMoments.h.

◆ m_fillHVMoments

Gaudi::Property<bool> GPUToAthenaImporterWithMoments::m_fillHVMoments {this, "FillHVMoments", false, "Fill the HV-related moments using the respective tools."}

private

if set to true, fill the HV-related moments using the respective tools.

Definition at line 84 of file GPUToAthenaImporterWithMoments.h.

84{this, "FillHVMoments", false, "Fill the HV-related moments using the respective tools."};

◆ m_HVCablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> GPUToAthenaImporterWithMoments::m_HVCablingKey {this, "LArCablingKey","LArOnOffIdMap","SG Key of LAr Cabling object"}

private

Cabling for the CPU-based HV moments calculation.

Definition at line 87 of file GPUToAthenaImporterWithMoments.h.

87{this, "LArCablingKey","LArOnOffIdMap","SG Key of LAr Cabling object"};

◆ m_HVScaleKey

SG::ReadCondHandleKey<ILArHVScaleCorr> GPUToAthenaImporterWithMoments::m_HVScaleKey {this,"HVScaleCorrKey","LArHVScaleCorr","SG key of HVScaleCorr conditions object"}

private

HV corrections for the CPU-based HV moments.

Definition at line 90 of file GPUToAthenaImporterWithMoments.h.

90{this,"HVScaleCorrKey","LArHVScaleCorr","SG key of HVScaleCorr conditions object"};

◆ m_HVthreshold

Gaudi::Property<float> GPUToAthenaImporterWithMoments::m_HVthreshold {this,"HVThreshold",0.2,"Threshold to consider a cell 'affected' by HV issues"}

private

Threshold above which a cell contributes to the HV moments.

Definition at line 93 of file GPUToAthenaImporterWithMoments.h.

93{this,"HVThreshold",0.2,"Threshold to consider a cell 'affected' by HV issues"};

◆ m_keepGPUData

Gaudi::Property<bool> GPUToAthenaImporterWithMoments::m_keepGPUData {this, "KeepGPUData", true, "Keep GPU allocated data"}

private

If true, do not delete the GPU data representation.

Defaults to true.

Definition at line 56 of file GPUToAthenaImporterWithMoments.h.

56{this, "KeepGPUData", true, "Keep GPU allocated data"};

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

Gaudi::Property<std::vector<int> > GPUToAthenaImporterWithMoments::m_missingCellsToFill {this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."}

private

Cell indices to fill as disabled cells (useful if the cell vector is always missing the same cells).

Definition at line 97 of file GPUToAthenaImporterWithMoments.h.

97{this, "MissingCellsToFill", {}, "Force fill these cells as disabled on empty containers."};

◆ m_momentsNames

Gaudi::Property<std::vector<std::string> > GPUToAthenaImporterWithMoments::m_momentsNames {this, "MomentsNames", {}, "List of names of moments to calculate"}

private

vector holding the input list of names of moments to calculate.

This is the list of desired names of moments given in the jobOptions.

Definition at line 111 of file GPUToAthenaImporterWithMoments.h.

111{this, "MomentsNames", {}, "List of names of moments to calculate"};

◆ m_momentsToDo

CaloRecGPU::MomentsOptionsArray GPUToAthenaImporterWithMoments::m_momentsToDo

private

Holds (in a linearized way) the moments and whether to add them to the clusters.

(on the GPU side, they are unconditionally calculated).

Definition at line 116 of file GPUToAthenaImporterWithMoments.h.

◆ m_saveUncalibrated

Gaudi::Property<bool> GPUToAthenaImporterWithMoments::m_saveUncalibrated {this, "SaveUncalibratedSignalState", true, "Use CaloClusterKineHelper::calculateKine instead of GPU-calculated cluster properties"}

private

if set to true, the uncalibrated state is saved when importing the clusters.

Default is true.

Definition at line 102 of file GPUToAthenaImporterWithMoments.h.

102{this, "SaveUncalibratedSignalState", true, "Use CaloClusterKineHelper::calculateKine instead of GPU-calculated cluster properties"};

◆ 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

◆ GPUToAthenaImporterWithMoments()

◆ ~GPUToAthenaImporterWithMoments()

Member Function Documentation

◆ convert()

◆ finalize()

◆ initialize()

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

◆ m_caloMgrKey

◆ m_cellsKey

◆ m_clusterSize

◆ m_clusterSizeString

◆ m_doHVMoments

◆ m_fillHVMoments

◆ m_HVCablingKey

◆ m_HVScaleKey

◆ m_HVthreshold

◆ m_keepGPUData

◆ m_measureTimes

◆ m_missingCellsToFill

◆ m_momentsNames

◆ m_momentsToDo

◆ m_saveUncalibrated

◆ m_timeFileName

◆ m_timeMutex