v1.0.0-rc.36

common/DetectorSetup.cpp

@@ -7,42 +7,90 @@
 #include "JFJochException.h"
 #include "NetworkAddressConvert.h"
 
-DetectorSetup::DetectorSetup(const DetectorGeometry &in_geometry)
-        : DetectorSetup(in_geometry, DetectorType::JUNGFRAU, "Detector", std::vector<std::string>()) {}
+DetectorSetup::DetectorSetup(const DetectorGeometryFixed &geom, DetectorType detector_type,
+                             const std::string &description, const std::vector<std::string> &det_modules_hostname)
+        : DetectorSetup(std::make_shared<DetectorGeometryFixed>(geom),
+                        detector_type, description, det_modules_hostname) {
+    switch (detector_type) {
+        case DetectorType::DECTRIS:
+            break;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Detector not compatible with fixed geometry");
+    }
+}
 
-DetectorSetup::DetectorSetup(const DetectorGeometry &in_geometry, DetectorType in_detector_type)
-        : DetectorSetup(in_geometry, in_detector_type, "Detector", std::vector<std::string>()) {}
 
-DetectorSetup::DetectorSetup(const DetectorGeometry &in_geometry,
+DetectorSetup::DetectorSetup(const DetectorGeometryModular &geom, DetectorType detector_type,
+                             const std::string &description, const std::vector<std::string> &det_modules_hostname)
+        : DetectorSetup(std::make_shared<DetectorGeometryModular>(geom),
+                        detector_type, description, det_modules_hostname) {
+    switch (detector_type) {
+        case DetectorType::EIGER:
+        case DetectorType::JUNGFRAU:
+            break;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Detector not compatible with modular geometry");
+    }
+}
+
+DetectorSetup::DetectorSetup(std::shared_ptr<DetectorGeometry> in_geometry,
                              DetectorType in_detector_type,
                              const std::string &in_description,
                              const std::vector<std::string> &in_det_modules_hostname) :
-        geometry(in_geometry),
+        geometry(std::move(in_geometry)),
         description(in_description),
         det_modules_hostname(in_det_modules_hostname),
-        detector_type(in_detector_type) {
+        detector_type(in_detector_type),
+        read_out_time(0),
+        min_frame_time(std::chrono::milliseconds(1)),
+        min_count_time(std::chrono::microseconds(MIN_COUNT_TIME_IN_US)) {
+
+    if (description.empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Detector description cannot be empty");
+
     switch (detector_type) {
         case DetectorType::EIGER:
             high_voltage = 150;
             read_out_time = std::chrono::microseconds(3);
-            if (!det_modules_hostname.empty() && (2 * geometry.GetModulesNum() != det_modules_hostname.size()))
+            if (!det_modules_hostname.empty() && (2 * geometry->GetModulesNum() != det_modules_hostname.size()))
                 throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                       "Mismatch between number of modules in detector geometry and hostname (For EIGER - one module = 2 hostnames)");
             break;
         case DetectorType::JUNGFRAU:
             high_voltage = 120;
+            bit_depth_readout = 16;
             read_out_time = std::chrono::microseconds(20);
-            if (!det_modules_hostname.empty() && (geometry.GetModulesNum() != det_modules_hostname.size()))
+            if (!det_modules_hostname.empty() && (geometry->GetModulesNum() != det_modules_hostname.size()))
                 throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                       "Mismatch between number of modules in detector geometry and hostname");
             break;
+        case DetectorType::DECTRIS:
+            high_voltage = 0;
+            bit_depth_readout = 16;
+            bit_depth_image = 16;
+            read_out_time = std::chrono::microseconds(0);
+            if (!det_modules_hostname.empty() && ( det_modules_hostname.size() != 1))
+                throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                      "Just one address need to be provided for DECTRIS detector");
+            break;
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Detector not supported");
     }
 }
 
