ATLAS Offline Software
Classes | Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number > Class Template Reference

Holds an (eta, phi) to cell map for a given sampling. More...

#include <EtaPhiMap.h>

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

Classes

struct  FinishInitializingTemporaries
 

Public Member Functions

constexpr float delta_eta () const
 
constexpr float delta_phi () const
 
constexpr float start_eta (const bool positive=true) const
 
constexpr float start_phi () const
 
constexpr float end_eta (const bool positive=true) const
 
constexpr float end_phi () const
 
constexpr int eta_coordinate (const float eta, float &interval) const
 
constexpr int eta_coordinate (const float eta) const
 
constexpr int phi_coordinate (const float phi, float &interval) const
 
constexpr int phi_coordinate (const float phi) const
 
constexpr bool coordinates_in_range (const float eta, const float) const
 
constexpr float eta_value (const int eta_coord) const
 
constexpr float phi_value (const int phi_coord) const
 
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, const float max_eta)
 
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
 
constexpr int get_max_real_overlap () const
 

Static Public Member Functions

constexpr static size_t finish_initializing_buffer_size ()
 

Static Public Attributes

static constexpr int s_max_overlap_cells = 8
 

Private Member Functions

constexpr void add_cell_to_grid (const int cell, const float eta_fraction, const float phi_fraction, const int eta, const int phi)
 

Private Attributes

float m_eta_limits [1+!continuous]
 
float m_delta_eta
 
int m_cells [s_eta_grid_size][phi_grid][s_max_overlap_cells]
 
float m_eta_coordinates [s_eta_grid_size][phi_grid][s_max_overlap_cells]
 
float m_phi_coordinates [s_eta_grid_size][phi_grid][s_max_overlap_cells]
 

Static Private Attributes

static constexpr float s_phi_min = - Helpers::Constants::pi<float>
 
static constexpr float s_phi_max = + Helpers::Constants::pi<float>
 
static constexpr float s_delta_phi = (s_phi_max - s_phi_min) / phi_grid
 
static constexpr int s_eta_grid_size = eta_grid * (1 + !continuous)
 

Detailed Description

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
class CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >

Holds an (eta, phi) to cell map for a given sampling.

eta_grid: number of subdivisions in eta (doubled for non-continuous)
phi_grid: number of subdivisions in phi
respect_deltas: If true, the cells stretch only as far as their deta and dphi (Tile).
If false, always return closest cell (LAr).
continuous: If true, the sampling provides continuous coverage for positive and negative etas (e. g. contains eta == 0).
If false, the sampling is separated between its positive and negative eta cells.

Definition at line 34 of file EtaPhiMap.h.

Member Function Documentation

◆ add_cell_to_grid()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::add_cell_to_grid ( const int  cell,
const float  eta_fraction,
const float  phi_fraction,
const int  eta,
const int  phi 
)
inlineconstexprprivate

Definition at line 182 of file EtaPhiMap.h.

183  {
184  if (eta < 0 || eta >= s_eta_grid_size || phi < 0 || phi >= phi_grid)
185  {
186 #if CALORECGPU_ETA_PHI_MAP_DEBUG
187  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Attempt out of bounds store %d (%d): %f %f (%d / %d, %d / %d)\n",
188  cell, sampling_number, eta_fraction, phi_fraction, eta, eta_grid, phi, phi_grid);
189 #endif
190  return;
191  }
192 
193  for (int i = 0; i < s_max_overlap_cells; ++i)
194  {
195  if (m_cells[eta][phi][i] < 0)
196  {
197  m_cells [eta][phi][i] = cell;
198  m_eta_coordinates [eta][phi][i] = eta_fraction;
199  m_phi_coordinates [eta][phi][i] = phi_fraction;
200  return;
201  }
202  }
203 
204 #if CALORECGPU_ETA_PHI_MAP_DEBUG
205  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Unable to store %d (%d): ", cell, sampling_number);
206  for (int i = 0; i < s_max_overlap_cells; ++i)
207  {
208  printf("%d ", m_cells[eta][phi][i]);
209  }
210  printf("(%d / %d , %d / %d)\n", eta, s_eta_grid_size, phi, phi_grid);
211 
212  if (!respect_deltas)
213  {
214  const float this_eta = eta_value(eta);
215  const float this_phi = phi_value(phi);
216  for (int i = 0; i < s_max_overlap_cells; ++i)
217  {
218  const float cell_eta = m_eta_coordinates [eta][phi][i];
219  const float cell_phi = m_phi_coordinates [eta][phi][i];
220 
221  const float d_eta_1 = fabsf(this_eta - cell_eta);
222  const float d_eta_2 = fabsf(this_eta + delta_eta() - cell_eta);
223 
224  const float d_phi_1 = fabsf(Helpers::angular_difference(this_phi, cell_phi));
225  const float d_phi_2 = fabsf(Helpers::angular_difference(this_phi + delta_phi(), cell_phi));
226 
227  printf(" %f %f %f %f | %f %f %f %f (%f %f | %f %f %f %f)\n",
228  d_eta_1 + d_phi_1,
229  d_eta_1 + d_phi_2,
230  d_eta_2 + d_phi_1,
231  d_eta_2 + d_phi_2,
232  d_eta_1,
233  d_eta_2,
234  d_phi_1,
235  d_phi_2,
236  cell_eta,
237  cell_phi,
238  this_eta,
239  this_eta + delta_eta(),
240  this_phi,
241  this_phi + delta_phi());
242  }
243  }
244 #endif
245  }

