TopoAutomatonClustering Class Reference

Topological cluster maker algorithm to be run on GPUs. More...

#include <TopoAutomatonClustering.h>

Inheritance diagram for TopoAutomatonClustering:

Collaboration diagram for TopoAutomatonClustering:

Public Member Functions
	TopoAutomatonClustering (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	~TopoAutomatonClustering ()=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< std::vector< std::string > >	m_caloNames {this, "CalorimeterNames", {}, "Name(s) of Calorimeters to use for clustering"}
	vector of names of the calorimeters to consider.
Gaudi::Property< std::vector< std::string > >	m_samplingNames {this, "SeedSamplingNames", {}, "Name(s) of Calorimeter Samplings to consider for seeds"}
	vector of names of the calorimeter samplings to consider for seeds.
Gaudi::Property< float >	m_cellThresholdOnEorAbsEinSigma {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"}
	all cells have to satisfy \(|E| > N_{\rm cell}\,\sigma\)
Gaudi::Property< float >	m_neighborThresholdOnEorAbsEinSigma {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"}
	cells with \(|E| > N_{\rm neighbor}\,\sigma\) extend the cluster
Gaudi::Property< float >	m_seedThresholdOnEorAbsEinSigma {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"}
	cells with \(|E| > N_{\rm seed}\,\sigma\) start a cluster
Gaudi::Property< bool >	m_seedCutsInAbsE {this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"}
	if set to true seed cuts are on \(|E|\) and \(|E|_\perp\).
Gaudi::Property< bool >	m_neighborCutsInAbsE {this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"}
	if set to true neighbor cuts are on \(|E|\) and \(|E|_\perp\).
Gaudi::Property< bool >	m_cellCutsInAbsE {this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"}
	if set to true cell cuts are on \(|E|\) and \(|E|_\perp\).
Gaudi::Property< bool >	m_cutCellsInTime {this, "SeedCutsInT", false, "Do seed cuts in time"}
	if set to true, time cut is applied to seed cells, no cut otherwise
Gaudi::Property< float >	m_timeThreshold {this, "SeedThresholdOnTAbs", 12.5 * CLHEP::ns, "Time thresholds (in abs. val.)"}
	threshold used for timing cut on seed cells.
Gaudi::Property< float >	m_thresholdForKeeping {this, "TimeCutUpperLimit", 20., "Significance upper limit for applying time cut"}
	upper limit on the energy significance, for applying the cell time cut
Gaudi::Property< bool >	m_treatL1PredictedCellsAsGood {this, "TreatL1PredictedCellsAsGood", true, "Treat bad cells with dead OTX if predicted from L1 as good"}
	if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead of bad cells
Gaudi::Property< bool >	m_excludeCutSeedsFromClustering {this, "CutOOTseed", true, "Exclude out-of-time seeds from neighbouring and cell stage"}
	if set to true, seed cells failing the time cut are also excluded from cluster at all
Gaudi::Property< bool >	m_keepSignificantCells {this, "UseTimeCutUpperLimit", false, "Do not apply time cut on cells of large significance"}
	if set to true, the time cut is not applied on cell of large significance
Gaudi::Property< bool >	m_twoGaussianNoise {this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"}
	if set to true use 2-gaussian noise description for TileCal
Gaudi::Property< std::string >	m_neighborOptionString
	type of neighbor relations to use.
Gaudi::Property< bool >	m_restrictHECIWandFCalNeighbors
	if set to true limit the neighbors in HEC IW and FCal2&3.
Gaudi::Property< bool >	m_restrictPSNeighbors
	if set to true limit the neighbors in presampler Barrel and Endcap.
Gaudi::Property< bool >	m_xtalkEM2
	If set to true, the time window is softened in the EMB2 and EME2_OW due to crosstalk from direct neighbour cells in phi.
Gaudi::Property< float >	m_xtalkDeltaT
	Additional maximum delta t added to the upper limit time window in case crosstalk in EM2 should be accounted for.
TAGrowing::TACOptionsHolder	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

Topological cluster maker algorithm to be run on GPUs.

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

31 May 2022

Definition at line 36 of file TopoAutomatonClustering.h.

Constructor & Destructor Documentation

TopoAutomatonClustering()

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

Definition at line 24 of file TopoAutomatonClustering.cxx.

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

~TopoAutomatonClustering()

virtual TopoAutomatonClustering::~TopoAutomatonClustering ( )

virtualdefault

Member Function Documentation

execute()

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

overridevirtual

Definition at line 254 of file TopoAutomatonClustering.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_snr = clock_type::now();
 
  signalToNoise(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
 
  const auto before_pairs = clock_type::now();
 
  cellPairs(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
 
  const auto before_growing = clock_type::now();
 
  clusterGrowing(event_data, constant_data, m_options, *(m_kernelSizeOptimizer.get()), m_measureTimes);
 
  const auto end = clock_type::now();
 
 
  if (m_measureTimes)
    {
      record_times(ctx.evt(),
                   time_cast(start, before_snr),
                   time_cast(before_snr, before_pairs),
                   time_cast(before_pairs, before_growing),
                   time_cast(before_growing, end)
                  );
    }
 
  return StatusCode::SUCCESS;
 
 
}

finalize()

StatusCode TopoAutomatonClustering::finalize ( )

overridevirtual

Definition at line 297 of file TopoAutomatonClustering.cxx.

{
  if (m_measureTimes)
    {
      print_times("Preprocessing Signal-to-Noise_Ratio Cell_Pair_Creation Cluster_Growing", 4);
    }
  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 TopoAutomatonClustering::initialize ( )

inlineoverridevirtual

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 43 of file TopoAutomatonClustering.h.

  {
    return CaloGPUCUDAInitialization::initialize();
  }

initialize_CUDA()

StatusCode TopoAutomatonClustering::initialize_CUDA ( )

overridevirtual

Initialization that invokes CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 244 of file TopoAutomatonClustering.cxx.

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

initialize_non_CUDA()

StatusCode TopoAutomatonClustering::initialize_non_CUDA ( )

overridevirtual

Initialization that does not invoke CUDA functions.

Reimplemented from CaloGPUCUDAInitialization.

Definition at line 30 of file TopoAutomatonClustering.cxx.

{
 
  m_options.allocate();
 
 
  using PackType = decltype(m_options.m_options->valid_sampling_seed);
 
  static_assert(CaloCell_ID::getNumberOfSamplings() <= sizeof(PackType) * CHAR_BIT,  "We are assuming that we have fewer samplings that bits per int!");
 
  //Possibly more elegant alternative: compile-time packed bool vector (std::bitset?) with CUDA compat.
  //Been there, done that, overkill since number of samplings shouldn't change unexpectedly overnight
  //and it doesn't seem that likely to me that it'll reach anything that a 64-bit int wouldn't cover
  //(at least without implying such a major overhaul that the code will need a deeper redesign anyway...)
 
  auto get_sampling_from_string = [](const std::string & str, bool & failed)
  {
    failed = false;
    CRGPU_RECURSIVE_MACRO(
            CRGPU_CHEAP_STRING_TO_ENUM( str, CaloCell_ID,
                                        PreSamplerB,
                                        EMB1,
                                        EMB2,
                                        EMB3,
                                        PreSamplerE,
                                        EME1,
                                        EME2,
                                        EME3,
                                        HEC0,
                                        HEC1,
                                        HEC2,
                                        HEC3,
                                        TileBar0,
                                        TileBar1,
                                        TileBar2,
                                        TileGap1,
                                        TileGap2,
                                        TileGap3,
                                        TileExt0,
                                        TileExt1,
                                        TileExt2,
                                        FCAL0,
                                        FCAL1,
                                        FCAL2
                                      )
    )
    else
      {
        failed = true;
        return CaloCell_ID::Unknown;
      }
  };
 
 
  PackType & seed_samplings = m_options.m_options->valid_sampling_seed;
 
  seed_samplings = 0;
  
  for (const std::string & samp_name : m_samplingNames)
    {
      bool failed = false;
      const PackType sampling = (PackType) get_sampling_from_string(samp_name, failed);
 
      if (failed)
        {
          ATH_MSG_ERROR( "Calorimeter sampling" << samp_name
                         << " is not a valid Calorimeter sampling name and will be ignored! "
                         << "Valid names are: "
                         << "PreSamplerB, EMB1, EMB2, EMB3, "
                         << "PreSamplerE, EME1, EME2, EME3, "
                         << "HEC0, HEC1, HEC2, HEC3, "
                         << "TileBar0, TileBar1, TileBar2, "
                         << "TileGap1, TileGap2, TileGap3, "
                         << "TileExt0, TileExt1, TileExt2, "
                         << "FCAL0, FCAL1, FCAL2."  );
        }
      else
        {
          seed_samplings |= ((PackType) 1) << sampling;
        }
    }
 
  auto get_calo_from_string = [](const std::string & str, bool & failed)
  {
    failed = false;
    CRGPU_RECURSIVE_MACRO(
            CRGPU_CHEAP_STRING_TO_ENUM( str, CaloCell_ID,
                                        LAREM, LARHEC,
                                        LARFCAL, TILE,
                                        LARMINIFCAL
                                      )
    )
    else
      {
        failed = true;
        return CaloCell_ID::NOT_VALID;
      }
  };
  
  
  auto calo_to_sampling_mask = [](const CaloCell_ID::SUBCALO sc) -> PackType
  {
    switch (sc)
      {
        case CaloCell_ID::LAREM:
          return 0xFFU;
        //PreSamplerB=0, EMB1, EMB2, EMB3,
        //PreSamplerE, EME1, EME2, EME3=7,
        case CaloCell_ID::LARHEC:
          return 0xF00U;
        //HEC0=8, HEC1, HEC2, HEC3=11,
        case CaloCell_ID::TILE:
          return 0x1FF000U;
        //TileBar0=12, TileBar1, TileBar2,
        //TileGap1, TileGap2, TileGap3,
        //TileExt0, TileExt1, TileExt2=20,
        case CaloCell_ID::LARFCAL:
          return 0xE00000U;
        //FCAL0=21, FCAL1, FCAL2=23
        case CaloCell_ID::LARMINIFCAL:
          return 0xF000000U;
        //MINIFCAL0=24, MINIFCAL1, MINIFCAL2, MINIFCAL3=27,
        default:
          return 0;
      }
  };
  
  PackType & calo_samplings = m_options.m_options->valid_calorimeter_by_sampling;
 
  calo_samplings = 0;
  
  for (const std::string & calo_name : m_caloNames)
    {
      bool failed = false;
      const PackType sample_mask = calo_to_sampling_mask(get_calo_from_string(calo_name, failed));
 
      if (failed)
        {
          ATH_MSG_ERROR( "Calorimeter " << calo_name
                         << " is not a valid Calorimeter name and will be ignored! "
                         << "Valid names are: LAREM, LARHEC, LARFCAL, and TILE."  );
        }
      else
        {
          calo_samplings |= sample_mask;
        }
    }
  
    auto get_neighbour_option_from_string = [](const std::string & str, bool & failed)
  {
    failed = false;
    CRGPU_RECURSIVE_MACRO(
            CRGPU_CHEAP_STRING_TO_ENUM( str, LArNeighbours,
                                        prevInPhi,
                                        nextInPhi,
                                        prevInEta,
                                        nextInEta,
                                        faces2D,
                                        corners2D,
                                        all2D,
                                        prevInSamp,
                                        nextInSamp,
                                        upAndDown,
                                        prevSubDet,
                                        nextSubDet,
                                        all3D,
                                        corners3D,
                                        all3DwithCorners,
                                        prevSuperCalo,
                                        nextSuperCalo,
                                        super3D
                                      )
    )
    else
      {
        failed = true;
        return LArNeighbours::super3D;
      }
  };
 
  bool neigh_failed = false;
  m_options.m_options->neighbour_options = (unsigned int) get_neighbour_option_from_string(m_neighborOptionString, neigh_failed);
 
  if (neigh_failed)
    {
      ATH_MSG_ERROR("Invalid Neighbour Option: " << m_neighborOptionString);
    }
 
  m_options.m_options->seed_threshold = m_seedThresholdOnEorAbsEinSigma;
  m_options.m_options->grow_threshold = m_neighborThresholdOnEorAbsEinSigma;
  m_options.m_options->terminal_threshold = m_cellThresholdOnEorAbsEinSigma;
  m_options.m_options->abs_seed = m_seedCutsInAbsE;
  m_options.m_options->abs_grow = m_neighborCutsInAbsE;
  m_options.m_options->abs_terminal = m_cellCutsInAbsE;
  m_options.m_options->use_two_gaussian = m_twoGaussianNoise;
 
  m_options.m_options->treat_L1_predicted_as_good = m_treatL1PredictedCellsAsGood;
  m_options.m_options->use_time_cut = m_cutCellsInTime;
  m_options.m_options->keep_significant_cells = m_keepSignificantCells;
  m_options.m_options->completely_exclude_cut_seeds = m_excludeCutSeedsFromClustering;
  m_options.m_options->time_threshold = m_timeThreshold;
  m_options.m_options->snr_threshold_for_keeping_cells = m_thresholdForKeeping;
 
  m_options.m_options->limit_HECIW_and_FCal_neighs = m_restrictHECIWandFCalNeighbors;
  m_options.m_options->limit_PS_neighs = m_restrictPSNeighbors;
  
  m_options.m_options->use_crosstalk = m_xtalkEM2;
  m_options.m_options->crosstalk_delta = m_xtalkDeltaT;
 
  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_caloNames

Gaudi::Property<std::vector<std::string> > TopoAutomatonClustering::m_caloNames {this, "CalorimeterNames", {}, "Name(s) of Calorimeters to use for clustering"}

private

vector of names of the calorimeters to consider.

The default is to use all calorimeters (i.e. LAREM, LARHEC, LARFCAL, TILE). Cells which belong to one of the input cell containers and to one of the calorimeters in this vector are used as input for the cluster maker. This property is used in order to ignore a certain subsystem (e.g. for LAREM only clusters specify only LAREM in the jobOptions).

Definition at line 72 of file TopoAutomatonClustering.h.

{this, "CalorimeterNames", {}, "Name(s) of Calorimeters to use for clustering"};  

m_cellCutsInAbsE

Gaudi::Property<bool> TopoAutomatonClustering::m_cellCutsInAbsE {this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"}

private

if set to true cell cuts are on \(|E|\) and \(|E|_\perp\).

The cell cuts will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 150 of file TopoAutomatonClustering.h.

{this, "CellCutsInAbsE", true, "Cell (terminal) cuts in Abs E instead of E"};

m_cellThresholdOnEorAbsEinSigma

Gaudi::Property<float> TopoAutomatonClustering::m_cellThresholdOnEorAbsEinSigma {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"}

private

all cells have to satisfy \(|E| > N_{\rm cell}\,\sigma\)

This cut determines how much the cluster will extend beyond the last cell passing the neighbor threshold. The smaller this cut is the more cells will be allowed in the tail of the cluster. It should be smaller or equal to the neighbor threshold. If a cell passing this cut is neighbor of two or more cells passing the neighbor cut it will be inserted in the cluster which has the neighbor cell that was asked first for its neighbors. Since the original list of seed cells is ordered in descending order of \(E/\sigma\) (or \(|E|/\sigma\)) the distance of the cell (in number of cell generations passing the neighbor cut until this cell will be reached) usually determines in which cluster the cell will end up in. The cell cut should be lower or equal to the neighbor cut.

Definition at line 102 of file TopoAutomatonClustering.h.

{this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"};

m_cutCellsInTime

Gaudi::Property<bool> TopoAutomatonClustering::m_cutCellsInTime {this, "SeedCutsInT", false, "Do seed cuts in time"}

private

if set to true, time cut is applied to seed cells, no cut otherwise

Definition at line 155 of file TopoAutomatonClustering.h.

{this, "SeedCutsInT", false, "Do seed cuts in time"};

m_excludeCutSeedsFromClustering

Gaudi::Property<bool> TopoAutomatonClustering::m_excludeCutSeedsFromClustering {this, "CutOOTseed", true, "Exclude out-of-time seeds from neighbouring and cell stage"}

private

if set to true, seed cells failing the time cut are also excluded from cluster at all

Definition at line 174 of file TopoAutomatonClustering.h.

{this, "CutOOTseed", true, "Exclude out-of-time seeds from neighbouring and cell stage"};

m_keepSignificantCells

Gaudi::Property<bool> TopoAutomatonClustering::m_keepSignificantCells {this, "UseTimeCutUpperLimit", false, "Do not apply time cut on cells of large significance"}

private

if set to true, the time cut is not applied on cell of large significance

Definition at line 179 of file TopoAutomatonClustering.h.

{this, "UseTimeCutUpperLimit", false, "Do not apply time cut on cells of large significance"};

m_kernelSizeOptimizer

ServiceHandle<IGPUKernelSizeOptimizerSvc> TopoAutomatonClustering::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 256 of file TopoAutomatonClustering.h.

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

Gaudi::Property<bool> TopoAutomatonClustering::m_neighborCutsInAbsE {this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"}

private

if set to true neighbor cuts are on \(|E|\) and \(|E|_\perp\).

The neighbor cuts will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 142 of file TopoAutomatonClustering.h.

{this, "NeighborCutsInAbsE", true, "Neighbor (grow) cuts in Abs E instead of E"};

m_neighborOptionString

Gaudi::Property<std::string> TopoAutomatonClustering::m_neighborOptionString

private

Initial value:

{this, "NeighborOption", "super3D",
                                                       "Neighbor option to be used for cell neighborhood relations"}

type of neighbor relations to use.

The CaloIdentifier package defines different types of neighbors for the calorimeter cells. Currently supported neighbor relations for topological clustering are:

• "all2D" for all cells in the same layer (sampling or module) of one calorimeter subsystem. Note that endcap and barrel will be unconnected in this case even for the LAREM.

• "all3D" for all cells in the same calorimeter. This means all the "all2D" neighbors for each cell plus the cells in adjacent samplings overlapping at least partially in \(\eta\) and \(\phi\) with the cell. Note that endcap and barrel will be connected in this case for the LAREM.

• "super3D" for all cells. This means all the "all3D" neighbors for each cell plus the cells in adjacent samplings from other subsystems overlapping at least partially in \(\eta\) and \(\phi\) with the cell. All calorimeters are connected in this case.

The default setting is "super3D".

Definition at line 211 of file TopoAutomatonClustering.h.

                                                  {this, "NeighborOption", "super3D",
                                                       "Neighbor option to be used for cell neighborhood relations"};

m_neighborThresholdOnEorAbsEinSigma

Gaudi::Property<float> TopoAutomatonClustering::m_neighborThresholdOnEorAbsEinSigma {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"}

private

cells with \(|E| > N_{\rm neighbor}\,\sigma\) extend the cluster

This cut determines how many cells are asked for their neighbors to expand the cluster. The smaller this cut is the more cells will be asked for their neighbors. If a cell passing this cut is neighbor of two other cells passing this cut from different clusters, the two clusters are merged. The neighbor cut should be lower or equal to the seed cut.

Definition at line 113 of file TopoAutomatonClustering.h.

{this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"};

m_options

TAGrowing::TACOptionsHolder TopoAutomatonClustering::m_options

private

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

Definition at line 253 of file TopoAutomatonClustering.h.

m_restrictHECIWandFCalNeighbors

Gaudi::Property<bool> TopoAutomatonClustering::m_restrictHECIWandFCalNeighbors

private

Initial value:

{this, "RestrictHECIWandFCalNeighbors",
                                                         false, "Limit the neighbors in HEC IW and FCal2&3"}

if set to true limit the neighbors in HEC IW and FCal2&3.

The cells in HEC IW and FCal2&3 get very large in terms of eta and phi. Since this might pose problems on certain jet algorithms one might need to avoid expansion in eta and phi for those cells. If this property is set to true the 2d neighbors of these cells are not used - only the next sampling neighbors are probed.

Definition at line 223 of file TopoAutomatonClustering.h.

                                                      {this, "RestrictHECIWandFCalNeighbors",
                                                         false, "Limit the neighbors in HEC IW and FCal2&3"};

m_restrictPSNeighbors

Gaudi::Property<bool> TopoAutomatonClustering::m_restrictPSNeighbors

private

Initial value:

{this, "RestrictPSNeighbors",
                                               false, "Limit the neighbors in presampler Barrel and Endcap"}

if set to true limit the neighbors in presampler Barrel and Endcap.

The presampler cells add a lot of PileUp in the Hilum samples. With this option set to true the presampler cells do not expand the cluster in the presampler layer. Only the next sampling is used as valid neighbor source.

Definition at line 233 of file TopoAutomatonClustering.h.

                                            {this, "RestrictPSNeighbors",
                                               false, "Limit the neighbors in presampler Barrel and Endcap"};

m_samplingNames

Gaudi::Property<std::vector<std::string> > TopoAutomatonClustering::m_samplingNames {this, "SeedSamplingNames", {}, "Name(s) of Calorimeter Samplings to consider for seeds"}

private

vector of names of the calorimeter samplings to consider for seeds.

The default is to use all calorimeter samplings. Excluding a sampling from this vector prevents the definition of a seed cell in this sampling. Cells in those samplings are still used and incorporated in the topo clusters (both on the neighbor and the cell level) they can therefore even expand a cluster but not seed one ...

Definition at line 84 of file TopoAutomatonClustering.h.

{this, "SeedSamplingNames", {}, "Name(s) of Calorimeter Samplings to consider for seeds"};

m_seedCutsInAbsE

Gaudi::Property<bool> TopoAutomatonClustering::m_seedCutsInAbsE {this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"}

private

if set to true seed cuts are on \(|E|\) and \(|E|_\perp\).

The seed cuts and the \(E_\perp\) cut on the final clusters before insertion to the CaloClusterContainer will be on absolute energy and absolute transverse energy if this is set to true. If set to false the cuts will be on energy and transverse energy instead.

Definition at line 134 of file TopoAutomatonClustering.h.

{this, "SeedCutsInAbsE", true, "Seed cuts in Abs E instead of E"};

m_seedThresholdOnEorAbsEinSigma

Gaudi::Property<float> TopoAutomatonClustering::m_seedThresholdOnEorAbsEinSigma {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"}

private

cells with \(|E| > N_{\rm seed}\,\sigma\) start a cluster

This cut determines how many clusters are formed initially. The smaller this cut is the more clusters will be created. During the accumulation of cells inside the clusters it can happen that clusters are merged if a cell passing the neighbor threshold would be included in both clusters.

Definition at line 123 of file TopoAutomatonClustering.h.

{this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"};

m_thresholdForKeeping

Gaudi::Property<float> TopoAutomatonClustering::m_thresholdForKeeping {this, "TimeCutUpperLimit", 20., "Significance upper limit for applying time cut"}

private

upper limit on the energy significance, for applying the cell time cut

Definition at line 163 of file TopoAutomatonClustering.h.

{this, "TimeCutUpperLimit", 20., "Significance upper limit for applying time cut"};

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_timeThreshold

Gaudi::Property<float> TopoAutomatonClustering::m_timeThreshold {this, "SeedThresholdOnTAbs", 12.5 * CLHEP::ns, "Time thresholds (in abs. val.)"}

private

threshold used for timing cut on seed cells.

Implemented as |seed_cell_time|<m_timeThreshold. No such cut on neighbouring cells.

Definition at line 159 of file TopoAutomatonClustering.h.

{this, "SeedThresholdOnTAbs", 12.5 * CLHEP::ns, "Time thresholds (in abs. val.)"};

m_treatL1PredictedCellsAsGood

Gaudi::Property<bool> TopoAutomatonClustering::m_treatL1PredictedCellsAsGood {this, "TreatL1PredictedCellsAsGood", true, "Treat bad cells with dead OTX if predicted from L1 as good"}

private

if set to true treat cells with a dead OTX which can be predicted by L1 trigger info as good instead of bad cells

Definition at line 169 of file TopoAutomatonClustering.h.

{this, "TreatL1PredictedCellsAsGood", true, "Treat bad cells with dead OTX if predicted from L1 as good"};

m_twoGaussianNoise

Gaudi::Property<bool> TopoAutomatonClustering::m_twoGaussianNoise {this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"}

private

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

Definition at line 184 of file TopoAutomatonClustering.h.

{this, "TwoGaussianNoise", false, "Use 2-gaussian noise description for TileCal"};

m_xtalkDeltaT

Gaudi::Property<float> TopoAutomatonClustering::m_xtalkDeltaT

private

Initial value:

{this, "XTalkDeltaT",
                                        15 * CLHEP::ns, "Delta T to add to upper time threshold for EM2 cells affected by xtalk."}

Additional maximum delta t added to the upper limit time window in case crosstalk in EM2 should be accounted for.

Definition at line 247 of file TopoAutomatonClustering.h.

                                     {this, "XTalkDeltaT",
                                        15 * CLHEP::ns, "Delta T to add to upper time threshold for EM2 cells affected by xtalk."};

m_xtalkEM2

Gaudi::Property<bool> TopoAutomatonClustering::m_xtalkEM2

private

Initial value:

{this, "XTalkEM2",
                                    false, "Relax time window (if timing is used) in EM2 when xTalk is present"}

If set to true, the time window is softened in the EMB2 and EME2_OW due to crosstalk from direct neighbour cells in phi.

Definition at line 241 of file TopoAutomatonClustering.h.

                                 {this, "XTalkEM2",
                                    false, "Relax time window (if timing is used) in EM2 when xTalk is present"};

---

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

• TopoAutomatonClustering.h
• TopoAutomatonClustering.cxx