CaloCellsCounterGPU Class Reference

Outputs counts of cells, both by type and cluster presence, with each cluster being identified by its cell with the largest signal-to-noise ratio. More...

#include <CaloCellsCounterGPU.h>

Inheritance diagram for CaloCellsCounterGPU:

Collaboration diagram for CaloCellsCounterGPU:

Public Member Functions
	CaloCellsCounterGPU (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	execute (const EventContext &ctx, const CaloRecGPU::ConstantDataHolder &constant_data, CaloRecGPU::EventDataHolder &event_data, void *temporary_buffer) const override
virtual	~CaloCellsCounterGPU ()=default

Private Attributes
Gaudi::Property< std::string >	m_savePath {this, "SavePath", "./cell_counts", "Path to where the files should be saved"}
	The path specifying the folder to which the files should be saved.
Gaudi::Property< std::string >	m_filePrefix {this, "FilePrefix", "", "Prefix of the saved files"}
	The prefix of the saved files.
Gaudi::Property< std::string >	m_fileSuffix {this, "FileSuffix", "", "Suffix of the saved files"}
	The suffix of the saved files.
Gaudi::Property< unsigned int >	m_numWidth {this, "NumberWidth", 9, "The number of digits to reserve for the events"}
	The number of digits to reserve for the events.
Gaudi::Property< float >	m_seedThreshold {this, "SeedThresholdOnEorAbsEinSigma", 4., "Seed threshold (in units of noise Sigma)"}
	Value to consider for the seed threshold.
Gaudi::Property< float >	m_growThreshold {this, "NeighborThresholdOnEorAbsEinSigma", 2., "Neighbor (grow) threshold (in units of noise Sigma)"}
	Value to consider for the seed threshold.
Gaudi::Property< float >	m_cellThreshold {this, "CellThresholdOnEorAbsEinSigma", 0., "Cell (terminal) threshold (in units of noise Sigma)"}
	Value to consider for the seed threshold.

Detailed Description

Outputs counts of cells, both by type and cluster presence, with each cluster being identified by its cell with the largest signal-to-noise ratio.

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

22 July 2022

Definition at line 22 of file CaloCellsCounterGPU.h.

Constructor & Destructor Documentation

CaloCellsCounterGPU()

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

Definition at line 16 of file CaloCellsCounterGPU.cxx.

                                                                                                                 :
  base_class(type, name, parent)
{
}

~CaloCellsCounterGPU()

virtual CaloCellsCounterGPU::~CaloCellsCounterGPU ( )

virtualdefault

Member Function Documentation

execute()

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

overridevirtual

Definition at line 50 of file CaloCellsCounterGPU.cxx.

{
  Helpers::CPU_object<CellNoiseArr> cell_noise(constant_data.m_cell_noise_dev);
  //We could try to keep this in CPU memory by default,
  //but, since it isn't quite needed and we don't mind taking a bit longer for this
  //since we're only debugging, let this be as generic as possible.
 
  Helpers::CPU_object<CellInfoArr> cell_info(event_data.m_cell_info_dev);
  Helpers::CPU_object<ClusterInfoArr> clusters(event_data.m_clusters_dev);
 
  unsigned int gain_counts[GainConversion::num_gain_values()] = {0};
 
  size_struct global_counts, global_cluster_counts;
 
  std::vector<int> cluster_max_cell(clusters->number, -1);
  std::vector<float> cluster_max_snr(clusters->number, -9e99);
  std::vector<float> cluster_max_energy(clusters->number, -9e99);
 
  std::vector<size_struct> cluster_counts(clusters->number);
 
  if (clusters->has_cells_per_cluster())
    {
      for (int i = 0; i < cell_info->number; ++i)
        {
          if (!cell_info->is_valid(i))
            {
              continue;
            }
 
          const int gain = cell_info->gain[i];
          ++gain_counts[gain - GainConversion::min_gain_value()];
 
          const float energy = cell_info->energy[i];
 
          const float SNR = std::abs( energy / cell_noise->get_noise(cell_info->hashID[i], gain) );
 
          if (SNR > m_seedThreshold)
            {
              ++global_counts.seed;
            }
          else if (SNR > m_growThreshold)
            {
              ++global_counts.grow;
            }
          else if (SNR > m_cellThreshold)
            {
              ++global_counts.term;
            }
          else
            {
              ++global_counts.invalid;
            }
        }
 
      std::vector<char> counted_cells(NCaloCells, 0);
 
      for (int i = 0; i < clusters->number_cells; ++i)
        {
          const int cell_index = clusters->cells.indices[i];
          const int cell_hash_ID = cell_info->hashID[cell_index];
 
 
          const int gain = cell_info->gain[cell_index];
          ++gain_counts[gain - GainConversion::min_gain_value()];
 
          const float energy = cell_info->energy[cell_index];
 
          const float SNR = std::abs( energy / cell_noise->get_noise(cell_hash_ID, gain) );
 
          const bool is_new_cell = !counted_cells[cell_index];
 
          if (is_new_cell)
            {
              counted_cells[cell_index] = 1;
              ++global_cluster_counts.total;
            }
 
          const int cluster_index = clusters->clusterIndices[i];
 
          if (SNR > cluster_max_snr[cluster_index] || (SNR == cluster_max_snr[cluster_index] && cell_hash_ID > cluster_max_cell[cluster_index]))
            {
              cluster_max_snr[cluster_index] = SNR;
              cluster_max_cell[cluster_index] = cell_hash_ID;
              cluster_max_energy[cluster_index] = std::abs(energy);
            }
 
          if (SNR > m_seedThreshold)
            {
              global_cluster_counts.seed += is_new_cell;
              ++cluster_counts[cluster_index].seed;
            }
          else if (SNR > m_growThreshold)
            {
              global_cluster_counts.grow += is_new_cell;
              ++cluster_counts[cluster_index].grow;
            }
          else if (SNR > m_cellThreshold)
            {
              global_cluster_counts.term += is_new_cell;
              ++cluster_counts[cluster_index].term;
            }
          else
            {
              global_cluster_counts.invalid += is_new_cell;
              ++cluster_counts[cluster_index].invalid;
            }
 
 
          ++cluster_counts[cluster_index].total;
 
          global_cluster_counts.shared += !is_new_cell;
          cluster_counts[cluster_index].shared += !is_new_cell;
 
        }
 
    }
  else
    {
      for (int i = 0; i < cell_info->number; ++i)
        {
          if (!cell_info->is_valid(i))
            {
              continue;
            }
 
          const int gain = cell_info->gain[i];
          ++gain_counts[gain - GainConversion::min_gain_value()];
 
          const float energy = cell_info->energy[i];
 
          const float SNR = std::abs( energy / cell_noise->get_noise(cell_info->hashID[i], gain) );
 
          const ClusterTag tag = clusters->cells.tags[i];
 
          const bool is_cluster = tag.is_part_of_cluster();
 
          global_cluster_counts.total += is_cluster;
 
          if (SNR > m_seedThreshold)
            {
              ++global_counts.seed;
              global_cluster_counts.seed += is_cluster;
            }
          else if (SNR > m_growThreshold)
            {
              ++global_counts.grow;
              global_cluster_counts.grow += is_cluster;
            }
          else if (SNR > m_cellThreshold)
            {
              ++global_counts.term;
              global_cluster_counts.term += is_cluster;
            }
          else
            {
              ++global_counts.invalid;
              global_cluster_counts.invalid += is_cluster;
            }
 
          if (is_cluster)
            {
              const int cluster = tag.cluster_index();
              const int other_cluster = tag.is_shared_between_clusters() ? tag.secondary_cluster_index() : cluster;
              if (!tag.is_shared_between_clusters() && (SNR > cluster_max_snr[cluster] || (SNR == cluster_max_snr[cluster] && i > cluster_max_cell[cluster])))
                {
                  cluster_max_snr[cluster] = SNR;
                  cluster_max_cell[cluster] = i;
                  cluster_max_energy[cluster] = std::abs(energy);
                }
              ++cluster_counts[cluster].total;
              cluster_counts[other_cluster].total += (cluster != other_cluster);
 
              global_cluster_counts.shared += tag.is_shared_between_clusters();
              cluster_counts[cluster].shared += tag.is_shared_between_clusters();
              cluster_counts[other_cluster].shared += tag.is_shared_between_clusters();
 
              if (SNR > m_seedThreshold)
                {
                  ++cluster_counts[cluster].seed;
                  cluster_counts[other_cluster].seed += (cluster != other_cluster);
                }
              else if (SNR > m_growThreshold)
                {
                  ++cluster_counts[cluster].grow;
                  cluster_counts[other_cluster].grow += (cluster != other_cluster);
                }
              else if (SNR > m_cellThreshold)
                {
                  ++cluster_counts[cluster].term;
                  cluster_counts[other_cluster].term += (cluster != other_cluster);
                }
              else
                {
                  ++cluster_counts[cluster].invalid;
                  cluster_counts[other_cluster].invalid += (cluster != other_cluster);
                }
            }
        }
    }
 
  std::map<int, cluster_info_struct> cluster_sizes;
 
  for (int i = 0; i < clusters->number; ++i)
    {
      if (cluster_max_cell[i] >= 0)
        {
          cluster_sizes[cluster_max_cell[i]] = cluster_info_struct{cluster_counts[i], cluster_max_snr[i], cluster_max_energy[i]};
        }
    }
 
  const auto err1 = StandaloneDataIO::prepare_folder_for_output(std::string(m_savePath));
  if (err1 != StandaloneDataIO::ErrorState::OK)
    {
      return StatusCode::FAILURE;
    }
 
  const std::filesystem::path save_file = m_savePath + "/" +  StandaloneDataIO::build_filename((m_filePrefix.size() > 0 ? m_filePrefix + "_counts" : "counts"),
                                                                                               ctx.evt(), m_fileSuffix, "txt", m_numWidth);
 
  std::ofstream out_file(save_file);
 
  if (!out_file.is_open())
    {
      return StatusCode::FAILURE;
    }
 
  out_file << "Cell counts: " << global_counts << "\n\n";
 
  out_file << "Cells in clusters count: " << global_cluster_counts << "\n\n";
  out_file << "Clusters:\n\n";
 
  for (const auto & it : cluster_sizes)
    {
      out_file << it.first << " " << it.second << "\n";
    }
 
  out_file << std::endl;
 
  if (!out_file.good())
    {
      return StatusCode::FAILURE;
    }
 
  out_file.close();
 
  return StatusCode::SUCCESS;
 
}

Member Data Documentation

m_cellThreshold

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

private

Value to consider for the seed threshold.

Should be consistent with the one used in Topological Clustering to ensure cell classification is correct.

Definition at line 73 of file CaloCellsCounterGPU.h.

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

m_filePrefix

Gaudi::Property<std::string> CaloCellsCounterGPU::m_filePrefix {this, "FilePrefix", "", "Prefix of the saved files"}

private

The prefix of the saved files.

Empty string by default.

Definition at line 48 of file CaloCellsCounterGPU.h.

{this, "FilePrefix", "", "Prefix of the saved files"};

m_fileSuffix

Gaudi::Property<std::string> CaloCellsCounterGPU::m_fileSuffix {this, "FileSuffix", "", "Suffix of the saved files"}

private

The suffix of the saved files.

Empty string by default.

Definition at line 53 of file CaloCellsCounterGPU.h.

{this, "FileSuffix", "", "Suffix of the saved files"};

m_growThreshold

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

private

Value to consider for the seed threshold.

Should be consistent with the one used in Topological Clustering to ensure cell classification is correct.

Definition at line 68 of file CaloCellsCounterGPU.h.

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

m_numWidth

Gaudi::Property<unsigned int> CaloCellsCounterGPU::m_numWidth {this, "NumberWidth", 9, "The number of digits to reserve for the events"}

private

The number of digits to reserve for the events.

9 by default.

Definition at line 58 of file CaloCellsCounterGPU.h.

{this, "NumberWidth", 9, "The number of digits to reserve for the events"};

m_savePath

Gaudi::Property<std::string> CaloCellsCounterGPU::m_savePath {this, "SavePath", "./cell_counts", "Path to where the files should be saved"}

private

The path specifying the folder to which the files should be saved.

Default ./cell_counts

Definition at line 43 of file CaloCellsCounterGPU.h.

{this, "SavePath", "./cell_counts", "Path to where the files should be saved"};

m_seedThreshold

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

private

Value to consider for the seed threshold.

Should be consistent with the one used in Topological Clustering to ensure cell classification is correct.

Definition at line 63 of file CaloCellsCounterGPU.h.

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

---

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

• CaloCellsCounterGPU.h
• CaloCellsCounterGPU.cxx