Translation between real-space positions and cell IDs within the ECal. More...

#include <EcalGeometry.h>

Public Member Functions
virtual	~EcalGeometry ()=default
	Class destructor.

EcalID	getID (double x, double y, double z, bool fallible=false) const
	Get a cell's ID number from its position.

EcalID	getID (double x, double y, int layer_id, bool fallible=false) const
	Get a cell's ID from its x,y global position and layer number.

EcalID	getID (double x, double y, int layer_id, int module_id, bool fallible=false) const
	Get a cell's ID from its x,y global position and layer/module numbers as deduced from GDML copy numbers.

std::tuple< double, double, double >	getPosition (EcalID id) const
	Get a cell's position from its ID number.

std::pair< double, double >	getPositionInModule (int cell_id) const
	Get a cell's position within a module.

double	getZPosition (int layer) const
	Get the z-coordinate given the layer id.

int	getNumLayers () const
	Get the number of layers in the Ecal Geometry.

int	getNumModulesPerLayer () const
	Get the number of modules in the Ecal flower.

int	getNumCellsPerModule () const
	Get the number of cells in each module of the Ecal Geometry.

std::vector< EcalID >	getNN (EcalID id) const
	Get the Nearest Neighbors of the input ID.

bool	isNN (EcalID centroid, EcalID probe) const
	Check if the probe id is one of the nearest neightbors of the centroid id.

std::vector< EcalID >	getNNN (EcalID id) const
	Get the Next-to-Nearest Neighbors of the input ID.

bool	isNNN (EcalID centroid, EcalID probe) const
	Check if the probe id is one of the next-to-nearest neightbors of the centroid id.

double	getModuleMinR () const
	Get the center-to-flat radius of the module hexagons.

double	getModuleMaxR () const
	Get the center-to-corner radius of the module hexagons.

double	getCellMinR () const
	Get the center-to-flat radius of the cell hexagons.

double	getCellMaxR () const
	Get the center-to-corner radius of the cell hexagons.

TH2Poly *	getCellPolyMap () const
	Get a reference to the TH2Poly used for Cell IDs.

Public Member Functions inherited from framework::ConditionsObject
	ConditionsObject (const std::string &name)
	Class constructor.

virtual	~ConditionsObject ()
	Destructor.

std::string	getName () const
	Get the name of this object.

Static Public Member Functions
static EcalGeometry *	debugMake (const framework::config::Parameters &p)

Static Public Attributes
static constexpr const char *	CONDITIONS_OBJECT_NAME {"EcalGeometry"}

Private Member Functions
	EcalGeometry (const framework::config::Parameters &ps)
	Class constructor, for use only by the provider.

void	buildLayerMap ()
	Constructs the positions of the layers in world coordinates.

void	buildModuleMap ()
	Constructs the positions of the seven modules (moduleID) relative to the ecal center.

void	buildCellMap ()
	Constructs the flat-bottomed hexagonal grid (cellID) of corner-down hexagonal cells.

void	buildCellModuleMap ()
	Constructs the positions of all the cells in a layer relative to the ecal center.

void	buildNeighborMaps ()
	Construts NNMap and NNNMap.

double	distanceToEdge (EcalID id) const
	Distance to module edge, and whether cell is on edge of module.

bool	isEdgeCell (EcalID cellModuleID) const
	Check if input cell is on the edge of a module.

bool	isInside (double normX, double normY) const
	Determines if point (x,y), already normed to max hexagon radius, lies within a hexagon.

Private Attributes
double	gap_
	Gap between module flat sides [mm].

double	cellr_ {0}
	Center-to-Flat Radius of cell hexagon [mm].

double	moduler_ {0}
	Center-to-Flat Radius of module hexagon [mm].

double	cellR_ {0}
	Center-to-Corner Radius of cell hexagon [mm].

double	moduleR_ {0}
	Center-to-Corner Radius of module hexagon [mm].

bool	cornersSideUp_
	indicator of geometry orientation if true, flower shape's corners side (ie: side with two modules) is at the top

double	layer_shift_x_
	shift of layers in the x-direction [mm]

double	layer_shift_y_
	shift of layers in the y-direction [mm]

bool	layer_shift_odd_
	shift odd layers

bool	layer_shift_odd_bilayer_
	shift odd bi layers

double	nCellRHeight_ {0}
	Number of cell center-to-corner radii (one side of the cell) from the bottom to the top of the module.

double	ecalFrontZ_ {0}
	Front of ECal relative to world geometry [mm].

std::vector< double >	layerZPositions_
	The layer Z postions are with respect to the front of the ECal [mm].

int	verbose_
	verbosity

std::map< int, std::tuple< double, double, double > >	layer_pos_xy_
	Position of layer centers in world coordinates (uses layer ID as key)

std::map< int, std::pair< double, double > >	module_pos_xy_
	Postion of module centers relative to the center of the layer in world coordinates.

std::map< int, std::pair< double, double > >	cell_pos_in_module_
	Position of cell centers relative to center of module in p,q space.

std::map< EcalID, std::pair< double, double > >	cell_pos_in_layer_
	Position of cell centers relative to center of layer in world coordinates.

std::map< EcalID, std::tuple< double, double, double > >	cell_global_pos_
	Position of cell centers relative to world geometry.

std::map< EcalID, std::vector< EcalID > >	NNMap_
	Map of cell ID to neighboring cells.

std::map< EcalID, std::vector< EcalID > >	NNNMap_
	Map of cell ID to neighbors of neighbor cells.

TH2Poly	cell_id_in_module_
	Honeycomb Binning from ROOT.

Friends
class	ecal::EcalGeometryProvider

Detailed Description

Translation between real-space positions and cell IDs within the ECal.

This is the object that does the extra geometry not implemented in the gdml. In order to save time during the simulation, the individual cells in the readout hexagons are not constructed individually in Geant4. This means we have to have a translation between position and cell ID which is accomplished by this class.

Moreover, downstream processors sometimes need access to the cell position when they only know the cell ID. This class can also do this conversion.

ORIENTATION ASSUMPTIONS:

modules and cells have opposite orientation. i.e. if modules are corner-side down, then cells are flat-side down.

SOME GEOMETRY:

hexagons have two radii:
- r (half of flat-to-flat width) and R (half of corner-to-corner width).
- r = (sqrt(3)/2)R and s = R, where s is the length of an edge.
for seven ecal modules oriented flat-side-down, maximum x and y extents are:
- deltaY = 6r' + 2g = 3sqrt(3)R' + 2g
- deltaX = 4R' + s' + 2g/cos(30 deg) = 5R' + 4g/sqrt(3)
- where g is uniform gap width between modules, and primed variables correspond to modules.

Since the whole hexagon flower has changed orientation since previous versions of the detector (which we wish to still support), I am defining an extra set of axes with respect to the flower itself. Below I have drawn the ECal hexagon i flower and defined two axes: p (through the "pointy sides") and q (through the "flat sides"). In some versions of the ECal flower, p == x and q == y while in others p == -y and q == x.

     ^
     | q axis
    __
 __/1 \__
/6 \__/2 \
\__/0 \__/ __ p axis __>
/5 \__/3 \
\__/4 \__/
   \__/

Now we can define a process for determining the cellular IDs.

