Jungfraujoch/common/DetectorSetup.cpp

// Copyright (2019-2023) Paul Scherrer Institute

#include "DetectorSetup.h"
#include "JFJochException.h"

DetectorSetup::DetectorSetup(const DetectorGeometry &in_geometry)
        : DetectorSetup(in_geometry, DetectorType::JUNGFRAU, "Detector", std::vector<std::string>()) {}

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,
                             DetectorType in_detector_type,
                             const std::string &in_description,
                             const std::vector<std::string> &in_det_modules_hostname) :
        geometry(in_geometry),
        description(in_description),
        det_modules_hostname(in_det_modules_hostname),
        detector_type(in_detector_type) {
    switch (detector_type) {
        case DetectorType::EIGER:
            high_voltage = 150;
            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;
            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;
        default:
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Detector not supported");
    }
}

const DetectorGeometry &DetectorSetup::GetGeometry() const {
    return geometry;
}

const std::vector<std::string> &DetectorSetup::GetDetectorModuleHostname() const {
    return det_modules_hostname;
}

uint64_t DetectorSetup::GetModulesNum() const {
    return geometry.GetModulesNum();
}

std::string DetectorSetup::GetDescription() const {
    return description;
}

float DetectorSetup::GetPixelSize_mm() const {
    return pixel_size_um / 1000.0f;
}

std::string DetectorSetup::GetSensorMaterial() const {
    return sensor_material;
}

float DetectorSetup::GetSensorThickness_um() const {
    return sensor_thickness_um;
}

void DetectorSetup::LoadGain(const std::vector<std::string> &filenames) {
    if (filenames.size() != GetModulesNum())
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Mismatch in number of gain calibration files");
    gain_file_names = filenames;
    for (const auto& i: filenames)
        gain_calibration.emplace_back(i);
}

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");
    udp_interface_count = input;
    return *this;
}

const std::vector<JFModuleGainCalibration> &DetectorSetup::GetGainCalibration() const {
    return gain_calibration;
}

int64_t DetectorSetup::GetUDPInterfaceCount() const {
    if (detector_type == DetectorType::EIGER)
        return 2;
    return udp_interface_count;
}

DetectorSetup &DetectorSetup::SensorMaterial(const std::string &input) {
    sensor_material = input;
    return *this;
}

DetectorSetup &DetectorSetup::SensorThickness_um(float input) {
    sensor_thickness_um = input;
    return *this;
}

DetectorSetup &DetectorSetup::PixelSize_um(float input) {
    pixel_size_um = input;
    return *this;
}

DetectorSetup &DetectorSetup::TxDelay(const std::vector<int64_t> &v) {
    if (!v.empty() && (v.size() != GetModulesNum()))
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Mismatch between size of TX delay vector and modules number");
    for (const auto &i: v) {
        if ((i < 0) || (i > 31))
            throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "TX delay must be in range 0-31");
    }
    tx_delay = v;
    return *this;
}

const std::vector<int64_t> &DetectorSetup::GetTxDelay() const {
    return tx_delay;
}

const std::vector<std::string> &DetectorSetup::GetGainFileNames() const {
    return gain_file_names;
}

DetectorType DetectorSetup::GetDetectorType() const {
    return detector_type;
}

DetectorSetup &DetectorSetup::HighVoltage(int32_t input) {
    high_voltage = input;
    return *this;
}

int32_t DetectorSetup::GetHighVoltage() const {
    return high_voltage;
}

void DetectorSetup::SetTrimFiles(const std::vector<std::string> &filenames) {
    if (filenames.size() != 2 * GetModulesNum())
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Mismatch in number of trim bit calibration files");
    trim_file_names = filenames;
}

const std::vector<std::string> &DetectorSetup::GetTrimFileNames() const {
    return trim_file_names;
}

std::string DetectorSetup::GetSerialNumber() const {
    return serial_number;
}

DetectorSetup &DetectorSetup::SerialNumber(const std::string &input) {
    serial_number = input;
    return *this;
}