RawHeader_v0.h

//+
// File : RawHeader_v0.h
// Description : Module to handle RawHeader_v0 attached to raw data from COPPER
//
// Author : Satoru Yamada, IPNS, KEK
// Date : 2 - Aug - 2013
//-
 
#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();
 
    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();
    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