eventdisplay::DetectorGeometry Class Reference

Class to translated between detector location (section, layer, strip) and real space. More...

#include <DetectorGeometry.h>

Public Member Functions
BoundingBox	getBoundingBox (const ldmx::HcalHit &hit) const
	Calculate real space coordinates from detector location.
BoundingBox	getBoundingBox (const std::vector< ldmx::HcalHit > &hitVec) const
	Calculate real space coordinates of a cluster of hits.
BoundingBox	getBoundingBox (ldmx::HcalID::HcalSection section) const
	Get bounding box for the input section.
HexPrism	getHexPrism (const ldmx::EcalID &id) const
	Calculate bounding hexagonal prism for input EcalHit.
HexPrism	getHexTower (int towerIndex) const
	Get HexPrism for a tower.
double	getRotAngle (int layerID, int moduleID) const
	Get Rotation Angle around z-axis for the input layerID and moduleID.
BoundingBox	getBoundingBox (int layerID, int moduleID) const
	Get Bounding Box for input recoil module NOTE: This does not take into account any rotation! Use getRotAngle as well!
BoundingBox	getBoundingBox (const ldmx::SimTrackerHit &recoilHit) const
	Get Bounding Box for input recoil hit NOTE: This does not take into account any rotation! Use getRotAngle as well!

Static Public Member Functions
static const DetectorGeometry &	getInstance ()
	Get the single instance of this class.

Private Member Functions
	DetectorGeometry ()
	Constructor This is where all the detector constants are set.

Private Attributes
std::map< ldmx::HcalID::HcalSection, int >	hcal_n_layers_
	Number of layers in each section.
std::map< ldmx::HcalID::HcalSection, int >	hcal_n_strips_
	Number of strips per layer in each section.
std::map< ldmx::HcalID::HcalSection, double >	hcal_length_scint_
	Length of Scintillator Strip [mm].
std::map< ldmx::HcalID::HcalSection, double >	hcal_zero_layer_
	The plane of the zero'th layer of each section [mm].
std::map< ldmx::HcalID::HcalSection, double >	hcal_zero_strip_
	The plane of the zero'th strip of each section [mm].
std::map< ldmx::HcalID::HcalSection, double >	hcal_layer_thickness_
	Thickness of the layers in each seciton [mm].
int	hcal_parity_vertical_
	an example layer number of a vertical layer
double	hcal_uncertainty_timing_pos_
	Uncertainty in timing position along a bar/strip [mm].
double	hcal_thickness_scint_
	Thickness of Scintillator Strip [mm].
double	hcal_width_scint_
	Width of Scintillator Strip [mm].
double	ecal_si_thickness_
	Thickness of sensitive Si layers.
double	ecal_depth_
	Total depth of ECAL (length in Z direction)
double	ecal_zero_layer_
	z-coordinate of plane for first ecal layer [mm]
std::unique_ptr< ldmx::EcalHexReadout >	ecal_hex_reader_
	Helper class to calculate (x,y) coordinate from hexagons.
double	recoil_stereo_strip_length_
double	recoil_stereo_x_width_
double	recoil_stereo_y_width_
double	recoil_stereo_separation_
double	recoil_stereo_angle_
double	recoil_mono_strip_length_
double	recoil_mono_x_width_
double	recoil_mono_y_width_
double	recoil_mono_separation_
double	recoil_sensor_thickness_
std::map< int, std::vector< double > >	recoil_module_pos_
	position of each module in recoil detector The key in this map is 10*layerID+moduleID
std::map< int, double >	recoil_module_angle_
	angular tilt for each module in recoil detector The key in this map is 10*layerID+moduleID

Detailed Description

Class to translated between detector location (section, layer, strip) and real space.

Definition at line 54 of file DetectorGeometry.h.

Constructor & Destructor Documentation

DetectorGeometry()

eventdisplay::DetectorGeometry::DetectorGeometry ( )

private

Constructor This is where all the detector constants are set.

It is private so that the user is forced to use the single instance acquired from getInstance() above.

