ldmx::HcalGeometry Class Reference

Implementation of HCal strip readout. More...

#include <HcalGeometry.h>

Public Types
enum class	ScintillatorOrientation { horizontal = 0 , vertical = 1 , depth = 2 }
	Encodes the orientation of a bar. More...

Public Member Functions
	~HcalGeometry ()=default
	Class destructor.
ScintillatorOrientation	getScintillatorOrientation (const ldmx::HcalID id) const
ROOT::Math::XYZVector	getStripCenterPosition (ldmx::HcalID id) const
	Get a strip center position from a combined hcal ID.
std::map< ldmx::HcalID, ROOT::Math::XYZVector >	getStripPositionMap () const
	Get the strip position map.
bool	backLayerIsHorizontal (const int layer) const
	Check whether a given layer corresponds to a horizontal (scintillator length along the x-axis) or vertical layer in the back HCal.
double	getHalfTotalWidth (int isection, int layer=1) const
	Get the half total width of a layer for a given section(strip) for back(side) Hcal.
double	getScintillatorLength (ldmx::HcalID id) const
	Get the length of a scintillator bar.
double	getScintillatorWidth () const
	Get the scitillator width.
double	getScintillatorThickness () const
	Get the scitillator thickness.
int	getNumSections () const
	Get the number of sections.
int	getNumLayers (int isection) const
	Get the number of layers for that section.
int	getNumStrips (int isection, int layer=1) const
	Get the number of strips per layer for that section and layer.
int	getZeroStrip (int isection, int layer=1) const
	Get the location of the zeroStrip in a given section and layer.
double	getEcalDx () const
	Get the length of the Ecal in (x) for the side Hcal.
double	getEcalDy () const
	Get the length of the Ecal in (y) for the side Hcal.
bool	hasSide3DReadout () const
	Does the Side Hcal have 3D readout?