Define a mapping of cell IDs within a module (center of module is the origin)
- Use TH2Poly to do the Hexagon tiling in p,q space
Define center of modules with respect to center of layer in p,q space
- currently this is assumed to be the same within all layers BUT will depend on geometry parameters like the gap between modules
Define center of layers (INCLUDING x,y position)
- some versions of the geometry shift layers off the z axis to cover the gaps between modules
- Will need to handle the conversion between x,y and p,q axes

THIS GRID:

column-to-column distance in a grid such as ours is 2r = sqrt(3)R.
row-to-row distance is 1.5R (easy to observe that twice that distance = 3R)

The cell radius is calculated from the total number of center-to-corner cell radii that span the module height. This count can have fractional counts to account for the fractions of cell radii at the module edges.

Definition at line 101 of file EcalGeometry.h.

Constructor & Destructor Documentation

◆ ~EcalGeometry()

virtual ldmx::EcalGeometry::~EcalGeometry ( )

virtualdefault

Class destructor.

Does nothing because the member variables clean up themselves.

◆ EcalGeometry()

ldmx::EcalGeometry::EcalGeometry ( const framework::config::Parameters & ps )

private

Class constructor, for use only by the provider.

Parameters

ps	Parameters to configure the EcalGeometry

Definition at line 51 of file EcalGeometry.cxx.

    : framework::ConditionsObject(EcalGeometry::CONDITIONS_OBJECT_NAME) {
  layerZPositions_ = ps.getParameter<std::vector<double>>("layerZPositions");
  ecalFrontZ_ = ps.getParameter<double>("ecalFrontZ");
  moduler_ = ps.getParameter<double>("moduleMinR");
  gap_ = ps.getParameter<double>("gap");
  nCellRHeight_ = ps.getParameter<double>("nCellRHeight");
  verbose_ = ps.getParameter<int>("verbose");
  cornersSideUp_ = ps.getParameter<bool>("cornersSideUp");
  layer_shift_x_ = ps.getParameter<double>("layer_shift_x");
  layer_shift_y_ = ps.getParameter<double>("layer_shift_y");
  layer_shift_odd_ = ps.getParameter<bool>("layer_shift_odd");
  layer_shift_odd_bilayer_ = ps.getParameter<bool>("layer_shift_odd_bilayer");
 
  if (layer_shift_odd_ and layer_shift_odd_bilayer_) {
    EXCEPTION_RAISE("BadConf",
                    "Cannot shift both odd sensitive layers and odd bilayers");
  }
 
  moduleR_ = moduler_ * (2 / sqrt(3));
  cellR_ = 2 * moduler_ / nCellRHeight_;
  cellr_ = (sqrt(3.) / 2.) * cellR_;
 
  if (verbose_ > 0) {
    std::cout << std::endl
              << "[EcalGeometry] Verbosity set in header to " << verbose_
              << std::endl;
    std::cout << "     Building module map with gap " << std::setprecision(2)
              << gap_ << ", nCellRHeight " << nCellRHeight_
              << ",  min/max radii of cell " << cellr_ << " / " << cellR_
              << ", and module " << moduler_ << " / " << moduleR_ << std::endl;
  }
 
  buildLayerMap();
  buildModuleMap();
  buildCellMap();
  buildCellModuleMap();
  buildNeighborMaps();
 
  if (verbose_ > 0)
    std::cout << "[EcalGeometry] : fully constructed" << std::endl;
}

References buildCellMap(), buildCellModuleMap(), buildLayerMap(), buildModuleMap(), buildNeighborMaps(), cellr_, cellR_, cornersSideUp_, ecalFrontZ_, gap_, framework::config::Parameters::getParameter(), layer_shift_odd_, layer_shift_odd_bilayer_, layer_shift_x_, layer_shift_y_, layerZPositions_, moduler_, moduleR_, nCellRHeight_, and verbose_.

Member Function Documentation

◆ buildCellMap()

void ldmx::EcalGeometry::buildCellMap ( )

private

Constructs the flat-bottomed hexagonal grid (cellID) of corner-down hexagonal cells.

Sets ecalMap_ with the defined bins being the ecal cells in coordinates with respect to the module center. Also sets cellPostionMap_ with the keys being the cell ID and the values being the position of the cell with respect to the module center.

Strategy

Use ROOT's TH2Poly::HoneyComb method to build a large hexagonal grid, then copy the polygons from it which overlap with the module with more than one vertex.

A vertex between three cells is placed at the origin, then the bottom left corner of the honeycomb and the number of x and y cells across the honeycomb is calculated by continuing to decrement the grid x/y point until the module center-to-flat distance is reached.

The hexagons that only have one vertex outside the module hexagon leave a small space un-covered by the tiling, so the vertices adjacent to the external vertex are projected onto the module edge.

Parameters

[in]	cellr_	the center-to-flat cell radius
[in]	cellR_	the center-to-corner cell radius
[in]	moduler_	the center-to-flat module radius
[in]	moduleR_	the center-to-flat module radius
[out]	ecalMap_	TH2Poly with local cell ID to local cell position mapping
[out]	cellPostionMap_	map of local cell ID to cell center position relative to module

STRATEGY use ROOT HoneyComb method (build large hex grid, copy polygons that cover module)

the sneaky bit is that the center of TH2Poly::HoneyComb is the center of a cell while the center of one of our modules is the corner between three cells. This means some of the hexagons along the edges of the module will not be regular and need to stretched/squashed a bit.

REMEMBER: We are in p,q space for the cells_in_module_ map. i.e.

^ | q axis __ / \ – > p axis __/

TODO is this needed?

