CaloRecGPU::CellNoiseArr Struct Reference

#include <ConstantInfoDefinitions.h>

Collaboration diagram for CaloRecGPU::CellNoiseArr:

Public Member Functions
constexpr float	get_noise (const int cell, const int gain) const
CUDA_HOS_DEV float	get_double_gaussian_noise (const int cell, const int gain, const float energy) const
	Calculates the double gaussian noise for a Tile cell.

Public Attributes
float	noise [NCaloCells][NumGainStates] {}
float	double_gaussian_constants [s_numDoubleGaussianConstants][NTileCells][NumGainStates] {}
CellNoiseProperties::carrier	noise_properties {}
float	luminosity {}

Static Public Attributes
static constexpr int	s_numDoubleGaussianConstants = 4

Protected Member Functions
CUDA_HOS_DEV float	get_double_gaussian_significance (const int cell, const int gain, const float energy) const

Detailed Description

Definition at line 461 of file ConstantInfoDefinitions.h.

Member Function Documentation

get_double_gaussian_noise()

CUDA_HOS_DEV float CaloRecGPU::CellNoiseArr::get_double_gaussian_noise ( const int cell, const int gain, const float energy ) const

inline

Calculates the double gaussian noise for a Tile cell.

Does not check explicitly for a cell being from Tile.

Definition at line 541 of file ConstantInfoDefinitions.h.

    {
      using namespace std;
 
      CellNoiseProperties props(this->noise_properties);
      if (!props.is_valid())
        {
          return get_noise(cell, gain);
        }
 
      const float sigma = get_double_gaussian_significance(cell, gain, energy);
 
      const float first_factor = (sigma != 0.f ? fabsf(energy / sigma) : 0.f);
 
      if (props.is_electronic_noise())
        {
          return first_factor;
        }
      else
        {
          const float second_factor = this->double_gaussian_constants[3][cell - TileCellStart][gain];
 
          switch (props.version())
            {
              case 1:
                return sqrtf(first_factor * first_factor + second_factor * second_factor * this->luminosity);
              case 2:
                return first_factor + second_factor * this->luminosity;
              default:
                return 0.f / 0.f;
            }
        }
    }

get_double_gaussian_significance()

CUDA_HOS_DEV float CaloRecGPU::CellNoiseArr::get_double_gaussian_significance ( const int cell, const int gain, const float energy ) const

inlineprotected

Definition at line 481 of file ConstantInfoDefinitions.h.

    {
 
      using namespace std;
 
      const int delta_from_tile_start = cell - TileCellStart;
 
      const float sigma_1 = this->double_gaussian_constants[0][delta_from_tile_start][gain];
      const float sigma_2 = this->double_gaussian_constants[1][delta_from_tile_start][gain];
      const float ratio   = this->double_gaussian_constants[2][delta_from_tile_start][gain];
      
      if ((sigma_1 == 0.f && sigma_2 == 0.f) || energy == 0.f)
        {
          return 0.f;
        }
      else if (sigma_1 == 0.f)
        {
          return energy / sigma_2;
        }
      else if (ratio == 0.f || sigma_2 == 0.f)
        {
          return energy / sigma_1;
        }
        
      const float x_1 = energy / sigma_1;
      const float x_2 = energy / sigma_2;
      const float x_1_abs = fabsf(x_1);
      const float x_2_abs = fabsf(x_2);
 
      const float min_abs = min(x_1_abs, x_2_abs);
 
      const float max_abs = max(x_1_abs, x_2_abs);
 
      if (min_abs > 7.4f)
        {
          return min_abs;
        }
      if (max_abs < 0.9f)
        {
          return max_abs;
        }
 
      const float y_1 = erff(Helpers::Constants::inv_sqrt2<float> * x_1);
      const float y_2 = erff(Helpers::Constants::inv_sqrt2<float> * x_2);
      
 
      const float z = (y_1 * sigma_1 + ratio * y_2 * sigma_2) / (sigma_1 + ratio * sigma_2);
      
      const float ret = Helpers::Constants::sqrt2<float> * Helpers::erf_inv_wrapper(z);
      
      //printf("GPU %d %f %f %f %f %f %f\n", delta_from_tile_start, min_abs, max_abs, y_1, y_2, z, ret);
      
      return ret;
 
    }

get_noise()

float CaloRecGPU::CellNoiseArr::get_noise ( const int cell, const int gain ) const

inlineconstexpr

Definition at line 474 of file ConstantInfoDefinitions.h.

    {
      return noise[cell][gain];
    }

Member Data Documentation

double_gaussian_constants

float CaloRecGPU::CellNoiseArr::double_gaussian_constants[s_numDoubleGaussianConstants][NTileCells][NumGainStates] {}

Definition at line 468 of file ConstantInfoDefinitions.h.

{};

luminosity

float CaloRecGPU::CellNoiseArr::luminosity {}

Definition at line 472 of file ConstantInfoDefinitions.h.

{};

noise

float CaloRecGPU::CellNoiseArr::noise[NCaloCells][NumGainStates] {}

Definition at line 465 of file ConstantInfoDefinitions.h.

{};

noise_properties

CellNoiseProperties::carrier CaloRecGPU::CellNoiseArr::noise_properties {}

Definition at line 470 of file ConstantInfoDefinitions.h.

{};

s_numDoubleGaussianConstants

int CaloRecGPU::CellNoiseArr::s_numDoubleGaussianConstants = 4

staticconstexpr

Definition at line 463 of file ConstantInfoDefinitions.h.

---

The documentation for this struct was generated from the following file:

• ConstantInfoDefinitions.h