ATLAS Offline Software
Loading...
Searching...
No Matches
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)
 !
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.
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

static constexpr 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>
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 }
CaloRecGPU::EtaPhiMapEntry
Holds an (eta, phi) to cell map for a given sampling.
Definition EtaPhiMap.h:35
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::s_eta_grid_size
static constexpr int s_eta_grid_size
Definition EtaPhiMap.h:47
CaloRecGPU::EtaPhiMapEntry::m_cells
int m_cells[s_eta_grid_size][phi_grid][s_max_overlap_cells]
Definition EtaPhiMap.h:49
CaloRecGPU::EtaPhiMapEntry::delta_phi
constexpr float delta_phi() const
Definition EtaPhiMap.h:69
CaloRecGPU::EtaPhiMapEntry::s_max_overlap_cells
static constexpr int s_max_overlap_cells
Definition EtaPhiMap.h:36
CaloRecGPU::EtaPhiMapEntry::m_eta_coordinates
float m_eta_coordinates[s_eta_grid_size][phi_grid][s_max_overlap_cells]
Definition EtaPhiMap.h:50
CaloRecGPU::EtaPhiMapEntry::phi_value
constexpr float phi_value(const int phi_coord) const
Definition EtaPhiMap.h:175
CaloRecGPU::EtaPhiMapEntry::eta_value
constexpr float eta_value(const int eta_coord) const
Definition EtaPhiMap.h:163
CaloRecGPU::EtaPhiMapEntry::delta_eta
constexpr float delta_eta() const
Definition EtaPhiMap.h:64

◆ coordinates_in_range()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
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 }
CaloRecGPU::EtaPhiMapEntry::end_eta
constexpr float end_eta(const bool positive=true) const
Definition EtaPhiMap.h:95
CaloRecGPU::EtaPhiMapEntry::start_eta
constexpr float start_eta(const bool positive=true) const
Definition EtaPhiMap.h:74

◆ 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 >::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>
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 }
CaloRecGPU::EtaPhiMapEntry::s_delta_phi
static constexpr float s_delta_phi
Definition EtaPhiMap.h:42

◆ end_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 >::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 }
CaloRecGPU::EtaPhiMapEntry::m_eta_limits
float m_eta_limits[1+!continuous]
Definition EtaPhiMap.h:44

◆ end_phi()

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 >::end_phi ( ) const
inlineconstexpr

Definition at line 111 of file EtaPhiMap.h.

112 {
113 return s_phi_max;
114 }
CaloRecGPU::EtaPhiMapEntry::s_phi_max
static constexpr float s_phi_max
Definition EtaPhiMap.h:41

◆ eta_coordinate() [1/2]

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 >::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 }
CaloRecGPU::EtaPhiMapEntry::eta_coordinate
constexpr int eta_coordinate(const float eta, float &interval) const
Definition EtaPhiMap.h:116

◆ eta_coordinate() [2/2]

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 >::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>
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 }
CaloRecGPU::EtaPhiMapEntry::get_max_real_overlap
constexpr int get_max_real_overlap() const
Definition EtaPhiMap.h:1049

◆ finish_initializing_buffer_size()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
constexpr 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>
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>
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 }
CaloRecGPU::Helpers::angular_difference
static CUDA_HOS_DEV T angular_difference(const T x, const T y)
Definition Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h:444
CaloRecGPU::EtaPhiMapEntry::phi_coordinate
constexpr int phi_coordinate(const float phi, float &interval) const
Definition EtaPhiMap.h:140
CaloRecGPU::EtaPhiMapEntry::coordinates_in_range
constexpr bool coordinates_in_range(const float eta, const float) const
Definition EtaPhiMap.h:156

◆ has_cell_in_coords()

template<int eta_grid, int phi_grid, bool respect_deltas, bool continuous, int sampling_number>
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>
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>
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 }
CaloRecGPU::EtaPhiMapEntry::start_phi
constexpr float start_phi() const
Definition EtaPhiMap.h:90
CaloRecGPU::EtaPhiMapEntry::end_phi
constexpr float end_phi() const
Definition EtaPhiMap.h:111
CaloRecGPU::EtaPhiMapEntry::initialize
constexpr void initialize()
Definition EtaPhiMap.h:327

◆ phi_coordinate() [1/2]

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 >::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>
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>
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>
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 }
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
CaloRecGPU::EtaPhiMapEntry::s_phi_min
static constexpr float s_phi_min
Definition EtaPhiMap.h:40

◆ start_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 >::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>
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>
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>
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>
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>
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>
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:
Generated on for ATLAS Offline Software by doxygen 1.14.0