CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true > Struct Template Reference

#include <EtaPhiMap.h>

Collaboration diagram for CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >:

Public Member Functions
constexpr void	register_cell (const int cell, const float cell_eta, const float cell_phi, const float cell_deta, const float cell_dphi)
constexpr void	initialize ()
constexpr void	initialize (const float min_eta_neg, const float min_phi_neg, const float, const float, const float, const float, const float max_eta_pos, const float max_phi_pos, const float deta, const float dphi)
CUDA_HOS_DEV void	finish_initializing (void *buffer)
	! More...
constexpr int	get_possible_cells_from_coords (const float test_eta, const float test_phi, int *cell_arr) const
	We assume cell_arr is large enough. More...
constexpr bool	has_cell_in_coords (const float test_eta, const float test_phi) const

Static Public Member Functions
constexpr static size_t	finish_initializing_buffer_size ()

Public Attributes
float	eta_min
float	phi_min
float	eta_max
float	phi_max
float	delta_eta
float	delta_phi
int	cells [eta_grid][phi_grid][s_max_overlap_cells]
float	corner_eta [eta_grid][phi_grid][s_max_overlap_cells]
float	corner_phi [eta_grid][phi_grid][s_max_overlap_cells]

Static Public Attributes
static constexpr int	s_max_overlap_cells = 10

Private Member Functions
constexpr int	eta_coordinate (const float eta) const
constexpr int	eta_coordinate (const float eta, float &interval) const
	Version that returns the floating point remainder too via the second argument. More...
constexpr int	phi_coordinate (const float phi) const
constexpr int	phi_coordinate (const float phi, float &interval) const
	Version that returns the floating point remainder too via the second argument. More...
constexpr void	add_cell_to_grid (const int cell, const float eta_corner, const float phi_corner, const int eta, const int phi)
constexpr void	register_cell_with_deltas (const int cell, const float cell_eta, const float cell_phi, const float cell_deta, const float cell_dphi)
constexpr void	register_cell_center (const int cell, const float cell_eta, const float cell_phi)
constexpr void	initialize (const float min_eta, const float min_phi, const float max_eta, const float max_phi, const float deta, const float dphi)

Friends
struct	EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, false >

Detailed Description

template<int eta_grid, int phi_grid, bool respect_deltas>
struct CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >

Definition at line 33 of file EtaPhiMap.h.

Member Function Documentation

add_cell_to_grid()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::add_cell_to_grid ( const int  cell, const float  eta_corner, const float  phi_corner, const int  eta, const int  phi  )

inlineconstexprprivate

Definition at line 94 of file EtaPhiMap.h.

    {
      for (int i = 0; i < s_max_overlap_cells; ++i)
        {
          if (cells[eta][phi][i] < 0)
            {
              cells      [eta][phi][i] = cell;
              corner_eta [eta][phi][i] = eta_corner;
              corner_phi [eta][phi][i] = phi_corner;
              return;
            }
        }
      // /*
      printf("Unable to store %d: %d %d %d %d (%d %d %d %d)\n", cell,
             cells[eta][phi][0], cells[eta][phi][1],
             cells[eta][phi][2], cells[eta][phi][3],
             eta, eta_grid, phi, phi_grid                               );
      // */
    }

eta_coordinate() [1/2]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::eta_coordinate ( const float  eta ) const

inlineconstexprprivate

Definition at line 62 of file EtaPhiMap.h.

    {
      using namespace std;
      return floorf((eta - eta_min) / delta_eta);
    }

eta_coordinate() [2/2]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::eta_coordinate ( const float  eta, float &  interval  ) const

inlineconstexprprivate

Version that returns the floating point remainder too via the second argument.

Definition at line 69 of file EtaPhiMap.h.

    {
      using namespace std;
      const float frac = (eta - eta_min) / delta_eta;
      const float rounded = floorf(frac);
      interval = frac - rounded;
      return rounded;
    }

finish_initializing()

template<int eta_grid, int phi_grid, bool respect_deltas>

CUDA_HOS_DEV void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::finish_initializing ( void *  buffer )

inline

!

buffer is casted to a sufficiently large array (minimum size given by finish_initializing_buffer_size).

