RawCOPPER.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#ifndef RAWCOPPER_H
#define RAWCOPPER_H
 
// Includes
#include <stdio.h>
 
#include <rawdata/dataobjects/RawDataBlock.h>
#include <rawdata/dataobjects/RawDataBlockFormat.h>
#include <rawdata/dataobjects/RawCOPPERFormat.h>
#include <rawdata/dataobjects/RawCOPPERFormat_latest.h>
#include <rawdata/dataobjects/RawCOPPERFormat_v0.h>
#include <rawdata/dataobjects/RawCOPPERFormat_v1.h>
#include <rawdata/dataobjects/RawCOPPERFormat_v2.h>
#include <rawdata/dataobjects/PreRawCOPPERFormat_v1.h>
#include <rawdata/dataobjects/PreRawCOPPERFormat_v2.h>
#include <rawdata/dataobjects/PreRawCOPPERFormat_latest.h>
#include <rawdata/RawCOPPERPackerInfo.h>
 
//#define USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
 
 
// Divide ECL and KLM to barrel and endcap categories from Itoh-san's suggestion
// Updated on May 9, 2014
 
//
// The latest DAQformat version number
#define LATEST_POSTREDUCTION_FORMAT_VER 4 // Since Aug. 18, 2020
//
 
 
namespace Belle2 {
  class RawCOPPER : public RawDataBlock {
  public:
    RawCOPPER();
 
    //RawCOPPER(int* bufin, int nwords);
    virtual ~RawCOPPER();
 
    //
    // Get position of or pointer to data
    //
 
    /* cppcheck-suppress missingOverride */
    void SetBuffer(int* bufin, int nwords, int delete_flag, int num_events, int num_nodes) OVERRIDE_CPP17;
 
    // POINTER TO "DETECTOR BUFFER"
    //( after removing "B2link headers" from "FINESSE buffer". THIS IS THE RAW DATA FROM A DETECTOR
    int GetDetectorNwords(int n, int finesse_num);
 
    int Get1stDetectorNwords(int n);
 
    int Get2ndDetectorNwords(int n);
 
    int Get3rdDetectorNwords(int n);
 
    int Get4thDetectorNwords(int n);
 
    int* GetDetectorBuffer(int n, int finesse_num);
 
    int* Get1stDetectorBuffer(int n);
 
    int* Get2ndDetectorBuffer(int n);
 
    int* Get3rdDetectorBuffer(int n);
 
    int* Get4thDetectorBuffer(int n);
 
    /* cppcheck-suppress missingOverride */
    virtual int GetBufferPos(int n) OVERRIDE_CPP17;
 
    virtual int* GetRawHdrBufPtr(int n);
 
    virtual int* GetRawTrlBufPtr(int n);
 
    int* GetFINESSEBuffer(int n, int finesse_num);
 
    int* Get1stFINESSEBuffer(int n);
 
    int* Get2ndFINESSEBuffer(int n);
 
    int* Get3rdFINESSEBuffer(int n);
 
    int* Get4thFINESSEBuffer(int n);
 
 
    //
    // Get information from "RawCOPPER header" attached by DAQ software
    //
 
    int GetExpNo(int n);    
 
    unsigned int GetExpRunSubrun(int n);    
 
    int GetRunNo(int n);    
 
    int GetSubRunNo(int n);    
 
    unsigned int GetEveNo(int n);    
 
    int GetDataType(int n);    
 
    int GetTruncMask(int n);    
 
    unsigned int GetErrorBitFlag(int n);
 
    void AddErrorBitFlag(int n, unsigned int error_bit_flag);
 
 
    int GetPacketCRCError(int n);
 
    int GetEventCRCError(int n);
 
    int GetEventCRC16Value(int n, int finesse_num);
 
    unsigned int GetNodeID(int n);
 
    //
    // Get information from 13words "COPPER header" attached by COPPER board
    //
    virtual unsigned int GetCOPPERCounter(int n);
 
    virtual int GetNumFINESSEBlock(int n);
 
    int GetOffsetFINESSE(int n, int finesse);
 
    int GetOffset1stFINESSE(int n);
 
    int GetOffset2ndFINESSE(int n);
 
    int GetOffset3rdFINESSE(int n);
 
    int GetOffset4thFINESSE(int n);
 
    int GetFINESSENwords(int n, int finesse);
 
    int Get1stFINESSENwords(int n);
 