+DetectorSetup &DetectorSetup::Description(const std::string &input) {
+    if (input.empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Detector description cannot be empty");
+    description = input;
+    return *this;
+}
+
 const DetectorGeometry &DetectorSetup::GetGeometry() const {
-    return geometry;
+    return *geometry;
 }
 
 const std::vector<std::string> &DetectorSetup::GetDetectorModuleHostname() const {
@@ -50,7 +98,7 @@ const std::vector<std::string> &DetectorSetup::GetDetectorModuleHostname() const
 }
 
 uint64_t DetectorSetup::GetModulesNum() const {
-    return geometry.GetModulesNum();
+    return geometry->GetModulesNum();
 }
 
 std::string DetectorSetup::GetDescription() const {
@@ -81,7 +129,7 @@ void DetectorSetup::LoadGain(const std::vector<std::string> &filenames) {
 DetectorSetup &DetectorSetup::UDPInterfaceCount(int64_t input) {
     if ((input != 1) && (input != 2))
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
-                     "Only 1 and 2 are supported as UDP interface count");
+                              "Only 1 and 2 are supported as UDP interface count");
     udp_interface_count = input;
     return *this;
 }
@@ -111,6 +159,14 @@ DetectorSetup &DetectorSetup::PixelSize_um(float input) {
     return *this;
 }
 
+DetectorSetup &DetectorSetup::Geometry(const DetectorGeometryFixed &input) {
+    if (detector_type != DetectorType::DECTRIS)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "PSI detector geometry cannot be updated during operation");
+    geometry = std::make_shared<DetectorGeometryFixed>(input);
+    return *this;
+}
+
 DetectorSetup &DetectorSetup::TxDelay(const std::vector<int64_t> &v) {
     if (!v.empty() && (v.size() != GetModulesNum()))
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
@@ -207,9 +263,9 @@ DetectorSetup &DetectorSetup::ModuleSync(bool input) {
 }
 
 DetectorSetup & DetectorSetup::ReadOutTime(std::chrono::microseconds input) {
-    if (input.count() <= 0)
+    if (input.count() < 0)
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
-            "Read out time has to be more than zero");
+                              "Read out time has to be non-negative");
     read_out_time = input;
     return *this;
 }
@@ -226,6 +282,8 @@ std::chrono::microseconds DetectorSetup::GetMinFrameTime() const {
             if (GetUDPInterfaceCount() == 1)
                 return std::chrono::microseconds(MIN_FRAME_TIME_JUNGFRAU_HALF_SPEED_IN_US);
             return std::chrono::microseconds(MIN_FRAME_TIME_JUNGFRAU_FULL_SPEED_IN_US);
+        case DetectorType::DECTRIS:
+            return min_frame_time;
         default:
             throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                                   "Detector not supported");
@@ -233,5 +291,138 @@ std::chrono::microseconds DetectorSetup::GetMinFrameTime() const {
 }
 
 std::chrono::microseconds DetectorSetup::GetMinCountTime() const {
-    return std::chrono::microseconds(MIN_COUNT_TIME_IN_US);
+    return min_count_time;
 }