Definition at line 276 of file EtaPhiMap.h.

    {
      if (!respect_deltas)
        //If we could be sure of C++17 compatibility,
        //this would be a constexpr if...
        {
          //This is O( N * M * (N + M) ) for a N * M grid,
          //but gives us reasonable results.
          //And, since this is just an initialization step,
          //not too serious. Still, we could optimize it further...
          //(Or do it on the GPU. Really.
          //Because it ends up being quite cellular automaton-y.)
          //
          //Of course the proper way to do this would be to build
          //a Voronoi diagram based on the cell positions
          //and then discretize it in the grid (overlapping where needed),
          //but the complexity versus performance gains trade-off
          //in this case favours keeping this simpler version.
 
          int (*casted)[eta_grid][phi_grid][s_max_overlap_cells] = (int (*)[eta_grid][phi_grid][s_max_overlap_cells]) buffer;
 
          int (&cell_arr_dest)[eta_grid][phi_grid][s_max_overlap_cells] = *casted;
 
          using namespace std;
 
          memcpy(&(cell_arr_dest[0][0][0]), &(cells[0][0][0]), finish_initializing_buffer_size());
 
          bool keep_going = true;
 
          bool second_phase = false;
          //The first phase grows out the clusters,
          //I mean, the elements of the grid that are
          //closest to a cell and stops when they intersect.
          //The second phase grows out those who do intersect
          //to empty elements, to handle the cases where an element
          //is all surrounded by intersections...
 
 
          auto propagate_cell = [&](const int eta_c, const int phi_c, const int input_cell,
                                    const float input_eta, const float input_phi, const bool only_empty )
          {
            if (only_empty && cells[eta_c][phi_c][0] >= 0)
              {
                return;
              }
            int to_add_index = 0;
            for (; to_add_index < s_max_overlap_cells; ++to_add_index)
              {
                if (cell_arr_dest[eta_c][phi_c][to_add_index] == input_cell)
                  {
                    return;
                  }
                else if (cell_arr_dest[eta_c][phi_c][to_add_index] < 0)
                  {
                    break;
                  }
              }
            if (to_add_index == s_max_overlap_cells)
              {
                // /*
                printf("Unable to store %d: %d %d %d %d (%d %d %d %d)\n", input_cell,
                       cell_arr_dest[eta_c][phi_c][0], cell_arr_dest[eta_c][phi_c][1],
                       cell_arr_dest[eta_c][phi_c][2], cell_arr_dest[eta_c][phi_c][3],
                       eta_c, eta_grid, phi_c, phi_grid                                );
                // */
                return;
              }
 
            cell_arr_dest [eta_c][phi_c][to_add_index] = input_cell;
            corner_eta    [eta_c][phi_c][to_add_index] = input_eta;
            corner_phi    [eta_c][phi_c][to_add_index] = input_phi;
 
            keep_going = true;
          };
 
          auto process_cell = [&](const int eta_c, const int phi_c, const int cell_index, const bool only_empty)
          {
            const int   this_cell = cells      [eta_c][phi_c][cell_index];
            const float this_eta  = corner_eta [eta_c][phi_c][cell_index];
            const float this_phi  = corner_phi [eta_c][phi_c][cell_index];
 
            for (int delta_eta = -1; delta_eta <= 1; ++delta_eta)
              {
                const int target_eta_c = eta_c + delta_eta;
                if (target_eta_c < 0 || target_eta_c >= eta_grid)
                  {
                    continue;
                  }
                for (int delta_phi = -1; delta_phi <= 1; ++delta_phi)
                  {
                    int target_phi_c = phi_c + delta_phi;
                    if (target_phi_c < 0)
                      {
                        target_phi_c = phi_coordinate(phi_min + delta_phi * target_phi_c + 2 * Helpers::Constants::pi<float>);
                        if (target_phi_c < 0 || target_phi_c >= phi_grid)
                          {
                            continue;
                          }
                      }
                    else if (target_phi_c >= phi_grid)
                      {
                        target_phi_c = phi_coordinate(phi_min + delta_phi * target_phi_c - 2 * Helpers::Constants::pi<float>);
                        if (target_phi_c < 0 || target_phi_c >= phi_grid)
                          {
                            continue;
                          }
                      }
                    propagate_cell(target_eta_c, target_phi_c, this_cell, this_eta, this_phi, only_empty);
                  }
              }
          };
 
          while (keep_going)
            {
              keep_going = false;
              for (int eta_c = 0; eta_c < eta_grid; ++eta_c)
                {
                  for (int phi_c = 0; phi_c < phi_grid; ++phi_c)
                    {
                      const auto & this_square_cells = cells[eta_c][phi_c];
                      if (!second_phase)
                        {
                          if (this_square_cells[0] >= 0 && this_square_cells[1] < 0)
                            {
                              process_cell(eta_c, phi_c, 0, false);
                            }
                        }
                      else
                        {
                          for (int cell_index = 0; cell_index < s_max_overlap_cells; ++cell_index)
                            {
                              if (this_square_cells[cell_index] < 0)
                                {
                                  break;
                                }
                              process_cell(eta_c, phi_c, cell_index, true);
                            }
                        }
                    }
                }
              memcpy(&(cells[0][0][0]), &(cell_arr_dest[0][0][0]), finish_initializing_buffer_size());
              if (!keep_going && !second_phase)
                {
                  second_phase = true;
                  keep_going = true;
                }
            }
        }
      else
        {
          //Do nothing: when respecting deltas,
          //cells get properly initialized outright...
        }
    }