Definition at line 10 of file DetectorGeometry.cxx.

                                   {
  // HCAL
 
  hcal_parity_vertical_ = 1;
 
  hcal_uncertainty_timing_pos_ = 50.0;
 
  hcal_thickness_scint_ = 20.0;
 
  hcal_width_scint_ = 50.0;
 
  hcal_n_layers_[ldmx::HcalID::HcalSection::BACK] = 100;
  hcal_n_layers_[ldmx::HcalID::HcalSection::TOP] = 28;
  hcal_n_layers_[ldmx::HcalID::HcalSection::BOTTOM] = 28;
  hcal_n_layers_[ldmx::HcalID::HcalSection::LEFT] = 26;
  hcal_n_layers_[ldmx::HcalID::HcalSection::RIGHT] = 26;
 
  hcal_n_strips_[ldmx::HcalID::HcalSection::BACK] = 62;
  hcal_n_strips_[ldmx::HcalID::HcalSection::TOP] = 12;
  hcal_n_strips_[ldmx::HcalID::HcalSection::BOTTOM] = 12;
  hcal_n_strips_[ldmx::HcalID::HcalSection::LEFT] = 12;
  hcal_n_strips_[ldmx::HcalID::HcalSection::RIGHT] = 12;
 
  double ecal_z = 440.;
  double ecal_xy = 600.;
  double back_transverse_width = 3100.;
  double ecal_front_z = 220.;
 
  hcal_length_scint_[ldmx::HcalID::HcalSection::BACK] = back_transverse_width;
  hcal_length_scint_[ldmx::HcalID::HcalSection::TOP] =
      (back_transverse_width + ecal_xy) / 2.;
  hcal_length_scint_[ldmx::HcalID::HcalSection::BOTTOM] =
      (back_transverse_width + ecal_xy) / 2.;
  hcal_length_scint_[ldmx::HcalID::HcalSection::LEFT] =
      (back_transverse_width + ecal_xy) / 2.;
  hcal_length_scint_[ldmx::HcalID::HcalSection::RIGHT] =
      (back_transverse_width + ecal_xy) / 2.;
 
  hcal_zero_layer_[ldmx::HcalID::HcalSection::BACK] =
      ecal_front_z + 600.;  // leaving 60cm cube for ecal
  hcal_zero_layer_[ldmx::HcalID::HcalSection::TOP] = ecal_xy / 2.;
  hcal_zero_layer_[ldmx::HcalID::HcalSection::BOTTOM] = ecal_xy / 2.;
  hcal_zero_layer_[ldmx::HcalID::HcalSection::LEFT] = ecal_xy / 2.;
  hcal_zero_layer_[ldmx::HcalID::HcalSection::RIGHT] = ecal_xy / 2.;
 
  hcal_zero_strip_[ldmx::HcalID::HcalSection::BACK] =
      back_transverse_width / 2.;
  hcal_zero_strip_[ldmx::HcalID::HcalSection::TOP] = ecal_front_z;
  hcal_zero_strip_[ldmx::HcalID::HcalSection::BOTTOM] = ecal_front_z;
  hcal_zero_strip_[ldmx::HcalID::HcalSection::LEFT] = ecal_front_z;
  hcal_zero_strip_[ldmx::HcalID::HcalSection::RIGHT] = ecal_front_z;
 
  // absorber + scintillator + 2*air
  hcal_layer_thickness_[ldmx::HcalID::HcalSection::BACK] =
      25. + hcal_thickness_scint_ + 2 * 2.;
  hcal_layer_thickness_[ldmx::HcalID::HcalSection::TOP] =
      20. + hcal_thickness_scint_ + 2 * 2.;
  hcal_layer_thickness_[ldmx::HcalID::HcalSection::BOTTOM] =
      20. + hcal_thickness_scint_ + 2 * 2.;
  hcal_layer_thickness_[ldmx::HcalID::HcalSection::LEFT] =
      20. + hcal_thickness_scint_ + 2 * 2.;
  hcal_layer_thickness_[ldmx::HcalID::HcalSection::RIGHT] =
      20. + hcal_thickness_scint_ + 2 * 2.;
 
  // ECAL
 
  ecal_zero_layer_ = ecal_front_z;
 
  ecal_si_thickness_ = 0.5;
 
  ecal_depth_ = ecal_z;
 
  std::vector<double> ecalSiPlanes = {
      7.850,   13.300,  26.400,  33.500,  47.950,  56.550,  72.250,
      81.350,  97.050,  106.150, 121.850, 130.950, 146.650, 155.750,
      171.450, 180.550, 196.250, 205.350, 221.050, 230.150, 245.850,
      254.950, 270.650, 279.750, 298.950, 311.550, 330.750, 343.350,
      362.550, 375.150, 394.350, 406.950, 426.150, 438.750};
 
  std::map<std::string, std::any> hexReadoutParams;
  hexReadoutParams["gap"] = 1.5;
  hexReadoutParams["moduleMinR"] = 85.0;
  hexReadoutParams["layerZPositions"] = ecalSiPlanes;
  hexReadoutParams["ecalFrontZ"] = ecal_zero_layer_;
  hexReadoutParams["nCellRHeight"] = 35.3;
  hexReadoutParams["verbose"] = 0;
 
  framework::config::Parameters hexReadout;
  hexReadout.setParameters(hexReadoutParams);
  ecal_hex_reader_ = std::unique_ptr<ldmx::EcalHexReadout>(
      ldmx::EcalHexReadout::debugMake(hexReadout));
 
  // RECOIL TRACKER
  //      The gdml file for the recoil tracker is kinda opaque.
  //      The layer and module IDs are calculated from the copy number of each
  //      of the sensor volumes.
  //          layer  = copyNum / 10 (integer division)
  //          module = copyNum % 10
  //      The first 8 layer IDs are the first 4 layers of stereo sensors.
  //          Each stereo layer contains a front layer that is not tilted at an
  //          angle and a back layer that is tilted.
  //      The last 2 layer IDs correspond to the 2 layers of mono sensors.
  //          Each mono layer contains 10 modules (ids 0 - 9) that have a
  //          complicated position arrangement.
  //
  //      In order to avoid mistakes, the position and angle of each module will
  //      be hard coded here instead of calculated from design specifications
  //      like the HCAL case.
 
  recoil_stereo_strip_length_ = 98.0;
 
  recoil_stereo_x_width_ = 40.34;
 
  recoil_stereo_y_width_ = 100.0;
 
  recoil_stereo_separation_ = 3.0;
 
  recoil_stereo_angle_ = 0.1;
 
  recoil_mono_strip_length_ = 78.0;
 
  recoil_mono_x_width_ = 50.0;
 
  recoil_mono_y_width_ = 80.0;
 
  recoil_mono_separation_ = 1.0;
 
  recoil_sensor_thickness_ = 0.52;
 
  // The following keys for the position and angle maps should correspond to the
  // copynumber in the recoil.gdml file At writing, the layerIDs and moduleIDs
  // are set in the simulation from this copy number (TrackerSD.cxx in SimCore)
 
  std::vector<double> recoilStereoLayerZPos = {7.5, 22.5, 37.5, 52.5};
 
  recoil_module_pos_[10] = {
      0, 0, recoilStereoLayerZPos.at(0) - recoil_stereo_separation_};
  recoil_module_pos_[20] = {
      0, 0, recoilStereoLayerZPos.at(0) + recoil_stereo_separation_};
 
  recoil_module_pos_[30] = {
      0, 0, recoilStereoLayerZPos.at(1) - recoil_stereo_separation_};
  recoil_module_pos_[40] = {
      0, 0, recoilStereoLayerZPos.at(1) + recoil_stereo_separation_};
 
  recoil_module_pos_[50] = {
      0, 0, recoilStereoLayerZPos.at(2) - recoil_stereo_separation_};
  recoil_module_pos_[60] = {
      0, 0, recoilStereoLayerZPos.at(2) + recoil_stereo_separation_};
 
  recoil_module_pos_[70] = {
      0, 0, recoilStereoLayerZPos.at(3) - recoil_stereo_separation_};
  recoil_module_pos_[80] = {
      0, 0, recoilStereoLayerZPos.at(3) + recoil_stereo_separation_};
 
  std::vector<double> recoilMonoLayerZPos = {90.0, 180.0};
 
  recoil_module_pos_[90] = {
      2 * recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) + recoil_mono_separation_};
  recoil_module_pos_[91] = {
      recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) - recoil_mono_separation_};
  recoil_module_pos_[92] = {
      0.0, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) + recoil_mono_separation_};
  recoil_module_pos_[93] = {
      -1 * recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) - recoil_mono_separation_};
  recoil_module_pos_[94] = {
      -2 * recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) + recoil_mono_separation_};
  recoil_module_pos_[95] = {
      2 * recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) + recoil_mono_separation_};
  recoil_module_pos_[96] = {
      recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) - recoil_mono_separation_};
  recoil_module_pos_[97] = {
      0.0, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) + recoil_mono_separation_};
  recoil_module_pos_[98] = {
      -1 * recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) - recoil_mono_separation_};
  recoil_module_pos_[99] = {
      -2 * recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(0) + recoil_mono_separation_};
 
  recoil_module_pos_[100] = {
      2 * recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) + recoil_mono_separation_};
  recoil_module_pos_[101] = {
      recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) - recoil_mono_separation_};
  recoil_module_pos_[102] = {
      0.0, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) + recoil_mono_separation_};
  recoil_module_pos_[103] = {
      -1 * recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) - recoil_mono_separation_};
  recoil_module_pos_[104] = {
      -2 * recoil_mono_x_width_, 0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) + recoil_mono_separation_};
  recoil_module_pos_[105] = {
      2 * recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) + recoil_mono_separation_};
  recoil_module_pos_[106] = {
      recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) - recoil_mono_separation_};
  recoil_module_pos_[107] = {
      0.0, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) + recoil_mono_separation_};
  recoil_module_pos_[108] = {
      -1 * recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) - recoil_mono_separation_};
  recoil_module_pos_[109] = {
      -2 * recoil_mono_x_width_, -0.5 * recoil_mono_y_width_,
      recoilMonoLayerZPos.at(1) + recoil_mono_separation_};
 
  // Recoil Angles
  recoil_module_angle_[10] = 0.0;
  recoil_module_angle_[20] = recoil_stereo_angle_;
 
  recoil_module_angle_[30] = 0.0;
  recoil_module_angle_[40] = -recoil_stereo_angle_;
 
  recoil_module_angle_[50] = 0.0;
  recoil_module_angle_[60] = recoil_stereo_angle_;
 
  recoil_module_angle_[70] = 0.0;
  recoil_module_angle_[80] = -recoil_stereo_angle_;
 
  recoil_module_angle_[90] = 0.0;
  recoil_module_angle_[91] = 0.0;
  recoil_module_angle_[92] = 0.0;
  recoil_module_angle_[93] = 0.0;
  recoil_module_angle_[94] = 0.0;
  recoil_module_angle_[95] = 0.0;
  recoil_module_angle_[96] = 0.0;
  recoil_module_angle_[97] = 0.0;
  recoil_module_angle_[98] = 0.0;
  recoil_module_angle_[99] = 0.0;
 
  recoil_module_angle_[100] = 0.0;
  recoil_module_angle_[101] = 0.0;
  recoil_module_angle_[102] = 0.0;
  recoil_module_angle_[103] = 0.0;
  recoil_module_angle_[104] = 0.0;
  recoil_module_angle_[105] = 0.0;
  recoil_module_angle_[106] = 0.0;
  recoil_module_angle_[107] = 0.0;
  recoil_module_angle_[108] = 0.0;
  recoil_module_angle_[109] = 0.0;
 
  // TODO Tagger
  // TODO Trigger Pad
}