◆ coordinates_in_range()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr bool CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::coordinates_in_range ( const float  eta,
const float   
) const
inlineconstexpr

Definition at line 156 of file EtaPhiMap.h.

157  {
158  const bool eta_in_range = eta >= start_eta(eta > 0) && eta <= end_eta(eta > 0);
159  const bool phi_in_range = true; //By definition, we wrap around in phi...
160  return eta_in_range && phi_in_range;
161  }

◆ delta_eta()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::delta_eta ( ) const
inlineconstexpr

Definition at line 64 of file EtaPhiMap.h.

65  {
66  return m_delta_eta;
67  }

◆ delta_phi()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::delta_phi ( ) const
inlineconstexpr

Definition at line 69 of file EtaPhiMap.h.

70  {
71  return s_delta_phi;
72  }

◆ end_eta()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::end_eta ( const bool  positive = true) const
inlineconstexpr

Definition at line 95 of file EtaPhiMap.h.

96  {
97  if (continuous)
98  {
99  return m_eta_limits[0];
100  }
101  else if (positive)
102  {
103  return m_eta_limits[1];
104  }
105  else
106  {
107  return -m_eta_limits[0];
108  }
109  }

◆ end_phi()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::end_phi ( ) const
inlineconstexpr

Definition at line 111 of file EtaPhiMap.h.

112  {
113  return s_phi_max;
114  }

◆ eta_coordinate() [1/2]

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::eta_coordinate ( const float  eta) const
inlineconstexpr

Definition at line 134 of file EtaPhiMap.h.

135  {
136  float dummy = 0.f;
137  return eta_coordinate(eta, dummy);
138  }

◆ eta_coordinate() [2/2]

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::eta_coordinate ( const float  eta,
float &  interval 
) const
inlineconstexpr

Definition at line 116 of file EtaPhiMap.h.

117  {
118  using namespace std;
119  const float frac = (eta - start_eta(eta > 0)) / delta_eta();
120  const float rounded = floorf(frac);
121  interval = frac - rounded;
122  const int casted = static_cast<int>(rounded);
123  if ((casted == eta_grid || casted == 2 * eta_grid) && interval == 0.f)
124  {
125  interval = 1.f;
126  return casted - 1 + (eta > 0 && !continuous) * eta_grid;
127  }
128  else
129  {
130  return casted + (eta > 0 && !continuous) * eta_grid;
131  }
132  }

◆ eta_value()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::eta_value ( const int  eta_coord) const
inlineconstexpr

Definition at line 163 of file EtaPhiMap.h.

164  {
165  if (!continuous && eta_coord >= eta_grid)
166  {
167  return start_eta(true) + (eta_coord - eta_grid) * delta_eta();
168  }
169  else
170  {
171  return start_eta(false) + eta_coord * delta_eta();
172  }
173  }

◆ finish_initializing()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
CUDA_HOS_DEV void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::finish_initializing ( void *  buffer)
inline

!

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

Definition at line 484 of file EtaPhiMap.h.

