Jungfraujoch/common/DetectorSetup.h

// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only

#pragma once

#include <memory>
#include <chrono>
#include <optional>

#include "DetectorGeometry.h"
#include "DetectorOrientation.h"
#include "../jungfrau/JFModuleGainCalibration.h"
#include "DetectorGeometryFixed.h"
#include "DetectorGeometryModular.h"
#include "DetectorSettings.h"

constexpr uint16_t SimplonStream2Port = 31001;

enum class DetectorType {EIGER, JUNGFRAU, DECTRIS};

class DetectorSetup {
    std::string description;
    std::string serial_number;
    std::shared_ptr<DetectorGeometry> geometry;
    std::vector<std::string> det_modules_hostname;
    std::vector<std::string> gain_file_names;
    std::vector<std::string> trim_file_names;
    std::string trim_file_directory;
    std::vector<int> trim_energy_eV_values;
    std::shared_ptr<JFGainCalibration> gain_calibration;
    int64_t udp_interface_count = 2;
    float pixel_size_um = 75.0f;
    std::string sensor_material = "Si";
    float sensor_thickness_um = 320.0f;
    std::vector<int64_t> tx_delay;
    DetectorType detector_type;
    int32_t high_voltage = 120.0;
    uint32_t ipv4_base_addr = 0x010a0a0a;
    bool module_sync = true;
    // Whether the assembled image is mirrored in Y relative to the detector's raw readout order.
    // A property of the configuration, not something derivable from the assembled image: it says
    // how the modules were laid out to reach the MX convention of row 0 at the top.
    bool mirror_y = true;
    // How the ASSEMBLED image sits in the detector plane - mirrored in Y, turned by a multiple of 90
    // degrees. A different thing from mirror_y above, which is spent on the module layout before the
    // geometry sees anything; this one changes no pixel, only how a pixel coordinate is taken to the
    // laboratory. Identity by default, which is every detector assembled by this system.
    DetectorOrientation image_orientation;
    std::chrono::nanoseconds read_out_time;
    std::chrono::nanoseconds min_count_time;
    std::chrono::nanoseconds min_frame_time;
    float min_energy_threshold_keV = 2.7f;
    int32_t temperature_thresold_degC = 55;

    std::string dectris_roi;

    std::optional<int64_t> bit_depth_image;
    std::optional<int64_t> bit_depth_readout;
    std::optional<int64_t> saturation_limit;
    std::optional<DetectorSettings> settings;

    DetectorSetup(std::shared_ptr<DetectorGeometry> geom,
                  DetectorType detector_type,
                  const std::string &description = "Detector",
                  const std::vector<std::string> &det_modules_hostname = {});
public:
    DetectorSetup(const DetectorGeometryFixed& geom,
                  DetectorType detector_type,
                  const std::string &description = "Detector",
                  const std::vector<std::string> &det_modules_hostname = {});
    DetectorSetup(const DetectorGeometryModular& geom,
                  DetectorType detector_type,
                  const std::string &description = "Detector",
                  const std::vector<std::string> &det_modules_hostname = {});
    void LoadGain(const std::vector<std::string> &filenames);
    void SetTrimFiles(const std::vector<std::string> &filenames);

    DetectorSetup& TxDelay(const std::vector<int64_t> &v);
    DetectorSetup& UDPInterfaceCount(int64_t input);
    DetectorSetup& SensorMaterial(const std::string &input);
    DetectorSetup& SensorThickness_um(float input);
    DetectorSetup& PixelSize_um(float input);
    DetectorSetup& HighVoltage(int32_t input);
    DetectorSetup& SerialNumber(const std::string &input);
    DetectorSetup& BaseIPv4Addr(const std::string &input);
    DetectorSetup& ModuleSync(bool input);
    DetectorSetup& MirrorY(bool input);
    DetectorSetup& ImageOrientation(const DetectorOrientation &input);
    DetectorSetup& ReadOutTime(std::chrono::nanoseconds input);
    DetectorSetup& Geometry(const DetectorGeometryFixed& input);
    DetectorSetup& BitDepthImage(int64_t input);
    DetectorSetup& MinFrameTime(std::chrono::nanoseconds input);
    DetectorSetup& MinCountTime(std::chrono::nanoseconds input);
    DetectorSetup& MinThreshold_keV(float input);
    DetectorSetup& SaturationLimit(std::optional<int64_t> input);
    DetectorSetup& Description(const std::string &input);
    DetectorSetup& DECTRISROI(const std::string &input);
    DetectorSetup& DefaultSettings(const std::optional<DetectorSettings> &input);
    DetectorSetup& TempThreshold_degC(int64_t input);
    DetectorSetup& TrimEnergies_eV(std::vector<int> input);