References ecal_depth_, ecal_hex_reader_, ecal_si_thickness_, ecal_zero_layer_, hcal_layer_thickness_, hcal_length_scint_, hcal_n_layers_, hcal_n_strips_, hcal_parity_vertical_, hcal_thickness_scint_, hcal_uncertainty_timing_pos_, hcal_width_scint_, hcal_zero_layer_, hcal_zero_strip_, recoil_module_angle_, and recoil_module_pos_.

Member Function Documentation

getBoundingBox() [1/5]

BoundingBox eventdisplay::DetectorGeometry::getBoundingBox

(

const ldmx::HcalHit &

hit

)

const

Calculate real space coordinates from detector location.

Parameters

hit	HcalHit to find real space hit for

Returns

BoundingBox in real space

Definition at line 271 of file DetectorGeometry.cxx.

                                                                         {
  // pairs that will go into BoundingBox
  std::pair<double, double> X(0, 0), Y(0, 0), Z(0, 0);
 
  ldmx::HcalID id(hit.getID());
  ldmx::HcalID::HcalSection section = (ldmx::HcalID::HcalSection)id.section();
  int layer = id.layer();
  int strip = id.strip();
 
  // calculate center of layer,strip with respect to detector section
  double layercenter =
      layer * hcal_layer_thickness_.at(section) + 0.5 * hcal_thickness_scint_;
  double stripcenter = (strip + 0.5) * hcal_width_scint_;
 
  // calculate error in layer,strip position
  double elayer = 0.5 * hcal_thickness_scint_;
  double estrip = 0.5 * hcal_width_scint_;
 
  double x, y, z;
  if (section == ldmx::HcalID::HcalSection::BACK) {
    z = hcal_zero_layer_.at(section) + layercenter;
    Z.first = z - elayer;
    Z.second = z + elayer;
 
    // only horizontal layers implemented currently
    if (false) {  //( (layer ^ hcal_parity_vertical_) & 1) == 0 ) { //checks for
                  // same parity
      // Vertical Layers
 
      x = -hcal_zero_strip_.at(section) + stripcenter;
      X.first = x - estrip;
      X.second = x + estrip;
 
      y = hit.getYPos();
      Y.first = y - hcal_uncertainty_timing_pos_;
      Y.second = y + hcal_uncertainty_timing_pos_;
 
    } else {
      // Horizontal Layers
 
      x = hit.getXPos();
      X.first = x - hcal_uncertainty_timing_pos_;
      X.second = x + hcal_uncertainty_timing_pos_;
 
      y = -1 * hcal_zero_strip_.at(section) + stripcenter;
      Y.first = y - estrip;
      Y.second = y + estrip;
 
    }  // calculate depending on layer
 
  } else {
    z = hcal_zero_strip_.at(section) + stripcenter;
    Z.first = z - estrip;
    Z.second = z + estrip;
 
    if (section == ldmx::HcalID::HcalSection::TOP or
        section == ldmx::HcalID::HcalSection::BOTTOM) {
      x = hit.getXPos();
      X.first = x - hcal_uncertainty_timing_pos_;
      X.second = x + hcal_uncertainty_timing_pos_;
 
      y = hcal_zero_layer_.at(section) + layercenter;
      if (section == ldmx::HcalID::HcalSection::BOTTOM) {
        y *= -1;
      }
 
      Y.first = y - elayer;
      Y.second = y + elayer;
 
    } else if (section == ldmx::HcalID::HcalSection::LEFT or
               section == ldmx::HcalID::HcalSection::RIGHT) {
      y = hit.getYPos();
      Y.first = y - hcal_uncertainty_timing_pos_;
      Y.second = y + hcal_uncertainty_timing_pos_;
 
      x = hcal_zero_layer_.at(section) + layercenter;
      if (section == ldmx::HcalID::HcalSection::RIGHT) {
        x *= -1;
      }
 
      X.first = x - elayer;
      X.second = x + elayer;
 
    } else {
      std::cerr
          << "[ DetectorGeometry::getBoundingBox ] : Unknown Hcal Section!"
          << std::endl;
      std::cerr << "    Returning a valid BoundingBox but with values that are "
                   "all zero."
                << std::endl;
    }  // side hcal
 
  }  // calculate depending on section
 
  BoundingBox hbox;
  hbox.push_back(X);
  hbox.push_back(Y);
  hbox.push_back(Z);
  return hbox;
}