485  {
486  if (!respect_deltas)
487  {
488  using namespace std;
489 
490  FinishInitializingTemporaries * temp_ptr = new (buffer) FinishInitializingTemporaries;
491 
492  FinishInitializingTemporaries & temps = *temp_ptr;
493 
494  auto calculate_minima = [&](float & min_dist_eta, float & min_dist_phi,
495  const float this_eta, const float this_phi,
496  const float gridcell_eta, const float gridcell_phi)
497  {
498  if (this_eta >= gridcell_eta && this_eta <= gridcell_eta + delta_eta())
499  {
500  min_dist_eta = this_eta;
501  }
502  else
503  {
504  if (this_eta < gridcell_eta)
505  {
506  min_dist_eta = gridcell_eta;
507  }
508 #if CALORECGPU_ETA_PHI_MAP_DEBUG
509  else if (this_eta <= gridcell_eta + delta_eta())
510  {
511  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Strange things going on with eta distance (%d): %f | %f %f\n",
512  sampling_number, this_eta, gridcell_eta, gridcell_eta + delta_eta());
513  }
514 #endif
515  else
516  {
517  min_dist_eta = gridcell_eta + delta_eta();
518  }
519  }
520 
521  if (this_phi >= gridcell_phi && this_phi <= gridcell_phi + delta_phi())
522  {
523  min_dist_phi = this_phi;
524  }
525  else
526  {
527  const float d1 = fabsf(Helpers::angular_difference(gridcell_phi, this_phi));
528  const float d2 = fabsf(Helpers::angular_difference(gridcell_phi + delta_phi(), this_phi));
529  if (d1 < d2)
530  {
531  min_dist_phi = gridcell_phi;
532  }
533 #if CALORECGPU_ETA_PHI_MAP_DEBUG
534  else if (d1 == d2)
535  {
536  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Strange things going on with phi distance (%d): %f | %f %f\n",
537  sampling_number, this_phi, gridcell_phi, gridcell_phi + delta_phi());
538  }
539 #endif
540  else
541  {
542  min_dist_phi = gridcell_phi + delta_phi();
543  }
544  }
545  };
546 
547  auto calculate_dist = [](const float e_1, const float p_1,
548  const float e_2, const float p_2)
549  {
550  return fabsf(e_1 - e_2) + fabsf(Helpers::angular_difference(p_1, p_2));
551  };
552 
553  auto update_cell_list = [&](int (&cells) [s_max_overlap_cells],
554  float (&etas) [s_max_overlap_cells],
555  float (&phis) [s_max_overlap_cells],
556  float (&min_etas) [s_max_overlap_cells],
557  float (&min_phis) [s_max_overlap_cells],
558  const int this_cell,
559  const float this_eta,
560  const float this_phi,
561  const float min_dist_eta,
562  const float min_dist_phi)
563  {
564  int i = 0;
565  int to_replace[s_max_overlap_cells];
566  int replace_count = 0;
567 
568  const float new_dist_at_new_minimum = calculate_dist(this_eta, this_phi, min_dist_eta, min_dist_phi);
569 
570  for (i = 0; i < s_max_overlap_cells; ++i)
571  {
572  if (cells[i] < 0)
573  {
574  break;
575  }
576 
577  if (cells[i] == this_cell)
578  {
579  //Already part of the list...
580  return false;
581  }
582 
583  const float old_dist_at_new_minimum = calculate_dist(etas[i], phis[i], min_dist_eta, min_dist_phi);
584 
585  if (old_dist_at_new_minimum <= new_dist_at_new_minimum)
586  {
587  //There is a cell that will always be closer
588  return false;
589  }
590 
591  const float new_dist_at_old_minimum = calculate_dist(this_eta, this_phi, min_etas[i], min_phis[i]);
592  const float old_dist_at_old_minimum = calculate_dist(etas[i], phis[i], min_etas[i], min_phis[i]);
593 
594  if (new_dist_at_old_minimum < old_dist_at_old_minimum)
595  {
596  //An old cell was actually further away.
597  to_replace[replace_count] = i;
598  ++replace_count;
599  }
600  }
601 
602  while (replace_count > 0 && i > 0)
603  {
604  const int orig = to_replace[replace_count - 1];
605  if (orig != i - 1)
606  {
607  cells [orig] = cells [i - 1];
608  etas [orig] = etas [i - 1];
609  phis [orig] = phis [i - 1];
610  min_etas [orig] = min_etas [i - 1];
611  min_phis [orig] = min_phis [i - 1];
612  }
613  cells[i - i] = -1;
614  --replace_count;
615  --i;
616  if (i < 0 || (i == 0 && replace_count > 0))
617  {
618 #if CALORECGPU_ETA_PHI_MAP_DEBUG
619  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Negative count on cell list update, somehow... (%d)\n", sampling_number);
620 #endif
621  break;
622  }
623  }
624 
625  if (i < s_max_overlap_cells)
626  {
627  cells [i] = this_cell;
628  etas [i] = this_eta;
629  phis [i] = this_phi;
630  min_etas [i] = min_dist_eta;
631  min_phis [i] = min_dist_phi;
632  return true;
633  }
634 #if CALORECGPU_ETA_PHI_MAP_DEBUG
635  else
636  {
637  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Warning: overfull list of overlapping cells: %d (%d)\n", i, sampling_number);
638  }
639 #endif
640  return false;
641  };
642 
643  auto add_possible_cells = [&](int (&cells) [s_max_overlap_cells],
644  float (&etas) [s_max_overlap_cells],
645  float (&phis) [s_max_overlap_cells],
646  float (&min_etas) [s_max_overlap_cells],
647  float (&min_phis) [s_max_overlap_cells],
648  const float gridcell_eta,
649  const float gridcell_phi,
650  const int orig_eta,
651  const int orig_phi)
652  {
653  bool updated = false;
654  for (int i = 0; i < s_max_overlap_cells; ++i)
655  {
656  const int this_cell = m_cells[orig_eta][orig_phi][i];
657 
658  if (this_cell < 0)
659  {
660  break;
661  }
662 
663  const float this_eta = m_eta_coordinates[orig_eta][orig_phi][i];
664  const float this_phi = m_phi_coordinates[orig_eta][orig_phi][i];
665 
666  float min_dist_eta = 0.f, min_dist_phi = 0.f;
667 
668  calculate_minima(min_dist_eta, min_dist_phi, this_eta, this_phi, gridcell_eta, gridcell_phi);
669 
670  updated = updated || update_cell_list(cells, etas, phis, min_etas, min_phis,
671  this_cell, this_eta, this_phi, min_dist_eta, min_dist_phi);
672 
673  }
674 
675  return updated;
676  };
677 
678  auto process_cell = [&](const int eta, const int phi)
679  {
680  const int phi_before = (phi == 0 ? phi_grid - 1 : phi - 1);
681  const int phi_after = (phi == phi_grid - 1 ? 0 : phi + 1);
682  const int eta_before = (eta == 0 || eta == eta_grid ? -1 : eta - 1);
683  const int eta_after = (eta == eta_grid - 1 || eta == 2 * eta_grid - 1 ? -1 : eta + 1);
684 
685  const float this_grid_eta = eta_value(eta);
686  const float this_grid_phi = phi_value(phi);
687 
688  float min_etas[s_max_overlap_cells], min_phis[s_max_overlap_cells];
689 
690  for (int i = 0; i < s_max_overlap_cells; ++i)
691  {
692  if (temps.cells[eta][phi][i] < 0)
693  {
694  break;
695  }
696 
697  const float this_eta = m_eta_coordinates[eta][phi][i];
698  const float this_phi = m_phi_coordinates[eta][phi][i];
699 
700  calculate_minima(min_etas[i], min_phis[i], this_eta, this_phi, this_grid_eta, this_grid_phi);
701  }
702 
703  bool added = false;
704 
705  added = added || add_possible_cells(temps.cells[eta][phi],
706  temps.etas[eta][phi], temps.phis[eta][phi],
707  min_etas, min_phis,
708  this_grid_eta, this_grid_phi,
709  eta, phi_before);
710  added = added || add_possible_cells(temps.cells[eta][phi],
711  temps.etas[eta][phi], temps.phis[eta][phi],
712  min_etas, min_phis,
713  this_grid_eta, this_grid_phi,
714  eta, phi_after);
715 
716  if (eta_before >= 0)
717  {
718  added = added || add_possible_cells(temps.cells[eta][phi],
719  temps.etas[eta][phi], temps.phis[eta][phi],
720  min_etas, min_phis,
721  this_grid_eta, this_grid_phi,
722  eta_before, phi);
723  }
724  if (eta_after >= 0)
725  {
726  added = added || add_possible_cells(temps.cells[eta][phi],
727  temps.etas[eta][phi], temps.phis[eta][phi],
728  min_etas, min_phis,
729  this_grid_eta, this_grid_phi,
730  eta_after, phi);
731  }
732 
733  bool ret = false;
734 
735  if (added)
736  {
737  ret = ret || temps.try_add_next_gridcell(eta, phi_before);
738  ret = ret || temps.try_add_next_gridcell(eta, phi_after);
739  if (eta_before >= 0)
740  {
741  ret = ret || temps.try_add_next_gridcell(eta_before, phi);
742  }
743  if (eta_after >= 0)
744  {
745  ret = ret || temps.try_add_next_gridcell(eta_after, phi);
746  }
747  }
748 
749  return ret;
750  };
751 
752  temps.counter[0] = 0;
753  temps.counter[1] = 0;
754  temps.select = false;
755 
756  temps.swap();
757 
758  for (int eta = 0; eta < s_eta_grid_size; ++eta)
759  {
760  for (int phi = 0; phi < phi_grid; ++phi)
761  {
762  memcpy(temps.cells[eta][phi], m_cells[eta][phi], s_max_overlap_cells * sizeof(int));
763 
764  if (m_cells[eta][phi][0] >= 0)
765  {
766  memcpy(temps.etas[eta][phi], m_eta_coordinates[eta][phi], s_max_overlap_cells * sizeof(float));
767  memcpy(temps.phis[eta][phi], m_phi_coordinates[eta][phi], s_max_overlap_cells * sizeof(float));
768 
769  const int phi_before = (phi == 0 ? phi_grid - 1 : phi - 1);
770  const int phi_after = (phi == phi_grid - 1 ? 0 : phi + 1);
771  const int eta_before = (eta == 0 || eta == eta_grid ? -1 : eta - 1);
772  const int eta_after = (eta == eta_grid - 1 || eta == s_eta_grid_size - 1 ? -1 : eta + 1);
773 
774  temps.try_add_next_gridcell(eta, phi);
775 
776  temps.try_add_next_gridcell(eta, phi_before);
777  temps.try_add_next_gridcell(eta, phi_after);
778  if (eta_before >= 0)
779  {
780  temps.try_add_next_gridcell(eta_before, phi);
781  }
782  if (eta_after >= 0)
783  {
784  temps.try_add_next_gridcell(eta_after, phi);
785  }
786  }
787  }
788  }
789 
790  temps.swap();
791  temps.clear_next_gridcells();
792 
793 #if CALORECGPU_ETA_PHI_MAP_DEBUG
794  int iter_count = 0;
795  int equal_iter_counter = 0;
796 #endif
797 
798  while (temps.get_counter() > 0)
799  {
800  for (int i = 0; i < temps.get_counter(); ++i)
801  {
802  int eta, phi;
803  temps.get_gridcell(i, eta, phi);
804  process_cell(eta, phi);
805  }
806 
807 #if CALORECGPU_ETA_PHI_MAP_DEBUG
808  ++iter_count;
809 
810  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Init %d: %d | %d %d (%d)\n",
811  sampling_number, iter_count, temps.get_counter(), temps.get_next_counter(), equal_iter_counter);
812 
813  if (temps.get_counter() == temps.get_next_counter())
814  {
815  int count_same = 0;
816 
817  for (int i = 0; i < temps.get_counter(); ++i)
818  {
819  count_same += (temps.get_gridcells()[i] == temps.get_next_gridcells()[i]);
820  }
821  if (count_same == temps.get_counter())
822  {
823  ++equal_iter_counter;
824  if (equal_iter_counter >= 4)
825  //Assume we got stuck in some weird loop...
826  {
827  temps.clear_next_gridcells();
828  }
829  if (temps.get_counter() < 10)
830  {
831  for (int i = 0; i < temps.get_counter(); ++i)
832  {
833  int eta, phi;
834  temps.get_gridcell(i, eta, phi);
835  printf(" %d %d", eta, phi);
836  for (int j = 0; j < s_max_overlap_cells; ++j)
837  {
838  if (temps.cells[eta][phi][j] < 0)
839  {
840  break;
841  }
842  printf(" (%d: %f %f)", temps.cells[eta][phi][j], temps.etas[eta][phi][j], temps.phis[eta][phi][j]);
843  }
844  printf("\n");
845  }
846  }
847  }
848  else
849  {
850  equal_iter_counter = 0;
851  }
852  }
853  else
854  {
855  equal_iter_counter = 0;
856  }
857 #endif
858 
859  for (int i = 0; i < temps.get_counter(); ++i)
860  {
861  int eta, phi;
862  temps.get_gridcell(i, eta, phi);
863 
864  memcpy(m_cells [eta][phi], temps.cells[eta][phi], s_max_overlap_cells * sizeof(int) );
865  memcpy(m_eta_coordinates[eta][phi], temps.etas [eta][phi], s_max_overlap_cells * sizeof(float));
866  memcpy(m_phi_coordinates[eta][phi], temps.phis [eta][phi], s_max_overlap_cells * sizeof(float));
867  }
868 
869  temps.swap();
870  temps.clear_next_gridcells();
871 
872  }
873 
874 #if CALORECGPU_ETA_PHI_MAP_DEBUG
875  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: Finished %d: %d (%d %d)\n",
876  sampling_number, get_max_real_overlap(), iter_count, equal_iter_counter);
877 #endif
878  }
879  else
880  {
881  //Do nothing: when respecting deltas,
882  //cells get properly initialized outright...
883  }
884  }