bool	isPrototype () const
bool	hasExplicitLayout () const
	Are the strip positions given layer by layer (e.g.
bool	isDoubleEnded (int isection) const
	Are the bars of this section read out at both ends?
double	getDistanceAlongBar (ldmx::HcalID id, double x, double y, double z) const
	Signed distance along the bar from the strip center [mm].
std::vector< double >	rotateGlobalToLocalBarPosition (const std::vector< double > &globalPosition, const ldmx::HcalID &id) const
	Coordinates that are given by Geant4 are typically global.
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 Attributes
static constexpr const char *	CONDITIONS_OBJECT_NAME {"hcal_geometry"}
	Conditions object: The name of the python configuration calling this class (Hcal/python/HcalGeometry.py) needs to match the CONDITIONS_OBJECT_NAME exactly.

Private Member Functions
	HcalGeometry (const framework::config::Parameters &ps)
	Class constructor, for use only by the provider.
void	buildStripPositionMap ()
	Map builder of HcalID and position.
void	printPositionMap (int section) const
	Debugging utility, prints out the HcalID and corresponding value of all entries in the strip_position_map_ for a given section.
void	printPositionMap () const
	Debugging utility, prints out the HcalID and corresponding value of all entries in the strip_position_map_.

Private Attributes
int	verbose_ {0}
	Parameters that apply to all types of geometries Verbosity, not configurable but helpful if developing.
double	scint_thickness_
	Thickness of scintillator.
double	scint_width_
	Width of Scintillator Strip [mm].
std::vector< double >	zero_layer_
	Front of HCal relative to world geometry for each section [mm].
std::vector< double >	layer_thickness_
	Thickness of the layers in each section [mm].
std::vector< int >	num_layers_
	Number of layers in each section.
int	num_sections_
	Number of sections.
double	ecal_dx_
	Lenght of the Ecal (in x and y)
double	ecal_dy_
double	y_offset_
int	back_horizontal_parity_ {}
int	side_3d_readout_ {}
std::vector< std::vector< int > >	num_strips_
	Number of strips per layer in each section and each layer.
std::vector< std::vector< double > >	zero_strip_
	The plane of the zero'th strip of each section [mm].
std::vector< std::vector< double > >	half_total_width_
	Half Total Width of Strips [mm].
std::vector< std::vector< double > >	scint_length_
	Length of strips [mm].
bool	is_prototype_ {}
std::vector< std::vector< double > >	layer_z_
	Explicit layout: world z of each layer center [mm].
std::vector< std::vector< int > >	layer_long_axis_
	Explicit layout: 0 = bar long along x, 1 = along y.
std::vector< std::vector< double > >	layer_bar_center_
	Explicit layout: world along-bar coordinate of the bar centers [mm].
std::vector< std::vector< double > >	layer_strip_zero_
	Explicit layout: world transverse coordinate of strip 0 [mm].
std::vector< int >	double_ended_
	Explicit layout: section read out at both ends.
std::map< ldmx::HcalID, ROOT::Math::XYZVector >	strip_position_map_
	Map of the HcalID position of strip centers relative to world geometry.

Friends
class	hcal::HcalGeometryProvider

Detailed Description

Implementation of HCal strip readout.

Definition at line 33 of file HcalGeometry.h.

Member Enumeration Documentation

ScintillatorOrientation

enum class ldmx::HcalGeometry::ScintillatorOrientation

strong

Encodes the orientation of a bar.

horizontal : The length of the bar is along the x-axis vertical : The length of the bar is along the y-axis depth : The length of the bar is along the z-axis

Definition at line 49 of file HcalGeometry.h.

                                     {
    horizontal = 0,
    vertical = 1,
    depth = 2
  };

Constructor & Destructor Documentation

~HcalGeometry()

ldmx::HcalGeometry::~HcalGeometry ( )

default

Class destructor.

Does nothing because the stl containers clean up automatically.

HcalGeometry()

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

private

Class constructor, for use only by the provider.

Parameters

ps	Parameters to configure the HcalGeometry

Definition at line 12 of file HcalGeometry.cxx.

    : framework::ConditionsObject(HcalGeometry::CONDITIONS_OBJECT_NAME) {
  scint_thickness_ = ps.get<double>("scint_thickness");
  scint_width_ = ps.get<double>("scint_width");
  zero_layer_ = ps.get<std::vector<double>>("zero_layer");
  layer_thickness_ = ps.get<std::vector<double>>("layer_thickness");
  num_layers_ = ps.get<std::vector<int>>("num_layers");
  num_sections_ = ps.get<int>("num_sections");
  ecal_dx_ = ps.get<double>("ecal_dx");
  ecal_dy_ = ps.get<double>("ecal_dy");
  verbose_ = ps.get<int>("verbose");
  back_horizontal_parity_ = ps.get<int>("back_horizontal_parity");
  side_3d_readout_ = ps.get<int>("side_3d_readout");
  y_offset_ = ps.get<double>("y_offset");
 
  auto detectors_valid = ps.get<std::vector<std::string>>("detectors_valid");
  // If one of the strings in detectors_valid is "ldmx-hcal-prototype", we
  // will use prototype geometry initialization
  is_prototype_ = std::find_if(detectors_valid.cbegin(), detectors_valid.cend(),
                               [](const auto detector) {
                                 return detector.find("ldmx-hcal-prototype") !=
                                        std::string::npos;
                               }) != detectors_valid.cend();
 
  num_strips_ = ps.get<std::vector<std::vector<int>>>("num_strips");
  half_total_width_ =
      ps.get<std::vector<std::vector<double>>>("half_total_width");
  zero_strip_ = ps.get<std::vector<std::vector<double>>>("zero_strip");
  scint_length_ = ps.get<std::vector<std::vector<double>>>("scint_length");
 
  // optional explicit layout, empty for the LDMX and prototype geometries
  layer_z_ = ps.get<std::vector<std::vector<double>>>("layer_z", {});
  layer_long_axis_ =
      ps.get<std::vector<std::vector<int>>>("layer_long_axis", {});
  layer_bar_center_ =
      ps.get<std::vector<std::vector<double>>>("layer_bar_center", {});
  layer_strip_zero_ =
      ps.get<std::vector<std::vector<double>>>("layer_strip_zero", {});
  double_ended_ = ps.get<std::vector<int>>("double_ended", {});
  if (hasExplicitLayout()) {
    for (int section = 0; section < num_sections_; ++section) {
      const auto n{static_cast<std::size_t>(num_layers_.at(section))};
      if (layer_z_.at(section).size() != n ||
          layer_long_axis_.at(section).size() != n ||
          layer_bar_center_.at(section).size() != n ||
          layer_strip_zero_.at(section).size() != n ||
          double_ended_.size() != static_cast<std::size_t>(num_sections_)) {
        EXCEPTION_RAISE(
            "HcalGeometry",
            "Explicit layout does not match num_layers in section " +
                std::to_string(section));
      }
    }
  }
 
  buildStripPositionMap();
 
  if (verbose_ > 0) {
    printPositionMap();
  }
}

References buildStripPositionMap(), double_ended_, ecal_dx_, framework::config::Parameters::get(), half_total_width_, hasExplicitLayout(), layer_bar_center_, layer_long_axis_, layer_strip_zero_, layer_thickness_, layer_z_, num_layers_, num_sections_, num_strips_, printPositionMap(), scint_length_, scint_thickness_, scint_width_, verbose_, zero_layer_, and zero_strip_.

Member Function Documentation

backLayerIsHorizontal()

bool ldmx::HcalGeometry::backLayerIsHorizontal ( const int layer ) const

inline

Check whether a given layer corresponds to a horizontal (scintillator length along the x-axis) or vertical layer in the back HCal.

See the back_horizontal_parity_ member for details.

Definition at line 89 of file HcalGeometry.h.

                                                    {
    return layer % 2 == back_horizontal_parity_;
  }

buildStripPositionMap()

void ldmx::HcalGeometry::buildStripPositionMap ( )

private

Map builder of HcalID and position.

To build the map we loop over the number of Hcal sections, layers and strips. The Hcal sections range from 0 to 4. (We hard-code the number of sections as seen in HcalID) The Hcal layers range from 1 to NumLayers_[section]. The Hcal strips range from 0 to NumStrips_[section].

Odd layers have horizontal strips. Even layers have vertical strips.

For back Hcal:

• layers in z
• strips occupy thickness of scintillator in z (e.g. 20mm)
• strips orientation is in x(y) depending on back_horizontal parity

Now compute, y(x) position for horizontal(vertical) layers, relative to the center of detector. Strips enumeration starts from -y(-x) stripcenter will be large for +y(+x) and the half width of the strip needs to be subtracted The halfwidth of the scintillator is given by half_total_width_. The x(y) position is set to the center of the strip (0).

For side Hcal before 3D readout

• layers in y(x)
• all layers have strips in x(y) for top-bottom (left-right) sections
• all layers have strips occupying width of scintillator in z (e.g. 50mm)

Definition at line 218 of file HcalGeometry.cxx.

                                         {
  // We hard-code the number of sections as seen in HcalID
  for (unsigned int section = 0; section < num_sections_; section++) {
    for (unsigned int layer = 1; layer <= num_layers_[section]; layer++) {
      for (unsigned int strip = 0; strip < getNumStrips(section, layer);
           strip++) {
        // initialize values
        double x{-99999}, y{-99999}, z{-99999};
 
        // get hcal section
        ldmx::HcalID::HcalSection hcalsection =
            (ldmx::HcalID::HcalSection)section;
 
        const ldmx::HcalID id{section, layer, strip};
        const auto orientation{getScintillatorOrientation(id)};
        // the center of a layer: (layer-1) * (layer_thickness) +
        // scint_thickness/2
        double layercenter =
            (layer - 1) * layer_thickness_.at(section) + 0.5 * scint_thickness_;
 
        // the center of a strip: (strip + 0.5) * (strip_dx)
        double stripcenter = (strip + 0.5) * scint_width_;
 
        if (hasExplicitLayout()) {
          const auto i_layer{layer - 1};
          const double along{layer_bar_center_.at(section).at(i_layer)};
          const double across{layer_strip_zero_.at(section).at(i_layer) +
                              strip * scint_width_};
          if (orientation == ScintillatorOrientation::horizontal) {
            x = along;
            y = across;
          } else {
            x = across;
            y = along;
          }
          z = layer_z_.at(section).at(i_layer);
        } else if (hcalsection == ldmx::HcalID::HcalSection::BACK) {
          // z position: zero-layer(z) + layer_z + scint_thickness / 2
          z = zero_layer_.at(section) + layercenter;
 
          if (orientation == ScintillatorOrientation::horizontal) {
            y = stripcenter - getZeroStrip(section, layer);
            x = 0;
          } else {
            x = stripcenter - getZeroStrip(section, layer);
            y = 0;
          }
        } else {
          if (side_3d_readout_) {
            /*
             *
             * For 3D readout:
             * - odd layers have strips in z
             * - even layers have strips in x(y) for top-bottom (left-right)
             * sections
             * - odd layers have strips occupying width of scintillator in x(y)
             * - even layers have strips occupying width of scintillator in z
             *
             */
            switch (hcalsection) {
              case ldmx::HcalID::HcalSection::BACK:
                // Handled earlier in the code!
              case ldmx::HcalID::HcalSection::LEFT:
              case ldmx::HcalID::HcalSection::RIGHT:
                if (orientation == ScintillatorOrientation::vertical) {
                  x = zero_layer_[section] + 0.5 * scint_thickness_ +
                      (layer - 1) * layer_thickness_[section];
                  y = ecal_dy_ -
                      (getScintillatorLength({id.section(), 2, id.strip()}) -
                       getScintillatorLength(id)) /
                          2;
                  z = getZeroStrip(section, layer) +
                      (strip + 0.5) * getScintillatorWidth();
                } else if (orientation == ScintillatorOrientation::depth) {
                  x = zero_layer_[section] + 0.5 * scint_thickness_ +
                      layer_thickness_[section] * (layer - 1);
                  y = -ecal_dy_ / 2 + (strip + 0.5) * getScintillatorWidth();
                  z = getZeroStrip(section, layer + 1) +
                      getScintillatorLength(id) / 2;
                }
                if (section == ldmx::HcalID::HcalSection::LEFT) {
                  y *= -1;
                  x *= -1;
                }
                break;
 
              case ldmx::HcalID::HcalSection::BOTTOM:
              case ldmx::HcalID::HcalSection::TOP:
                if (orientation == ScintillatorOrientation::horizontal) {
                  //
                  // Second half of the expression is the difference between the
                  // longest strips (first module) and the current module.
                  //
                  // 22 mm extra for space for 1 absorber and one air box
                  x = -ecal_dx_ / 2 - 2 - 20 +
                      (getScintillatorLength({id.section(), 2, id.strip()}) -
                       getScintillatorLength(id)) /
                          2;
                  y = zero_layer_[section] + 0.5 * scint_thickness_ +
                      (layer - 1) * layer_thickness_[section];
                  z = getZeroStrip(section, layer) +
                      (strip + 0.5) * getScintillatorWidth();
                }
                if (orientation == ScintillatorOrientation::depth) {
                  x = (ecal_dx_ / 2) - (strip + 0.5) * getScintillatorWidth();
                  y = zero_layer_[section] + 0.5 * scint_thickness_ +
                      layer_thickness_[section] * (layer - 1);
                  z = getZeroStrip(section, layer + 1) +
                      getScintillatorLength(id) / 2;
                }
                if (section == ldmx::HcalID::HcalSection::BOTTOM) {
                  y *= -1;
                  x *= -1;
                }
                break;
            }
 
          } else {
            // z position: zero-strip(z) + strip_center(z)
            z = getZeroStrip(section, layer) + stripcenter;
            if (hcalsection == ldmx::HcalID::HcalSection::TOP or
                hcalsection == ldmx::HcalID::HcalSection::BOTTOM) {
              y = zero_layer_.at(section) + layercenter;
              x = getHalfTotalWidth(section, layer);
              if (hcalsection == ldmx::HcalID::HcalSection::BOTTOM) {
                y *= -1;
                x *= -1;
              }
 
            } else {
              x = zero_layer_.at(section) + layercenter;
              y = getHalfTotalWidth(section, layer);
              if (hcalsection == ldmx::HcalID::HcalSection::RIGHT) {
                x *= -1;
                y *= -1;
              }
            }
          }
        }
 
        y += y_offset_;
        ROOT::Math::XYZVector pos;
        pos.SetXYZ(x, y, z);
        strip_position_map_[ldmx::HcalID(section, layer, strip)] = pos;
      }  // loop over strips
    }  // loop over layers
  }  // loop over sections
}  // strip position map

References ecal_dx_, getHalfTotalWidth(), getNumStrips(), getScintillatorLength(), getScintillatorWidth(), getZeroStrip(), hasExplicitLayout(), layer_bar_center_, layer_strip_zero_, layer_thickness_, layer_z_, num_layers_, num_sections_, scint_thickness_, scint_width_, strip_position_map_, and zero_layer_.

Referenced by HcalGeometry().

getDistanceAlongBar()

double ldmx::HcalGeometry::getDistanceAlongBar	(	ldmx::HcalID	id,
		double	x,
		double	y,
		double	z ) const

Signed distance along the bar from the strip center [mm].

Parameters

id	The HcalID of the bar
x,y,z	Global position

Definition at line 73 of file HcalGeometry.cxx.

                                                         {
  const auto center{getStripCenterPosition(id)};
  switch (getScintillatorOrientation(id)) {
    case ScintillatorOrientation::horizontal:
      return x - center.X();
    case ScintillatorOrientation::vertical:
      return y - center.Y();
    default:
      return z - center.Z();
  }
}

References getStripCenterPosition().

getEcalDx()

double ldmx::HcalGeometry::getEcalDx ( ) const

inline

Get the length of the Ecal in (x) for the side Hcal.

Definition at line 152 of file HcalGeometry.h.

{ return ecal_dx_; }

References ecal_dx_.

getEcalDy()

double ldmx::HcalGeometry::getEcalDy ( ) const

inline

Get the length of the Ecal in (y) for the side Hcal.

Definition at line 157 of file HcalGeometry.h.

{ return ecal_dy_; }

getHalfTotalWidth()

double ldmx::HcalGeometry::getHalfTotalWidth ( int isection, int layer = 1 ) const

inline

Get the half total width of a layer for a given section(strip) for back(side) Hcal.

Parameters

section
layer

Returns

half total width [mm]

Definition at line 99 of file HcalGeometry.h.

                                                              {
    // Layer numbering starts at 1, but a vector is zero-indexed
    auto layer_index = layer - 1;
    return half_total_width_.at(isection).at(layer_index);
  }

References half_total_width_.

Referenced by buildStripPositionMap().

getNumLayers()

int ldmx::HcalGeometry::getNumLayers ( int isection ) const

inline

Get the number of layers for that section.

Definition at line 131 of file HcalGeometry.h.

{ return num_layers_.at(isection); }

References num_layers_.

getNumSections()

int ldmx::HcalGeometry::getNumSections ( ) const

inline

Get the number of sections.

Definition at line 126 of file HcalGeometry.h.

{ return num_sections_; }

References num_sections_.

getNumStrips()

int ldmx::HcalGeometry::getNumStrips ( int isection, int layer = 1 ) const

inline

Get the number of strips per layer for that section and layer.

Definition at line 136 of file HcalGeometry.h.

                                                      {
    auto layer_index = layer - 1;
    return num_strips_.at(isection).at(layer_index);
  }

References num_strips_.

Referenced by buildStripPositionMap(), and printPositionMap().

getScintillatorLength()

double ldmx::HcalGeometry::getScintillatorLength ( ldmx::HcalID id ) const

inline

Get the length of a scintillator bar.

Parameters

id	The HcalID of the bar

Returns

The length of the bar with ID id [mm]

Definition at line 110 of file HcalGeometry.h.

                                                    {
    return scint_length_.at(id.section()).at(id.layer() - 1);
  }

References scint_length_.

Referenced by buildStripPositionMap().

getScintillatorOrientation()

HcalGeometry::ScintillatorOrientation ldmx::HcalGeometry::getScintillatorOrientation

(

const ldmx::HcalID

id

)

const

Definition at line 142 of file HcalGeometry.cxx.

                               {
  if (hasExplicitLayout()) {
    return layer_long_axis_.at(id.section()).at(id.layer() - 1) == 0
               ? ScintillatorOrientation::horizontal
               : ScintillatorOrientation::vertical;
  }
  if (hasSide3DReadout()) {
    // v14 or later detector
    switch (id.section()) {
      case ldmx::HcalID::HcalSection::TOP:
      case ldmx::HcalID::HcalSection::BOTTOM:
        // Odd layers are in z/depth direction, even are in the x/horizontal
        // direction
        return id.layer() % 2 == 0 ? ScintillatorOrientation::horizontal
                                   : ScintillatorOrientation::depth;
 
      case ldmx::HcalID::HcalSection::LEFT:
      case ldmx::HcalID::HcalSection::RIGHT:
        // Odd layers are in the z/depth direction, even are in the y/vertical
        // direction
        return id.layer() % 2 == 0 ? ScintillatorOrientation::vertical
                                   : ScintillatorOrientation::depth;
      case ldmx::HcalID::HcalSection::BACK:
        // Configurable
        return id.layer() % 2 == back_horizontal_parity_
                   ? ScintillatorOrientation::horizontal
                   : ScintillatorOrientation::vertical;
    }  // V14 or later detector
  }
  if (isPrototype()) {
    // The prototype only has the back section. However, the orientation
    // depends on the configuration so we delegate to the
    // back_horizontal_parity parameter
    return id.layer() % 2 == back_horizontal_parity_
               ? ScintillatorOrientation::horizontal
               : ScintillatorOrientation::vertical;
  }  // Prototype detector
  // v13/v12
  switch (id.section()) {
    // For the v13 side hcal, the bars in each section have the same
    // orientation
    case ldmx::HcalID::HcalSection::TOP:
    case ldmx::HcalID::HcalSection::BOTTOM:
      return ScintillatorOrientation::horizontal;
    case ldmx::HcalID::HcalSection::LEFT:
    case ldmx::HcalID::HcalSection::RIGHT:
      return ScintillatorOrientation::vertical;
    case ldmx::HcalID::HcalSection::BACK:
      // Configurable
      return id.layer() % 2 == back_horizontal_parity_
                 ? ScintillatorOrientation::horizontal
                 : ScintillatorOrientation::vertical;
  }  // v13/v12 detector
  // Can only reach this part if we somehow didn't match any of the options
  // above. This could happen if someone introduces a new geometry but doesn't
  // patch this part.
  EXCEPTION_RAISE("InvalidRotation",
                  "Attempted to rotate into an invalid "
                  "orientation for a scintillator bar!");
}

getScintillatorThickness()

double ldmx::HcalGeometry::getScintillatorThickness ( ) const

inline

Get the scitillator thickness.

Definition at line 121 of file HcalGeometry.h.

{ return scint_thickness_; }

References scint_thickness_.

getScintillatorWidth()

double ldmx::HcalGeometry::getScintillatorWidth ( ) const

inline

Get the scitillator width.

Definition at line 116 of file HcalGeometry.h.

{ return scint_width_; }

References scint_width_.

Referenced by buildStripPositionMap().

getStripCenterPosition()

ROOT::Math::XYZVector ldmx::HcalGeometry::getStripCenterPosition ( ldmx::HcalID id ) const

inline

Get a strip center position from a combined hcal ID.

Exceptions

std::out_of_range

if HcalID is not on map.

Parameters

HcalID

Returns

A ROOT::Math::XYZVector with the X, Y and Z position of the center of the bar.

Definition at line 74 of file HcalGeometry.h.

                                                                {
    return strip_position_map_.at(id);
  }

References strip_position_map_.

Referenced by getDistanceAlongBar(), printPositionMap(), and hcal::HcalClusterProducer::produce().

getStripPositionMap()

std::map< ldmx::HcalID, ROOT::Math::XYZVector > ldmx::HcalGeometry::getStripPositionMap ( ) const

inline

Get the strip position map.

Definition at line 81 of file HcalGeometry.h.

                                                                    {
    return strip_position_map_;
  }

References strip_position_map_.

getZeroStrip()

int ldmx::HcalGeometry::getZeroStrip ( int isection, int layer = 1 ) const

inline

Get the location of the zeroStrip in a given section and layer.

Definition at line 144 of file HcalGeometry.h.

                                                      {
    auto layer_index = layer - 1;
    return zero_strip_.at(isection).at(layer_index);
  }

References zero_strip_.

Referenced by buildStripPositionMap().

hasExplicitLayout()

bool ldmx::HcalGeometry::hasExplicitLayout ( ) const

inline

Are the strip positions given layer by layer (e.g.

cosmic stand)?

Definition at line 176 of file HcalGeometry.h.

{ return !layer_z_.empty(); }

References layer_z_.

Referenced by buildStripPositionMap(), HcalGeometry(), isDoubleEnded(), and rotateGlobalToLocalBarPosition().

hasSide3DReadout()

bool ldmx::HcalGeometry::hasSide3DReadout ( ) const

inline

Does the Side Hcal have 3D readout?

In other words, does the side hcal layers alter in scintillator direction (z vs x/y).

Definition at line 165 of file HcalGeometry.h.

{ return side_3d_readout_; }

isDoubleEnded()

bool ldmx::HcalGeometry::isDoubleEnded ( int isection ) const

inline

Are the bars of this section read out at both ends?

Definition at line 181 of file HcalGeometry.h.

                                         {
    if (hasExplicitLayout()) return double_ended_.at(isection) != 0;
    return isection == ldmx::HcalID::HcalSection::BACK;
  }

References double_ended_, and hasExplicitLayout().

isPrototype()

bool ldmx::HcalGeometry::isPrototype ( ) const

inline

Definition at line 171 of file HcalGeometry.h.

{ return is_prototype_; }

printPositionMap() [1/2]

void ldmx::HcalGeometry::printPositionMap ( ) const

inlineprivate

Debugging utility, prints out the HcalID and corresponding value of all entries in the strip_position_map_.

For printing only one of the sections, see the overloaded version of this function taking a section parameter.

Definition at line 253 of file HcalGeometry.h.

                                {
    for (int section = 0; section < num_sections_; ++section) {
      printPositionMap(section);
    }
  }

References num_sections_, and printPositionMap().

Referenced by HcalGeometry(), and printPositionMap().

printPositionMap() [2/2]

void ldmx::HcalGeometry::printPositionMap ( int section ) const

private

Debugging utility, prints out the HcalID and corresponding value of all entries in the strip_position_map_ for a given section.

Parameters

section

The section number to print, see HcalID for details.

Definition at line 203 of file HcalGeometry.cxx.

                                                     {
  // Note that layer numbering starts at 1 rather than 0
  for (int layer = 1; layer <= num_layers_[section]; ++layer) {
    for (int strip = 0; strip < getNumStrips(section, layer); ++strip) {
      HcalID id(section, layer, strip);
      auto center_position = getStripCenterPosition(id);
      auto x = center_position.X();
      auto y = center_position.Y();
      auto z = center_position.Z();
      std::cout << id << ": Center position: (" << x << ", " << y << ", " << z
                << ")\n";
    }
  }
}

References getNumStrips(), getStripCenterPosition(), and num_layers_.

rotateGlobalToLocalBarPosition()

std::vector< double > ldmx::HcalGeometry::rotateGlobalToLocalBarPosition	(	const std::vector< double > &	globalPosition,
		const ldmx::HcalID &	id ) const

Coordinates that are given by Geant4 are typically global.

These can be transformed into corresponding local coordinates of a volume with a TopTransform. However, a TopTransform translates to the local bar but does not do the rotation (this is because we don't do a rotation when placing the bars in the GDML). This is used primarily for recording pre and post step positions in local coordinates of the volume in HcalSD.

the logic below does the rotation to the local coordiates where x : short transverse side of bar y : long transverse side of bar z : along length of bar

Note

This logic only applies to the v14 and prototype detector; however, support for v12 is not broken because no studies using these pre/post step positions have been (or should be) done with the v12 detector. /

: The native position type in Geant4 is typically a G4ThreeVector, which is a typedef for a CLHEP::Hep3Vector. However, DetDescr currently does not have a dependency on Geant4/CLHEP so we are taking the position as a vector of floats (which is what is used by SimCalorimeterHit)

Definition at line 86 of file HcalGeometry.cxx.

                                                                         {
  const auto orientation{getScintillatorOrientation(id)};
  // explicit layout bars lie flat in z like the back HCal
  const unsigned int section{
      hasExplicitLayout()
          ? static_cast<unsigned int>(ldmx::HcalID::HcalSection::BACK)
          : id.section()};
  switch (section) {
    case ldmx::HcalID::HcalSection::BACK:
      switch (orientation) {
        case ScintillatorOrientation::horizontal:
          return {globalPosition[2], globalPosition[1], globalPosition[0]};
        case ScintillatorOrientation::vertical:
          return {globalPosition[2], globalPosition[0], globalPosition[1]};
        default:  // Should not be possible with current geometries
          EXCEPTION_RAISE("InvalidRotation",
                          "Attempted to rotate into an invalid "
                          "orientation for a scintillator bar!");
      }
    case ldmx::HcalID::HcalSection::TOP:
      [[fallthrough]];
    case ldmx::HcalID::HcalSection::BOTTOM:
      switch (orientation) {
        case ScintillatorOrientation::horizontal:
          return {globalPosition[1], globalPosition[2], globalPosition[0]};
        case ScintillatorOrientation::depth:
          return {globalPosition[1], globalPosition[0], globalPosition[2]};
        default:  // Should not be possible with current geometries
          EXCEPTION_RAISE("InvalidRotation",
                          "Attempted to rotate into an invalid "
                          "orientation for a scintillator bar!");
      }
    case ldmx::HcalID::HcalSection::LEFT:
      [[fallthrough]];
    case ldmx::HcalID::HcalSection::RIGHT:
      switch (orientation) {
        case ScintillatorOrientation::vertical:
          return {globalPosition[0], globalPosition[2], globalPosition[1]};
        case ScintillatorOrientation::depth:
          return globalPosition;
        default:  // Should not be possible with current geometries
          EXCEPTION_RAISE("InvalidRotation",
                          "Attempted to rotate into an invalid "
                          "orientation for a scintillator bar!");
      }
    default:
      // Can only reach this part if we somehow didn't match any of the options
      // above. This could happen if someone introduces a new geometry but
      // doesn't patch this part.
      EXCEPTION_RAISE("InvalidRotation",
                      "Attempted to rotate into an invalid "
                      "orientation for a scintillator bar!");
  }
}

References hasExplicitLayout().

Friends And Related Symbol Documentation

hcal::HcalGeometryProvider

friend class hcal::HcalGeometryProvider

friend

Definition at line 227 of file HcalGeometry.h.

Member Data Documentation

back_horizontal_parity_

int ldmx::HcalGeometry::back_horizontal_parity_ {}

private

Definition at line 292 of file HcalGeometry.h.

{};

CONDITIONS_OBJECT_NAME

const char* ldmx::HcalGeometry::CONDITIONS_OBJECT_NAME {"hcal_geometry"}

staticconstexpr

Conditions object: The name of the python configuration calling this class (Hcal/python/HcalGeometry.py) needs to match the CONDITIONS_OBJECT_NAME exactly.

Definition at line 41 of file HcalGeometry.h.

{"hcal_geometry"};

Referenced by simcore::HcalSD::decodeCopyNumber(), hcal::HcalTriggerGeometryProvider::getCondition(), simcore::HcalSD::ProcessHits(), hcal::HcalClusterProducer::produce(), hcal::HcalDigiProducer::produce(), hcal::HcalDoubleEndRecProducer::produce(), hcal::HcalRecProducer::produce(), hcal::HcalSimpleDigiAndRecProducer::produce(), and hcal::HcalSingleEndRecProducer::produce().

double_ended_

std::vector<int> ldmx::HcalGeometry::double_ended_

private

Explicit layout: section read out at both ends.

Definition at line 317 of file HcalGeometry.h.

Referenced by HcalGeometry(), and isDoubleEnded().

ecal_dx_

double ldmx::HcalGeometry::ecal_dx_

private

Lenght of the Ecal (in x and y)

Definition at line 283 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), getEcalDx(), and HcalGeometry().

ecal_dy_

double ldmx::HcalGeometry::ecal_dy_

private

Definition at line 284 of file HcalGeometry.h.

half_total_width_

std::vector<std::vector<double> > ldmx::HcalGeometry::half_total_width_

private

Half Total Width of Strips [mm].

Definition at line 302 of file HcalGeometry.h.

Referenced by getHalfTotalWidth(), and HcalGeometry().

is_prototype_

bool ldmx::HcalGeometry::is_prototype_ {}

private

Definition at line 306 of file HcalGeometry.h.

{};

layer_bar_center_

std::vector<std::vector<double> > ldmx::HcalGeometry::layer_bar_center_

private

Explicit layout: world along-bar coordinate of the bar centers [mm].

Definition at line 313 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), and HcalGeometry().

