loadstream.hpp

Go to the documentation of this file.

// ╭─╮╭─╴╷╭─╮┌─╮
// ╰─╯╵  ╵╰─╯╵ ╵
#pragma once
 
#include <vector>
#include <span>
#include <map>
 
#include <iostream>
#include <fstream>
#include <string>
#include<functional>
 
#include "itk/logger.hpp"
 
namespace itk::fragment {
 
extern itk::Logger log;
 
 
struct Hit {
  uint16_t col;
  uint16_t row;
  uint16_t tot;
};
 
struct SimData {
  uint32_t stream_id;
  std::vector<Hit> hits;
  std::vector<uint64_t> stream;
};
 
 
void sort_sims(std::map<uint32_t, SimData>& sims) {
 
  for (auto &[id, sim] : sims) {
    // sort hits in (row, col, tot) order
    std::sort(sim.hits.begin(), sim.hits.end(),
      [](const Hit& a, const Hit& b) {
        uint64_t aval = uint64_t(a.row) << 32 | a.col << 16 | a.tot;
        uint64_t bval = uint64_t(b.row) << 32 | b.col << 16 | b.tot;
        return aval < bval;
      });
  }
}
 
 
void remove_bad_sims(std::map<uint32_t, SimData>& sims) {
 
  std::vector<uint32_t> ids;
 
  for (auto &[id, sim] : sims) {
    // sim.hits should be already sorted
    uint64_t prev_val = -1;
    for (auto& hit : sim.hits) {
      uint64_t val = uint64_t(hit.row) << 32 | hit.col << 16;
      if (prev_val == val) {
        ids.push_back(sim.stream_id);
        log.error("stream_id: 0x{:x} | duplicated pixel [col: {:3}, row: {:3}]",
          sim.stream_id, int(hit.col), int(hit.row), int(hit.tot));
        break;
      }
      prev_val = val;
    }
  }
 
  for (auto id : ids) sims.erase(id);
 
  log.warn("Removed bad streams due to duplicated pixel hits: {}", ids.size());
}
 
 
std::map<uint32_t, SimData> load_stream(const std::string& fname) {
  std::fstream fin;
 
  std::map<uint32_t, SimData> sims;
 
  // // Open file for writing
  // fout.open("xyz.txt", ios::out); 
 
  // // Checking if open.
  // if (fout.is_open()) {
  //     fout << "My Function \n";
  //     fout.close();
  // }
 
  fin.open(fname, std::ios::in); 
 
  if (!fin.is_open()) {
    log.error("cannot open file.");
    return std::map<uint32_t, SimData>{};
  }
 
  std::string line;
  int prev_stream_id = -1;
  int prev_chip_id   = -1;
 
  while (getline(fin, line)) {
    std::string str;
    char s[200];
    char sid[200] = "";
    char stype[200] = "";
    char spix[200];
    uint32_t stream_id = -1;
    std::sscanf(line.c_str(), "%s %x %s", sid, &stream_id, stype);
 
    if (strcmp(sid, "OnlineID:") != 0) continue;
 
    auto& sim = sims[stream_id];
    sim.stream_id = stream_id;
 
 
    if (strcmp(stype, "pixelID:") == 0) {
 
        char schip[200];
        char scol[200];
        char srow[200];
        char stot[200];
        uint64_t pix_id;
        int chip_id, col, row, tot;
 
        stream_id = -1;
        chip_id   = -1;
        // OnlineID: 0x11191002 pixelID: 0x44644391b000000 IDoff: 0x446440000000000 Chip: 2  ToT: 5 col: 216  row: 114
        std::sscanf(line.c_str(), "%s %x %s %s %s %s %s %x %s %d %s %d %s %d",
          sid, &stream_id, spix, s, s, s, schip, &chip_id, stot, &tot, scol, &col, srow, &row);
        if (strcmp(scol, "col:") != 0 or strcmp(srow, "row:") != 0 or strcmp(stot, "ToT:") != 0) {
          log.error("incorrect line: {}", line);
          return std::map<uint32_t, SimData>{};
        }
        if (stream_id == -1 || chip_id == -1) {
          log.error("undefined stream: {} or chip: {}", stream_id, chip_id);
          abort();
        }
        if (stream_id == prev_stream_id && chip_id != prev_chip_id) {
          log.error("chip id mismatch");
          abort();
        }
        // log.info("{} {:3} | {} {:3} | {} {:2}", scol, col, srow, row, stot, tot);
        sim.hits.emplace_back(col, row, tot);
    } else
    if (strcmp(stype, "Stream:") == 0) {
      char sstr[200];
      char shex[200];
        // OnlineID: 0x1012c800 Stream: a9883017 35cb4300 
      auto buff = line.c_str();
      int cnt = 0;
      std::sscanf(buff, "%s %x %s %n", sid, &stream_id, sstr, &cnt);
      buff += cnt;
 
      // log.info("{} 0x{:x} | {} {}", sid, stream_id, sstr, buff);
 
      std::vector<uint64_t> stream;
      uint64_t data64 = 0;
      int i = 0;
      while (true) {
        cnt = 0;
        std::sscanf(buff, " %s%n", shex, &cnt);
        if (cnt == 0) break;
        buff += cnt;
        uint32_t data = strtol(shex, NULL, 16);
        // log.info("  {} | 0x{:08x}", shex, data);
        data64 = data64 << 32 | data;
        if (i % 2 == 1) stream.push_back(data64);
        i++;
      }
 
      sim.stream = std::move(stream);
 
      for (auto data : stream) {
        // log.info("  0x{:016x}", data);
      }
    } else {
      log.warn("line: {}", line);
    }
  } // while
 
  // Close the file object.
  fin.close();
 
  sort_sims(sims);
  remove_bad_sims(sims);
 
  for (auto &[id, sim] : sims) {
 
    log.trace("id: 0x{:08x} hits.count: {}, stream.size: {}", id, sim.hits.size(), sim.stream.size());
  }
  log.debug("sims.size: {}", sims.size());
 
 
  return sims;
}
 
 
 
 
} // itk::fragment