◆ finish_initializing_buffer_size()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr static size_t CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::finish_initializing_buffer_size ( )
inlinestaticconstexpr

Definition at line 478 of file EtaPhiMap.h.

479  {
480  return sizeof(FinishInitializingTemporaries);
481  }

◆ get_max_real_overlap()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::get_max_real_overlap ( ) const
inlineconstexpr

Definition at line 1049 of file EtaPhiMap.h.

1050  {
1051  int ret = 0;
1052 
1053  for (int eta = 0; eta < s_eta_grid_size; ++eta)
1054  {
1055  for (int phi = 0; phi < phi_grid; ++phi)
1056  {
1057  int this_count = 0;
1058 
1059  for (int i = 0; i < s_max_overlap_cells; ++i)
1060  {
1061  if (m_cells[eta][phi][i] >= 0)
1062  {
1063  ++this_count;
1064  }
1065  else
1066  {
1067  break;
1068  }
1069  }
1070 
1071  if (this_count > ret)
1072  {
1073  ret = this_count;
1074  }
1075  }
1076  }
1077 
1078  return ret;
1079  }

◆ get_possible_cells_from_coords()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::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 887 of file EtaPhiMap.h.

888  {
889  if (!coordinates_in_range(test_eta, test_phi))
890  {
891  return 0;
892  }
893 
894  int num_cells = 0;
895 
896  float frac_eta = 0.f, frac_phi = 0.f;
897 
898  const int eta_coord = eta_coordinate(test_eta, frac_eta);
899  const int phi_coord = phi_coordinate(test_phi, frac_phi);
900 
901  if (eta_coord < 0 || eta_coord >= s_eta_grid_size || phi_coord < 0 || phi_coord >= phi_grid)
902  {
903  return 0;
904  }
905 
906  if (respect_deltas)
907  {
908  auto check_coord = [](const float test, const float target)
909  {
910  using namespace std;
911  if (target > 0 && fabsf(test) <= fabsf(target))
912  {
913  return true;
914  }
915  else if (target < 0 && fabsf(test) >= fabsf(target))
916  {
917  return true;
918  }
919  else if (target == 0)
920  {
921  return true;
922  }
923  else
924  {
925  return false;
926  }
927  };
928 
929  for (int i = 0; i < s_max_overlap_cells; ++i)
930  {
931  const int this_cell = m_cells[eta_coord][phi_coord][i];
932 
933  if (this_cell < 0)
934  {
935  break;
936  }
937 
938  if (check_coord(frac_eta, m_eta_coordinates[eta_coord][phi_coord][i]) &&
939  check_coord(frac_phi, m_phi_coordinates[eta_coord][phi_coord][i]) )
940  {
941  cell_arr[num_cells] = this_cell;
942  ++num_cells;
943  }
944  }
945  }
946  else
947  {
948  float distance = 1e38f;
949  int ret = -1;
950 
951  for (int i = 0; i < s_max_overlap_cells; ++i)
952  {
953  const int this_cell = m_cells[eta_coord][phi_coord][i];
954 
955  if (this_cell < 0)
956  {
957  break;
958  }
959 
960  const float this_delta_eta = m_eta_coordinates[eta_coord][phi_coord][i] - test_eta;
961 
962  const float this_delta_phi = Helpers::angular_difference(m_phi_coordinates[eta_coord][phi_coord][i], test_phi);
963 
964  using namespace std;
965 
966  const float this_dist = fabsf(this_delta_eta) + fabsf(this_delta_phi);
967 
968  if (this_dist < distance || (this_dist == distance && this_cell > ret))
969  {
970  distance = this_dist;
971  ret = this_cell;
972  }
973  }
974 
975  if (ret > 0)
976  {
977  cell_arr[0] = ret;
978  num_cells = 1;
979  }
980  }
981 
982  return num_cells;
983  }