layer_long_axis_

std::vector<std::vector<int> > ldmx::HcalGeometry::layer_long_axis_

private

Explicit layout: 0 = bar long along x, 1 = along y.

Definition at line 311 of file HcalGeometry.h.

Referenced by HcalGeometry().

layer_strip_zero_

std::vector<std::vector<double> > ldmx::HcalGeometry::layer_strip_zero_

private

Explicit layout: world transverse coordinate of strip 0 [mm].

Definition at line 315 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), and HcalGeometry().

layer_thickness_

std::vector<double> ldmx::HcalGeometry::layer_thickness_

private

Thickness of the layers in each section [mm].

Definition at line 274 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), and HcalGeometry().

layer_z_

std::vector<std::vector<double> > ldmx::HcalGeometry::layer_z_

private

Explicit layout: world z of each layer center [mm].

Definition at line 309 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), hasExplicitLayout(), and HcalGeometry().

num_layers_

std::vector<int> ldmx::HcalGeometry::num_layers_

private

Number of layers in each section.

Definition at line 277 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), getNumLayers(), HcalGeometry(), and printPositionMap().

num_sections_

int ldmx::HcalGeometry::num_sections_

private

Number of sections.

Definition at line 280 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), getNumSections(), HcalGeometry(), and printPositionMap().