finish_initializing_buffer_size()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr static size_t CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::finish_initializing_buffer_size ( )

inlinestaticconstexpr

Definition at line 270 of file EtaPhiMap.h.

    {
      return eta_grid * phi_grid * s_max_overlap_cells * sizeof(int);
    }

get_possible_cells_from_coords()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::get_possible_cells_from_coords ( const float  test_eta, const float  test_phi, int *  cell_arr  ) const

inlineconstexpr

We assume cell_arr is large enough.

Definition at line 432 of file EtaPhiMap.h.

    {
      int num_cells = 0;
 
      float frac_eta = 0.f, frac_phi = 0.f;
 
      const int eta_coord = eta_coordinate(test_eta, frac_eta);
      const int phi_coord = phi_coordinate(test_phi, frac_phi);
 
      if ( test_eta < eta_min || test_eta > eta_max    ||
           test_phi < phi_min || test_phi > phi_max    ||
           eta_coord < 0      || eta_coord >= eta_grid ||
           phi_coord < 0      || phi_coord >= phi_grid     )
        {
          /*
          printf("OOB: %f %d %f %f %d | %f %d %f %f %d\n",
                 test_eta, eta_coord, eta_min, eta_max, eta_grid,
                 test_phi, phi_coord, phi_min, phi_max, phi_grid);
          // */
          return 0;
        }
 
      if (respect_deltas)
        //If we could be sure of C++17 compatibility,
        //this would be a constexpr if...
        {
          auto check_coord = [](const float test, const float target)
          {
            using namespace std;
            if (target > 0 && fabsf(test) <= fabsf(target))
              {
                return true;
              }
            else if (target < 0 && fabsf(test) >= fabsf(target))
              {
                return true;
              }
            else if (target == 0)
              {
                return true;
              }
            else
              {
                return false;
              }
          };
 
          for (int i = 0; i < s_max_overlap_cells; ++i)
            {
              if (cells[eta_coord][phi_coord][i] < 0)
                {
                  break;
                }
              if ( check_coord(frac_eta, corner_eta[eta_coord][phi_coord][i]) &&
                   check_coord(frac_phi, corner_phi[eta_coord][phi_coord][i])      )
                {
                  cell_arr[num_cells] = cells[eta_coord][phi_coord][i];
                  ++num_cells;
                }
            }
        }
      else
        {
          float distance = 1e38f;
          int ret = -1;
 
          for (int i = 0; i < s_max_overlap_cells; ++i)
            {
              const int this_cell = cells[eta_coord][phi_coord][i];
              if (this_cell < 0)
                {
                  break;
                }
              const float delta_eta = corner_eta[eta_coord][phi_coord][i] - test_eta;
              const float delta_phi = Helpers::angular_difference(corner_phi[eta_coord][phi_coord][i], test_phi);
              //If respect_deltas == false,
              //corner_coords are actually
              //the center (eta, phi) of the cell.
              const float this_dist = delta_eta * delta_eta + delta_phi * delta_phi;
 
              if (this_dist < distance || (this_dist == distance && this_cell > ret))
                {
                  distance = this_dist;
                  ret = this_cell;
                }
            }
 
          if (ret > 0)
            {
              cell_arr[0] = ret;
              num_cells = 1;
            }
        }
 
      return num_cells;
    }