    int Get2ndFINESSENwords(int n);
 
    int Get3rdFINESSENwords(int n);
 
    int Get4thFINESSENwords(int n);
 
    //
    // Get information from "B2link(attached by FEE and HLSB) header"
    //
    //    virtual int* GetFTSW2Words(int n);
 
    virtual int* GetExpRunSubrunBuf(int n);
 
    virtual unsigned int GetB2LFEE32bitEventNumber(int n);
 
    //
    // read magic word to check data
    //
    unsigned int GetMagicDriverHeader(int n);
 
    unsigned int GetMagicFPGAHeader(int n);
 
    unsigned int GetMagicFPGATrailer(int n);
 
    unsigned int GetMagicDriverTrailer(int n);
 
    unsigned int GetTrailerChksum(int  n);
 
    bool CheckCOPPERMagic(int n);
 
#ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
    void CheckB2LFEEHeaderVersion(int  n);
#endif
 
    unsigned int GetTTCtimeTRGType(int n);
 
    unsigned int GetTTUtime(int n);
 
    unsigned int FillTopBlockRawHeader(unsigned int m_node_id,
                                       unsigned int prev_eve32, unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no);
 
    unsigned int GetDriverChkSum(int n);
 
    unsigned int CalcDriverChkSum(int n);
 
    unsigned int CalcXORChecksum(int* buf, int nwords);
 
    void CheckData(int n,
                   unsigned int prev_evenum, unsigned int* cur_evenum,
                   unsigned int prev_copper_ctr, unsigned int* cur_copper_ctr,
                   unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no);
 
    void CheckUtimeCtimeTRGType(int n);
 
    int GetTTCtime(int n);
 
    int GetTRGType(int n);
 
    void GetTTTimeVal(int n, struct timeval* tv);
 
    void SetVersion();
 
    void SetVersion(std::string class_name);
 
    void CheckVersionSetBuffer();
 
    void ShowBuffer();
 
    void PackDetectorBuf(int* detector_buf_1st, int nwords_1st,
                         int* detector_buf_2nd, int nwords_2nd,
                         int* detector_buf_3rd, int nwords_3rd,
                         int* detector_buf_4th, int nwords_4th,
                         RawCOPPERPackerInfo rawcprpacker_info);
 
    void PackDetectorBuf4DummyData(int* detector_buf_1st, int nwords_1st,
                                   int* detector_buf_2nd, int nwords_2nd,
                                   int* detector_buf_3rd, int nwords_3rd,
                                   int* detector_buf_4th, int nwords_4th,
                                   RawCOPPERPackerInfo rawcprpacker_info);
 
    void PackDetectorBuf(int* const(&detector_buf_ch)[MAX_PCIE40_CH],
                         int const(&nwords_ch)[MAX_PCIE40_CH],
                         RawCOPPERPackerInfo  rawcprpacker_info);
 
    int GetMaxNumOfCh(int n);
 
    void CompareHeaderValue(int n, const unsigned int (&input_val)[MAX_PCIE40_CH] , std::vector<std::vector< unsigned int>>& result);
 
    std::string getInfoHTML() const;
 
    enum {
      POS_FORMAT_VERSION = 1,
      FORMAT_MASK = 0x0000FF00
    };
 
    RawCOPPERFormat* m_access; 
 
    int m_version; 
 
  protected :
    ClassDefOverride(RawCOPPER, 3);
 
  };
 
 
  inline int* RawCOPPER::GetRawHdrBufPtr(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetRawHdrBufPtr(n);
  }
 
  inline int* RawCOPPER::GetRawTrlBufPtr(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetRawTrlBufPtr(n);
  }
 
  inline unsigned int RawCOPPER::GetDriverChkSum(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetDriverChkSum(n);
  }
 
  inline int RawCOPPER::GetExpNo(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetExpNo(n);
  }
 
  inline unsigned int RawCOPPER::GetExpRunSubrun(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetExpRunSubrun(n);
  }
 
  inline int RawCOPPER::GetRunNo(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetRunNo(n);
  }
 
 
  inline int RawCOPPER::GetSubRunNo(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetSubRunNo(n);
  }
 
  inline unsigned int RawCOPPER::GetEveNo(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetEveNo(n);
  }
 
 
  inline unsigned int RawCOPPER::GetNodeID(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetNodeID(n);
  }
 
 
  inline int RawCOPPER::GetDataType(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetDataType(n);
  }
 