num_strips_

std::vector<std::vector<int> > ldmx::HcalGeometry::num_strips_

private

Number of strips per layer in each section and each layer.

Definition at line 298 of file HcalGeometry.h.

Referenced by getNumStrips(), and HcalGeometry().

scint_length_

std::vector<std::vector<double> > ldmx::HcalGeometry::scint_length_

private

Length of strips [mm].

Definition at line 304 of file HcalGeometry.h.

Referenced by getScintillatorLength(), and HcalGeometry().

scint_thickness_

double ldmx::HcalGeometry::scint_thickness_

private

Thickness of scintillator.

Definition at line 265 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), getScintillatorThickness(), and HcalGeometry().

scint_width_

double ldmx::HcalGeometry::scint_width_

private

Width of Scintillator Strip [mm].

Definition at line 268 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), getScintillatorWidth(), and HcalGeometry().

side_3d_readout_

int ldmx::HcalGeometry::side_3d_readout_ {}

private

Definition at line 295 of file HcalGeometry.h.

{};

strip_position_map_

std::map<ldmx::HcalID, ROOT::Math::XYZVector> ldmx::HcalGeometry::strip_position_map_

private

Map of the HcalID position of strip centers relative to world geometry.

The map is not configurable and is calculated by buildStripPositionMap().

Definition at line 323 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), getStripCenterPosition(), and getStripPositionMap().

verbose_

int ldmx::HcalGeometry::verbose_ {0}

private

Parameters that apply to all types of geometries Verbosity, not configurable but helpful if developing.

Definition at line 262 of file HcalGeometry.h.

{0};

Referenced by HcalGeometry().

y_offset_

double ldmx::HcalGeometry::y_offset_

private

Definition at line 287 of file HcalGeometry.h.

zero_layer_

std::vector<double> ldmx::HcalGeometry::zero_layer_

private

Front of HCal relative to world geometry for each section [mm].

Definition at line 271 of file HcalGeometry.h.

Referenced by buildStripPositionMap(), and HcalGeometry().

zero_strip_

std::vector<std::vector<double> > ldmx::HcalGeometry::zero_strip_

private

The plane of the zero'th strip of each section [mm].

Definition at line 300 of file HcalGeometry.h.

Referenced by getZeroStrip(), and HcalGeometry().

---

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

• DetDescr/include/DetDescr/HcalGeometry.h
• DetDescr/src/DetDescr/HcalGeometry.cxx