Definition at line 271 of file EcalGeometry.cxx.

                                {
  TH2Poly gridMap;
 
  // make hexagonal grid [boundary is rectangle] larger than the module
  double gridMinP = 0., gridMinQ = 0.;  // start at the origin
  int numPCells = 0, numQCells = 0;
 
  // first x-cell is only a half
  gridMinP -= cellr_;
  numPCells++;
  while (gridMinP > -1 * moduleR_) {
    gridMinP -= 2 * cellr_;  // decrement x by cell center-to-flat diameter
    numPCells++;
  }
  while (gridMinQ > -1 * moduler_) {
    // decrement y by cell center-to-corner radius
    //  alternate between a full corner-to-corner diameter
    //  and a side of a cell (center-to-corner radius)
    if (numQCells % 2 == 0)
      gridMinQ -= 1 * cellR_;
    else
      gridMinQ -= 2 * cellR_;
    numQCells++;
  }
  // only counted one half of the cells
  numPCells *= 2;
  numQCells *= 2;
 
  gridMap.Honeycomb(gridMinP, gridMinQ, cellR_, numPCells, numQCells);
 
  if (verbose_ > 0) {
    std::cout << std::setprecision(2)
              << "[EcalGeometry::buildCellMap] cell rmin: " << cellr_
              << " cell rmax: " << cellR_ << " (gridMinP,gridMinQ) = ("
              << gridMinP << "," << gridMinQ << ")"
              << " (numPCells,numQCells) = (" << numPCells << "," << numQCells
              << ")" << std::endl;
  }
 
  // copy cells lying within module boundaries to a module grid
  TListIter next(gridMap.GetBins());  // a TH2Poly is a TList of TH2PolyBin
  TH2PolyBin* polyBin = 0;
  TGraph* poly = 0;  // a polygon returned by TH2Poly is a TGraph
  // cells_in_module_ IDs go from 0 to N-1, not equal to original grid cell ID
  int cell_id = 0;
  while ((polyBin = (TH2PolyBin*)next())) {
    // these bins are coming from the honeycomb
    //  grid so we assume that they are regular
    //  hexagons i.e. has 6 vertices
    poly = (TGraph*)polyBin->GetPolygon();
 
    // decide whether to copy polygon to new map.
    // use all vertices in case of cut-off edge polygons.
    int numVerticesInside = 0;
    double vertex_p[6], vertex_q[6];  // vertices of the cell
    bool isinside[6];                 // which vertices are inside
    if (verbose_ > 2) std::cout << "    Cell vertices" << std::endl;
    for (unsigned i = 0; i < 6; i++) {
      poly->GetPoint(i, vertex_p[i], vertex_q[i]);
      if (verbose_ > 2) {
        std::cout << "      vtx # " << i << std::endl;
        std::cout << "      vtx p,q " << vertex_p[i] << " " << vertex_q[i]
                  << std::endl;
      }
      isinside[i] = isInside(vertex_p[i] / moduleR_, vertex_q[i] / moduleR_);
      if (isinside[i]) numVerticesInside++;
    }
 
    if (numVerticesInside > 1) {
      // Include this cell if more than one of its vertices is inside the module
      // hexagon
      double actual_p[8], actual_q[8];
      int num_vertices{0};
      if (numVerticesInside < 6) {
        // This cell is stradling the edge of the module
        // and is NOT cleanly cut by module edge
 
        if (verbose_ > 1) {
          std::cout << "    Polygon " << cell_id
                    << " has vertices poking out of module hexagon."
                    << std::endl;
        }
 
        // loop through vertices
        for (int i = 0; i < 6; i++) {
          int up = i == 5 ? 0 : i + 1;
          int dn = i == 0 ? 5 : i - 1;
          if (isinside[i] and (not isinside[up] or not isinside[dn])) {
            // this vertex is inside the module hexagon and is adjacent to a
            // vertex outside
            // ==> project this vertex onto the nearest edge of the module
            // hexagon
 
            // determine which side of hexagon we should project onto
            double edge_origin_p, edge_origin_q;
            double edge_dest_p, edge_dest_q;
            if (vertex_p[i] < -moduleR_ / 2.) {
              // sloped edge on negative-x side
              edge_origin_p = -1. * moduleR_;
              edge_origin_q = 0.;
              edge_dest_p = -0.5 * moduleR_;
              edge_dest_q = moduler_;
            } else if (vertex_p[i] > moduleR_ / 2.) {
              // sloped edge on positive-x side
              edge_origin_p = 0.5 * moduleR_;
              edge_origin_q = moduler_;
              edge_dest_p = moduleR_;
              edge_dest_q = 0.;
            } else {
              // flat edge at top
              edge_origin_p = 0.5 * moduleR_;
              edge_origin_q = moduler_;
              edge_dest_p = -0.5 * moduleR_;
              edge_dest_q = moduler_;
            }
            // flip to bottom half if below x-axis
            if (vertex_q[i] < 0) {
              edge_dest_q *= -1;
              edge_origin_q *= -1;
            }
 
            // get edge slope vector
            double edge_slope_p = edge_dest_p - edge_origin_p;
            double edge_slope_q = edge_dest_q - edge_origin_q;
 
            if (verbose_ > 2) {
              std::cout
                  << "Vertex " << i
                  << " is inside and adjacent to a vertex outside the module."
                  << std::endl;
              std::cout << "Working on edge with slope (" << edge_slope_p << ","
                        << edge_slope_q << ")"
                        << " and origin (" << edge_origin_p << ","
                        << edge_origin_q << ")" << std::endl;
            }
 
            // project vertices adjacent to the vertex outside the module onto
            // the module edge
            double projection_factor =
                ((vertex_p[i] - edge_origin_p) * edge_slope_p +
                 (vertex_q[i] - edge_origin_q) * edge_slope_q) /
                (edge_slope_p * edge_slope_p + edge_slope_q * edge_slope_q);
 
            double proj_p = edge_origin_p + projection_factor * edge_slope_p;
            double proj_q = edge_origin_q + projection_factor * edge_slope_q;
 
            if (not isinside[up]) {
              // the next point is outside
              actual_p[num_vertices] = vertex_p[i];
              actual_q[num_vertices] = vertex_q[i];
              actual_p[num_vertices + 1] = proj_p;
              actual_q[num_vertices + 1] = proj_q;
            } else {
              // the previous point was outside
              actual_p[num_vertices] = proj_p;
              actual_q[num_vertices] = proj_q;
              actual_p[num_vertices + 1] = vertex_p[i];
              actual_q[num_vertices + 1] = vertex_q[i];
            }
            num_vertices += 2;
 
            if (verbose_ > 2) {
              std::cout << "New Vertex " << i << " : (" << vertex_p[i] << ","
                        << vertex_q[i] << ")" << std::endl;
            }
          } else {
            actual_p[num_vertices] = vertex_p[i];
            actual_q[num_vertices] = vertex_q[i];
            num_vertices++;
          }  // should we project or not
        }    // loop through vertices
      } else {
        // all 6 inside, just copy the vertices over
        num_vertices = 6;
        for (int i = 0; i < 6; i++) {
          actual_p[i] = vertex_p[i];
          actual_q[i] = vertex_q[i];
        }
      }  // if numVerticesInside is less than 5
 
      // TH2Poly needs to have its own copy of the polygon TGraph
      //  otherwise, we get a seg fault when EcalGeometry is destructed
      //  because the polygon that was copied over from gridMap is deleted at
      //  the end of this function
      cell_id_in_module_.AddBin(num_vertices, actual_p, actual_q);
 
      double p = (polyBin->GetXMax() + polyBin->GetXMin()) / 2.;
      double q = (polyBin->GetYMax() + polyBin->GetYMin()) / 2.;
      if (verbose_ > 1) {
        std::cout << "    Copying poly with ID " << polyBin->GetBinNumber()
                  << " and (p,q) (" << std::setprecision(2) << p << "," << q
                  << ")" << std::endl;
      }
      // save cell location as center of ENTIRE hexagon
      cell_pos_in_module_[cell_id] = std::pair<double, double>(p, q);
      ++cell_id;  // incrememnt cell ID
    }             // if num vertices inside is > 1
  }               // loop over larger grid spanning module hexagon
  return;
}

References cell_id_in_module_, cell_pos_in_module_, cellr_, cellR_, isInside(), moduler_, moduleR_, and verbose_.

Referenced by EcalGeometry().

◆ buildCellModuleMap()

void ldmx::EcalGeometry::buildCellModuleMap ( )

private

Constructs the positions of all the cells in a layer relative to the ecal center.

This uses the modulePostionMap_ and cellPositionMap_ to calculate the center of all cells relative to the ecal center.

Parameters

[in]	modulePositionMap_	map of module IDs to module centers relative to ecal
[in]	cellPositionMap_	map of cell IDs to cell centers relative to module
[out]

construct map of cell centers relative to layer center

construct map of global cell centers relative to target center