has_cell_in_coords()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr bool CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::has_cell_in_coords ( const float  test_eta, const float  test_phi  ) const

inlineconstexpr

Definition at line 529 of file EtaPhiMap.h.

    {
      float frac_eta = 0.f, frac_phi = 0.f;
 
      const int eta_coord = eta_coordinate(test_eta, frac_eta);
      const int phi_coord = phi_coordinate(test_phi, frac_phi);
 
      if ( test_eta  < eta_min || test_eta  >  eta_max    ||
           test_phi  < phi_min || test_phi  >  phi_max    ||
           eta_coord < 0       || eta_coord >= eta_grid   ||
           phi_coord < 0       || phi_coord >= phi_grid      )
        {
          return false;
        }
 
      if (respect_deltas)
        //If we could be sure of C++17 compatibility,
        //this would be a constexpr if...
        {
          auto check_coord = [](const float test, const float target)
          {
            using namespace std;
            if (fabsf(test) >= fabs(target) && target < 0)
              {
                return true;
              }
            else if (fabs(test) <= fabs(target) && target > 0)
              {
                return true;
              }
            else if (target == 0)
              {
                return true;
              }
            else
              {
                return false;
              }
          };
 
          for (int i = 0; i < s_max_overlap_cells; ++i)
            {
              if (cells[eta_coord][phi_coord][i] < 0)
                {
                  break;
                }
              if ( check_coord(frac_eta, corner_eta[eta_coord][phi_coord][i]) &&
                   check_coord(frac_phi, corner_phi[eta_coord][phi_coord][i])      )
                {
                  return true;
                }
            }
          return false;
        }
      else
        {
          return true;
          //Except for being out-of-bounds,
          //if respect_deltas == false
          //we can always find a closest cell
          //for each coordinate.
        }
    }

initialize() [1/3]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::initialize ( )

inlineconstexpr

Definition at line 256 of file EtaPhiMap.h.

    {
      initialize(0, 0, 0, 0, 0, 0);
    }

initialize() [2/3]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::initialize ( const float  min_eta, const float  min_phi, const float  max_eta, const float  max_phi, const float  deta, const float  dphi  )

inlineconstexprprivate

Definition at line 217 of file EtaPhiMap.h.

    {
      for (int i = 0; i < eta_grid; ++i)
        {
          for (int j = 0; j < phi_grid; ++j)
            {
              for (int k = 0; k < s_max_overlap_cells; ++k)
                {
                  cells[i][j][k] = -1;
                }
            }
        }
      eta_min = min_eta;
      phi_min = min_phi;
      eta_max = max_eta;
      phi_max = max_phi;
      delta_eta = deta;
      delta_phi = dphi;
    }

initialize() [3/3]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::initialize ( const float  min_eta_neg, const float  min_phi_neg, const float  , const float  , const float  , const float  , const float  max_eta_pos, const float  max_phi_pos, const float  deta, const float  dphi  )

inlineconstexpr

Definition at line 261 of file EtaPhiMap.h.

    {
      initialize(min_eta_neg, min_phi_neg, max_eta_pos, max_phi_pos, deta, dphi);
    }

phi_coordinate() [1/2]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::phi_coordinate ( const float  phi ) const

inlineconstexprprivate

Definition at line 78 of file EtaPhiMap.h.

    {
      using namespace std;
      return floorf((phi - phi_min) / delta_phi);
    }

phi_coordinate() [2/2]

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::phi_coordinate ( const float  phi, float &  interval  ) const

inlineconstexprprivate

Version that returns the floating point remainder too via the second argument.

Definition at line 85 of file EtaPhiMap.h.

    {
      using namespace std;
      const float frac = (phi - phi_min) / delta_phi;
      const float rounded = floorf(frac);
      interval = frac - rounded;
      return rounded;
    }

