RawHeader_v0.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 RAWHEADER_V0_H
#define RAWHEADER_V0_H
 
#include <stdio.h>
#include <string.h>
#include <rawdata/switch_basf2_standalone.h>
 
//#include <framework/datastore/DataStore.h>
 
 
//#define HEADER_SIZE 16
 
namespace Belle2 {

 
  //  class RawHeader_v0 : public TObject {
  class RawHeader_v0  {
  public:
    RawHeader_v0();

    explicit RawHeader_v0(int*);

    ~RawHeader_v0();

    int* GetBuffer() { return m_buffer; }

    void SetBuffer(int* bufin) { m_buffer = bufin; }

    void CheckSetBuffer();

    void CheckGetBuffer();

    void Initialize();

    void SetNwords(int nwords);

    void SetEveNo(unsigned int eve_no);    
 
    void SetNodeID(unsigned int node_id);    
 
    void SetDataType(int data_type);    
 
    void SetTruncMask(int trunc_mask);    
 
    //    void SetB2LFEEHdrPart(unsigned int word1, unsigned int word2);   //! set contents of header
    //     void SetFTSW2Words(int* ftsw_buf);

    void SetFTSW2Words(unsigned int word1, unsigned int word2);

    void SetExpRunNumber(int* exprun_buf);

    void SetOffset1stFINESSE(int offset_1st_FINESSE);    
 
    void SetOffset2ndFINESSE(int offset_2nd_FINESSE);    
 
    void SetOffset3rdFINESSE(int offset_3rd_FINESSE);    
 
    void SetOffset4thFINESSE(int offset_4th_FINESSE);    
 
    void SetMagicWordEntireHeader(); 

    int AddNodeInfo(int node_id);

    int GetNwords();  
 
    int GetHdrNwords();  
 
    unsigned int GetExpRunSubrun(); 
 
    int GetExpNo();  
 
    int GetRunNo();    
 
    int GetSubRunNo();    
 
    unsigned int GetEveNo();  
 
    unsigned int GetNodeID();  
 
    int GetDataType();  
 
    int GetTruncMask();  

    unsigned int GetErrorBitFlag();

    void AddErrorBitFlag(unsigned int error_bit_flag);

    int GetOffset1stFINESSE();

    int GetOffset2ndFINESSE();

    int GetOffset3rdFINESSE();

    int GetOffset4thFINESSE();

    int GetNumNodes();

    int GetNodeInfo(int node_no, int* node_id);

    unsigned int GetTTCtimeTRGType();

    int GetTTCtime();

    int GetTRGType();

    unsigned int GetTTUtime();

    void GetTTTimeVal(struct  timeval* tv);

    unsigned int GetMagicWordEntireHeader();
 
    /*
      Experimental(10bit) #, Run#(14bit), restat# bit mask(8bit)
    */
    enum {
      FORMAT_VERSION__MASK = 0x0000FF00,
      FORMAT_VERSION_SHIFT = 8
    };
 
    enum {
      EXP_MASK = 0xFFC00000,
      EXP_SHIFT = 22,
      RUNNO_MASK = 0x003FFF00,
      RUNNO_SHIFT = 8,
      SUBRUNNO_MASK = 0x000000FF
    };
 
    enum {
      RAWHEADER_NWORDS = 20
    };
 
    /* Data Format : Fixed length part*/
    enum {
      POS_NWORDS = 0,
      POS_HDR_NWORDS = 1,
      POS_EXP_RUN_NO = 2,
      POS_EVE_NO = 3,
      POS_TTCTIME_TRGTYPE = 4,
      POS_TTUTIME = 5,
      POS_NODE_ID = 6,
      POS_TRUNC_MASK_DATATYPE = 7,
      POS_OFFSET_1ST_FINESSE = 8,
      POS_OFFSET_2ND_FINESSE = 9,
      POS_OFFSET_3RD_FINESSE = 10,
      POS_OFFSET_4TH_FINESSE = 11,
      POS_RESVD_1 = 12,
      POS_RESVD_2 = 13,
      POS_NUM_NODES = 14,
      POS_NODES_1 = 15,
      POS_NODES_2 = 16,
      POS_NODES_3 = 17,
      POS_NODES_4 = 18,
      POS_TERM_HEADER = 19
    };
    /* Data Format : Node info */
    enum {
      NUM_MAX_NODES = 4   /* (NUM_MAX_NODES + 1) slots are available in m_buffer.
         (NUM_MAX_NODES +1 )th slot is filled with -1, when the number of total nodes
         exceeds NUM_MAX_NODES */
    };
 
    /* Data Format : Magic word */
    enum {
      MAGIC_WORD_TERM_HEADER = 0x7fff0005
    };
 
    /* To extract ctime */
    enum {
      TTCTIME_MASK = 0x7FFFFFF0,
      TTCTIME_SHIFT = 4,
      TRGTYPE_MASK = 0xF
    };
 
  private:
    int* m_buffer; 