References ldmx::CalorimeterHit::getID(), ldmx::CalorimeterHit::getXPos(), ldmx::CalorimeterHit::getYPos(), hcal_layer_thickness_, hcal_thickness_scint_, hcal_uncertainty_timing_pos_, hcal_width_scint_, hcal_zero_layer_, and hcal_zero_strip_.

Referenced by eventdisplay::Objects::draw(), and getBoundingBox().

getBoundingBox() [2/5]

BoundingBox eventdisplay::DetectorGeometry::getBoundingBox

(

const ldmx::SimTrackerHit &

recoilHit

)

const

Get Bounding Box for input recoil hit NOTE: This does not take into account any rotation! Use getRotAngle as well!

Parameters

recoilHit

SimTrackerHit in recoil tracker

Returns

BoundingBox that bounds the hit

Definition at line 545 of file DetectorGeometry.cxx.

                                              {
  int layerID = recoilHit.getLayerID();
  int moduleID = recoilHit.getModuleID();
  int combined = layerID * 10 + moduleID;
 
  BoundingBox bbox;
  if (recoil_module_pos_.find(combined) == recoil_module_pos_.end()) {
    std::cerr
        << "[ Warning ] : DetectorGeometry::getBoundingBox : Input layerID ("
        << layerID << ") and input moduleID (" << moduleID
        << ") are not included in the geometry!" << std::endl;
    return bbox;
  }
 
  std::vector<float> hitPos = recoilHit.getPosition();
 
  double xWidth = 1.0;
  double yWidth = recoil_stereo_strip_length_;
  if (layerID > 8) {
    yWidth = recoil_mono_strip_length_;
  }
 
  // we have to un-rotate the x-position of the hit, so we can rotate it later
  // with the drawer
  double rotAngle = this->getRotAngle(layerID, moduleID);
  double xPos = hitPos.at(0) * cos(-rotAngle) - hitPos.at(1) * sin(-rotAngle);
 
  bbox.emplace_back(xPos - xWidth / 2., xPos + xWidth / 2.);
  bbox.emplace_back(recoil_module_pos_.at(combined).at(1) - yWidth / 2.,
                    recoil_module_pos_.at(combined).at(1) + yWidth / 2.);
  bbox.emplace_back(
      recoil_module_pos_.at(combined).at(2) - recoil_sensor_thickness_ / 2.,
      recoil_module_pos_.at(combined).at(2) + recoil_sensor_thickness_ / 2.);
 
  return bbox;
}

