FlatDetector: long c'tor instead of setter fcts

Device/Detector/FlatDetector.cpp

@@ -24,52 +24,49 @@
 #include <numbers>
 using std::numbers::pi;
 
-FlatDetector::FlatDetector(const Frame& frame)
-    : IDetector(frame)
-    , m_u0(0.0)
-    , m_v0(0.0)
+FlatDetector::FlatDetector(size_t nxbins, size_t nybins, double width, double height,
+                           const Beam& beam, NominalNormal nominalNormal, double distance,
+                           double pitch, double yaw, double roll, double offcenter_w,
+                           double offcenter_h)
+    : IDetector(
+        Frame{newEquiDivision("u", nxbins, 0.0, width), newEquiDivision("v", nybins, 0.0, height)})
+    , m_nominalNormal(nominalNormal)
+    , m_u0(width / 2 + offcenter_w)
+    , m_v0(height / 2 + offcenter_h)
     , m_direction(R3(0.0, -1.0, 0.0))
-    , m_distance(0.0)
+    , m_distance(distance)
 {
-}
+    ASSERT(m_distance > 0);
+    ASSERT(!pitch); // TODO: implement
+    ASSERT(!yaw);   // TODO: implement
+    ASSERT(!roll);  // TODO: implement
 
-FlatDetector::FlatDetector(size_t nxbins, double width, size_t nybins, double height)
-    : FlatDetector(
-        Frame{newEquiDivision("u", nxbins, 0.0, width), newEquiDivision("v", nybins, 0.0, height)})
-{
-}
+    if (m_nominalNormal == X)
+        m_normal_to_detector = R3(m_distance, 0.0, 0.0);
 
-FlatDetector::FlatDetector(const FlatDetector& other) = default;
+    else if (m_nominalNormal == T)
+        m_normal_to_detector = m_distance * beam.ki().unit_or_throw();
 
-FlatDetector::~FlatDetector() = default;
+    else if (m_nominalNormal == R)
+        m_normal_to_detector = m_distance * beam.k_reflected().unit_or_throw();
 
-FlatDetector* FlatDetector::clone() const
-{
-    return new FlatDetector(*this);
-}
+    else
+        ASSERT(false);
 
-void FlatDetector::setDetectorNormal(const R3& k)
-{
-    initNormalVector(k);
-    initUandV();
+    double d2 = m_normal_to_detector.dot(m_normal_to_detector);
+    R3 u_direction =
+        d2 * m_direction - m_direction.dot(m_normal_to_detector) * m_normal_to_detector;
+    m_u_unit = u_direction.unit_or_throw();
+    m_v_unit = m_u_unit.cross(m_normal_to_detector).unit_or_throw();
 }
 
-void FlatDetector::setPerpendicularToSampleX(double distance, double u0, double v0)
-{
-    m_detector_arrangement = X;
-    setDistanceAndOffset(distance, u0, v0);
-}
+FlatDetector::FlatDetector(const FlatDetector& other) = default;
 
-void FlatDetector::setPerpendicularToDirectBeam(double distance, double u0, double v0)
-{
-    m_detector_arrangement = T;
-    setDistanceAndOffset(distance, u0, v0);
-}
+FlatDetector::~FlatDetector() = default;
 
-void FlatDetector::setPerpendicularToReflectedBeam(double distance, double u0, double v0)
+FlatDetector* FlatDetector::clone() const
 {
-    m_detector_arrangement = R;
-    setDistanceAndOffset(distance, u0, v0);
+    return new FlatDetector(*this);
 }
 
 double FlatDetector::width() const
@@ -92,11 +89,6 @@ size_t FlatDetector::ySize() const
     return axis(1).size();
 }
 
-R3 FlatDetector::getNormalVector() const
-{
-    return m_normal_to_detector;
-}
-
 double FlatDetector::getU0() const
 {
     return m_u0;
@@ -107,11 +99,6 @@ double FlatDetector::getV0() const
     return m_v0;
 }
 
-R3 FlatDetector::getDirectionVector() const
-{
-    return m_direction;
-}
-
 double FlatDetector::getDistance() const
 {
     return m_distance;
@@ -119,7 +106,7 @@ double FlatDetector::getDistance() const
 
 FlatDetector::NominalNormal FlatDetector::getDetectorArrangment() const
 {
-    return m_detector_arrangement;
+    return m_nominalNormal;
 }
 
 const RectangularPixel* FlatDetector::regionOfInterestPixel() const
@@ -174,48 +161,21 @@ size_t FlatDetector::indexOfSpecular(const Beam& beam) const
     return getGlobalIndex(u_axis.closestIndex(u), v_axis.closestIndex(v));
 }
 
-void FlatDetector::setDistanceAndOffset(double distance, double u0, double v0)
+Frame FlatDetector::scatteringCoords() const
 {
-    if (distance <= 0.0) {
-        std::ostringstream message;
-        message << "FlatDetector::setPerpendicularToSample -> Error. "
-                << "Distance to sample cannot be negative or zero";
-        throw std::runtime_error(message.str());
-    }
-    m_distance = distance;
-    m_u0 = u0;
-    m_v0 = v0;
+    return {axesClippedToRegionOfInterest()};
 }
 
-void FlatDetector::initNormalVector(const R3 central_k)
+std::string FlatDetector::normalName() const
 {
-    R3 central_k_unit = central_k.unit_or_throw();
-
-    if (m_detector_arrangement == X)
-        m_normal_to_detector = R3(m_distance, 0.0, 0.0);
-
-    else if (m_detector_arrangement == T)
-        m_normal_to_detector = m_distance * central_k_unit;
-
-    else if (m_detector_arrangement == R) {
-        m_normal_to_detector = m_distance * central_k_unit;
-        m_normal_to_detector.setZ(-m_normal_to_detector.z());
+    switch (m_nominalNormal) {
+    case X:
+        return "X";
+    case T:
+        return "T";
+    case R:
+        return "R";
+    default:
+        ASSERT(false);
     }
-
-    else
-        ASSERT_NEVER;
-}
-
-void FlatDetector::initUandV()
-{
-    double d2 = m_normal_to_detector.dot(m_normal_to_detector);
-    R3 u_direction =
-        d2 * m_direction - m_direction.dot(m_normal_to_detector) * m_normal_to_detector;
-    m_u_unit = u_direction.unit_or_throw();
-    m_v_unit = m_u_unit.cross(m_normal_to_detector).unit_or_throw();
-}
-
-Frame FlatDetector::scatteringCoords() const
-{
-    return {axesClippedToRegionOfInterest()};
 }