  inline int RawCOPPER::GetTruncMask(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetTruncMask(n);
  }
 
  inline unsigned int RawCOPPER::GetErrorBitFlag(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetErrorBitFlag(n);
  }
 
  inline void RawCOPPER::AddErrorBitFlag(int n, unsigned int error_bit_flag)
  {
    CheckVersionSetBuffer();
    return m_access->AddErrorBitFlag(n, error_bit_flag);
  }
 
  inline int RawCOPPER::GetPacketCRCError(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetPacketCRCError(n);
  }
 
  inline int RawCOPPER::GetEventCRCError(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetEventCRCError(n);
  }
 
  inline int RawCOPPER::GetEventCRC16Value(int n, int finesse_num)
  {
    CheckVersionSetBuffer();
    return m_access->GetEventCRC16Value(n, finesse_num);
  }
 
  inline unsigned int RawCOPPER::GetCOPPERCounter(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetCOPPERCounter(n);
  }
 
  inline int RawCOPPER::Get1stDetectorNwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get1stDetectorNwords(n);
  }
 
  inline int RawCOPPER::Get2ndDetectorNwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get2ndDetectorNwords(n);
  }
 
  inline int RawCOPPER::Get3rdDetectorNwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get3rdDetectorNwords(n);
  }
 
  inline int RawCOPPER::Get4thDetectorNwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get4thDetectorNwords(n);
  }
 
  inline int RawCOPPER::Get1stFINESSENwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get1stFINESSENwords(n);
  }
 
  inline int RawCOPPER::Get2ndFINESSENwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get2ndFINESSENwords(n);
  }
 
  inline int RawCOPPER::Get3rdFINESSENwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get3rdFINESSENwords(n);
  }
 
  inline int RawCOPPER::Get4thFINESSENwords(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get4thFINESSENwords(n);
  }
 
  inline int RawCOPPER::GetOffset1stFINESSE(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetOffset1stFINESSE(n);
  }
 
  inline int RawCOPPER::GetOffset2ndFINESSE(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetOffset2ndFINESSE(n);
  }
 
  inline int RawCOPPER::GetOffset3rdFINESSE(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetOffset3rdFINESSE(n);
  }
 
  inline int RawCOPPER::GetOffset4thFINESSE(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetOffset4thFINESSE(n);
  }
 
  inline int* RawCOPPER::Get1stFINESSEBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get1stFINESSEBuffer(n);
  }
 
  inline int* RawCOPPER::Get2ndFINESSEBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get2ndFINESSEBuffer(n);
  }
 
  inline int* RawCOPPER::Get3rdFINESSEBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get3rdFINESSEBuffer(n);
  }
 
  inline int* RawCOPPER::Get4thFINESSEBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get4thFINESSEBuffer(n);
  }
 
  inline int* RawCOPPER::Get1stDetectorBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get1stDetectorBuffer(n);
  }
 
  inline int* RawCOPPER::Get2ndDetectorBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get2ndDetectorBuffer(n);
  }
 
  inline int* RawCOPPER::Get3rdDetectorBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get3rdDetectorBuffer(n);
  }
 
  inline int* RawCOPPER::Get4thDetectorBuffer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->Get4thDetectorBuffer(n);
  }
 
  inline int* RawCOPPER::GetExpRunSubrunBuf(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetExpRunSubrunBuf(n);
  }
 
  inline unsigned int RawCOPPER::GetMagicDriverHeader(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetMagicDriverHeader(n);
  }
 
  inline unsigned int RawCOPPER::GetMagicFPGAHeader(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetMagicFPGAHeader(n);
  }
 
  inline unsigned int RawCOPPER::GetMagicFPGATrailer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetMagicFPGATrailer(n);
  }
 
  inline unsigned int RawCOPPER::GetMagicDriverTrailer(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetMagicDriverTrailer(n);
  }
 
  inline unsigned int RawCOPPER::GetTrailerChksum(int  n)
  {
    CheckVersionSetBuffer();
    return m_access->GetTrailerChksum(n);
  }
 
  inline unsigned int RawCOPPER::GetTTCtimeTRGType(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetTTCtimeTRGType(n);
  }
 
  inline unsigned int RawCOPPER::GetTTUtime(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetTTUtime(n);
  }
 
  inline int RawCOPPER::GetTTCtime(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetTTCtime(n);
  }
 
  inline int RawCOPPER::GetTRGType(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetTRGType(n);
  }
 
  inline void RawCOPPER::GetTTTimeVal(int n, struct timeval* tv)
  {
    CheckVersionSetBuffer();
    return m_access->GetTTTimeVal(n, tv);
  }
 
  inline int RawCOPPER::GetBufferPos(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetBufferPos(n);
  }
 
  inline   unsigned int RawCOPPER::CalcDriverChkSum(int n)
  {
    CheckVersionSetBuffer();
    return m_access->CalcDriverChkSum(n);
  }
 
 
  inline  int RawCOPPER::GetNumFINESSEBlock(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetNumFINESSEBlock(n);
  }
 
  inline  int RawCOPPER::GetDetectorNwords(int n, int finesse_num)
  {
    CheckVersionSetBuffer();
    return m_access->GetDetectorNwords(n, finesse_num);
  }
 
  inline  int RawCOPPER::GetFINESSENwords(int n, int finesse_num)
  {
    CheckVersionSetBuffer();
    return m_access->GetFINESSENwords(n, finesse_num);
  }
 
  inline  int RawCOPPER::GetOffsetFINESSE(int n, int finesse_num)
  {
    CheckVersionSetBuffer();
    return m_access->GetOffsetFINESSE(n, finesse_num);
  }
 
  inline  int* RawCOPPER::GetFINESSEBuffer(int n, int finesse_num)
  {
    CheckVersionSetBuffer();
    return m_access->GetFINESSEBuffer(n, finesse_num);
  }
 
  inline  int* RawCOPPER::GetDetectorBuffer(int n, int finesse_num)
  {
    CheckVersionSetBuffer();
    return m_access->GetDetectorBuffer(n, finesse_num);
  }
 
  inline  unsigned int RawCOPPER::GetB2LFEE32bitEventNumber(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetB2LFEE32bitEventNumber(n);
  }
 
  inline  unsigned int RawCOPPER::CalcXORChecksum(int* buf, int nwords)
  {
    CheckVersionSetBuffer();
    return m_access->CalcXORChecksum(buf, nwords);
  }
 
  inline  void RawCOPPER::CheckData(int n,
                                    unsigned int prev_evenum, unsigned int* cur_evenum_rawcprhdr,
                                    unsigned int prev_copper_ctr, unsigned int* cur_copper_ctr,
                                    unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
  {
 
    CheckVersionSetBuffer();
    m_access->CheckData(n,
                        prev_evenum, cur_evenum_rawcprhdr,
                        prev_copper_ctr, cur_copper_ctr,
                        prev_exprunsubrun_no,  cur_exprunsubrun_no);
    return;
  }
 
  inline  bool RawCOPPER::CheckCOPPERMagic(int n)
  {
    CheckVersionSetBuffer();
    return m_access->CheckCOPPERMagic(n);
  }
 
  inline  void RawCOPPER::CheckUtimeCtimeTRGType(int n)
  {
    CheckVersionSetBuffer();
    return m_access->CheckUtimeCtimeTRGType(n);
  }
 
  inline  unsigned int RawCOPPER::FillTopBlockRawHeader(unsigned int m_node_id, unsigned int prev_eve32,
                                                        unsigned int prev_exprunsubrun_no, unsigned int* cur_exprunsubrun_no)
  {
    CheckVersionSetBuffer();
    return m_access->FillTopBlockRawHeader(m_node_id, prev_eve32,
                                           prev_exprunsubrun_no, cur_exprunsubrun_no);
  }
 
#ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
  inline  void RawCOPPER::CheckB2LFEEHeaderVersion(int n)
  {
    CheckVersionSetBuffer();
    return m_access->CheckB2LFEEHeaderVersion(n);
  }
#endif
 
  inline void RawCOPPER::CheckVersionSetBuffer()
  {
    if (((m_buffer[ POS_FORMAT_VERSION ] & FORMAT_MASK) >> 8)  != m_version
        || m_access == NULL) {
      SetVersion();
    }
    m_access->SetBuffer(m_buffer, m_nwords, 0, m_num_events, m_num_nodes);
  }
 
  inline int RawCOPPER::GetMaxNumOfCh(int n)
  {
    CheckVersionSetBuffer();
    return m_access->GetMaxNumOfCh(n);
  }
 
}
 
#endif