CDCTrigger2DFinderFirmwareModule.h

#pragma once
#include <framework/core/Module.h>
#include <trg/cdc/Cosim.h>
 
#include <string>
#include <cstring>
#include <iostream>
#include <vector>
#include <bitset>
#include <array>
 
#include <unistd.h>
 
#include "trg/cdc/modules/houghtracking/xsi_loader.h"
 
namespace Belle2 {
  class CDCTriggerSegmentHit;
 
  using tsOut = std::array<unsigned, 4>;
  using tsOutArray = std::array<tsOut, 5>;
  struct TRGFinderTrack {
    double omega;
    double phi0;
    tsOutArray ts;
  };
 
  class CDCTrigger2DFinderFirmwareModule : public Module {
  public:
    CDCTrigger2DFinderFirmwareModule();
 
    virtual ~CDCTrigger2DFinderFirmwareModule();
 
    void initialize() override;
 
    void event() override;
 
  protected:
    std::string m_hitCollectionName;
 
    std::string m_outputCollectionName;
 
    std::string m_bitstreamNameTo2D;
 
    bool m_fromFastSim = false;
 
    int m_nClockPerEvent = 32;
 
    int m_debugLevel  = 0;
 
    static const int m_tsVectorWidth = 21;
 
    static const int m_nInTSPerClock = 10;
 
    static const int m_nOutTracksPerClock = 4;
 
    using tsVector = std::array<char, m_tsVectorWidth>;
 
    int localSegmentID(int globalID);
 
    /* std::bitset<m_tsVectorWidth> encodeTSHit(CDCTriggerSegmentHit const *); */
    auto encodeTSHit(CDCTriggerSegmentHit const*);
 
    auto toTSSLV(const std::bitset<m_tsVectorWidth>);
 
    TRGFinderTrack decodeTrack(std::string trackIn);
 
    void decodeOutput(short latency);
 
    std::string lib_extension = ".so";
    std::string cwd = getcurrentdir();
    std::string design_libname = cwd + "/xsim.dir/t2d/xsimk" + lib_extension;
    std::string simengine_libname = "librdi_simulator_kernel" + lib_extension;
 
    Xsi::Loader* Xsi_Instance;
    s_xsi_setup_info info; // How should this be initialized?
 
    static const int width_in = 219;
    static const int width_out = 732;
 
    static constexpr int nAxialSuperLayer = 5;
    using tsArrayPerSL = std::vector<std::bitset<m_tsVectorWidth> >;
    using tsArrayPerClock = std::array<tsArrayPerSL, nAxialSuperLayer>;
    using tsArray = std::vector<tsArrayPerClock>;
 
    tsArray m_tsHitVector;
 
    using inputVector = std::array<char, width_in>;
    std::array<inputVector, 5> tsfInput;
 
    std::array<char, width_out> finderOutput;
 
    char t2d_out[width_out] = {};
 
    int clk = 0;
    int tsfPort[5] = {0};
    int out = 0;
 
    void initializeFastSim();
 
    void loadFromFirmware(int iclock);
 
    void loadFromFastSim(unsigned iclock);
 
  };
}