BmnHgndRaw2Digit.cxx

Go to the documentation of this file.

#include "BmnHgndRaw2Digit.h"
 
#include "TMath.h"
#include "TSystem.h"
 
#include <bitset>
#include <nlohmann/json.hpp>
 
#define TDCBIN 0.1   // 100 ps
 
void BmnHgndRaw2Digit::print()
{
    LOG(info) << Form("BmnHgndRaw2Digit");
}
 
BmnHgndRaw2Digit::BmnHgndRaw2Digit(int period, int run, const std::string& mappingFile, const std::string& calibFile)
{
    std::string resolvedMapFile = mappingFile.empty() ? Form("HGND_map_period%d.json", period) : mappingFile;
    std::string resolvedCalibFile = calibFile.empty() ? Form("HGND_calibration_period%d.json", period) : calibFile;
 
    LOG(info) << "BmnHgndRaw2Digit: Using mapping file: " << resolvedMapFile;
    LOG(info) << "BmnHgndRaw2Digit: Using calibration file: " << resolvedCalibFile;
 
    ParseConfig(resolvedMapFile);
    ParseCalibration(resolvedCalibFile);
}
 
void BmnHgndRaw2Digit::ParseConfig(const std::string& mappingFile)
{
    std::string fullPath = std::string(getenv("VMCWORKDIR")) + "/input/" + mappingFile;
    std::ifstream config_file(fullPath);
    if (!config_file.is_open()) {
        LOG(error) << Form("BmnHgndRaw2Digit::ParseConfig: Cannot open config file: %s", fullPath.c_str());
        return;
    }
 
    nlohmann::json j;
    try {
        config_file >> j;
    } catch (const std::exception& e) {
        LOG(error) << "BmnHgndRaw2Digit::ParseConfig: Failed to parse JSON: " << e.what();
        return;
    }
 
    std::string version = j.value("version", "unknown");
    std::string comment = j.value("comment", "none");
 
    LOG(debug) << "BmnHgndRaw2Digit::ParseConfig. Mapping version: " << version;
    LOG(debug) << "BmnHgndRaw2Digit::ParseConfig. Comment: " << comment;
 
    fuoChannelMap.clear();
    for (const auto& entry : j["mapping"]) {
        int gl_ch = entry["global_ch"];
        int det = entry["detector"];
        int lay = entry["layer"];
        int row = entry["row"];
        int col = entry["column"];
 
        fuoChannelMap[gl_ch] = BmnNdetAddress::GetAddress(det, row, col, lay);
    }
}
 
void BmnHgndRaw2Digit::ParseCalibration(const std::string& calibrationFile)
{
    std::string fullPath = std::string(getenv("VMCWORKDIR")) + "/parameters/hgnd/" + calibrationFile;
    std::ifstream input(fullPath);
    if (!input.is_open()) {
        LOG(error) << "BmnHgndRaw2Digit::ParseCalibration: Cannot open file " << fullPath;
        return;
    }
 
    nlohmann::json j;
    try {
        input >> j;
    } catch (const std::exception& e) {
        LOG(error) << "BmnHgndRaw2Digit::ParseCalibration: Failed to parse JSON: " << e.what();
        return;
    }
 
    std::string version = j.value("version", "unknown");
    std::string comment = j.value("comment", "none");
    double totThreshold = j.value("totThreshold", 20.0);   // default in mV
    double Rload = j.value("Rload", 33.0);                 // default in Ohm
 
    LOG(debug) << "BmnHgndRaw2Digit::ParseCalibration. Calibration version: " << version;
    LOG(debug) << "BmnHgndRaw2Digit::ParseCalibration. Comment: " << comment;
 
    fuoCalibMap.clear();
    for (const auto& entry : j["calibration"]) {
        int det = entry["detector"];
        int lay = entry["layer"];
        int row = entry["row"];
        int col = entry["column"];
        double off = entry["offset"];
        double p = entry["p"];
        double tau = entry["tau"];
        double RC = entry["RC"];
 
        uint32_t address = BmnNdetAddress::GetAddress(det, row, col, lay);
        TdcFromTot tdc(off, p, tau, RC);
        QdcFromTotApprox qdc(p, tau, RC, totThreshold, Rload);
        fuoCalibMap.emplace(address, std::make_pair(tdc, qdc));
    }
}
 
std::optional<uint32_t> BmnHgndRaw2Digit::GetAddressFromBoard(uint32_t key) const
{
    try {
        return fuoChannelMap.at(key);
    } catch (const std::out_of_range& e) {
        LOG(debug) << "BmnHgndRaw2Digit::GetAddressFromBoard. Invalid key " << key;
        return std::nullopt;
    }
}
 
std::optional<std::pair<TdcFromTot, QdcFromTotApprox>> BmnHgndRaw2Digit::GetCalibPairFromAddress(uint32_t address) const
{
    try {
        return fuoCalibMap.at(address);
    } catch (const std::out_of_range& e) {
        LOG(debug) << "BmnHgndRaw2Digit::GetCalibPairFromAddress " << std::bitset<32>(address)
                   << " is marked badly in calibration file.";
        return std::nullopt;
    }
}
 
void BmnHgndRaw2Digit::fillEvent(TClonesArray* tdc, BmnEventHeader* hdr, TClonesArray* digits)
{
    LOG(debug) << "BmnHgndRaw2Digit::fillEvent";
    for (Int_t iTdc = 0, nEntries = tdc->GetEntriesFast(); iTdc < nEntries; ++iTdc) {
        const auto* tdcDig = static_cast<const BmnAbstractTDCDigit*>(tdc->At(iTdc));
 
        const auto catch_address = GetAddressFromBoard(tdcDig->GetChannel());
        if (!catch_address.has_value())
            continue;
 
        const auto address = catch_address.value();
        if (address == 0)
            continue;
 
        const auto catch_calib = GetCalibPairFromAddress(address);
        if (!catch_calib.has_value())
            continue;
 
        const auto& [slew_func, charge_func] = catch_calib.value();
 
        LOG(debug4) << Form("BmnHgndRaw2Digit::fillEvent: Ev %d Hdr ns %d. Hdr+ST %d. Hgnd l%d ns %ld",
                            hdr->GetEventId(), hdr->GetEventTimeTS().GetNanoSec(),
                            static_cast<int>(hdr->GetEventTimeTS().GetNanoSec() + hdr->GetStartSignalTime()),
                            BmnNdetAddress::GetLayerId(address), tdcDig->GetTimeNsec());
        const int64_t delta_sec = tdcDig->GetTimeSec() - hdr->GetEventTimeTS().GetSec();
        const int64_t delta_nsec = tdcDig->GetTimeNsec() - hdr->GetEventTimeTS().GetNanoSec();
        const int64_t wr_tof_ns = delta_sec * 1000000000LL + delta_nsec;
 
        if (delta_sec != 0)
            LOG(warn) << Form("BmnHgndRaw2Digit::fillEvent: Sync lost. Hdr sec %ld Hgnd sec %ld",
                              hdr->GetEventTimeTS().GetSec(), tdcDig->GetTimeSec());
 
        const double raw_time = wr_tof_ns + tdcDig->GetToa() * TDCBIN;   // - hdr->GetStartSignalTime();
        const double tot = tdcDig->GetTot() * TDCBIN;
        const double time = raw_time - slew_func(tot);
        const double signal = charge_func(tot);
 
        new ((*digits)[digits->GetEntriesFast()]) BmnHgndDigi(address, time, signal, raw_time, tot);
    }
}
 
BmnHgndRaw2Digit::~BmnHgndRaw2Digit() {}