Definition at line 494 of file EcalGeometry.cxx.

                                      {
  if (verbose_ > 0)
    std::cout
        << "[EcalGeometry::buildCellModuleMap] Building cellModule position map"
        << std::endl;
  for (auto const& [module_id, module_xy] : module_pos_xy_) {
    for (auto const& [cell_id, cell_pq] : cell_pos_in_module_) {
      double cell_x{cell_pq.first}, cell_y{cell_pq.second};
      // convert from (p,q) to (x,y) space
      // when the corners are not up, x = p and y = q
      // so no transformation needs to be done
      if (cornersSideUp_) unrotate(cell_x, cell_y);
 
      // calculate cell's pq relative to entire layer center
      auto cell_rel_to_layer =
          std::make_pair(module_xy.first + cell_x, module_xy.second + cell_y);
 
      // now add the layer-center values to get the global position
      // of the cell
      cell_pos_in_layer_[EcalID(0, module_id, cell_id)] = cell_rel_to_layer;
    }
  }
 
  for (auto const& [layer_id, layer_xyz] : layer_pos_xy_) {
    for (auto const& [flat_id, rel_to_layer] : cell_pos_in_layer_) {
      // now add the layer-center values to get the global position
      // of the cell
      cell_global_pos_[EcalID(layer_id, flat_id.module(), flat_id.cell())] =
          std::make_tuple(rel_to_layer.first + std::get<0>(layer_xyz),
                          rel_to_layer.second + std::get<1>(layer_xyz),
                          std::get<2>(layer_xyz));
    }
  }
 
  if (verbose_ > 0)
    std::cout << "  contained " << cell_global_pos_.size() << " entries. "
              << std::endl;
  return;
}

References cell_global_pos_, cell_pos_in_layer_, cell_pos_in_module_, cornersSideUp_, layer_pos_xy_, module_pos_xy_, and verbose_.

Referenced by EcalGeometry().

◆ buildLayerMap()

void ldmx::EcalGeometry::buildLayerMap ( )

private

Constructs the positions of the layers in world coordinates.

Definition at line 201 of file EcalGeometry.cxx.

                                 {
  if (verbose_ > 0) {
    std::cout << "[EcalGeometry::buildLayerMap] "
              << " Building layer map with " << layerZPositions_.size()
              << " layers" << std::endl;
    ;
    if (layer_shift_odd_ or layer_shift_odd_bilayer_) {
      std::cout << "  shifting odd ";
      if (layer_shift_odd_)
        std::cout << "layers";
      else
        std::cout << "bilayers";
      std::cout << " by (x,y) = (" << layer_shift_x_ << ", " << layer_shift_y_
                << ") mm" << std::endl;
    } else {
      std::cout << "  without any shifting" << std::endl;
    }
  }
  for (std::size_t i_layer{0}; i_layer < layerZPositions_.size(); ++i_layer) {
    // default is centered on z-axis
    double x{0}, y{0}, z{ecalFrontZ_ + layerZPositions_.at(i_layer)};
    if (layer_shift_odd_ and (i_layer % 2 == 1)) {
      x += layer_shift_x_;
      y += layer_shift_y_;
    } else if (layer_shift_odd_bilayer_ and ((i_layer / 2) % 2 == 1)) {
      x += layer_shift_x_;
      y += layer_shift_y_;
    }
    if (verbose_ > 2) {
      std::cout << "    Layer " << i_layer << " has center at (" << x << ", "
                << y << ", " << z << ") mm" << std::endl;
    }
    layer_pos_xy_[i_layer] = std::make_tuple(x, y, z);
  }
}

References ecalFrontZ_, layer_pos_xy_, layer_shift_odd_, layer_shift_odd_bilayer_, layer_shift_x_, layer_shift_y_, layerZPositions_, and verbose_.

Referenced by EcalGeometry().

◆ buildModuleMap()

void ldmx::EcalGeometry::buildModuleMap ( )

private

Constructs the positions of the seven modules (moduleID) relative to the ecal center.

Sets modulePositionMap_ using the module IDs for keys and the centers of the module hexagons for values.

The module IDs are set in the ecal.gdml file and are replicated here.