    // ver.2 Do not record m_buffer pointer. (Dec.19, 2014)
    //    ClassDef(RawHeader_v0, 2);
  };
 
 
  inline void RawHeader_v0::CheckSetBuffer()
  {
    if (m_buffer == NULL) {
      B2FATAL("m_buffer is NULL. Exiting...");
    }
  }
 
  inline void RawHeader_v0::CheckGetBuffer()
  {
    if (m_buffer == NULL) {
      B2FATAL("m_buffer is NULL. Data is corrupted or header info has not yet filled. Exiting...");
    } else if (m_buffer[ POS_TERM_HEADER ] != MAGIC_WORD_TERM_HEADER) {
      B2FATAL("magic word is invalid(0x" << std::hex << m_buffer[ POS_TERM_HEADER ] << "," << m_buffer << " pos " << std::dec <<
              POS_TERM_HEADER
              << "). Data is corrupted or header info has not yet filled. Exiting...");
    }
  }
 
 
 
//
// Set info.
//
  inline void RawHeader_v0::Initialize()
  {
    CheckSetBuffer();
    memset(m_buffer, 0, sizeof(int)*RAWHEADER_NWORDS);
    m_buffer[ POS_HDR_NWORDS ] = RAWHEADER_NWORDS;
    m_buffer[ POS_NUM_NODES ] = 0;
 
  }
 
  inline void RawHeader_v0::SetMagicWordEntireHeader()
  {
    m_buffer[ POS_TERM_HEADER ] = MAGIC_WORD_TERM_HEADER;
  }
 
  inline void RawHeader_v0::SetNwords(int nwords)
  {
    CheckSetBuffer();
    m_buffer[ POS_NWORDS ] = nwords;
 
  }
 
  inline void RawHeader_v0::SetEveNo(unsigned int eve_no)
  {
    CheckSetBuffer();
    m_buffer[ POS_EVE_NO ] = eve_no;
  }
 
  inline void RawHeader_v0::SetNodeID(unsigned int node_id)
  {
    CheckSetBuffer();
    m_buffer[ POS_NODE_ID ] = node_id;
  }
 
  inline void RawHeader_v0::SetDataType(int data_type)
  {
    CheckSetBuffer();
    m_buffer[ POS_TRUNC_MASK_DATATYPE ] =
      (data_type & 0x7FFFFFFF) | (m_buffer[ POS_TRUNC_MASK_DATATYPE ] & 0x80000000);
  }
 
  inline void RawHeader_v0::SetTruncMask(int trunc_mask)
  {
    CheckSetBuffer();
    /* cppcheck-suppress shiftTooManyBitsSigned */
    m_buffer[ POS_TRUNC_MASK_DATATYPE ] = (trunc_mask << 31) | (m_buffer[ POS_TRUNC_MASK_DATATYPE ] & 0x7FFFFFFF);
  }
 
  /*   inline void RawHeader_v0::SetB2LFEEHdrPart(unsigned int word1, unsigned int word2) */
  /*   { */
  /*     m_buffer[ POS_HSLB_1 ] = word1; */
  /*     m_buffer[ POS_HSLB_2 ] = word2; */
  /*   } */
 
 
  inline void RawHeader_v0::SetOffset1stFINESSE(int offset_1st_FINESSE)
  {
    CheckSetBuffer();
    m_buffer[ POS_OFFSET_1ST_FINESSE ] = offset_1st_FINESSE;
  }
 
  inline void RawHeader_v0::SetOffset2ndFINESSE(int offset_2nd_FINESSE)
  {
    CheckSetBuffer();
    m_buffer[ POS_OFFSET_2ND_FINESSE ] = offset_2nd_FINESSE;
  }
 
  inline void RawHeader_v0::SetOffset3rdFINESSE(int offset_3rd_FINESSE)
  {
    CheckSetBuffer();
    m_buffer[ POS_OFFSET_3RD_FINESSE ] = offset_3rd_FINESSE;
  }
 
  inline void RawHeader_v0::SetOffset4thFINESSE(int offset_4th_FINESSE)
  {
    CheckSetBuffer();
    m_buffer[ POS_OFFSET_4TH_FINESSE ] = offset_4th_FINESSE;
  }
 
  /*   inline void RawHeader_v0::SetFTSW2Words(int* ftsw_buf) */
  /*   { */
  /*     CheckSetBuffer(); */
  /*     memcpy(&(m_buffer[ POS_HSLB_1 ]), (char*)ftsw_buf, sizeof(int) * 2); */
  /*     return; */
  /*   } */
 
  inline void RawHeader_v0::SetFTSW2Words(unsigned int word1,
                                          unsigned int word2)
  {
    CheckSetBuffer();
    m_buffer[ POS_TTCTIME_TRGTYPE ] = word1;
    m_buffer[ POS_TTUTIME ] = word2;
    return;
  }
 
 
  inline void RawHeader_v0::SetExpRunNumber(int* exprun_buf)
  {
    CheckSetBuffer();
    memcpy(&(m_buffer[ POS_EXP_RUN_NO ]), (char*)exprun_buf, sizeof(int) * 1);
    return;
  }
 
 
//
// Obtain info
//
 