+
+DetectorSetup &DetectorSetup::MinCountTime(std::chrono::microseconds input) {
+    min_count_time = input;
+    return *this;
+}
+
+DetectorSetup &DetectorSetup::MinFrameTime(std::chrono::microseconds input) {
+    min_frame_time = input;
+    return *this;
+}
+
+DetectorSetup &DetectorSetup::BitDepthImage(int64_t input) {
+    if (GetDetectorType() != DetectorType::DECTRIS)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Bit depth image can be only changed for DECTRIS detector");
+    switch (input) {
+        case 8:
+        case 16:
+        case 32:
+            bit_depth_image = input;
+            return *this;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Bit depth image can be only 8, 16 or 32");
+    }
+}
+
+DetectorSetup &DetectorSetup::BitDepthReadout(int64_t input) {
+    if (GetDetectorType() != DetectorType::DECTRIS)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Bit depth readout can be only changed for DECTRIS detector");
+    switch (input) {
+        case 8:
+        case 12:
+        case 16:
+        case 32:
+            bit_depth_readout = input;
+            return *this;
+        default:
+            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                                  "Bit depth readout can be only 8, 12, 16 or 32");
+    }
+}
+
+std::optional<int64_t> DetectorSetup::GetBitDepthReadout() const {
+    return bit_depth_readout;
+}
+
+std::optional<int64_t> DetectorSetup::GetBitDepthImage() const {
+    return bit_depth_image;
+}
+
+std::string DetectorSetup::GetDECTRISStream2Addr() const {
+    if (GetDetectorType() != DetectorType::DECTRIS)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Stream2 only possible for DECTRIS systems");
+    if (det_modules_hostname.size() != 1)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Stream2 address not defined");
+    return "tcp://" + det_modules_hostname[0] + ":" + std::to_string(SimplonStream2Port);
+}
+
+float DetectorSetup::GetMinThreshold_keV() const {
+    return min_energy_threshold_keV;
+}
+
+DetectorSetup &DetectorSetup::MinThreshold_keV(float input) {
+    if (input <= 0.0f)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Min threshold must be positive number");
+    min_energy_threshold_keV = input;
+    return *this;
+}
+
+DetectorSetup &DetectorSetup::SaturationLimit(std::optional<int64_t> input) {
+    if (input && input <= 0)
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Saturation limit must be positive number");
+    saturation_limit = input;
+    return *this;
+}
+
+std::optional<int64_t> DetectorSetup::GetSaturationLimit() const {
+    return saturation_limit;
+}
+
+DetectorSetup &DetectorSetup::DECTRISROI(const std::string &input) {
+    dectris_roi = input;
+    return *this;
+}
+
+std::string DetectorSetup::GetDECTRISROI() const {
+    if (dectris_roi.empty())
+        return "disabled";
+    return dectris_roi;
+}
+
+DetectorSetup DetJF4M(const std::string &description, const std::vector<std::string> &det_modules_hostname) {
+    return DetJF(8, 2, 8, 36, true, description, det_modules_hostname);
+}
+
+DetectorSetup DetJF9M(const std::string &description, const std::vector<std::string> &det_modules_hostname) {
+    return DetJF(18, 3, 8, 36, true, description, det_modules_hostname);
+}
+
+DetectorSetup DetJF(int32_t nmodules, int32_t horizontal_stacking, int32_t gap_x, int32_t gap_y, bool mirror_y,
+                    const std::string &description, const std::vector<std::string> &det_modules_hostname) {
+    return DetJF(DetectorGeometryModular(nmodules, horizontal_stacking, gap_x, gap_y, mirror_y),
+                 description, det_modules_hostname);
+}
+
+DetectorSetup DetJF(const DetectorGeometryModular &geom, const std::string &description,
+                    const std::vector<std::string> &det_modules_hostname) {
+    return {geom, DetectorType::JUNGFRAU, description, det_modules_hostname};
+}
+
+DetectorSetup DetEIGER(int32_t nmodules, int32_t horizontal_stacking, int32_t gap_x, int32_t gap_y, bool mirror_y,
+                       const std::string &description, const std::vector<std::string> &det_modules_hostname) {
+    return DetEIGER(DetectorGeometryModular(nmodules, horizontal_stacking, gap_x, gap_y, mirror_y),
+                    description, det_modules_hostname);
+}
+
+DetectorSetup DetEIGER(const DetectorGeometryModular &geom, const std::string &description,
+                       const std::vector<std::string> &det_modules_hostname) {
+    return {geom, DetectorType::EIGER, description, det_modules_hostname};
+}
+
+DetectorSetup DetDECTRIS(int64_t width, int64_t height, const std::string &description, const std::string &addr) {
+    if (addr.empty())
+        return {DetectorGeometryFixed(width, height), DetectorType::DECTRIS, description, {}};
+    else
+        return {DetectorGeometryFixed(width, height), DetectorType::DECTRIS, description, {addr}};
+}