0 for center module
1 on top (12 o'clock)
clockwise till 6 at 11 o'clock

Parameters

[in]	gap_	separation between module flat-sides
[in]	moduler_	center-to-flat module radius
[out]	modulePositionMap_	map of module IDs to module centers relative to ecal

Definition at line 237 of file EcalGeometry.cxx.

                                  {
  static double C_PI =
      3.14159265358979323846;  // or TMath::Pi(), #define, atan(), ...
  if (verbose_ > 0) {
    std::cout << "[EcalGeometry::buildModuleMap] "
              << "Building module position map for module min r of " << moduler_
              << " and gap of " << gap_ << std::endl;
  }
 
  // the center module (module_id == 0) has always been (and will always be?)
  //  centered with respect to the layer position
  module_pos_xy_[0] = std::pair<double, double>(0., 0.);
 
  // for flat-side-up designs (v12 and earlier), the modules are numbered 1 on
  // positive y-axis and then counter-clockwise until 6
  //
  // for corner-side-up designes (v13 and later), the modules are numbered 1 on
  // positive x-axis and then counter-clockwise until 6.
  for (unsigned id = 1; id < 7; id++) {
    // flat-side-up
    double x = (2. * moduler_ + gap_) * sin((id - 1) * (C_PI / 3.));
    double y = (2. * moduler_ + gap_) * cos((id - 1) * (C_PI / 3.));
    if (cornersSideUp_) {
      // re-calculating to make sure centers match GDML
      x = (2. * moduler_ + gap_) * cos((id - 1) * (C_PI / 3.));
      y = -(2. * moduler_ + gap_) * sin((id - 1) * (C_PI / 3.));
    }
    module_pos_xy_[id] = std::pair<double, double>(x, y);
    if (verbose_ > 2)
      std::cout << "    Module " << id << " is centered at (x,y) = "
                << "(" << x << ", " << y << ") mm" << std::endl;
  }
}

References cornersSideUp_, gap_, module_pos_xy_, moduler_, and verbose_.

Referenced by EcalGeometry().

◆ buildNeighborMaps()

void ldmx::EcalGeometry::buildNeighborMaps ( )

private

Construts NNMap and NNNMap.

Since this only occurs once during processing, we can be wasteful. We do a nested loop over the entire cellular position map and calculate neighbors by seeing which cells are within multiples of the cellular radius of each other.

Note: We require two cells to be in the same layer in order to be nearest neighbors or next-nearest neighbors.

Parameters

[in]	cellModulePostionMap_	map of cells to cell centers relative to ecal
[out]	NNMap_	map of cell IDs to list of cell IDs that are its nearest neighbors
[out]	NNNMap_	map of cell IDs to list of cell IDs that are its next-to-nearest neighbors

STRATEGY

Neighbors may include from other modules. All this is precomputed. So we can be wasteful here. Gaps may be nonzero, so we simply apply an anulus requirement (r < point <= r+dr) using total x,y positions relative to the ecal center (cell+module positions). This makes the routine portable to future cell layouts. Note that the module centers already take into account a nonzero gap. The number of neighbors is not simple because: edges, and that module edges have cutoff cells. (NN) Center within [1*cellr_, 3*cellr_] (NNN) Center within [3*cellr_, 4.5*cellr_] Chosen b/c in ideal case, centers are at 2*cell_ (NN), and at 3*cellR_=3.46*cellr_ and 4*cellr_ (NNN).

do distance calculation

Definition at line 536 of file EcalGeometry.cxx.

                                     {
  if (verbose_ > 0)
    std::cout << "[EcalGeometry::buildNeighborMaps] : "
              << "Building Nearest and Next-Nearest Neighbor maps" << std::endl;
 
  NNMap_.clear();
  NNNMap_.clear();
  for (auto const& [center_id, center_xyz] : cell_pos_in_layer_) {
    for (auto const& [probe_id, probe_xyz] : cell_pos_in_layer_) {
      double dist = distance(probe_xyz, center_xyz);
      if (dist > 1 * cellr_ && dist <= 3. * cellr_) {
        NNMap_[center_id].push_back(probe_id);
      } else if (dist > 3. * cellr_ && dist <= 4.5 * cellr_) {
        NNNMap_[center_id].push_back(probe_id);
      }
    }
    if (verbose_ > 1)
      std::cout << "  Found " << NNMap_[center_id].size() << " NN and "
                << NNNMap_[center_id].size() << " NNN for cell " << center_id
                << std::endl;
  }
  /*
   * DEBUG CHECK HERE
   *  this is double checking that NN and NNN can cross modules
  if (verbose_ > 2) {
    double specialX =
        0.5 * moduleR_ - 0.5 * cellr_;  // center of cell which is upper-right
                                        // corner of center module
    double specialY = moduler_ - 0.5 * cellR_;
    EcalID specialCellModuleID = getCellModuleID(specialX, specialY);
    std::cout << "The neighbors of the bin in the upper-right corner of the "
                 "center module, with cellModuleID "
              << specialCellModuleID << " include " << std::endl;
    for (auto centerNN : NNMap_.at(specialCellModuleID)) {
      std::cout << " NN " << centerNN
                << TString::Format(" (x,y) (%.2f, %.2f)",
                                   getCellCenterAbsolute(centerNN).first,
                                   getCellCenterAbsolute(centerNN).second)
                << std::endl;
    }
    for (auto centerNNN : NNNMap_.at(specialCellModuleID)) {
      std::cout << " NNN " << centerNNN
                << TString::Format(" (x,y) (%.2f, %.2f)",
                                   getCellCenterAbsolute(centerNNN).first,
                                   getCellCenterAbsolute(centerNNN).second)
                << std::endl;
    }
    std::cout << TString::Format(
                     "This bin is a distance of %.2f away from a module edge. "
                     "Decision isEdge %d.",
                     distanceToEdge(specialCellModuleID),
                     isEdgeCell(specialCellModuleID))
              << std::endl;
  }
  */
  return;
}

References cell_pos_in_layer_, cellr_, NNMap_, NNNMap_, and verbose_.

Referenced by EcalGeometry().

◆ debugMake()

static EcalGeometry * ldmx::EcalGeometry::debugMake ( const framework::config::Parameters & p )

inlinestatic

Definition at line 334 of file EcalGeometry.h.

                                                                     {
    return new EcalGeometry(p);
  }

◆ distanceToEdge()

double ldmx::EcalGeometry::distanceToEdge ( EcalID id ) const

private

Distance to module edge, and whether cell is on edge of module.

@TODO Use getNN()/getNNN() + isEdgeCell() to expand functionality.

Parameters

[in] cellModuleID EcalId where all we care about is module and cell

Returns: distance to edge of the module

Definition at line 608 of file EcalGeometry.cxx.

                                                   {
  // https://math.stackexchange.com/questions/1210572/find-the-distance-to-the-edge-of-a-hexagon
  std::pair<double, double> cellLocation = cell_pos_in_module_.at(id.cell());
  double x = fabs(cellLocation.first);  // bring to first quadrant
  double y = fabs(cellLocation.second);
  double r = sqrt(x * x + y * y);
  double theta = (r > 1E-3) ? fabs(std::atan(y / x)) : 0;
  if (x < moduleR_ / 2.)
    return (moduler_ - y);  // closest line is straight vertical to top edge
  double dist =
      sqrt(3.) * moduleR_ / (std::sin(theta) + sqrt(3.) * std::cos(theta));
  return dist;
}

References cell_pos_in_module_, moduler_, and moduleR_.

Referenced by isEdgeCell().

◆ getCellMaxR()

double ldmx::EcalGeometry::getCellMaxR ( ) const

inline

Get the center-to-corner radius of the cell hexagons.

Returns: cell max radius [mm]

Definition at line 316 of file EcalGeometry.h.

316{ return cellR_; }

References cellR_.

Referenced by ecal::EcalVetoProcessor::produce().

◆ getCellMinR()

double ldmx::EcalGeometry::getCellMinR ( ) const

inline

Get the center-to-flat radius of the cell hexagons.

Returns: cell min radius [mm]

Definition at line 309 of file EcalGeometry.h.

309{ return cellr_; }

References cellr_.

◆ getCellPolyMap()

TH2Poly * ldmx::EcalGeometry::getCellPolyMap ( ) const

inline

Get a reference to the TH2Poly used for Cell IDs.

Note: This is only helpful in the use case where you want to print the cell ID <-> cell position map. DO NOT USE THIS OTHERWISE.

Returns: pointer to member variable cell_id_in_module_

Definition at line 327 of file EcalGeometry.h.

                                  {
    for (auto const& [cell_id, cell_center] : cell_pos_in_module_) {
      cell_id_in_module_.Fill(cell_center.first, cell_center.second, cell_id);
    }
    return &cell_id_in_module_;
  }

References cell_id_in_module_, and cell_pos_in_module_.

◆ getID() [1/3]

EcalID ldmx::EcalGeometry::getID	(	double	x,
		double	y,
		double	z,
		bool	fallible = `false`
	)		const

Get a cell's ID number from its position.

Parameters

[in]	x	global x position [mm]
[in]	y	global y position [mm]
[in]	z	global z position [mm]
[in]	fallible	bool to decide if the function should fail

Returns: EcalID of the cell (null-id if fallible) Example for fallible use case
auto id = geometry.getID(x, y, z, true);

if (id.null()) {

// position (x,y) is not contained within a cell in layer at z

}

Definition at line 94 of file EcalGeometry.cxx.

                                                                            {
  static const double tolerance = 0.3;  // thickness of Si
  int layer_id{-1};
  for (const auto& [lid, layer_xyz] : layer_pos_xy_) {
    if (abs(std::get<2>(layer_xyz) - z) < tolerance) {
      layer_id = lid;
      break;
    }
  }
  if (layer_id < 0) {
    if (fallible) {
      return ldmx::EcalID(0);
    } else {
      EXCEPTION_RAISE("BadConf", "z = " + std::to_string(z) +
                                     " mm is not within any"
                                     " of the configured layers.");
    }
  }
  return getID(x, y, layer_id, fallible);
}

References getID(), and layer_pos_xy_.

Referenced by getID(), getID(), and ecal::EcalVetoProcessor::produce().

◆ getID() [2/3]

EcalID ldmx::EcalGeometry::getID	(	double	x,
		double	y,
		int	layer_id,
		bool	fallible = `false`
	)		const

Get a cell's ID from its x,y global position and layer number.

This is faster as long as we trust that the layer positions between GDML and the configured parameters of this class match.

Parameters

[in]	x	global x position [mm]
[in]	y	global y position [mm]
[in]	layer_id	integer ID of the layer the hit is in
[in]	fallible	bool to decide if the function should fail

Returns: EcalID of the cell (null-id if fallible) Example for fallible use case
auto id = geometry.getID(x, y, ilayer, true);

if (id.null()) {

// position (x,y) is not contained within a cell in layer ilayer

}

Definition at line 115 of file EcalGeometry.cxx.

                                                {
  // now assume we know the layer
  // shift to center of layer
  // and convert to flower coordinates
  double p{x - std::get<0>(layer_pos_xy_.at(layer_id))},
      q{y - std::get<1>(layer_pos_xy_.at(layer_id))};
 
  // deduce module ID
  //    there are only 7 modules so we just loop through them
  //    all and pick out the module ID that we are inside of
 
  int module_id{-1};
  for (auto const& [mid, module_xy] : module_pos_xy_) {
    double probe_x{p - module_xy.first}, probe_y{q - module_xy.second};
    if (cornersSideUp_) rotate(probe_x, probe_y);
    if (isInside(probe_x / moduleR_, probe_y / moduleR_)) {
      module_id = mid;
      break;
    }
  }
 
  if (module_id < 0) {
    if (fallible) {
      return ldmx::EcalID(0);
    } else {
      EXCEPTION_RAISE(
          "BadConf",
          TString::Format(
              "Coordinates relative to layer (p,q) = (%.2f, %.2f) mm "
              "derived from world coordinates (%.2f, %.2f) mm with layer = %d "
              "are not inside any module.",
              p, q, x, y, layer_id)
              .Data());
    }
  }
 
  return getID(x, y, layer_id, module_id);
}

References cornersSideUp_, getID(), isInside(), layer_pos_xy_, module_pos_xy_, and moduleR_.

◆ getID() [3/3]

EcalID ldmx::EcalGeometry::getID	(	double	x,
		double	y,
		int	layer_id,
		int	module_id,
		bool	fallible = `false`
	)		const

Get a cell's ID from its x,y global position and layer/module numbers as deduced from GDML copy numbers.

This is the fastest option but we need to carefully validated that the layer and module positions between the GDML and the configured parameters of this class match.

Parameters

[in]	x	global x position [mm]
[in]	y	global y position [mm]
[in]	layer_id	integer ID of the layer the hit is in
[in]	module_id	integer ID of the module the hit is in
[in]	fallible	bool to decide if the function should fail

Returns: EcalID of the cell (null-id if fallible) Example for fallible use case
auto id = geometry.getID(x, y, ilayer, imodule, true);

if (id.null()) {

// position (x,y) is not contained within a cell in layer ilayer in

module imodule

}

Definition at line 155 of file EcalGeometry.cxx.

                                                {
  // now assume we know the layer and module
  // shift to center of layer and then center of module
  double p{x - std::get<0>(layer_pos_xy_.at(layer_id)) -
           module_pos_xy_.at(module_id).first},
      q{y - std::get<1>(layer_pos_xy_.at(layer_id)) -
        module_pos_xy_.at(module_id).second};
 
  // need to rotate
  if (cornersSideUp_) rotate(p, q);
 
  // deduce cell ID
  int cell_id = cell_id_in_module_.FindBin(p, q) - 1;
 
  if (cell_id < 0) {
    if (fallible) {
      return ldmx::EcalID(0);
    } else {
      EXCEPTION_RAISE(
          "BadConf",
          TString::Format(
              "Relative cell coordinates (%.2f, %.2f) mm "
              "derived from world coordinates (%.2f, %.2f) mm with layer = %d "
              "and module = %d are outside module hexagon",
              p, q, x, y, layer_id, module_id)
              .Data());
    }
  }
 
  return EcalID(layer_id, module_id, cell_id);
}

References cell_id_in_module_, cornersSideUp_, layer_pos_xy_, and module_pos_xy_.

◆ getModuleMaxR()

double ldmx::EcalGeometry::getModuleMaxR ( ) const

inline

Get the center-to-corner radius of the module hexagons.

Returns: module max radius [mm]

Definition at line 302 of file EcalGeometry.h.

302{ return moduleR_; }

References moduleR_.

◆ getModuleMinR()

double ldmx::EcalGeometry::getModuleMinR ( ) const

inline

Get the center-to-flat radius of the module hexagons.

Returns: module min radius [mm]

Definition at line 295 of file EcalGeometry.h.

295{ return moduler_; }

References moduler_.

◆ getNN()

std::vector< EcalID > ldmx::EcalGeometry::getNN ( EcalID id ) const

inline

Get the Nearest Neighbors of the input ID.

Parameters

id id to get

Returns: list of EcalID that are the inputs nearest neighbors

Definition at line 241 of file EcalGeometry.h.

                                           {
    auto list = NNMap_.at(EcalID(0, id.module(), id.cell()));
    for (auto& flat : list)
      flat = EcalID(id.layer(), flat.module(), flat.cell());
    return list;
  }

References NNMap_.

Referenced by isNN().

◆ getNNN()

std::vector< EcalID > ldmx::EcalGeometry::getNNN ( EcalID id ) const

inline

Get the Next-to-Nearest Neighbors of the input ID.

Parameters

id id to get

Returns: list of EcalID that are the inputs next-to-nearest neighbors

Definition at line 268 of file EcalGeometry.h.

                                            {
    auto list = NNNMap_.at(EcalID(0, id.module(), id.cell()));
    for (auto& flat : list)
      flat = EcalID(id.layer(), flat.module(), flat.cell());
    return list;
  }

References NNNMap_.

Referenced by isNNN().

◆ getNumCellsPerModule()

int ldmx::EcalGeometry::getNumCellsPerModule ( ) const

inline

Get the number of cells in each module of the Ecal Geometry.

Note: This assumes that all modules are the full high-density hexagons from CMS (no triangles!)

Definition at line 231 of file EcalGeometry.h.

                                   {
    return cell_id_in_module_.GetNumberOfBins();
  }

References cell_id_in_module_.

◆ getNumLayers()

int ldmx::EcalGeometry::getNumLayers ( ) const

inline

Get the number of layers in the Ecal Geometry.

Returns: number fo layers in geometry

Definition at line 209 of file EcalGeometry.h.

209{ return layer_pos_xy_.size(); }

References layer_pos_xy_.

◆ getNumModulesPerLayer()

int ldmx::EcalGeometry::getNumModulesPerLayer ( ) const

inline

Get the number of modules in the Ecal flower.

Note: This number is hard-coded to reflect the fact that it is also hard-coded in the buildModuleMap function. If a future geometry adds more modules (perhaps "triangles" to fill in rectangular block in the HCal that the ECal is in), then buildModuleMap and this function will need to be modified.

Returns: number of modules

Definition at line 223 of file EcalGeometry.h.

223{ return 7; }

◆ getPosition()

std::tuple< double, double, double > ldmx::EcalGeometry::getPosition ( EcalID id ) const

Get a cell's position from its ID number.

std::tuple is useful here because you can use C++17's pattern matching to use code like the following

auto [x,y,z] = geometry.getPosition(id);

Definition at line 188 of file EcalGeometry.cxx.

                                                                          {
  return cell_global_pos_.at(id);
}

References cell_global_pos_.

Referenced by ecal::EcalTriggerGeometry::globalPosition(), ecal::DNNEcalVetoProcessor::make_inputs(), and ecal::EcalVetoProcessor::produce().

◆ getPositionInModule()

std::pair< double, double > ldmx::EcalGeometry::getPositionInModule ( int cell_id ) const

Get a cell's position within a module.

Definition at line 192 of file EcalGeometry.cxx.

                                                                           {
  auto pq = cell_pos_in_module_.at(cell_id);
 
  // going from (p,q) to (x,y) is a unrotate
  if (cornersSideUp_) unrotate(pq.first, pq.second);
 
  return pq;
}

References cell_pos_in_module_, and cornersSideUp_.

Referenced by ecal::EcalTriggerGeometry::localPosition().

◆ getZPosition()

double ldmx::EcalGeometry::getZPosition ( int layer ) const

inline

Get the z-coordinate given the layer id.

Parameters

[in] layer int layer id

Returns: z-coordinate of the input sensitive layer

Definition at line 200 of file EcalGeometry.h.

                                       {
    return std::get<2>(layer_pos_xy_.at(layer));
  }

References layer_pos_xy_.

Referenced by ecal::EcalVetoProcessor::produce().

◆ isEdgeCell()

bool ldmx::EcalGeometry::isEdgeCell ( EcalID cellModuleID ) const

inlineprivate

Check if input cell is on the edge of a module.

See also: distanceToEdge

Parameters

[in] cellModuleID EcalId where all we care about is module and cell return true if distance to edge is less than max cell radius

Definition at line 458 of file EcalGeometry.h.

                                             {
    return (distanceToEdge(cellModuleID) < cellR_);
  }

References cellR_, and distanceToEdge().

◆ isInside()

bool ldmx::EcalGeometry::isInside	(	double	normX,
		double	normY
	)		const

private

Determines if point (x,y), already normed to max hexagon radius, lies within a hexagon.

Corners are (1,0) and (0.5,sqrt(3)/2). Uses "<", not "<=".

Note: This function is in p,q space so any rotations need to be performed before calling this function.

Parameters

[in]	normX	X-coordinate relative to module hexagon divided by maximum hexagon radius
[in]	normY	Y-coordinate relative to module hexagon divided by maximum hexagon radius

Returns: true if (normX,normY) is within the hexagon centered at the origin with maximum radius 1.

Definition at line 622 of file EcalGeometry.cxx.

                                                            {
  if (verbose_ > 2)
    std::cout << TString::Format(
                     "[isInside] Checking if normXY=(%.2f,%.2f) is inside.",
                     normX, normY)
              << std::endl;
  normX = fabs(normX), normY = fabs(normY);
  double xvec = -1, yvec = -1. / sqrt(3);
  double xref = 0.5, yref = sqrt(3) / 2.;
  if ((normX > 1.) || (normY > yref)) {
    if (verbose_ > 2)
      std::cout << "[isInside]   they are outside quadrant." << std::endl;
    return false;
  }
  double dotProd = (xvec * (normX - xref) + yvec * (normY - yref));
  if (verbose_ > 2)
    std::cout << TString::Format(
                     "[isInside] they are inside quadrant. Dot product (>0 is "
                     "inside): %.2f ",
                     dotProd)
              << std::endl;
  return (dotProd > 0.);
}

References verbose_.

Referenced by buildCellMap(), and getID().

◆ isNN()

bool ldmx::EcalGeometry::isNN	(	EcalID	centroid,
		EcalID	probe
	)		const

inline

Check if the probe id is one of the nearest neightbors of the centroid id.

Parameters

probe	id to check if it is nearest neighbor
centroid	id that is center of neighbors

Returns: true if probe ID is a nearest neighbor of the centroid

Definition at line 255 of file EcalGeometry.h.

                                                 {
    for (auto& id : getNN(centroid)) {
      if (id == probe) return true;
    }
    return false;
  }

References getNN().

◆ isNNN()

bool ldmx::EcalGeometry::isNNN	(	EcalID	centroid,
		EcalID	probe
	)		const

inline

Check if the probe id is one of the next-to-nearest neightbors of the centroid id.

Parameters

probe	id to check if it is a next-to-nearest neighbor
centroid	id that is center of neighbors

Returns: true if probe ID is a next-to-nearest neighbor of the centroid

Definition at line 283 of file EcalGeometry.h.

                                                  {
    for (auto& id : getNNN(centroid)) {
      if (id == probe) return true;
    }
    return false;
  }

References getNNN().

Friends And Related Symbol Documentation

◆ ecal::EcalGeometryProvider

friend class ecal::EcalGeometryProvider

friend

Definition at line 345 of file EcalGeometry.h.

Member Data Documentation

◆ cell_global_pos_

std::map<EcalID, std::tuple<double, double, double> > ldmx::EcalGeometry::cell_global_pos_

private

Position of cell centers relative to world geometry.

This is where we convert p,q (flower) space into x,y (world) space by calculating the z-location as well as including rotations and shifts when converting from p,q to x,y.

The key is the full EcalID and the value is the x,y,z tuple.

Definition at line 596 of file EcalGeometry.h.

Referenced by buildCellModuleMap(), and getPosition().

◆ cell_id_in_module_

TH2Poly ldmx::EcalGeometry::cell_id_in_module_

mutableprivate

Honeycomb Binning from ROOT.

Needs to be mutable because ROOT doesn't have good const handling

Lookup a cell ID using its position relative to the center of the module in p,q space.

Definition at line 620 of file EcalGeometry.h.

Referenced by buildCellMap(), getCellPolyMap(), getID(), and getNumCellsPerModule().

◆ cell_pos_in_layer_

std::map<EcalID, std::pair<double, double> > ldmx::EcalGeometry::cell_pos_in_layer_

private

Position of cell centers relative to center of layer in world coordinates.

Note: Layer shifts are NOT included in this map since they depend on the layer number!!

Uses EcalID with layer set to zero as key.

Definition at line 585 of file EcalGeometry.h.

Referenced by buildCellModuleMap(), and buildNeighborMaps().

◆ cell_pos_in_module_

std::map<int, std::pair<double, double> > ldmx::EcalGeometry::cell_pos_in_module_

private

Position of cell centers relative to center of module in p,q space.

use cell ID as key

Definition at line 574 of file EcalGeometry.h.

Referenced by buildCellMap(), buildCellModuleMap(), distanceToEdge(), getCellPolyMap(), and getPositionInModule().

◆ cellr_

double ldmx::EcalGeometry::cellr_ {0}

private

Center-to-Flat Radius of cell hexagon [mm].

Definition at line 484 of file EcalGeometry.h.

484{0};

Referenced by buildCellMap(), buildNeighborMaps(), EcalGeometry(), and getCellMinR().

◆ cellR_

double ldmx::EcalGeometry::cellR_ {0}

private

Center-to-Corner Radius of cell hexagon [mm].

Definition at line 490 of file EcalGeometry.h.

490{0};

Referenced by buildCellMap(), EcalGeometry(), getCellMaxR(), and isEdgeCell().

◆ CONDITIONS_OBJECT_NAME

constexpr const char* ldmx::EcalGeometry::CONDITIONS_OBJECT_NAME {"EcalGeometry"}

staticconstexpr

Definition at line 103 of file EcalGeometry.h.

103{"EcalGeometry"};

◆ cornersSideUp_

bool ldmx::EcalGeometry::cornersSideUp_

private

indicator of geometry orientation if true, flower shape's corners side (ie: side with two modules) is at the top

Definition at line 500 of file EcalGeometry.h.

Referenced by buildCellModuleMap(), buildModuleMap(), EcalGeometry(), getID(), getID(), and getPositionInModule().

◆ ecalFrontZ_

double ldmx::EcalGeometry::ecalFrontZ_ {0}

private

Front of ECal relative to world geometry [mm].

Definition at line 545 of file EcalGeometry.h.

545{0};

Referenced by buildLayerMap(), and EcalGeometry().

◆ gap_

double ldmx::EcalGeometry::gap_

private

Gap between module flat sides [mm].

Definition at line 481 of file EcalGeometry.h.

Referenced by buildModuleMap(), and EcalGeometry().

◆ layer_pos_xy_

std::map<int, std::tuple<double, double, double> > ldmx::EcalGeometry::layer_pos_xy_

private

Position of layer centers in world coordinates (uses layer ID as key)

Definition at line 558 of file EcalGeometry.h.

Referenced by buildCellModuleMap(), buildLayerMap(), getID(), getID(), getID(), getNumLayers(), and getZPosition().

◆ layer_shift_odd_

bool ldmx::EcalGeometry::layer_shift_odd_

private

shift odd layers

odd layers are the high-z layer in each bi-layer

i.e. We will shift if layer_id_ % 2 == 1

Definition at line 519 of file EcalGeometry.h.

Referenced by buildLayerMap(), and EcalGeometry().

◆ layer_shift_odd_bilayer_

bool ldmx::EcalGeometry::layer_shift_odd_bilayer_

private

shift odd bi layers

NOT IMPLEMENTED IN GDML

This shifts the bi-layer grouping of two sensitive layers together.

i.e. We will shift if (layer_id_ / 2) % 2 == 1

where it is integer division.

Definition at line 533 of file EcalGeometry.h.

Referenced by buildLayerMap(), and EcalGeometry().

◆ layer_shift_x_

double ldmx::EcalGeometry::layer_shift_x_

private

shift of layers in the x-direction [mm]

Definition at line 505 of file EcalGeometry.h.

Referenced by buildLayerMap(), and EcalGeometry().

◆ layer_shift_y_

double ldmx::EcalGeometry::layer_shift_y_

private

shift of layers in the y-direction [mm]

Definition at line 510 of file EcalGeometry.h.

Referenced by buildLayerMap(), and EcalGeometry().

◆ layerZPositions_

std::vector<double> ldmx::EcalGeometry::layerZPositions_

private

The layer Z postions are with respect to the front of the ECal [mm].

Definition at line 548 of file EcalGeometry.h.

Referenced by buildLayerMap(), and EcalGeometry().

◆ module_pos_xy_

std::map<int, std::pair<double, double> > ldmx::EcalGeometry::module_pos_xy_

private

Postion of module centers relative to the center of the layer in world coordinates.

(uses module ID as key)

Definition at line 566 of file EcalGeometry.h.

Referenced by buildCellModuleMap(), buildModuleMap(), getID(), and getID().

◆ moduler_

double ldmx::EcalGeometry::moduler_ {0}

private

Center-to-Flat Radius of module hexagon [mm].

Definition at line 487 of file EcalGeometry.h.

487{0};

Referenced by buildCellMap(), buildModuleMap(), distanceToEdge(), EcalGeometry(), and getModuleMinR().

◆ moduleR_

double ldmx::EcalGeometry::moduleR_ {0}

private

Center-to-Corner Radius of module hexagon [mm].

Definition at line 493 of file EcalGeometry.h.

493{0};

Referenced by buildCellMap(), distanceToEdge(), EcalGeometry(), getID(), and getModuleMaxR().

◆ nCellRHeight_

double ldmx::EcalGeometry::nCellRHeight_ {0}

private

Number of cell center-to-corner radii (one side of the cell) from the bottom to the top of the module.

Could be fractional depending on how many fractions of a radii are spanning between the center of the top/bottom cell row and the edge of the module

Definition at line 542 of file EcalGeometry.h.

542{0};

Referenced by EcalGeometry().

◆ NNMap_

std::map<EcalID, std::vector<EcalID> > ldmx::EcalGeometry::NNMap_

private

Map of cell ID to neighboring cells.

The EcalID's in this map all have layer ID set to zero.

Definition at line 603 of file EcalGeometry.h.

Referenced by buildNeighborMaps(), and getNN().

◆ NNNMap_

std::map<EcalID, std::vector<EcalID> > ldmx::EcalGeometry::NNNMap_

private

Map of cell ID to neighbors of neighbor cells.

The EcalID's in this map all have layer ID set to zero.

Definition at line 610 of file EcalGeometry.h.

Referenced by buildNeighborMaps(), and getNNN().

◆ verbose_

int ldmx::EcalGeometry::verbose_

private

verbosity

Definition at line 552 of file EcalGeometry.h.

Referenced by buildCellMap(), buildCellModuleMap(), buildLayerMap(), buildModuleMap(), buildNeighborMaps(), EcalGeometry(), and isInside().

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

DetDescr/include/DetDescr/EcalGeometry.h
DetDescr/src/DetDescr/EcalGeometry.cxx

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

ORIENTATION ASSUMPTIONS:

SOME GEOMETRY:

THIS GRID:

Constructor & Destructor Documentation

◆ ~EcalGeometry()

◆ EcalGeometry()

Member Function Documentation

◆ buildCellMap()

Strategy

◆ buildCellModuleMap()

◆ buildLayerMap()

◆ buildModuleMap()

◆ buildNeighborMaps()

◆ debugMake()

◆ distanceToEdge()

◆ getCellMaxR()

◆ getCellMinR()

◆ getCellPolyMap()

◆ getID() [1/3]

◆ getID() [2/3]

◆ getID() [3/3]

◆ getModuleMaxR()

◆ getModuleMinR()

◆ getNN()

◆ getNNN()

◆ getNumCellsPerModule()

◆ getNumLayers()

◆ getNumModulesPerLayer()

◆ getPosition()

◆ getPositionInModule()

◆ getZPosition()

◆ isEdgeCell()

◆ isInside()

◆ isNN()

◆ isNNN()

Friends And Related Symbol Documentation

◆ ecal::EcalGeometryProvider

Member Data Documentation

◆ cell_global_pos_

◆ cell_id_in_module_

◆ cell_pos_in_layer_

◆ cell_pos_in_module_

◆ cellr_

◆ cellR_

◆ CONDITIONS_OBJECT_NAME

◆ cornersSideUp_

◆ ecalFrontZ_

◆ gap_

◆ layer_pos_xy_

◆ layer_shift_odd_

◆ layer_shift_odd_bilayer_

◆ layer_shift_x_

◆ layer_shift_y_

◆ layerZPositions_

◆ module_pos_xy_

◆ moduler_

◆ moduleR_

◆ nCellRHeight_

◆ NNMap_

◆ NNNMap_

◆ verbose_