mvd/UnpackMS.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 IKF Frankfurt University, Frankfurt am Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Ajit Kumar [committer], Bartosz Sobol, Benedikt Gutsche */
 
#include "algo/detectors/mvd/UnpackMS.h"
 
#include "AlgoFairloggerCompat.h"
 
#include <cassert>
#include <cmath>
#include <iostream>
#include <limits>
#include <utility>
#include <vector>
 
using std::unique_ptr;
using std::vector;
 
 
namespace cbm::algo::mvd
{
  uint32_t frame_nbr_l = 0;
  uint32_t frame_nbr_m = 0;
  int frLen            = 0;
 
  UnpackMS::UnpackMS(const UnpackPar& pars, const uint64_t& frameLengthNs)
    : fParams(pars)
    , fFrameLengthNs(frameLengthNs)
  {
  }
 
  UnpackMS::~UnpackMS() = default;
 
 
  // ----   Algorithm execution   ---------------------------------------------
  UnpackMS::Result_t UnpackMS::operator()(const uint8_t* msContent, const fles::MicrosliceDescriptor& msDescr,
                                          const uint64_t tTimeslice) const
  {
 
    // --- Output data
    Result_t result = {};
 
    // printMsContent(msContent, msDescr.size);
 
    auto msSize             = msDescr.size / 4;  // Size in 32 bit blocks;
    const uint32_t* pInBuff = reinterpret_cast<const uint32_t*>(msContent);
 
    auto eq_idx = msDescr.eq_id;  // equipment id
 
    const uint32_t len  = msSize;
    const uint32_t* arr = pInBuff;
    unsigned int n      = 0;
    uint32_t data;
 
    for (; n < len; n++) {
      data = arr[n];
      if (data == 0xFCAAFCAA) continue;
      ProcessData(data, tTimeslice, std::get<0>(result), std::get<1>(result), std::get<2>(result), eq_idx);
    }
 
    return result;
  }
 
  // -----   Process hit message   --------------------------------------------
  void UnpackMS::ProcessData(const uint32_t& data, const uint64_t& time, std::vector<CbmMvdRawDigi>& digiVec,
                             UnpackMonitorData& /*monitor*/, UnpackAuxData& /*aux*/, uint16_t& eq_idx) const
  {
    uint32_t column = std::numeric_limits<uint32_t>::max();
    uint32_t row    = std::numeric_limits<uint32_t>::max();
 
    if ((data & 0xFF000000) == 0xFE000000) {
      headersnow++;
 
      if (headersnow == 1) {
        frame_nbr_l = data & 0xFF;
        frame_nbr_l += (data & 0xFF0000) >> 8;
      }
      else if (headersnow == 2) {
        frame_nbr_l += (data & 0xFF) << 16;
        frame_nbr_l += (data & 0xFF0000) << 8;
      }
      else if (headersnow == 3) {
        frame_nbr_m = data & 0xFF;
        frame_nbr_m += (data & 0xFF0000) >> 8;
      }
      else if (headersnow == 4) {
        frame_nbr_m += (data & 0xFF) << 16;
        frame_nbr_m += (data & 0xFF0000) << 8;
        uint64_t tmp_l = static_cast<uint64_t>(frame_nbr_l);
        uint64_t tmp_m = static_cast<uint64_t>(frame_nbr_m);
        frameTime      = (tmp_m << 32) + tmp_l;
        frLen          = 0;
      }
    }
 
    //End of frame - process frame results and error flags
    else if ((data & 0xFF00) == 0xFF00) {
      headersnow = 0;
 
      // if(frLen > 0) digiVec.emplace_back(eq_idx, 0, 0, frLen, 0.1, 0.1, frameTime-time, 0, frameTime);
    }
 
    else {
      headersnow = 0;
 
      //New region starts - save region number
      if ((data & 0xFF00) == 0xFD00) {
        int tmp = data & 0xFF;
        if (tmp > 63) return;
        region = tmp;
      }
      else {
 
        frLen++;
 
        dcd_pxl(region, data & 0xFFFF, column, row);
        int code = data & 0b111;
 
        if (code & 0b1) {
          int codeTmp = 1;
          dcd_pxl(region, ((data & 0xFFFF) + (codeTmp << 6)), column, row);
        }
 
        if (code & 0b10) {
          int codeTmp = 2;
          dcd_pxl(region, ((data & 0xFFFF) + (codeTmp << 6)), column, row);
        }
 
        if (code & 0b100) {
          int codeTmp = 3;
          dcd_pxl(region, ((data & 0xFFFF) + (codeTmp << 6)), column, row);
        }
      }
 
      //Second Hit data - decode pixel address and save
      if ((data & 0xFF000000) != 0xFC000000) {
 
        dcd_pxl(region, data >> 16, column, row);
        int code = (data >> 16) & 0b111;
 
        if (code & 0b1) {
          int codeTmp = 1;
          dcd_pxl(region, ((data >> 16) + (codeTmp << 6)), column, row);
        }
 
        if (code & 0b10) {
          int codeTmp = 2;
          dcd_pxl(region, ((data >> 16) + (codeTmp << 6)), column, row);
        }
 
        if (code & 0b100) {
          int codeTmp = 3;
          dcd_pxl(region, ((data >> 16) + (codeTmp << 6)), column, row);
        }
      }
    }
    if (std::numeric_limits<uint32_t>::max() == row && std::numeric_limits<uint32_t>::max() == column) return;
 
    if (eq_idx == 0) column = 1023 - column;  // both sensor is facing each other for mcbm
 
    // --- Create MVD address
    uint32_t address = CbmMvdAddress::GetAddress(eq_idx, 0, 0, 0, 0, 0, row, column);
    // --- Create output digi
    // => FIXME: for support of mCBM 2025, compute frame-number from frameTime and enforce frame-number reset on each TS
    // => FIXME: unprotected conversion from 64b time in TS to 32b CbmMvdRawDigi time, safe for all TS sizes < ~4.294s
    uint64_t timeInTs = frameTime - time;
    digiVec.emplace_back(address, timeInTs, timeInTs / fFrameLengthNs, frameTime);
  }
 
  void UnpackMS::dcd_pxl(const uint16_t& regionIn, const uint16_t& word, uint32_t& column, uint32_t& row) const
  {
    unsigned pixelcode = (word >> 6) & 0x3ff;
    unsigned side = 0, topdown = 0;
    if ((pixelcode & 3) == 0x1 || (pixelcode & 3) == 0x2) side = 1;
    if ((pixelcode & 3) == 0x3 || (pixelcode & 3) == 0x2) topdown = 1;
    row    = (pixelcode >> 2) * 2 + topdown;
    column = (((word >> 3) & 0x7) + regionIn * 8) * 2 + side;
  }
 
 
  // --------------------------------------------------------------------------
  void UnpackMS::printMsContent(const uint8_t* msContent, size_t size) const
  {
    for (size_t i = 0; i < size; ++i) {
      std::cout << std::hex << static_cast<int>(msContent[i]) << " ";
    }
    std::cout << std::dec << std::endl;  // Reset formatting
  }
}  // namespace cbm::algo::mvd