ReadoutClass.h

Go to the documentation of this file.

// Copyright (C) 2022 European Spallation Source, ERIC. See LICENSE file
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
#pragma once
 
#include "cluon-complete.hpp"
 
#include <string>
#include <utility>
#include <optional>
#include <random>
 
#include "Structs.h"
#include "Readout.h"
#include "enums.h"
#include "hdf_interface.h"
#include "version.hpp"
#include "efu_time.h"
#include "writer.h"
 
class RL_API Readout {
public:
  Readout(
      std::string IpAddress,
        const int UDPPort,
        const int TCPPort,
        const int Type,
        const pulse_grid grid
  ): Type(detectorType_from_int(Type)),
     ipaddr(std::move(IpAddress)),
     port(UDPPort),
     tcp_port(TCPPort),
     grid(grid),
     period(grid.period()),
     sender{ipaddr, static_cast<uint16_t>(UDPPort)}
  {
//    sockOpen(ipaddr, port);
    hp = (PacketHeaderV0*)&buffer[0];
    set_pulse(grid.at_or_before(efu_time::now_nanoseconds()));
    newPacket();
  }
 
  Readout(
      std::string IpAddress,
        const int UDPPort,
        const int TCPPort,
        const int Type=0x34,
        const efu_time p = efu_time(1)
  ): Readout(std::move(IpAddress), UDPPort, TCPPort, Type, pulse_grid::from_period(p)) {}
 
  ~Readout() {
    // ensure any buffered data is sent before the object is destroyed
    send();
    report_long_tof();
  }
 
  void addReadout(uint8_t Ring, uint8_t FEN, double tof, double weight, const void * data);
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const void * data);
  // Specializations for handled data types
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const CAEN_readout_t * data);
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const CDT_readout_t * data);
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const VMM3_readout_t * data);
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const BM0_readout_t * data);
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const BM2_readout_t * data);
  void addReadout(uint8_t Ring, uint8_t FEN, efu_time t, const BMI_readout_t * data);
 
  int send();
 
  void setPulseTime(uint32_t PHI, uint32_t PLO, uint32_t PPHI, uint32_t PPLO);
 
  void update_time(){
    send();
    // the latest pulse on the grid; the previous one a period before it, as for a
    // continuously pulsed source (the CAEN EFUs reject a gap of more than five)
    set_pulse(grid.at_or_before(efu_time::now_nanoseconds()));
    newPacket();
  }
 
  // Query the current pulse and previous pulse times
  [[nodiscard]] std::pair<uint32_t, uint32_t> lastPulseTime() const;
  [[nodiscard]] std::pair<uint32_t, uint32_t> prevPulseTime() const;
  [[nodiscard]] std::pair<uint32_t, uint32_t> lastEventTime() const;
 
  void newPacket();
 
  int command_shutdown() const;
 
  int verbose(const Verbosity v){
    switch (v) {
      case Verbosity::details: verbosity=3; break;
      case Verbosity::info: verbosity=2; break;
      case Verbosity::warnings: verbosity=1; break;
      case Verbosity::errors: verbosity=0; break;
      case Verbosity::silent: verbosity=-1; break;
      default: verbosity=0;
    }
    return verbosity;
  }
  int verbose(const int v){verbosity = v; return verbosity;}
 
  void dump_to(const std::string & filename, const std::string & dataset_name = "events");
 
  void fold_tof(const bool fold) { fold_tof_ = fold; }
  [[nodiscard]] uint64_t long_tof_count() const { return long_tof_; }
 
  void output_queue(const int queue) {
    OutputQueue = queue;
    hp->OutputQueue = static_cast<uint8_t>(queue);
  }
  [[nodiscard]] int output_queue() const { return OutputQueue; }
  [[nodiscard]] int sequence_number() const { return SeqNum; }
 
  void enable_network() {network = true;}
  void disable_network() {network = false;}
 
  void set_random_seed(const uint32_t seed) {
    random_engine.seed(seed);
  }
 
  int random_poisson(const double mean) {
    std::poisson_distribution<int> distribution(mean);
    return distribution(random_engine);
  }
 
private:
  HighFive::CompoundType datatype() const {
    return ::hdf_compound_type(readoutType_from_detectorType(Type));
  }
 
  void check_size_and_send();
 
  // Packet header
  uint32_t phi{0}; // pulse and prev pulse high and low
  uint32_t plo{0};
  uint32_t pphi{0};
  uint32_t pplo{0};
 
  uint32_t lasthi{0};
  uint32_t lastlo{0};
 
  int SeqNum{0};
  int OutputQueue{0};
  DetectorType Type;
 
  // TX Buffer
  PacketHeaderV0 *hp{};
  char buffer[9000]{};
  const int MaxDataSize{8950};
  int DataSize{0};
  // IP and port number
  std::string ipaddr;
  int port{9000};
  int tcp_port{8888};
  int verbosity{0};
 
  std::optional<Writer> writer{std::nullopt};
  bool network{true};
  bool fold_tof_{false};
  uint64_t long_tof_{0};
  void report_long_tof() const;
  pulse_grid grid;
  efu_time period, time;
  cluon::UDPSender sender;
 
  void set_pulse(const uint64_t ns) {
    time = efu_time::from_nanoseconds(ns);
    const auto prev = efu_time::from_nanoseconds(ns - grid.period_ns());
    setPulseTime(time.high(), time.low(), prev.high(), prev.low());
  }
 
  std::mt19937 random_engine{std::default_random_engine{}()};
};