References ldmx::SimTrackerHit::getLayerID(), ldmx::SimTrackerHit::getModuleID(), ldmx::SimTrackerHit::getPosition(), getRotAngle(), and recoil_module_pos_.

getBoundingBox() [3/5]

BoundingBox eventdisplay::DetectorGeometry::getBoundingBox

(

const std::vector< ldmx::HcalHit > &

hitVec

)

const

Calculate real space coordinates of a cluster of hits.

Determines cluster's coordinates by a weighted mean of the individuals.

Parameters

hitVec

vector of HcalHits to find a "center" for

Returns

BoundingBox in real space

Definition at line 372 of file DetectorGeometry.cxx.

                                                {
  std::vector<double> pointSum(3, 0.0);   // sums of weighted coordinates
  std::vector<double> weightSum(3, 0.0);  // sums of weights for each coordinate
 
  // calculate real space point for each hit
  for (const ldmx::HcalHit &hit : hitVec) {
    BoundingBox box = getBoundingBox(hit);
 
    // Add weighted values to sums
    double weight;
    for (unsigned int iC = 0; iC < 3; iC++) {
      double cer = abs(box[iC].second - box[iC].first) / 2.0;
 
      weight = 1.0 / (cer * cer);
      weightSum[iC] += weight;
      pointSum[iC] += weight * ((box[iC].second + box[iC].first) / 2.0);
    }
  }  // go through hitVec
 
  // Construct final BoundingBox
  BoundingBox hbox;
  for (int iC = 0; iC < 3; iC++) {
    double c = pointSum[iC] / weightSum[iC];
    double ec = 1.0 / sqrt(weightSum[iC]);
    hbox.emplace_back(c - ec, c + ec);
  }
 
  return hbox;
}