register_cell()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::register_cell ( const int  cell, const float  cell_eta, const float  cell_phi, const float  cell_deta, const float  cell_dphi  )

inlineconstexpr

Definition at line 242 of file EtaPhiMap.h.

    {
      if (respect_deltas)
        //If we could be sure of C++17 compatibility,
        //this would be a constexpr if...
        {
          register_cell_with_deltas(cell, cell_eta, cell_phi, cell_deta, cell_dphi);
        }
      else
        {
          register_cell_center(cell, cell_eta, cell_phi);
        }
    }

register_cell_center()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::register_cell_center ( const int  cell, const float  cell_eta, const float  cell_phi  )

inlineconstexprprivate

Definition at line 198 of file EtaPhiMap.h.

    {
      const int eta_coord = eta_coordinate(cell_eta);
      const int phi_coord = phi_coordinate(cell_phi);
 
      if (eta_coord < 0 || eta_coord >= eta_grid || phi_coord < 0 || phi_coord >= phi_grid)
        {
          // /*
          printf("Out of bounds cell: %d | %f %d %f %f %d | %f %d %f %f %d\n", cell,
                 cell_eta, eta_coord, eta_min, eta_max, eta_grid,
                 cell_phi, phi_coord, phi_min, phi_max, phi_grid                        );
          // */
          return;
        }
 
      add_cell_to_grid(cell, cell_eta, cell_phi, eta_coord, phi_coord);
    }

register_cell_with_deltas()

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::register_cell_with_deltas ( const int  cell, const float  cell_eta, const float  cell_phi, const float  cell_deta, const float  cell_dphi  )

inlineconstexprprivate