◆ has_cell_in_coords()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr bool CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::has_cell_in_coords ( const float  test_eta,
const float  test_phi 
) const
inlineconstexpr

Definition at line 985 of file EtaPhiMap.h.

986  {
987  if (!coordinates_in_range(test_eta, test_phi))
988  {
989  return false;
990  }
991 
992  float frac_eta = 0.f, frac_phi = 0.f;
993 
994  const int eta_coord = eta_coordinate(test_eta, frac_eta);
995  const int phi_coord = phi_coordinate(test_phi, frac_phi);
996 
997  if (eta_coord < 0 || eta_coord >= s_eta_grid_size || phi_coord < 0 || phi_coord >= phi_grid)
998  {
999  return false;
1000  }
1001 
1002  if (respect_deltas)
1003  {
1004  auto check_coord = [](const float test, const float target)
1005  {
1006  using namespace std;
1007  if (target > 0 && fabsf(test) <= fabsf(target))
1008  {
1009  return true;
1010  }
1011  else if (target < 0 && fabsf(test) >= fabsf(target))
1012  {
1013  return true;
1014  }
1015  else if (target == 0)
1016  {
1017  return true;
1018  }
1019  else
1020  {
1021  return false;
1022  }
1023  };
1024 
1025  for (int i = 0; i < s_max_overlap_cells; ++i)
1026  {
1027  if (m_cells[eta_coord][phi_coord][i] < 0)
1028  {
1029  break;
1030  }
1031  if ( check_coord(frac_eta, m_eta_coordinates[eta_coord][phi_coord][i]) &&
1032  check_coord(frac_phi, m_phi_coordinates[eta_coord][phi_coord][i]) )
1033  {
1034  return true;
1035  }
1036  }
1037  return false;
1038  }
1039  else
1040  {
1041  return true;
1042  //Except for being out-of-bounds,
1043  //if respect_deltas == false
1044  //we can always find a closest cell
1045  //for each coordinate.
1046  }
1047  }