References getBoundingBox().

getBoundingBox() [4/5]

BoundingBox eventdisplay::DetectorGeometry::getBoundingBox	(	int	layerID,
		int	moduleID ) const

Get Bounding Box for input recoil module NOTE: This does not take into account any rotation! Use getRotAngle as well!

Parameters

layerID	index for layer of module
moduleID	index for module

Returns

BoundingBox that bounds the module

Definition at line 515 of file DetectorGeometry.cxx.

                                                                            {
  int combined = layerID * 10 + moduleID;
 
  BoundingBox bbox;
  if (recoil_module_pos_.find(combined) == recoil_module_pos_.end()) {
    std::cerr
        << "[ Warning ] : DetectorGeometry::getBoundingBox : Input layerID ("
        << layerID << ") and input moduleID (" << moduleID
        << ") are not included in the geometry!" << std::endl;
    return bbox;
  }
 
  double xWidth = recoil_stereo_x_width_;
  double yWidth = recoil_stereo_strip_length_;
  if (layerID > 8) {
    xWidth = recoil_mono_x_width_;
    yWidth = recoil_mono_strip_length_;
  }
 
  bbox.emplace_back(recoil_module_pos_.at(combined).at(0) - xWidth / 2.,
                    recoil_module_pos_.at(combined).at(0) + xWidth / 2.);
  bbox.emplace_back(recoil_module_pos_.at(combined).at(1) - yWidth / 2.,
                    recoil_module_pos_.at(combined).at(1) + yWidth / 2.);
  bbox.emplace_back(
      recoil_module_pos_.at(combined).at(2) - recoil_sensor_thickness_ / 2.,
      recoil_module_pos_.at(combined).at(2) + recoil_sensor_thickness_ / 2.);
 
  return bbox;
}

References recoil_module_pos_.

getBoundingBox() [5/5]

BoundingBox eventdisplay::DetectorGeometry::getBoundingBox

(

ldmx::HcalID::HcalSection

section

)

const

Get bounding box for the input section.

Parameters

section

HcalID::HcalSection

Returns

BoundingBox that bounds section

Definition at line 403 of file DetectorGeometry.cxx.

                                         {
  std::pair<double, double> X(0, 0), Y(0, 0), Z(0, 0);
 
  double total_strip_width = hcal_n_strips_.at(section) * hcal_width_scint_;
  double total_thickness =
      hcal_n_layers_.at(section) * hcal_layer_thickness_.at(section);
  if (section == ldmx::HcalID::HcalSection::BACK) {
    X.first = -hcal_zero_strip_.at(ldmx::HcalID::HcalSection::BACK);
    X.second = X.first + total_strip_width;
 
    Y.first = -hcal_length_scint_.at(ldmx::HcalID::HcalSection::BACK) / 2.0;
    Y.second = hcal_length_scint_.at(ldmx::HcalID::HcalSection::BACK) / 2.0;
 
    Z.first = hcal_zero_layer_.at(ldmx::HcalID::HcalSection::BACK);
    Z.second = Z.first + total_thickness;
 
  } else {
    Z.first = hcal_zero_strip_.at(section);
    Z.second = Z.first + total_strip_width;
 
    if (section == ldmx::HcalID::HcalSection::LEFT) {
      X.first = hcal_zero_layer_.at(ldmx::HcalID::HcalSection::LEFT);
      X.second = X.first + total_thickness;
 
      Y.second = hcal_zero_layer_.at(ldmx::HcalID::HcalSection::TOP);
      Y.first =
          Y.second - hcal_length_scint_.at(ldmx::HcalID::HcalSection::LEFT);
 
    } else if (section == ldmx::HcalID::HcalSection::RIGHT) {
      X.second = -hcal_zero_layer_.at(ldmx::HcalID::HcalSection::RIGHT);
      X.first = X.second - total_thickness;
 
      Y.first = -hcal_zero_layer_.at(ldmx::HcalID::HcalSection::BOTTOM);
      Y.second =
          Y.first + hcal_length_scint_.at(ldmx::HcalID::HcalSection::RIGHT);
 
    } else if (section == ldmx::HcalID::HcalSection::TOP) {
      Y.first = hcal_zero_layer_.at(ldmx::HcalID::HcalSection::TOP);
      Y.second = Y.first + total_thickness;
 
      X.first = -hcal_zero_layer_.at(ldmx::HcalID::HcalSection::RIGHT);
      X.second =
          X.first + hcal_length_scint_.at(ldmx::HcalID::HcalSection::TOP);
 
    } else if (section == ldmx::HcalID::HcalSection::BOTTOM) {
      Y.second = -hcal_zero_layer_.at(ldmx::HcalID::HcalSection::BOTTOM);
      Y.first = Y.second - total_thickness;
 
      X.second = hcal_zero_layer_.at(ldmx::HcalID::HcalSection::LEFT);
      X.first =
          X.second - hcal_length_scint_.at(ldmx::HcalID::HcalSection::BOTTOM);
 
    } else {
      std::cerr << "[ Warning ] : Unrecognized ldmx::HcalID::HcalSection in "
                   "DetectorGeometry::getBoundingBox."
                << std::endl;
      std::cerr << "    Will return an incorrect geometry description!"
                << std::endl;
    }
  }
 
  BoundingBox boundingbox;
  boundingbox.push_back(X);
  boundingbox.push_back(Y);
  boundingbox.push_back(Z);
 
  return boundingbox;
}