    [[nodiscard]] DetectorType GetDetectorType() const;
    [[nodiscard]] const DetectorGeometry& GetGeometry() const;
    [[nodiscard]] const std::vector<std::string>& GetDetectorModuleHostname() const;
    [[nodiscard]] uint64_t GetModulesNum() const;
    [[nodiscard]] std::string GetDescription() const;
    [[nodiscard]] float GetPixelSize_mm() const;
    [[nodiscard]] float GetSensorThickness_um() const;
    [[nodiscard]] std::string GetSensorMaterial() const;
    [[nodiscard]] const std::vector<JFModuleGainCalibration> &GetGainCalibration() const;
    [[nodiscard]] int64_t GetUDPInterfaceCount() const;
    [[nodiscard]] const std::vector<int64_t> &GetTxDelay() const; // can be empty for default
    [[nodiscard]] const std::vector<std::string> &GetGainFileNames() const;
    [[nodiscard]] const std::vector<std::string> &GetTrimFileNames() const;
    [[nodiscard]] std::string GetTrimFileDirectory() const;
    [[nodiscard]] int32_t GetHighVoltage() const;
    [[nodiscard]] std::string GetSerialNumber() const;
    [[nodiscard]] uint32_t GetSrcIPv4Addr(uint32_t half_module) const;
    [[nodiscard]] std::string GetBaseIPv4Addr() const;
    [[nodiscard]] bool IsModuleSync() const;
    [[nodiscard]] bool IsMirrorY() const;
    [[nodiscard]] DetectorOrientation GetImageOrientation() const;
    [[nodiscard]] std::chrono::nanoseconds GetReadOutTime() const;
    [[nodiscard]] std::chrono::nanoseconds GetMinFrameTime() const;
    [[nodiscard]] std::chrono::nanoseconds GetMinCountTime() const;
    [[nodiscard]] std::optional<int64_t> GetBitDepthReadout() const;
    [[nodiscard]] std::optional<int64_t> GetBitDepthImage() const;
    [[nodiscard]] std::string GetDECTRISStream2Addr() const;
    [[nodiscard]] float GetMinThreshold_keV() const;
    [[nodiscard]] std::optional<int64_t> GetSaturationLimit() const;
    [[nodiscard]] std::string GetDECTRISROI() const;
    [[nodiscard]] std::optional<DetectorSettings> GetDefaultSettings() const;
    [[nodiscard]] int32_t GetTempThreshold_degC() const;
    [[nodiscard]] std::vector<int> GetTrimEnergies_eV() const;
};

DetectorSetup DetJF4M(const std::string &description = "Detector",
                            const std::vector<std::string> &det_modules_hostname = {});
DetectorSetup DetJF9M(const std::string &description = "Detector",
                            const std::vector<std::string> &det_modules_hostname = {});

DetectorSetup DetJF(int32_t nmodules,
                    int32_t horizontal_stacking = 1,
                    int32_t gap_x = 0,
                    int32_t gap_y = 0,
                    bool mirror_y = true,
                    const std::string &description = "Detector",
                    const std::vector<std::string> &det_modules_hostname = {});
DetectorSetup DetJF(const DetectorGeometryModular &geom,
                    const std::string &description = "Detector",
                    const std::vector<std::string> &det_modules_hostname = {});

DetectorSetup DetEIGER(int32_t nmodules,
                       int32_t horizontal_stacking = 1,
                       int32_t gap_x = 0,
                       int32_t gap_y = 0,
                       bool mirror_y = true,
                       const std::string &description = "Detector",
                       const std::vector<std::string> &det_modules_hostname = {});
DetectorSetup DetEIGER(const DetectorGeometryModular &geom,
                    const std::string &description = "Detector",
                    const std::vector<std::string> &det_modules_hostname = {});

DetectorSetup DetDECTRIS(int64_t width, int64_t height,
                         const std::string &description,
                         const std::string &addr);