HcalGeometry.h

Go to the documentation of this file.

 
#ifndef DETDESCR_HCALGEOMETRY_H_
#define DETDESCR_HCALGEOMETRY_H_
 
// LDMX
#include "DetDescr/HcalID.h"
#include "Framework/ConditionsObject.h"
#include "Framework/Configure/Parameters.h"
 
// ROOT
#include "Math/Vector3D.h"  // IWYU pragma: keep
 
// STL
#include <map>
 
namespace hcal {
class HcalGeometryProvider;
}
 
namespace ldmx {
 
class HcalGeometryProvider;
 
class HcalGeometry : public framework::ConditionsObject {
 public:
  static constexpr const char* CONDITIONS_OBJECT_NAME{"hcal_geometry"};
 
  enum class ScintillatorOrientation {
    horizontal = 0,
    vertical = 1,
    depth = 2
  };
 
  ~HcalGeometry() = default;
 
  ScintillatorOrientation getScintillatorOrientation(
      const ldmx::HcalID id) const;
 
  ROOT::Math::XYZVector getStripCenterPosition(ldmx::HcalID id) const {
    return strip_position_map_.at(id);
  }
 
  std::map<ldmx::HcalID, ROOT::Math::XYZVector> getStripPositionMap() const {
    return strip_position_map_;
  }
 
  bool backLayerIsHorizontal(const int layer) const {
    return layer % 2 == back_horizontal_parity_;
  }
  double getHalfTotalWidth(int isection, int layer = 1) const {
    // 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);
  }
 
  double getScintillatorLength(ldmx::HcalID id) const {
    return scint_length_.at(id.section()).at(id.layer() - 1);
  }
  double getScintillatorWidth() const { return scint_width_; }
 
  double getScintillatorThickness() const { return scint_thickness_; }
 
  int getNumSections() const { return num_sections_; }
 
  int getNumLayers(int isection) const { return num_layers_.at(isection); }
 
  int getNumStrips(int isection, int layer = 1) const {
    auto layer_index = layer - 1;
    return num_strips_.at(isection).at(layer_index);
  }
 
  int getZeroStrip(int isection, int layer = 1) const {
    auto layer_index = layer - 1;
    return zero_strip_.at(isection).at(layer_index);
  }
 
  double getEcalDx() const { return ecal_dx_; }
 
  double getEcalDy() const { return ecal_dy_; }
 
  bool hasSide3DReadout() const { return side_3d_readout_; }
 
  /*
   * Is the hcal geometry one of the geometries used for the CERN testbeam
   * activities?
   */
  bool isPrototype() const { return is_prototype_; }
 
  bool hasExplicitLayout() const { return !layer_z_.empty(); }
 
  bool isDoubleEnded(int isection) const {
    if (hasExplicitLayout()) return double_ended_.at(isection) != 0;
    return isection == ldmx::HcalID::HcalSection::BACK;
  }
 
  double getDistanceAlongBar(ldmx::HcalID id, double x, double y,
                             double z) const;
 
  std::vector<double> rotateGlobalToLocalBarPosition(
      const std::vector<double>& globalPosition, const ldmx::HcalID& id) const;
 
 private:
  HcalGeometry(const framework::config::Parameters& ps);
  friend class hcal::HcalGeometryProvider;
 
  void buildStripPositionMap();
  void printPositionMap(int section) const;
  void printPositionMap() const {
    for (int section = 0; section < num_sections_; ++section) {
      printPositionMap(section);
    }
  }
 
 private:
  int verbose_{0};
 
  double scint_thickness_;
 
  double scint_width_;
 
  std::vector<double> zero_layer_;
 
  std::vector<double> layer_thickness_;
 
  std::vector<int> num_layers_;
 
  int num_sections_;
 
  double ecal_dx_;
  double ecal_dy_;
 
  // Offset of the entire Hcal geometry in y (mm)
  double y_offset_;
 
  // Defines what parity (0/1, i.e. even/odd parity) of a layer number in the
  // geometry that corresponds to a horizontal layer (scintillator bar length
  // along the x-axis) in the back HCal.
  int back_horizontal_parity_{};
 
  // 3D readout for side Hcal
  int side_3d_readout_{};
 
  std::vector<std::vector<int>> num_strips_;
  std::vector<std::vector<double>> zero_strip_;
  std::vector<std::vector<double>> half_total_width_;
  std::vector<std::vector<double>> scint_length_;
 
  bool is_prototype_{};
 
  std::vector<std::vector<double>> layer_z_;
  std::vector<std::vector<int>> layer_long_axis_;
  std::vector<std::vector<double>> layer_bar_center_;
  std::vector<std::vector<double>> layer_strip_zero_;
  std::vector<int> double_ended_;
 
  std::map<ldmx::HcalID, ROOT::Math::XYZVector> strip_position_map_;
};
 
}  // namespace ldmx
 
#endif