Definition at line 114 of file EtaPhiMap.h.

    {
      int eta_coord_start = 0, eta_coord_end = 0, phi_coord_start = 0, phi_coord_end = 0;
      int phi_coord_extra_neg = 0, phi_coord_extra_pos = 0;
      float eta_fraction_start = 0.f, eta_fraction_end = 0.f, phi_fraction_start = 0.f, phi_fraction_end = 0.f;
      float phi_fraction_extra_neg = 0.f, phi_fraction_extra_pos = 0.f;
 
      eta_coord_start = eta_coordinate(cell_eta - cell_deta / 2, eta_fraction_start);
      eta_coord_end   = eta_coordinate(cell_eta + cell_deta / 2, eta_fraction_end);
      phi_coord_start = phi_coordinate(cell_phi - cell_dphi / 2, phi_fraction_start);
      phi_coord_end   = phi_coordinate(cell_phi + cell_dphi / 2, phi_fraction_end);
 
      phi_coord_extra_neg = phi_coordinate(cell_phi + cell_dphi / 2 - 2 * Helpers::Constants::pi<float>, phi_fraction_extra_neg);
      phi_coord_extra_pos = phi_coordinate(cell_phi - cell_dphi / 2 + 2 * Helpers::Constants::pi<float>, phi_fraction_extra_pos);
 
      if ((eta_coord_end == eta_coord_start && (eta_fraction_start > 0 || eta_fraction_end < 1)) ||
          (phi_coord_end == phi_coord_start && (phi_fraction_start > 0 || phi_fraction_end < 1))     )
        {
          // /*
          printf("Something strange going on with cell %d: %f %f %f %f %f %f (%d %d %f %f | %d %d %f %f)\n",
                 cell, cell_eta, cell_deta, delta_eta, cell_phi, cell_dphi, delta_phi,
                 eta_coord_start, eta_coord_end, eta_fraction_start, eta_fraction_end,
                 phi_coord_start, phi_coord_end, phi_fraction_start, phi_fraction_end);
          // */
          return;
        }
 
      if (eta_coord_start < 0 || eta_coord_end < 0 || phi_coord_start < 0 || phi_coord_end < 0 ||
          eta_fraction_start < 0 || eta_fraction_end < 0 || phi_fraction_start < 0 || phi_fraction_end < 0)
        {
          // /*
          printf("Underflowing cell %d: %f %f %f %f %f %f (%d %d %f %f | %d %d %f %f) [%f %f]\n",
                 cell, cell_eta, cell_deta, cell_eta - cell_deta / 2, cell_phi, cell_dphi, cell_phi - cell_dphi / 2,
                 eta_coord_start, eta_coord_end, eta_fraction_start, eta_fraction_end,
                 phi_coord_start, phi_coord_end, phi_fraction_start, phi_fraction_end,
                 eta_min, phi_min);
          // */
          return;
        }
 
      if (eta_coord_start >= eta_grid || eta_coord_end >= eta_grid || phi_coord_start >= phi_grid || phi_coord_end >= phi_grid ||
          eta_fraction_start > 1 || eta_fraction_end > 1 || phi_fraction_start > 1 || phi_fraction_end > 1)
        {
          // /*
          printf("Overflowing cell %d: %f %f %f %f %f %f (%d %d %f %f | %d %d %f %f) [%f %f]\n",
                 cell, cell_eta, cell_deta, cell_eta + cell_deta / 2, cell_phi, cell_dphi, cell_phi + cell_dphi / 2,
                 eta_coord_start, eta_coord_end, eta_fraction_start, eta_fraction_end,
                 phi_coord_start, phi_coord_end, phi_fraction_start, phi_fraction_end,
                 eta_min, phi_min);
          // */
          return;
        }
 
      for (int eta_c = eta_coord_start; eta_c <= eta_coord_end; ++eta_c)
        {
          const float eta_corner = ( eta_c == eta_coord_start ?
                                     -eta_fraction_start : ( eta_c == eta_coord_end ?
                                                             eta_fraction_end : 0.f      )
                                   );
          for (int phi_c = 0; phi_c <= phi_coord_extra_neg; ++phi_c)
            {
              const float phi_corner = ( phi_c == phi_coord_extra_neg ?
                                         phi_fraction_extra_neg : 0.f   );
 
              add_cell_to_grid(cell, eta_corner, phi_corner, eta_c, phi_c);
 
            }
          for (int phi_c = phi_coord_start; phi_c <= phi_coord_end; ++phi_c)
            {
              const float phi_corner = ( phi_c == phi_coord_start ?
                                         -phi_fraction_start : ( phi_c == phi_coord_end ?
                                                                 phi_fraction_end : 0.f      )
                                       );
              add_cell_to_grid(cell, eta_corner, phi_corner, eta_c, phi_c);
            }
          for (int phi_c = phi_coord_extra_pos; phi_c < phi_grid; ++phi_c)
            {
              const float phi_corner = ( phi_c == phi_coord_extra_pos ?
                                         -phi_fraction_extra_pos : 0.f   );
              add_cell_to_grid(cell, eta_corner, phi_corner, eta_c, phi_c);
            }
        }
    }

Friends And Related Function Documentation

EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, false >

template<int eta_grid, int phi_grid, bool respect_deltas>

friend struct EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, false >

friend

Definition at line 1 of file EtaPhiMap.h.

Member Data Documentation

cells

template<int eta_grid, int phi_grid, bool respect_deltas>

int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::cells[eta_grid][phi_grid][s_max_overlap_cells]

Definition at line 49 of file EtaPhiMap.h.

corner_eta

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::corner_eta[eta_grid][phi_grid][s_max_overlap_cells]

Definition at line 50 of file EtaPhiMap.h.

corner_phi

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::corner_phi[eta_grid][phi_grid][s_max_overlap_cells]

Definition at line 51 of file EtaPhiMap.h.

delta_eta

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::delta_eta

Definition at line 47 of file EtaPhiMap.h.

delta_phi

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::delta_phi

Definition at line 48 of file EtaPhiMap.h.

eta_max

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::eta_max

Definition at line 45 of file EtaPhiMap.h.

eta_min

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::eta_min

Definition at line 43 of file EtaPhiMap.h.

phi_max

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::phi_max

Definition at line 46 of file EtaPhiMap.h.

phi_min

template<int eta_grid, int phi_grid, bool respect_deltas>

float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::phi_min

Definition at line 44 of file EtaPhiMap.h.

s_max_overlap_cells

template<int eta_grid, int phi_grid, bool respect_deltas>

constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, true >::s_max_overlap_cells = 10

staticconstexpr

Definition at line 37 of file EtaPhiMap.h.

---

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

• EtaPhiMap.h