BmnT0RawReader.cxx

Go to the documentation of this file.

#include "BmnT0RawReader.h"
// C++
#include <chrono>
#include <filesystem>
#include <iostream>
#include <sys/mman.h>
// FairRoot
#include "FairLogger.h"
// BmnRoot
#include "BmnConverterTools.h"
#include "RawTypes.h"
 
namespace fs = std::filesystem;
using namespace std::chrono;
 
BmnT0RawReader::BmnT0RawReader()
    : fTreeT0(nullptr)
{}
 
BmnT0RawReader::~BmnT0RawReader() {}
 
BmnStatus BmnT0RawReader::ReadFiles(const vector<string>& fileNames, const string& outFileName)
{
    const string tree_name = "T0RAW_ALL";
    const string t0raw_branch_name = "T0RAW";
    const string ts_map_name = "T0TsMap";
    unique_ptr<TFile> out_file(make_unique<TFile>(outFileName.data(), "recreate"));
    fTreeT0 = new TTree(tree_name.data(), tree_name.data());
    TClonesArray* arr = new TClonesArray(BmnT0Raw::Class());
    fTreeT0->Branch(t0raw_branch_name.data(), &arr);
 
    printf(ANSI_COLOR_RED "\n================ PARSING T0 RAW FILES ================\n" ANSI_COLOR_RESET);
    for (auto& fileName : fileNames) {
        ParseFile(fileName, arr);
    }
    out_file->WriteObjectAny(&fTsMap, TClass::GetClass(typeid(fTsMap)), ts_map_name.data());
    out_file->Write();
    out_file->Close();
    return kBMNSUCCESS;
}
 
BmnStatus BmnT0RawReader::ParseFile(const string& file, TClonesArray* t0raw)
{
    const uint8_t cfg_name[] = ".BMNCfg";
    const uint8_t cfg_line_breaks[] = {0x0D, 0x0A, 0x20, 0x0D, 0x0A};
    const ptrdiff_t t0raw_block_len = kT0_BIN_BLOCK_BYTES + kT0_TXT_BLOCK_BYTES;
    const ptrdiff_t max_cfg_len = 1024;        // search back no more than
    const ptrdiff_t cfg_breaks_shift = 1023;   // between block start and line breaks
    const TTimeStamp ZeroTS{0, 0};
 
    fs::path raw_file_path(file.data());
    size_t raw_file_size = fs::file_size(raw_file_path);
    printf("\nRAW FILE: ");
    printf(ANSI_COLOR_BLUE "%s" ANSI_COLOR_RESET, file.data());
    printf("\nRAW FILE LENGTH: ");
    printf(ANSI_COLOR_BLUE "%.3f MB\n" ANSI_COLOR_RESET, raw_file_size / 1024. / 1024.);
 
    int32_t fd = open(file.data(), O_RDONLY);
    if (fd < 0) {
        DBGERR("Cannot open file!")
        return kBMNERROR;
    }
    void* map = mmap(nullptr, raw_file_size, PROT_READ, MAP_PRIVATE, fd, 0);
    close(fd);
    if (map == MAP_FAILED) {
        DBGERR("Map Failed!")
        return kBMNERROR;
    }
    uint8_t* mptr = static_cast<uint8_t*>(map);
    uint8_t* end = mptr + raw_file_size;
    ptrdiff_t block_len = t0raw_block_len;
    while (mptr < end) {
        if (t0raw)
            t0raw->Delete();
        auto it = std::search(mptr, end, std::begin(cfg_name), std::end(cfg_name) - 1   // exclude null-terminator
        );
 
        if (it != end) {
            LOG(debug) << "Found at offset " << (it - mptr) << "\n";
            auto it_lb = std::search(it - max_cfg_len, it, std::begin(cfg_line_breaks), std::end(cfg_line_breaks));
            uint8_t* mptr_now = mptr;
            mptr += block_len;
            if (it_lb != end) {
                LOG(debug) << ".BMNCfg - breaks offset " << (it - it_lb);
                auto it_block_start = it_lb - cfg_breaks_shift;
                if (it_block_start < mptr_now)
                    continue;   // counters block incomplete (from start) -> skip
                block_len = (end - it_block_start >= t0raw_block_len) ? t0raw_block_len : end - it_block_start;
                if (block_len < kT0_BIN_BLOCK_BYTES)
                    break;   // counters block incomplete (EOF) -> skip
 
                BmnT0Raw* lastT0 = BmnConverterTools::Process_T0Raw(reinterpret_cast<const uint32_t*>(it_block_start),
                                                                    block_len, t0raw);
                if (t0raw && lastT0)
                    if (t0raw->GetEntriesFast() && (lastT0->GetTS() > ZeroTS)) {
                        fTsMap[lastT0->GetTS()] = fTreeT0->GetEntriesFast();
                        LOG(debug2) << "Add      " << lastT0->GetTS().AsString() << "   " << fTsMap[lastT0->GetTS()];
                        fTreeT0->Fill();
                    }
            }
        } else
            break;
    }
    munmap(map, raw_file_size);
    return kBMNSUCCESS;
}