References hcal_layer_thickness_, hcal_length_scint_, hcal_n_layers_, hcal_n_strips_, hcal_width_scint_, hcal_zero_layer_, and hcal_zero_strip_.

getHexPrism()

HexPrism eventdisplay::DetectorGeometry::getHexPrism

(

const ldmx::EcalID &

id

)

const

Calculate bounding hexagonal prism for input EcalHit.

Parameters

id	EcalID for the hit

Returns

HexPrism

Definition at line 473 of file DetectorGeometry.cxx.

                                                                 {
  HexPrism hexpris;
  ecal_hex_reader_->getCellAbsolutePosition(id, hexpris.x, hexpris.y,
                                            hexpris.z);
  hexpris.height = ecal_si_thickness_;
  hexpris.radius = ecal_hex_reader_->getCellMaxR();
 
  return hexpris;
}

References ecal_hex_reader_, and ecal_si_thickness_.

getHexTower()

HexPrism eventdisplay::DetectorGeometry::getHexTower

(

int

towerIndex

)

const

Get HexPrism for a tower.

Parameters

towerIndex

int index of hexagonal tower

Returns

HexPrism

Definition at line 483 of file DetectorGeometry.cxx.

                                                           {
  HexPrism hexpris;
 
  if (towerIndex < 0 or towerIndex > 6) {
    std::cerr << "[ Warning ] : towerIndex " << towerIndex << " out of bounds!"
              << std::endl;
    std::cerr << "    Will return a malformed HexPrism." << std::endl;
    return hexpris;
  }
 
  hexpris.x = ecal_hex_reader_->getModuleCenter(towerIndex).first;
  hexpris.y = ecal_hex_reader_->getModuleCenter(towerIndex).second;
  hexpris.z = ecal_zero_layer_ + ecal_depth_ / 2;
  hexpris.height = ecal_depth_;
  hexpris.radius = ecal_hex_reader_->getModuleMaxR();
 
  return hexpris;
}

References ecal_depth_, ecal_hex_reader_, and ecal_zero_layer_.

getInstance()

static const DetectorGeometry & eventdisplay::DetectorGeometry::getInstance ( )

inlinestatic

Get the single instance of this class.

Definition at line 59 of file DetectorGeometry.h.

                                               {
    static const DetectorGeometry detector_geometry;
    return detector_geometry;
  }

Referenced by eventdisplay::Objects::draw(), eventdisplay::Objects::draw(), eventdisplay::Objects::draw(), eventdisplay::Objects::draw(), eventdisplay::EveDetectorGeometry::drawECAL(), eventdisplay::EveDetectorGeometry::drawHCAL(), and eventdisplay::EveDetectorGeometry::drawRecoilTracker().

getRotAngle()

double eventdisplay::DetectorGeometry::getRotAngle	(	int	layerID,
		int	moduleID ) const

Get Rotation Angle around z-axis for the input layerID and moduleID.

Parameters

layerID	index for layer of recoil module
moduleID	index for module of recoil module

Returns

rotation angle in radians

Definition at line 502 of file DetectorGeometry.cxx.

                                                                    {
  int combined = layerID * 10 + moduleID;
 
  if (recoil_module_angle_.find(combined) == recoil_module_angle_.end()) {
    std::cerr << "[ Warning ] : DetectorGeometry::getRotAngle : Input layerID ("
              << layerID << ") and input moduleID (" << moduleID
              << ") are not included in the geometry!" << std::endl;
    return 0.0;
  }
 
  return recoil_module_angle_.at(combined);
}

References recoil_module_angle_.

Referenced by getBoundingBox().

Member Data Documentation

ecal_depth_

double eventdisplay::DetectorGeometry::ecal_depth_

private

Total depth of ECAL (length in Z direction)

Definition at line 186 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getHexTower().

ecal_hex_reader_

std::unique_ptr<ldmx::EcalHexReadout> eventdisplay::DetectorGeometry::ecal_hex_reader_

private

Helper class to calculate (x,y) coordinate from hexagons.

Definition at line 192 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), getHexPrism(), and getHexTower().

ecal_si_thickness_

double eventdisplay::DetectorGeometry::ecal_si_thickness_

private

Thickness of sensitive Si layers.

Definition at line 183 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getHexPrism().