◆ initialize() [1/2]

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::initialize ( )
inlineconstexpr

Definition at line 327 of file EtaPhiMap.h.

328  {
329  for (int i = 0; i < s_eta_grid_size; ++i)
330  {
331  for (int j = 0; j < phi_grid; ++j)
332  {
333  for (int k = 0; k < s_max_overlap_cells; ++k)
334  {
335  m_cells[i][j][k] = -1;
336  }
337  }
338  }
339  }

◆ initialize() [2/2]

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::initialize ( const float  min_eta,
const float  max_eta 
)
inlineconstexpr

Definition at line 341 of file EtaPhiMap.h.

342  {
343  initialize();
344 
345  if (continuous)
346  {
347  m_eta_limits[0] = max_eta;
348 
349  m_delta_eta = (max_eta / eta_grid) * 2;
350  }
351  else
352  {
353  m_eta_limits[0] = min_eta;
354  m_eta_limits[1] = max_eta;
355 
356  m_delta_eta = ((max_eta - min_eta) / eta_grid) * 2;
357  }
358 
359 #if CALORECGPU_ETA_PHI_MAP_DEBUG
360  if (sampling_number < 24)
361  {
362  printf("CALORECGPU ETA PHI MAP DEBUG OUTPUT: %d | %d | %f %f | %f %f | %f %f | %f %f\n",
363  sampling_number, static_cast<int>(continuous),
364  start_eta(false), end_eta(false),
365  start_eta(true), end_eta(true),
366  start_phi(), end_phi(),
367  delta_eta(), delta_phi());
368  }
369 #endif
370  }

◆ phi_coordinate() [1/2]

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::phi_coordinate ( const float  phi) const
inlineconstexpr

Definition at line 150 of file EtaPhiMap.h.

151  {
152  float dummy = 0.f;
153  return phi_coordinate(phi, dummy);
154  }

◆ phi_coordinate() [2/2]

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::phi_coordinate ( const float  phi,
float &  interval 
) const
inlineconstexpr

Definition at line 140 of file EtaPhiMap.h.

141  {
142  using namespace std;
143  const float frac = (phi - start_phi()) / delta_phi();
144  const float rounded = floorf(frac);
145  interval = frac - rounded;
146  const int to_return = static_cast<int>(rounded) % phi_grid;
147  return to_return + (to_return < 0) * phi_grid;
148  }

◆ phi_value()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::phi_value ( const int  phi_coord) const
inlineconstexpr

Definition at line 175 of file EtaPhiMap.h.

176  {
177  return start_phi() + phi_coord * delta_phi();
178  }

◆ register_cell()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr void CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::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 249 of file EtaPhiMap.h.

