EcalGeometry.h

Go to the documentation of this file.

 
#ifndef DETDESCR_ECALGEOMETRY_H_
#define DETDESCR_ECALGEOMETRY_H_
 
// LDMX
#include "DetDescr/EcalID.h"
#include "Framework/ConditionsObject.h"
#include "Framework/Configure/Parameters.h"
#include "Framework/Exception/Exception.h"
 
// STL
#include <map>
 
// ROOT
#include "TH2Poly.h"
 
namespace ecal {
class EcalGeometryProvider;
}
 
namespace ldmx {
 
class EcalGeometry : public framework::ConditionsObject {
 public:
  static constexpr const char* CONDITIONS_OBJECT_NAME{"EcalGeometry"};
 
  virtual ~EcalGeometry() = default;
 
  EcalID getID(double x, double y, double z, bool fallible = false) const;
 
  EcalID getID(double x, double y, int layer_id, bool fallible = false) const;
 
  EcalID getID(double x, double y, int layer_id, int module_id,
               bool fallible = false) const;
 
  std::tuple<double, double, double> getPosition(EcalID id) const;
 
  std::pair<double, double> getPositionInModule(int cell_id) const;
 
  double getZPosition(int layer) const {
    return std::get<2>(layer_pos_xy_.at(layer));
  }
 
  int getNumLayers() const { return layer_pos_xy_.size(); }
 
  int getNumModulesPerLayer() const { return 7; }
 
  int getNumCellsPerModule() const {
    return cell_id_in_module_.GetNumberOfBins();
  }
 
  std::vector<EcalID> getNN(EcalID id) const {
    auto list = NNMap_.at(EcalID(0, id.module(), id.cell()));
    for (auto& flat : list)
      flat = EcalID(id.layer(), flat.module(), flat.cell());
    return list;
  }
 
  bool isNN(EcalID centroid, EcalID probe) const {
    for (auto& id : getNN(centroid)) {
      if (id == probe) return true;
    }
    return false;
  }
 
  std::vector<EcalID> getNNN(EcalID id) const {
    auto list = NNNMap_.at(EcalID(0, id.module(), id.cell()));
    for (auto& flat : list)
      flat = EcalID(id.layer(), flat.module(), flat.cell());
    return list;
  }
 
  bool isNNN(EcalID centroid, EcalID probe) const {
    for (auto& id : getNNN(centroid)) {
      if (id == probe) return true;
    }
    return false;
  }
 
  double getModuleMinR() const { return moduler_; }
 
  double getModuleMaxR() const { return moduleR_; }
 
  double getCellMinR() const { return cellr_; }
 
  double getCellMaxR() const { return cellR_; }
 
  TH2Poly* getCellPolyMap() const {
    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_;
  }
 
  static EcalGeometry* debugMake(const framework::config::Parameters& p) {
    return new EcalGeometry(p);
  }
 
 private:
  EcalGeometry(const framework::config::Parameters& ps);
  friend class ecal::EcalGeometryProvider;
 
  void buildLayerMap();
 
  void buildModuleMap();
 
  void buildCellMap();
 
  void buildCellModuleMap();
 
  void buildNeighborMaps();
 
  double distanceToEdge(EcalID id) const;
 
  bool isEdgeCell(EcalID cellModuleID) const {
    return (distanceToEdge(cellModuleID) < cellR_);
  }
 
  bool isInside(double normX, double normY) const;
 
 private:
  double gap_;
 
  double cellr_{0};
 
  double moduler_{0};
 
  double cellR_{0};
 
  double moduleR_{0};
 
  bool cornersSideUp_;
 
  double layer_shift_x_;
 
  double layer_shift_y_;
 
  bool layer_shift_odd_;
 
  bool layer_shift_odd_bilayer_;
 
  double nCellRHeight_{0};
 
  double ecalFrontZ_{0};
 
  std::vector<double> layerZPositions_;
 
 private:
  int verbose_;
 
  std::map<int, std::tuple<double, double, double>> layer_pos_xy_;
 
  std::map<int, std::pair<double, double>> module_pos_xy_;
 
  std::map<int, std::pair<double, double>> cell_pos_in_module_;
 
  std::map<EcalID, std::pair<double, double>> cell_pos_in_layer_;
 
  std::map<EcalID, std::tuple<double, double, double>> cell_global_pos_;
 
  std::map<EcalID, std::vector<EcalID>> NNMap_;
 
  std::map<EcalID, std::vector<EcalID>> NNNMap_;
 
  mutable TH2Poly cell_id_in_module_;
};
 
}  // namespace ldmx
 
#endif