ecal_zero_layer_

double eventdisplay::DetectorGeometry::ecal_zero_layer_

private

z-coordinate of plane for first ecal layer [mm]

Definition at line 189 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getHexTower().

hcal_layer_thickness_

std::map<ldmx::HcalID::HcalSection, double> eventdisplay::DetectorGeometry::hcal_layer_thickness_

private

Thickness of the layers in each seciton [mm].

Definition at line 165 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), getBoundingBox(), and getBoundingBox().

hcal_length_scint_

std::map<ldmx::HcalID::HcalSection, double> eventdisplay::DetectorGeometry::hcal_length_scint_

private

Length of Scintillator Strip [mm].

Definition at line 156 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getBoundingBox().

hcal_n_layers_

std::map<ldmx::HcalID::HcalSection, int> eventdisplay::DetectorGeometry::hcal_n_layers_

private

Number of layers in each section.

Definition at line 150 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getBoundingBox().

hcal_n_strips_

std::map<ldmx::HcalID::HcalSection, int> eventdisplay::DetectorGeometry::hcal_n_strips_

private

Number of strips per layer in each section.

Definition at line 153 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getBoundingBox().

hcal_parity_vertical_

int eventdisplay::DetectorGeometry::hcal_parity_vertical_

private

an example layer number of a vertical layer

Definition at line 168 of file DetectorGeometry.h.

Referenced by DetectorGeometry().

hcal_thickness_scint_

double eventdisplay::DetectorGeometry::hcal_thickness_scint_

private

Thickness of Scintillator Strip [mm].

Definition at line 174 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getBoundingBox().

hcal_uncertainty_timing_pos_

double eventdisplay::DetectorGeometry::hcal_uncertainty_timing_pos_

private

Uncertainty in timing position along a bar/strip [mm].

Definition at line 171 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getBoundingBox().

hcal_width_scint_

double eventdisplay::DetectorGeometry::hcal_width_scint_

private

Width of Scintillator Strip [mm].

Definition at line 177 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), getBoundingBox(), and getBoundingBox().

hcal_zero_layer_

std::map<ldmx::HcalID::HcalSection, double> eventdisplay::DetectorGeometry::hcal_zero_layer_

private

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

Definition at line 159 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), getBoundingBox(), and getBoundingBox().

hcal_zero_strip_

std::map<ldmx::HcalID::HcalSection, double> eventdisplay::DetectorGeometry::hcal_zero_strip_

private

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

Definition at line 162 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), getBoundingBox(), and getBoundingBox().

recoil_module_angle_

std::map<int, double> eventdisplay::DetectorGeometry::recoil_module_angle_

private

angular tilt for each module in recoil detector The key in this map is 10*layerID+moduleID

Definition at line 225 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), and getRotAngle().

recoil_module_pos_

std::map<int, std::vector<double> > eventdisplay::DetectorGeometry::recoil_module_pos_

private

position of each module in recoil detector The key in this map is 10*layerID+moduleID

Definition at line 220 of file DetectorGeometry.h.

Referenced by DetectorGeometry(), getBoundingBox(), and getBoundingBox().

recoil_mono_separation_

double eventdisplay::DetectorGeometry::recoil_mono_separation_

private

Definition at line 213 of file DetectorGeometry.h.

recoil_mono_strip_length_

double eventdisplay::DetectorGeometry::recoil_mono_strip_length_

private

Definition at line 207 of file DetectorGeometry.h.

recoil_mono_x_width_

double eventdisplay::DetectorGeometry::recoil_mono_x_width_

private

Definition at line 209 of file DetectorGeometry.h.

recoil_mono_y_width_

double eventdisplay::DetectorGeometry::recoil_mono_y_width_

private

Definition at line 211 of file DetectorGeometry.h.

recoil_sensor_thickness_

double eventdisplay::DetectorGeometry::recoil_sensor_thickness_

private

Definition at line 215 of file DetectorGeometry.h.

recoil_stereo_angle_

double eventdisplay::DetectorGeometry::recoil_stereo_angle_

private

Definition at line 205 of file DetectorGeometry.h.

recoil_stereo_separation_

double eventdisplay::DetectorGeometry::recoil_stereo_separation_

private

Definition at line 203 of file DetectorGeometry.h.

recoil_stereo_strip_length_

double eventdisplay::DetectorGeometry::recoil_stereo_strip_length_

private

Definition at line 197 of file DetectorGeometry.h.

recoil_stereo_x_width_

double eventdisplay::DetectorGeometry::recoil_stereo_x_width_

private

Definition at line 199 of file DetectorGeometry.h.

recoil_stereo_y_width_

double eventdisplay::DetectorGeometry::recoil_stereo_y_width_

private

Definition at line 201 of file DetectorGeometry.h.

---

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

• EventDisplay/include/EventDisplay/DetectorGeometry.h
• EventDisplay/src/EventDisplay/DetectorGeometry.cxx