250  {
251  int start_eta_coord = -1, end_eta_coord = -1;
252  float start_eta_frac = 0.f, end_eta_frac = 0.f;
253 
254  start_eta_coord = eta_coordinate(cell_eta - cell_deta / 2, start_eta_frac);
255  end_eta_coord = eta_coordinate(cell_eta + cell_deta / 2, end_eta_frac);
256 
257  int start_phi_coord = -1, end_phi_coord = -1;
258  float start_phi_frac = 0.f, end_phi_frac = 0.f;
259  int start_phi_extra = -1, end_phi_extra = -1;
260  float start_phi_extra_frac = 0.f, end_phi_extra_frac = 0.f;
261 
262 
263  if (cell_phi - cell_dphi / 2 < s_phi_min && cell_phi + cell_dphi / 2 > s_phi_max)
264  //The (impossible) case of a full wraparound in phi
265  {
266  start_phi_coord = 0;
267  start_phi_frac = 0.f;
268 
269  end_phi_coord = phi_grid - 1;
270  end_phi_frac = 1.f;
271  }
272  else if (cell_phi - cell_dphi / 2 < s_phi_min)
273  {
274  start_phi_coord = 0;
275  start_phi_frac = 0.f;
276 
277  end_phi_coord = phi_coordinate(cell_phi + cell_dphi / 2, end_phi_frac);
278 
279  start_phi_extra = phi_coordinate(Helpers::regularize_angle(cell_phi - cell_dphi / 2), start_phi_extra_frac);
280 
281  end_phi_extra = phi_grid - 1;
282  end_phi_extra_frac = 1.f;
283  }
284  else if (cell_phi + cell_dphi / 2 > s_phi_max)
285  {
286  start_phi_coord = phi_coordinate(cell_phi - cell_dphi / 2, start_phi_frac);
287 
288  end_phi_coord = phi_grid - 1;
289  end_phi_frac = 1.f;
290 
291  start_phi_extra = phi_coordinate(Helpers::regularize_angle(cell_phi - cell_dphi / 2), start_phi_extra_frac);
292 
293  start_phi_extra = 0;
294  start_phi_extra_frac = 1.f;
295 
296  end_phi_extra = phi_coordinate(Helpers::regularize_angle(cell_phi + cell_dphi / 2), end_phi_extra_frac);
297  }
298  else
299  {
300  start_phi_coord = phi_coordinate(cell_phi - cell_dphi / 2, start_phi_frac);
301  end_phi_coord = phi_coordinate(cell_phi + cell_dphi / 2, end_phi_frac);
302  }
303 
304  for (int i = start_eta_coord; i <= end_eta_coord; ++i)
305  {
306  const float eta_frac = (i == start_eta_coord ? -start_eta_frac : i == end_eta_coord ? end_eta_frac : 0.f);
307 
308  for (int j = start_phi_coord; j <= end_phi_coord; ++j)
309  {
310  const float phi_frac = (j == start_phi_coord ? -start_phi_frac : j == end_phi_coord ? end_phi_frac : 0.f);
311 
312  add_cell_to_grid(cell, (respect_deltas ? eta_frac : cell_eta), (respect_deltas ? phi_frac : cell_phi), i, j);
313  }
314 
315  if (start_phi_extra >= 0)
316  {
317  for (int j = start_phi_extra; j <= end_phi_extra; ++j)
318  {
319  const float phi_frac = (j == start_phi_extra ? -start_phi_extra_frac : j == end_phi_extra ? end_phi_extra_frac : 0.f);
320 
321  add_cell_to_grid(cell, (respect_deltas ? eta_frac : cell_eta), (respect_deltas ? phi_frac : cell_phi), i, j);
322  }
323  }
324  }
325  }

◆ start_eta()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::start_eta ( const bool  positive = true) const
inlineconstexpr

Definition at line 74 of file EtaPhiMap.h.

75  {
76  if (continuous)
77  {
78  return -m_eta_limits[0];
79  }
80  else if (positive)
81  {
82  return m_eta_limits[0];
83  }
84  else
85  {
86  return -m_eta_limits[1];
87  }
88  }

◆ start_phi()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::start_phi ( ) const
inlineconstexpr

Definition at line 90 of file EtaPhiMap.h.

91  {
92  return s_phi_min;
93  }

Member Data Documentation

◆ m_cells

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::m_cells[s_eta_grid_size][phi_grid][s_max_overlap_cells]
private

Definition at line 49 of file EtaPhiMap.h.

◆ m_delta_eta

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::m_delta_eta
private

Definition at line 45 of file EtaPhiMap.h.

◆ m_eta_coordinates

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::m_eta_coordinates[s_eta_grid_size][phi_grid][s_max_overlap_cells]
private

Definition at line 50 of file EtaPhiMap.h.

◆ m_eta_limits

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::m_eta_limits[1+!continuous]
private

Definition at line 44 of file EtaPhiMap.h.

◆ m_phi_coordinates

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::m_phi_coordinates[s_eta_grid_size][phi_grid][s_max_overlap_cells]
private

Definition at line 51 of file EtaPhiMap.h.

◆ s_delta_phi

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::s_delta_phi = (s_phi_max - s_phi_min) / phi_grid
staticconstexprprivate

Definition at line 42 of file EtaPhiMap.h.

◆ s_eta_grid_size

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::s_eta_grid_size = eta_grid * (1 + !continuous)
staticconstexprprivate

Definition at line 47 of file EtaPhiMap.h.

◆ s_max_overlap_cells

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr int CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::s_max_overlap_cells = 8
staticconstexpr

Definition at line 36 of file EtaPhiMap.h.

◆ s_phi_max

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::s_phi_max = + Helpers::Constants::pi<float>
staticconstexprprivate

Definition at line 41 of file EtaPhiMap.h.

◆ s_phi_min

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr float CaloRecGPU::EtaPhiMapEntry< eta_grid, phi_grid, respect_deltas, continuous, sampling_number >::s_phi_min = - Helpers::Constants::pi<float>
staticconstexprprivate

Definition at line 40 of file EtaPhiMap.h.