  inline int RawHeader_v0::GetNwords()
  {
    CheckGetBuffer();
    return m_buffer[ POS_NWORDS ];
  }
 
  inline int RawHeader_v0::GetHdrNwords()
  {
 
    CheckGetBuffer();
 
    return m_buffer[ POS_HDR_NWORDS ];
  }
 
  inline int RawHeader_v0::GetExpNo()
  {
    CheckGetBuffer();
    return (((unsigned int)(m_buffer[ POS_EXP_RUN_NO ]) & EXP_MASK)
            >> EXP_SHIFT);
  }
 
 
  inline int RawHeader_v0::GetRunNo()
  {
    CheckGetBuffer();
    return (((unsigned int)(m_buffer[ POS_EXP_RUN_NO ]) & RUNNO_MASK)
            >> RUNNO_SHIFT);
  }
 
  inline int RawHeader_v0::GetSubRunNo()
  {
    CheckGetBuffer();
    return (m_buffer[ POS_EXP_RUN_NO ] & SUBRUNNO_MASK);
  }
 
  inline unsigned int RawHeader_v0::GetExpRunSubrun()
  {
    CheckGetBuffer();
    return ((unsigned int)(m_buffer[ POS_EXP_RUN_NO ]));
  }
 
 
  inline unsigned int RawHeader_v0::GetEveNo()
  {
    CheckGetBuffer();
    return m_buffer[ POS_EVE_NO ];
  }
 
  inline unsigned int RawHeader_v0::GetNodeID()
  {
    CheckGetBuffer();
    return (unsigned int)(m_buffer[ POS_NODE_ID ]);
  }
 
  inline int RawHeader_v0::GetDataType()
  {
    CheckGetBuffer();
    return (m_buffer[ POS_TRUNC_MASK_DATATYPE ] & 0x7FFFFFFF);
  }
 
  inline int RawHeader_v0::GetTruncMask()
  {
    CheckGetBuffer();
    return (m_buffer[ POS_TRUNC_MASK_DATATYPE ] >> 23) & 0x1;
  }
 
  inline unsigned int RawHeader_v0::GetErrorBitFlag()
  {
    CheckGetBuffer();
    return (unsigned int)(m_buffer[ POS_TRUNC_MASK_DATATYPE ]);
  }
 
  inline void RawHeader_v0::AddErrorBitFlag(unsigned int error_bit_flag)
  {
    CheckGetBuffer();
    m_buffer[ POS_TRUNC_MASK_DATATYPE ] |= (int)error_bit_flag;
    return;
  }
 
  inline int RawHeader_v0::GetOffset1stFINESSE()
  {
    CheckGetBuffer();
    return m_buffer[ POS_OFFSET_1ST_FINESSE ];
  }
 
  inline int RawHeader_v0::GetOffset2ndFINESSE()
  {
    CheckGetBuffer();
    return m_buffer[ POS_OFFSET_2ND_FINESSE ];
  }
 
  inline int RawHeader_v0::GetOffset3rdFINESSE()
  {
    CheckGetBuffer();
    return m_buffer[ POS_OFFSET_3RD_FINESSE ];
  }
 
  inline int RawHeader_v0::GetOffset4thFINESSE()
  {
    CheckGetBuffer();
    return m_buffer[ POS_OFFSET_4TH_FINESSE ];
  }
 
  inline int RawHeader_v0::GetNumNodes()
  {
    CheckGetBuffer();
    return m_buffer[ POS_NUM_NODES ];
  }
 
  inline unsigned int RawHeader_v0::GetTTCtimeTRGType()
  {
    CheckGetBuffer();
    return (unsigned int)(m_buffer[ POS_TTCTIME_TRGTYPE ]);
  }
 
  inline int RawHeader_v0::GetTTCtime()
  {
    CheckGetBuffer();
    return (int)((GetTTCtimeTRGType() & TTCTIME_MASK) >> TTCTIME_SHIFT);
  }
 
  inline int RawHeader_v0::GetTRGType()
  {
    CheckGetBuffer();
    return (int)(GetTTCtimeTRGType() & TRGTYPE_MASK);
  }
 
 
  inline unsigned int RawHeader_v0::GetTTUtime()
  {
    CheckGetBuffer();
    return (unsigned int)(m_buffer[ POS_TTUTIME ]);
  }
 
  inline void RawHeader_v0::GetTTTimeVal(struct timeval* tv)
  {
    tv->tv_sec = GetTTUtime();
    tv->tv_usec = (int)(((double)GetTTCtime()) / 127.216);
    return ;
  }
 
 
  inline unsigned int RawHeader_v0::GetMagicWordEntireHeader()
  {
    CheckGetBuffer();
    return m_buffer[ POS_TERM_HEADER ];
  }
 
 
 
 

}
 
#endif