The documentation for this class was generated from the following file:
CaloRecGPU::EtaPhiMapEntry::phi_coordinate
constexpr int phi_coordinate(const float phi, float &interval) const
Definition: EtaPhiMap.h:140
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:281
test_pyathena.eta
eta
Definition: test_pyathena.py:10
CaloRecGPU::EtaPhiMapEntry::m_eta_coordinates
float m_eta_coordinates[s_eta_grid_size][phi_grid][s_max_overlap_cells]
Definition: EtaPhiMap.h:50
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
CaloRecGPU::EtaPhiMapEntry::m_eta_limits
float m_eta_limits[1+!continuous]
Definition: EtaPhiMap.h:44
CaloRecGPU::EtaPhiMapEntry::initialize
constexpr void initialize()
Definition: EtaPhiMap.h:327
CaloRecGPU::EtaPhiMapEntry::eta_coordinate
constexpr int eta_coordinate(const float eta, float &interval) const
Definition: EtaPhiMap.h:116
dq_defect_virtual_defect_validation.d1
d1
Definition: dq_defect_virtual_defect_validation.py:79
TrigInDetValidation_Base.test
test
Definition: TrigInDetValidation_Base.py:142
CaloRecGPU::EtaPhiMapEntry::s_eta_grid_size
static constexpr int s_eta_grid_size
Definition: EtaPhiMap.h:47
CaloRecGPU::EtaPhiMapEntry::eta_value
constexpr float eta_value(const int eta_coord) const
Definition: EtaPhiMap.h:163
xAOD::phi
setEt phi
Definition: TrigEMCluster_v1.cxx:29
CaloRecGPU::EtaPhiMapEntry::m_phi_coordinates
float m_phi_coordinates[s_eta_grid_size][phi_grid][s_max_overlap_cells]
Definition: EtaPhiMap.h:51
CaloRecGPU::EtaPhiMapEntry::m_cells
int m_cells[s_eta_grid_size][phi_grid][s_max_overlap_cells]
Definition: EtaPhiMap.h:49
createCoolChannelIdFile.buffer
buffer
Definition: createCoolChannelIdFile.py:11
CaloRecGPU::EtaPhiMapEntry::start_phi
constexpr float start_phi() const
Definition: EtaPhiMap.h:90
lumiFormat.i
int i
Definition: lumiFormat.py:85
checkxAOD.frac
frac
Definition: Tools/PyUtils/bin/checkxAOD.py:259
getLatestRuns.interval
interval
Definition: getLatestRuns.py:24
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
module_driven_slicing.max_eta
max_eta
Definition: module_driven_slicing.py:165
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
CaloRecGPU::EtaPhiMapEntry::end_eta
constexpr float end_eta(const bool positive=true) const
Definition: EtaPhiMap.h:95
CaloRecGPU::EtaPhiMapEntry::add_cell_to_grid
constexpr void add_cell_to_grid(const int cell, const float eta_fraction, const float phi_fraction, const int eta, const int phi)
Definition: EtaPhiMap.h:182
copySelective.target
string target
Definition: copySelective.py:36
CaloRecGPU::EtaPhiMapEntry::start_eta
constexpr float start_eta(const bool positive=true) const
Definition: EtaPhiMap.h:74
dq_defect_virtual_defect_validation.d2
d2
Definition: dq_defect_virtual_defect_validation.py:81
module_driven_slicing.min_eta
min_eta
Definition: module_driven_slicing.py:165
CaloRecGPU::EtaPhiMapEntry::s_phi_min
static constexpr float s_phi_min
Definition: EtaPhiMap.h:40
CaloRecGPU::EtaPhiMapEntry::end_phi
constexpr float end_phi() const
Definition: EtaPhiMap.h:111
CaloRecGPU::EtaPhiMapEntry::m_delta_eta
float m_delta_eta
Definition: EtaPhiMap.h:45
CaloRecGPU::EtaPhiMapEntry::get_max_real_overlap
constexpr int get_max_real_overlap() const
Definition: EtaPhiMap.h:1049
CaloRecGPU::EtaPhiMapEntry::phi_value
constexpr float phi_value(const int phi_coord) const
Definition: EtaPhiMap.h:175
CaloRecGPU::EtaPhiMapEntry::s_max_overlap_cells
static constexpr int s_max_overlap_cells
Definition: EtaPhiMap.h:36
CaloRecGPU::EtaPhiMapEntry::s_delta_phi
static constexpr float s_delta_phi
Definition: EtaPhiMap.h:42
CaloRecGPU::EtaPhiMapEntry::s_phi_max
static constexpr float s_phi_max
Definition: EtaPhiMap.h:41
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
EgEfficiencyCorr_testFixedInput.etas
list etas
Definition: EgEfficiencyCorr_testFixedInput.py:9
CaloRecGPU::EtaPhiMapEntry::coordinates_in_range
constexpr bool coordinates_in_range(const float eta, const float) const
Definition: EtaPhiMap.h:156
CaloRecGPU::EtaPhiMapEntry::delta_eta
constexpr float delta_eta() const
Definition: EtaPhiMap.h:64
fitman.k
k
Definition: fitman.py:528
CaloRecGPU::EtaPhiMapEntry::delta_phi
constexpr float delta_phi() const
Definition: EtaPhiMap.h:69
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
Generated on Sun Aug 31 2025 21:57:02 for ATLAS Offline Software by   doxygen 1.8.18