PreRawCOPPERFormat_v2 Class Reference

The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class. More...

#include <PreRawCOPPERFormat_v2.h>

Inheritance diagram for PreRawCOPPERFormat_v2:

Public Types
enum	{   SIZE_COPPER_DRIVER_HEADER = 7 ,   SIZE_COPPER_DRIVER_TRAILER = 2 }
	Copy one datablock to buffer. More...
enum	{   POS_MAGIC_COPPER_1 = 0 ,   POS_EVE_NUM_COPPER = 1 ,   POS_SUBSYSTEM_ID = 2 ,   POS_CRATE_ID = 3 ,   POS_SLOT_ID = 4 ,   POS_MAGIC_COPPER_2 = 7 ,   POS_DATA_LENGTH = 8 ,   POS_CH_A_DATA_LENGTH = 9 ,   POS_CH_B_DATA_LENGTH = 10 ,   POS_CH_C_DATA_LENGTH = 11 ,   POS_CH_D_DATA_LENGTH = 12 ,   SIZE_COPPER_HEADER = 13 }
enum	{   POS_MAGIC_COPPER_3 = 0 ,   POS_CHKSUM_COPPER = 1 ,   POS_MAGIC_COPPER_4 = 2 ,   SIZE_COPPER_TRAILER = 3 }
enum	{   POS_MAGIC_B2LHSLB = 0 ,   SIZE_B2LHSLB_HEADER = 1 }
enum	{   POS_TT_CTIME_TYPE = 0 ,   POS_TT_TAG = 1 ,   POS_TT_UTIME = 2 ,   POS_EXP_RUN = 3 ,   POS_B2L_CTIME = 4 ,   SIZE_B2LFEE_HEADER = 5 }
enum	{   POS_TT_CTIME_B2LFEE = 0 ,   POS_CHKSUM_B2LFEE = 1 ,   SIZE_B2LFEE_TRAILER = 2 }
enum	{   POS_CHKSUM_B2LHSLB = 0 ,   SIZE_B2LHSLB_TRAILER = 1 }
enum	{   COPPER_MAGIC_DRIVER_HEADER = 0x7FFF0008 ,   COPPER_MAGIC_FPGA_HEADER = 0xFFFFFAFA ,   COPPER_MAGIC_FPGA_TRAILER = 0xFFFFF5F5 ,   COPPER_MAGIC_DRIVER_TRAILER = 0x7FFF0009 }
enum	{   B2LHSLB_HEADER_MAGIC = 0xFFAA0000 ,   B2LHSLB_TRAILER_MAGIC = 0xFF550000 }
enum	{ DATA_FORMAT_VERSION = 2 }
	Format version number. More...
enum	{   POS_NWORDS = 0 ,   POS_NODE_ID = 6 }
enum	{   POS_FTSW_ID_OLD = 5 ,   TEMP_POS_NWORDS_HEADER = 1 ,   OLD_FTSW_NWORDS_HEADER = 6 }

Public Member Functions
	PreRawCOPPERFormat_v2 ()
	Default constructor.
virtual	~PreRawCOPPERFormat_v2 ()
	Constructor using existing pointer to raw data buffer.
int	GetDetectorNwords (int n, int finesse_num) OVERRIDE_CPP17
	get Detector buffer length
int *	Get1stDetectorBuffer (int n) OVERRIDE_CPP17
	get Detector buffer of slot A
int *	Get2ndDetectorBuffer (int n) OVERRIDE_CPP17
	get Detector Buffer of slot B
int *	Get3rdDetectorBuffer (int n) OVERRIDE_CPP17
	get Detector Buffer of slot C
int *	Get4thDetectorBuffer (int n) OVERRIDE_CPP17
	get Detector Buffer of slot D
unsigned int	GetCOPPERCounter (int n) OVERRIDE_CPP17
	get posistion of COPPER block in unit of word
int	GetOffset1stFINESSE (int n) OVERRIDE_CPP17
	get # of offset words for FINESSE slot A buffer position
int	GetFINESSENwords (int n, int finesse) OVERRIDE_CPP17
	get data size of FINESSE buffer
virtual int *	GetExpRunSubrunBuf (int n) OVERRIDE_CPP17
	get b2l block from "FEE b2link header"
virtual unsigned int	GetB2LFEE32bitEventNumber (int n) OVERRIDE_CPP17
	get b2l block from "FEE b2link header"
unsigned int	GetMagicDriverHeader (int n) OVERRIDE_CPP17
	get magic word of COPPER driver header
unsigned int	GetMagicFPGAHeader (int n) OVERRIDE_CPP17
	get magic word of COPPER FPGA header
unsigned int	GetMagicFPGATrailer (int n) OVERRIDE_CPP17
	get magic word of COPPER FPGA trailer
unsigned int	GetMagicDriverTrailer (int n) OVERRIDE_CPP17
	get magic word of COPPER driver trailer
unsigned int	GetTrailerChksum (int n) OVERRIDE_CPP17
	get a checksum on trailer
bool	CheckCOPPERMagic (int n) OVERRIDE_CPP17
	Check if COPPER Magic words are correct.
unsigned int	FillTopBlockRawHeader (unsigned int m_node_id, unsigned int prev_eve32, unsigned int prev_exprunsubrun_no, unsigned int *cur_exprunsubrun_no) OVERRIDE_CPP17
	should be called by DeSerializerCOPPER.cc and fill contents in RawHeader
unsigned int	GetDriverChkSum (int n) OVERRIDE_CPP17
	read COPPER driver's checksum value
unsigned int	CalcDriverChkSum (int n) OVERRIDE_CPP17
	calc COPPER driver's checksum value
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) OVERRIDE_CPP17
	check data contents
void	CheckUtimeCtimeTRGType (int n) OVERRIDE_CPP17
	check data contents
int	CheckB2LHSLBMagicWords (int *finesse_buf, int finesse_nwords)
	check magic words of B2link HSLB header/trailer
int	CalcReducedDataSize (int *bufin, int nwords, int num_events, int num_nodes)
	reduce and merge header/trailer
void	CopyReducedData (int *bufin, int nwords, int num_events, int num_nodes, int *buf_to, int *nwords_to)
	reduce and merge header/trailer
int	CalcReducedNwords (int n)
	calculate reduced data size
int	CopyReducedBuffer (int n, int *buf_to)
	copy data to reduced buffer
int	CheckCRC16 (int n, int finesse_num)
	check CRC16 in B2LFEE trailer
int *	PackDetectorBuf (int *packed_buf_nwords, 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) OVERRIDE_CPP17
	Pack data (format ver. = -1 -> Select the latest format version)
int	Get1stDetectorNwords (int n) OVERRIDE_CPP17
	get Detector buffer length of slot A
int	Get2ndDetectorNwords (int n) OVERRIDE_CPP17
	get Detector buffer length of slot B
int	Get3rdDetectorNwords (int n) OVERRIDE_CPP17
	get Detector buffer length of slot C
int	Get4thDetectorNwords (int n) OVERRIDE_CPP17
	get Detector buffer length of slot D
int *	GetRawTrlBufPtr (int n) OVERRIDE_CPP17
	get buffer pointer of rawcopper trailer
int	GetExpNo (int n) OVERRIDE_CPP17
	get Experimental # from header
unsigned int	GetExpRunSubrun (int n) OVERRIDE_CPP17
	get Experimental # from header
int	GetRunNo (int n) OVERRIDE_CPP17
	Exp# (10bit) run# (14bit) restart # (8bit)
int	GetSubRunNo (int n) OVERRIDE_CPP17
	get run # (14bit)
unsigned int	GetEveNo (int n) OVERRIDE_CPP17
	get subrun #(8bit)
int	GetDataType (int n) OVERRIDE_CPP17
	get contents of header
int	GetTruncMask (int n) OVERRIDE_CPP17
	get contents of header
unsigned int	GetErrorBitFlag (int n) OVERRIDE_CPP17
	get contents of header
void	AddErrorBitFlag (int n, unsigned int error_bit_flag) OVERRIDE_CPP17
	Add Detected Error bitflag.
int	GetPacketCRCError (int n) OVERRIDE_CPP17
	check CRC packet Error
int	GetEventCRCError (int n) OVERRIDE_CPP17
	check CRC event Error
unsigned int	GetNodeID (int n) OVERRIDE_CPP17
	get node-ID from data
virtual int	GetNumFINESSEBlock (int n) OVERRIDE_CPP17
	get # of FINNESEs which contains data
int	Get1stFINESSENwords (int n) OVERRIDE_CPP17
	get data size of FINESSE slot A buffer
int	Get2ndFINESSENwords (int n) OVERRIDE_CPP17
	get data size of FINESSE slot B buffer
int	Get3rdFINESSENwords (int n) OVERRIDE_CPP17
	get data size of FINESSE slot C buffer
int	Get4thFINESSENwords (int n) OVERRIDE_CPP17
	get data size of FINESSE slot D buffer
unsigned int	GetTTCtimeTRGType (int n) OVERRIDE_CPP17
	get b2l block from "FEE b2link header"
unsigned int	GetTTUtime (int n) OVERRIDE_CPP17
	Check if COPPER Magic words are correct.
int	GetTTCtime (int n) OVERRIDE_CPP17
	Get ctime.
int	GetTRGType (int n) OVERRIDE_CPP17
	Get trgtype.
void	GetTTTimeVal (int n, struct timeval *tv) OVERRIDE_CPP17
	Get timeval.
int	GetMaxNumOfCh (int n) OVERRIDE_CPP17
	Get the max number of channels in a readout board.
virtual int *	GetDetectorBuffer (int n, int finesse_num)
	get Detector buffer
virtual int *	GetRawHdrBufPtr (int n)
	get buffer pointer of rawcopper header(Currently same as GetBufferPos)
virtual int *	GetFINESSEBuffer (int n, int finesse_num)
	get FINESSE buffer pointer
virtual int *	Get1stFINESSEBuffer (int n)
	get FINESSE buffer pointer for slot A
virtual int *	Get2ndFINESSEBuffer (int n)
	get FINESSE buffer pointer for slot B
virtual int *	Get3rdFINESSEBuffer (int n)
	get FINESSE buffer pointer for slot C
virtual int *	Get4thFINESSEBuffer (int n)
	get FINESSE buffer pointer for slot D
virtual int	GetEventCRC16Value (int n, int finesse_num)
	Get Event CRC16 value.
virtual int	GetOffsetFINESSE (int n, int finesse)
	get # of offset words
virtual int	GetOffset2ndFINESSE (int n)
	get # of offset words for FINESSE slot B buffer position
virtual int	GetOffset3rdFINESSE (int n)
	get # of offset words for FINESSE slot C buffer position
virtual int	GetOffset4thFINESSE (int n)
	get # of offset words for FINESSE slot D buffer position
virtual unsigned int	CalcXORChecksum (int *buf, int nwords)
	calc XOR checksum
virtual int *	PackDetectorBuf (int *packed_buf_nwords, int *const(&detector_buf_ch)[MAX_PCIE40_CH], int const(&nwords_ch)[MAX_PCIE40_CH], RawCOPPERPackerInfo rawcpr_info)
	Pack data for PCIe40 data-format.
virtual void	CompareHeaderValue (int n, const unsigned int(&input_val)[MAX_PCIE40_CH], std::vector< std::vector< unsigned int > > &result)
	Compare value from different channels and make a statistics table.
virtual void	GetNodeName (int n, char *node_name, int bufsize)
	Get hostname of a node from the RawCOPPER header.
virtual void	GetNodeName (char *node_name, unsigned int node_id, int bufsize)
	Get hostname of a node from an argument.
virtual bool	CheckOnlineRemovedDataBit (int n, int finesse_num)
	Check if COPPER Magic words are correct.
virtual void	SetBuffer (int *bufin, int nwords, int delete_flag, int num_events, int num_nodes)
	set buffer ( delete_flag : m_buffer is freeed( = 0 )/ not freeed( = 1 ) in Destructer )
virtual int	TotalBufNwords ()
	Get total length of m_buffer.
virtual int	GetBufferPos (int n)
	get position of data block in word
virtual int *	GetBuffer (int n)
	get nth buffer pointer
virtual int *	GetWholeBuffer ()
	get pointer to buffer(m_buffer)
virtual int	GetNumEntries ()
	get # of data blocks = (# of nodes)*(# of events)
virtual int	GetNumNodes ()
	get # of data sources(e.g. # of COPPER boards) in m_buffer
virtual int	GetNumEvents ()
	get # of events in m_buffer
virtual int	GetPreAllocFlag ()
	get malloc_flag
virtual int	GetBlockNwords (int n)
	get size of a data block
virtual int	CheckFTSWID (int n)
	get FTSW ID to check whether this data block is FTSW data or not
virtual int	CheckTLUID (int n)
	get FTSW ID to check whether this data block is FTSW data or not
virtual void	CopyBlock (int n, int *buf_to)
	Copy one datablock to buffer.
virtual void	PrintData (int *buf, int nwords)
	print data

Public Attributes
PostRawCOPPERFormat_v2	m_reduced_rawcpr
	data fromat after size reduction
RawHeader_v2	tmp_header
	header ( not recorded )
RawTrailer_v2	tmp_trailer
	trailer ( not recorded )

Protected Attributes
int	m_nwords
	number of words of buffer
int	m_num_nodes
	number of nodes in this object
int	m_num_events
	number of events in this object
int *	m_buffer
	Buffer.
int	m_use_prealloc_buf
	not recorded

Detailed Description

The Raw COPPER class ver.1 ( the latest version since May, 2014 ) This class stores data received by COPPER via belle2linkt Data from all detectors except PXD are stored in this class.

Definition at line 30 of file PreRawCOPPERFormat_v2.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Copy one datablock to buffer.

Copper data words = ( total_data_length in COPPER header ) + COPPER_HEADER_TRAILER_NWORDS

Definition at line 189 of file PreRawCOPPERFormat_v2.h.

         {
      SIZE_COPPER_DRIVER_HEADER = 7,
      SIZE_COPPER_DRIVER_TRAILER = 2
    };

anonymous enum

anonymous enum

Definition at line 197 of file PreRawCOPPERFormat_v2.h.

         {
      POS_MAGIC_COPPER_1 = 0,
      POS_EVE_NUM_COPPER = 1,
      POS_SUBSYSTEM_ID = 2,
      POS_CRATE_ID = 3,
      POS_SLOT_ID = 4,
      POS_MAGIC_COPPER_2 = 7,
      POS_DATA_LENGTH = 8,
      POS_CH_A_DATA_LENGTH = 9,
      POS_CH_B_DATA_LENGTH = 10,
      POS_CH_C_DATA_LENGTH = 11,
      POS_CH_D_DATA_LENGTH = 12,
 
      SIZE_COPPER_HEADER = 13
    };

anonymous enum

anonymous enum

Definition at line 218 of file PreRawCOPPERFormat_v2.h.

         {
      POS_MAGIC_COPPER_3 = 0,
      POS_CHKSUM_COPPER = 1,
      POS_MAGIC_COPPER_4 = 2,
 
      SIZE_COPPER_TRAILER = 3
    };

anonymous enum

anonymous enum

Definition at line 229 of file PreRawCOPPERFormat_v2.h.

         {
      POS_MAGIC_B2LHSLB = 0,
      //      POS_EVE_CNT_B2LHSLB = 1,
      SIZE_B2LHSLB_HEADER = 1
    };

anonymous enum

anonymous enum

Definition at line 237 of file PreRawCOPPERFormat_v2.h.

         {
      POS_TT_CTIME_TYPE = 0,
      POS_TT_TAG = 1,
      POS_TT_UTIME = 2,
      POS_EXP_RUN = 3,
      POS_B2L_CTIME = 4,
      SIZE_B2LFEE_HEADER = 5
    };

anonymous enum

anonymous enum

Definition at line 250 of file PreRawCOPPERFormat_v2.h.

         {
      POS_TT_CTIME_B2LFEE = 0,
      POS_CHKSUM_B2LFEE = 1,
      SIZE_B2LFEE_TRAILER = 2
    };

anonymous enum

anonymous enum

Definition at line 260 of file PreRawCOPPERFormat_v2.h.

         {
      POS_CHKSUM_B2LHSLB = 0,
      SIZE_B2LHSLB_TRAILER = 1
    };

anonymous enum

anonymous enum

Definition at line 270 of file PreRawCOPPERFormat_v2.h.

         {
      COPPER_MAGIC_DRIVER_HEADER = 0x7FFF0008,
      COPPER_MAGIC_FPGA_HEADER = 0xFFFFFAFA,
      COPPER_MAGIC_FPGA_TRAILER = 0xFFFFF5F5,
      COPPER_MAGIC_DRIVER_TRAILER = 0x7FFF0009
    };

anonymous enum

anonymous enum

Definition at line 281 of file PreRawCOPPERFormat_v2.h.

         {
      B2LHSLB_HEADER_MAGIC = 0xFFAA0000,
      B2LHSLB_TRAILER_MAGIC = 0xFF550000
    };

anonymous enum

anonymous enum

inherited

Format version number.

Definition at line 187 of file RawCOPPERFormat_v2.h.

         {
      DATA_FORMAT_VERSION = 2
    };

anonymous enum

anonymous enum

inherited

Definition at line 75 of file RawDataBlockFormat.h.

         {
      POS_NWORDS = 0,
      POS_NODE_ID = 6
    };

anonymous enum

anonymous enum

inherited

Definition at line 80 of file RawDataBlockFormat.h.

         {
      // Tentatively needed to distinguish new and old FTSW format, which will be changed in Nov. 2013
      POS_FTSW_ID_OLD = 5,
      TEMP_POS_NWORDS_HEADER = 1,
      OLD_FTSW_NWORDS_HEADER = 6
    };

Constructor & Destructor Documentation

PreRawCOPPERFormat_v2()

PreRawCOPPERFormat_v2

(

)

Default constructor.

Definition at line 20 of file PreRawCOPPERFormat_v2.cc.

{
 
}

~PreRawCOPPERFormat_v2()

~PreRawCOPPERFormat_v2 ( )

virtual

Constructor using existing pointer to raw data buffer.

Destructor

Definition at line 25 of file PreRawCOPPERFormat_v2.cc.

{
}

Member Function Documentation

CalcDriverChkSum()

unsigned int CalcDriverChkSum ( int  n )

virtual

calc COPPER driver's checksum value

Implements RawCOPPERFormat.

Definition at line 29 of file PreRawCOPPERFormat_v2.cc.

{
  int min = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS;
  int max = GetBufferPos(n) + GetBlockNwords(n)
            - tmp_trailer.RAWTRAILER_NWORDS - SIZE_COPPER_DRIVER_TRAILER;
  unsigned int chksum = 0;
  for (int i = min; i < max; i++) {
    chksum ^= m_buffer[ i ];
  }
  return chksum;
}

CalcReducedDataSize()

int CalcReducedDataSize	(	int *	bufin,
		int	nwords,
		int	num_events,
		int	num_nodes
	)

reduce and merge header/trailer

Definition at line 1074 of file PreRawCOPPERFormat_v2.cc.

{
  //
  // Calculate reduced length for a total RawDataBlock (containing multiple data blocks)
  //
  RawDataBlockFormat radblk_fmt;
  int delete_flag = 0;
  radblk_fmt.SetBuffer(bufin, nwords, delete_flag, num_events, num_nodes);
 
  int reduced_nwords = 0;
  for (int k = 0; k < radblk_fmt.GetNumEvents(); k++) {
    int num_nodes_in_sendblock = radblk_fmt.GetNumNodes();
    for (int l = 0; l < num_nodes_in_sendblock; l++) {
      int entry_id = l + k * num_nodes_in_sendblock;
 
      if (radblk_fmt.CheckFTSWID(entry_id) || radblk_fmt.CheckTLUID(entry_id)) {
        reduced_nwords += radblk_fmt.GetBlockNwords(entry_id);
      } else {
        PreRawCOPPERFormat_v2 temp_prerawcpr;
        int temp_delete_flag = 0, temp_num_eve = 1, temp_num_nodes = 1;
 
        // Call CalcReducedNwords
        temp_prerawcpr.SetBuffer(radblk_fmt.GetBuffer(entry_id),
                                 radblk_fmt.GetBlockNwords(entry_id),
                                 temp_delete_flag, temp_num_eve,
                                 temp_num_nodes);
        reduced_nwords += temp_prerawcpr.CalcReducedNwords(0);
      }
    }
  }
  return reduced_nwords;
 
}

CalcReducedNwords()

int CalcReducedNwords

(

int

n

)

calculate reduced data size

Definition at line 1145 of file PreRawCOPPERFormat_v2.cc.

{
  //
  // Calculate reduced length for one data block which is a part of a RawDataBlock
  //
 
  int nwords_to = 0;
 
  //RawCOPPER header
  nwords_to += tmp_header.RAWHEADER_NWORDS;
 
  for (int j = 0; j < 4; j++) {
 
    int finesse_nwords = GetFINESSENwords(n, j);
    if (finesse_nwords > 0) {
      //
      // B2L(HSLB/FEE) header and trailers are resized
      // m_reduced_rawcpr should be PostRawCOPPERFormat_v2
      //
      nwords_to +=
        finesse_nwords
        - (static_cast<int>(SIZE_B2LHSLB_HEADER) -  m_reduced_rawcpr.SIZE_B2LHSLB_HEADER)
        - (static_cast<int>(SIZE_B2LFEE_HEADER) -   m_reduced_rawcpr.SIZE_B2LFEE_HEADER)
        - (static_cast<int>(SIZE_B2LFEE_TRAILER) -  m_reduced_rawcpr.SIZE_B2LFEE_TRAILER)
        - (static_cast<int>(SIZE_B2LHSLB_TRAILER) - m_reduced_rawcpr.SIZE_B2LHSLB_TRAILER);
    }
 
  }
 
  //RawCOPPER Trailer
  nwords_to += tmp_trailer.GetTrlNwords();
 
  return nwords_to;
}

CalcXORChecksum()

unsigned int CalcXORChecksum ( int *  buf, int  nwords  )

virtualinherited

calc XOR checksum

Definition at line 24 of file RawCOPPERFormat.cc.

{
  unsigned int checksum = 0;
  for (int i = 0; i < nwords; i++) {
    checksum = checksum ^ buf[ i ];
  }
  return checksum;
}

CheckB2LHSLBMagicWords()

int CheckB2LHSLBMagicWords	(	int *	finesse_buf,
		int	finesse_nwords
	)

check magic words of B2link HSLB header/trailer

Definition at line 1416 of file PreRawCOPPERFormat_v2.cc.

{
 
  if ((finesse_buf[ POS_MAGIC_B2LHSLB ] & 0xFFFF0000) == B2LHSLB_HEADER_MAGIC &&
      ((finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER + POS_CHKSUM_B2LHSLB ] & 0xFFFF0000)
       == B2LHSLB_TRAILER_MAGIC)) {
    return 1;
  } else {
    PrintData(m_buffer, m_nwords);
    char err_buf[500];
    sprintf(err_buf,
            "Invalid B2LHSLB magic words : header 0x%x (= should be ffaa**** ) or trailer 0x%x (= should be ff55**** ). Exiting... :%s %s %d\n",
            finesse_buf[ POS_MAGIC_B2LHSLB ],
            finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER + POS_CHKSUM_B2LHSLB ],
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
#ifndef NO_ERROR_STOP
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf);
#endif
  }
}

CheckCOPPERMagic()

bool CheckCOPPERMagic ( int  n )

virtual

Check if COPPER Magic words are correct.

Implements RawCOPPERFormat.

Definition at line 348 of file PreRawCOPPERFormat_v2.cc.

{
  if (GetMagicDriverHeader(n) != COPPER_MAGIC_DRIVER_HEADER) {
    return false;
  } else if (GetMagicFPGAHeader(n) != COPPER_MAGIC_FPGA_HEADER) {
    return false;
  } else if (GetMagicFPGATrailer(n) != COPPER_MAGIC_FPGA_TRAILER) {
    return false;
  } else if (GetMagicDriverTrailer(n) != COPPER_MAGIC_DRIVER_TRAILER) {
    return false;
  }
  return true;
}

CheckCRC16()

int CheckCRC16	(	int	n,
		int	finesse_num
	)

check CRC16 in B2LFEE trailer

Definition at line 1440 of file PreRawCOPPERFormat_v2.cc.

{
  //
  // Calculate CRC16
  //
  int* buf = GetFINESSEBuffer(n, finesse_num) +  SIZE_B2LHSLB_HEADER;
  int nwords = GetFINESSENwords(n, finesse_num) - (static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_TRAILER +
                                                   SIZE_B2LHSLB_TRAILER);
  unsigned short temp_crc16 = CalcCRC16LittleEndian(0xffff, buf, nwords);
 
  //
  // Compare CRC16 with B2LCRC16
  //
  buf = GetFINESSEBuffer(n, finesse_num) +  GetFINESSENwords(n, finesse_num)
        - ((SIZE_B2LFEE_TRAILER - POS_CHKSUM_B2LFEE) + SIZE_B2LHSLB_TRAILER) ;
 
  if ((unsigned short)(*buf & 0xFFFF) != temp_crc16) {
    PrintData(GetBuffer(n), *(GetBuffer(n) + tmp_header.POS_NWORDS));
    char err_buf[500];
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    printf("[FATAL] %s ch=%d : ERROR_EVENT : PRE CRC16 error : slot %c : B2LCRC16 %x Calculated CRC16 %x : Nwords of FINESSE buf %d\n",
           hostname, finesse_num,
           65 + finesse_num, *buf, temp_crc16, GetFINESSENwords(n, finesse_num));
    int* temp_buf = GetFINESSEBuffer(n, finesse_num);
    for (int k = 0; k <  GetFINESSENwords(n, finesse_num); k++) {
      printf("%.8x ", temp_buf[ k ]);
      if ((k + 1) % 10 == 0) {
        printf("\n");
      }
    }
    printf("\n");
    fflush(stdout);
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : slot %c : B2LCRC16 (%.4x) differs from one ( %.4x) calculated by PreRawCOPPERfromat class. Exiting...\n %s %s %d\n",
            hostname, finesse_num,
            65 + finesse_num, (unsigned short)(*buf & 0xFFFF), temp_crc16,
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
  return 1;
 
}

CheckData()

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  )

virtual

check data contents

Implements RawCOPPERFormat.

Definition at line 186 of file PreRawCOPPERFormat_v2.cc.

{
 
  char err_buf[1000];
  int err_flag = 0;
  //
  // check Magic words
  //
  if (!CheckCOPPERMagic(n)) {
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : Invalid Magic word 0x7FFFF0008=%u 0xFFFFFAFA=%u 0xFFFFF5F5=%u 0x7FFF0009=%u : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
            hostname, -1,
            GetMagicDriverHeader(n), GetMagicFPGAHeader(n), GetMagicFPGATrailer(n), GetMagicDriverTrailer(n),
            GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    err_flag = 1;
  }
 
  //
  // Event # check
  //
  *cur_evenum_rawcprhdr = GetEveNo(n);
  unsigned int evenum_feehdr = GetB2LFEE32bitEventNumber(n);
  if (*cur_evenum_rawcprhdr != evenum_feehdr) {
 
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : Event # in PreRawCOPPERFormat_v2 header and FEE header is different : cprhdr 0x%x feehdr 0x%x : Exiting... : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
            hostname, -1,
            *cur_evenum_rawcprhdr, evenum_feehdr,
            GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    err_flag = 1;
  }
 
  //
  // Check incrementation of event #
  //
  *cur_exprunsubrun_no = GetExpRunSubrun(n);
  *cur_copper_ctr = GetCOPPERCounter(n);
  if (prev_exprunsubrun_no == *cur_exprunsubrun_no) {
    if ((unsigned int)(prev_evenum + 1) != *cur_evenum_rawcprhdr) {
      char hostname[128];
      GetNodeName(n, hostname, sizeof(hostname));
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : Event # jump : i %d prev 0x%x cur 0x%x : prevrun %.8x currun %.8x: Exiting... : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
              hostname, -1,
              n, prev_evenum, *cur_evenum_rawcprhdr, prev_exprunsubrun_no, *cur_exprunsubrun_no,
              GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      err_flag = 1;
    }
    if ((unsigned int)(prev_copper_ctr + 1) != *cur_copper_ctr) {
      char hostname[128];
      GetNodeName(n, hostname, sizeof(hostname));
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : COPPER counter jump : i %d prev 0x%x cur 0x%x : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
              hostname, -1,
              n, prev_copper_ctr, *cur_copper_ctr,
              GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      err_flag = 1;
    }
  } else {
    printf("[DEBUG] New run started. cur run %.8x prev. run %.8x cur eve %.8x prev eve %8.x : eve 0x%x exp %d run %d sub %d\n",
           *cur_exprunsubrun_no, prev_exprunsubrun_no, *cur_evenum_rawcprhdr, prev_evenum,
           GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n));
 
    // Check if the first event of a run is zero.
    if ((unsigned int)GetRunNo(n) != (prev_exprunsubrun_no & RawHeader_v2::RUNNO_MASK) >> RawHeader_v2::RUNNO_SHIFT) {
      if (*cur_evenum_rawcprhdr != 0) {
 
        unsigned int eve[4];
        for (int i = 0; i < 4 ; i++) {
          eve[ i ] = 0xbaadf00d;
          if (GetFINESSENwords(n, i) > 0) {
            int pos_nwords = GetOffsetFINESSE(n, i) + SIZE_B2LHSLB_HEADER + POS_TT_TAG;
            eve[ i ] = m_buffer[ pos_nwords ];
          }
        }
 
        char hostname[128];
        GetNodeName(n, hostname, sizeof(hostname));
        sprintf(err_buf,
                "[FATAL] %s ch=%d : ERROR_EVENT : Invalid Event # at the beginning of the run (It should be zero.): preveve 0x%x cureve 0x%x : prev(exp %u run %u sub %u ) cur(exp %u run %u sub %u ) ( A:0x%.8x B:0x%.8x C:0x%.8x D:0x%.8x ) Exiting... : eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
                hostname, -1,
                prev_evenum, *cur_evenum_rawcprhdr,
                prev_exprunsubrun_no >> 22, (prev_exprunsubrun_no >> 8) & 0x3FFF, prev_exprunsubrun_no & 0xFF,
                *cur_exprunsubrun_no >> 22, (*cur_exprunsubrun_no >> 8) & 0x3FFF, *cur_exprunsubrun_no & 0xFF,
                eve[ 0 ], eve[ 1 ], eve[ 2 ], eve[ 3 ],
                GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
                __FILE__, __PRETTY_FUNCTION__, __LINE__);
        err_flag = 1;
      }
    }
 
  }
 
 
 
  //
  // Check is utime and ctime_trgtype same over different FINESSE data
  //
  CheckUtimeCtimeTRGType(n);
 
  //
  // Check checksum calculated by COPPER driver
  //
  if (GetDriverChkSum(n) != CalcDriverChkSum(n)) {
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : COPPER driver checkSum error : block %d : length %d eve 0x%x : Trailer chksum 0x%.8x : calcd. now 0x%.8x : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
            hostname, -1,
            n, GetBlockNwords(n), *cur_evenum_rawcprhdr, GetDriverChkSum(n), CalcDriverChkSum(n),
            GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    err_flag = 1;
  }
 
  //
  // Check checksum calculated by DeSerializerCOPPER()
  //
  tmp_trailer.SetBuffer(GetRawTrlBufPtr(n));
  unsigned int xor_chksum = CalcXORChecksum(GetBuffer(n), GetBlockNwords(n) - tmp_trailer.GetTrlNwords());
  if (tmp_trailer.GetChksum() != xor_chksum) {
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : PreRawCOPPERFormat_v2 checksum error : block %d : length %d eve 0x%x : Trailer chksum 0x%.8x : calcd. now 0x%.8x : eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
            hostname, -1,
            n, GetBlockNwords(n), *cur_evenum_rawcprhdr, tmp_trailer.GetChksum(), xor_chksum,
            GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    err_flag = 1;
  }
 
  if (err_flag == 1) {
    printf("%s", err_buf); fflush(stdout);
    printf("[DEBUG] ========== dump a data blcok : block # %d==========\n", n);
    PrintData(GetBuffer(n), GetBlockNwords(n));
    for (int i = 0; i < 4; i++) {
      printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
      if (GetFINESSENwords(n, i) > 0) {
        CheckCRC16(n, i);
      }
    }
    printf("[DEBUG] ========== No CRC error : block %d =========\n", n);
    //    string err_str = err_buf;    throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  return;
 
}

CheckFTSWID()

int CheckFTSWID ( int  n )

virtualinherited

get FTSW ID to check whether this data block is FTSW data or not

Definition at line 73 of file RawDataBlockFormat.cc.

{
  int pos = POS_NODE_ID;
  if (m_buffer[ GetBufferPos(n) + TEMP_POS_NWORDS_HEADER ] == OLD_FTSW_NWORDS_HEADER) {
    pos =  POS_FTSW_ID_OLD;
  }
 
  if ((m_buffer[ GetBufferPos(n) + pos ] & 0xffffff00) == 0x54544400) {     // "TTD" + format version ( 0x20=DESY, 0x31=2018/7/11)
    return 1;
  } else {
    return 0;
  }
}

CheckOnlineRemovedDataBit()

bool CheckOnlineRemovedDataBit ( int  n, int  finesse_num  )

virtualinherited

Check if COPPER Magic words are correct.

Reimplemented in PostRawCOPPERFormat_latest, and PreRawCOPPERFormat_latest.

Definition at line 217 of file RawCOPPERFormat.cc.

{
  char err_buf[500];
  sprintf(err_buf,
          "[FATAL] This function is not supported in the version of RawCOPPER format that you're using. n=%d fin=%d : %s %s %d: Exiting...\n",
          n, finesse_num, __FILE__, __PRETTY_FUNCTION__, __LINE__);
  printf("%s\n", err_buf); fflush(stdout);
  B2FATAL(err_buf);
  return -1;
}

CheckTLUID()

int CheckTLUID ( int  n )

virtualinherited

get FTSW ID to check whether this data block is FTSW data or not

Definition at line 88 of file RawDataBlockFormat.cc.

{
  int pos = POS_NODE_ID;
  if (m_buffer[ GetBufferPos(n) + TEMP_POS_NWORDS_HEADER ] == OLD_FTSW_NWORDS_HEADER) {
    pos =  POS_FTSW_ID_OLD;
  }
  if (m_buffer[ GetBufferPos(n) + pos ] == 0x544c5520) { // "TLU "
    return 1;
  } else {
    return 0;
  }
}

CheckUtimeCtimeTRGType()

void CheckUtimeCtimeTRGType ( int  n )

virtual

check data contents

Implements RawCOPPERFormat.

Definition at line 362 of file PreRawCOPPERFormat_v2.cc.

{
 
#ifdef USE_B2LFEE_FORMAT_BOTH_VER1_AND_2
  CheckB2LFEEHeaderVersion(n);
#endif
  int err_flag = 0;
  int flag = 0;
  unsigned int temp_utime = 0, temp_ctime_trgtype = 0, temp_eve = 0, temp_exprun = 0;
  unsigned int temp_ctime_trgtype_footer, temp_eve_footer;
  unsigned int utime[4], ctime_trgtype[4], eve[4], exprun[4];
  char err_buf[4000];
  int first_ch = 0;
 
  memset(utime, 0, sizeof(utime));
  memset(ctime_trgtype, 0, sizeof(ctime_trgtype));
  memset(eve, 0, sizeof(eve));
  memset(exprun, 0, sizeof(exprun));
 
 
  for (int i = 0; i < 4; i++) {
    int finesse_nwords = GetFINESSENwords(n, i);
    if (finesse_nwords > 0) {
      int offset_finesse = GetOffsetFINESSE(n, i);
      ctime_trgtype[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_TT_CTIME_TYPE ];
      utime[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_TT_UTIME ];
      eve[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_TT_TAG ];
      exprun[ i ] = m_buffer[ offset_finesse + SIZE_B2LHSLB_HEADER + POS_EXP_RUN ];
      temp_ctime_trgtype_footer =
        m_buffer[ offset_finesse + finesse_nwords - (static_cast<int>(SIZE_B2LFEE_TRAILER) + SIZE_B2LHSLB_TRAILER) + POS_TT_CTIME_B2LFEE ];
      temp_eve_footer =
        m_buffer[ offset_finesse + finesse_nwords - (static_cast<int>(SIZE_B2LFEE_TRAILER) + SIZE_B2LHSLB_TRAILER) + POS_CHKSUM_B2LFEE ];
 
      if (flag == 0) {
        temp_ctime_trgtype = ctime_trgtype[ i ];
        temp_utime = utime[ i ];
        temp_eve = eve[ i ];
        temp_exprun = exprun[ i ];
        flag = 1;
        first_ch = i;
      } else {
        if (temp_ctime_trgtype != ctime_trgtype[ i ] || temp_utime != utime[ i ] ||
            temp_eve != eve[ i ] || temp_exprun != exprun[ i ]) {
          char hostname[128];
          GetNodeName(n, hostname, sizeof(hostname));
          if (err_flag == 0) {
            for (int j = 0; j < 4; j++) {
              printf("[DEBUG] %s ch=%d : FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x eve 0x%.8x exprun 0x%.8x\n",
                     hostname, -1,
                     j, GetFINESSENwords(n, j), ctime_trgtype[ j ], utime[ j ], eve[ j ], exprun[ j ]);
            }
          }
 
          char err_buf_1[2500], err_buf_2[3000], err_buf_3[3500];
          sprintf(err_buf_1,
                  "[FATAL] %s ch=%d : ERROR_EVENT : mismatch header value over FINESSEs. Exiting...",
                  hostname, -1);
          sprintf(err_buf_2,
                  "%s FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x eve 0x%.8x exprun 0x%.8x",
                  err_buf_1,
                  first_ch, GetFINESSENwords(n, first_ch), ctime_trgtype[ first_ch ], utime[ first_ch ], eve[ first_ch ], exprun[ first_ch ]);
          sprintf(err_buf_3,
                  "%s FINESSE #=%d buffsize %d ctimeTRGtype 0x%.8x utime 0x%.8x eve 0x%.8x exprun 0x%.8x",
                  err_buf_2,
                  i, GetFINESSENwords(n, i), ctime_trgtype[ i ], utime[ i ], eve[ i ], exprun[ i ]);
          sprintf(err_buf, "%s\n %s %s %d\n",
                  err_buf_3,
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
 
          err_flag = 1;
          break;
        } else if (temp_ctime_trgtype != temp_ctime_trgtype_footer ||
                   (temp_eve & 0xffff) != ((temp_eve_footer >> 16) & 0xffff)) {
          char hostname[128];
          GetNodeName(n, hostname, sizeof(hostname));
          sprintf(err_buf,
                  "[FATAL] %s ch=%d : ERROR_EVENT : mismatch(finesse %d) between header(ctime %.8x eve %.8x) and footer(ctime %.8x eve_crc16 %.8x). Exiting...\n %s %s %d\n",
                  hostname, i,
                  i,  temp_ctime_trgtype,  temp_eve, temp_ctime_trgtype_footer, temp_eve_footer,
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          err_flag = 1;
        }
      }
    }
  }
 
  if (err_flag != 0) {
    for (int i = 0; i < 4; i++) {
      if (GetFINESSENwords(n, i) > 0) {
        printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
        CheckCRC16(n, i);
        printf("[DEBUG] ========== CRC check is done. : block %d =========\n", n);
      }
    }
#ifndef NO_ERROR_STOP
    //    string err_str = err_buf; throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
#endif
  }
  return;
}

CompareHeaderValue()

void CompareHeaderValue ( int  n, const unsigned int(&)  input_val[MAX_PCIE40_CH], std::vector< std::vector< unsigned int > > &  result  )

virtualinherited

Compare value from different channels and make a statistics table.

Reimplemented in RawCOPPERFormat_latest.

Definition at line 170 of file RawCOPPERFormat.cc.

{
  char err_buf[500];
  sprintf(err_buf,
          "[FATAL] This function is not supported in the version of  RawCOPPER format that you're using. : %s %s %d: Exiting...\n", __FILE__,
          __PRETTY_FUNCTION__, __LINE__);
  printf("%s\n", err_buf); fflush(stdout);
  B2FATAL(err_buf);
  return;
}

CopyBlock()

void CopyBlock ( int  n, int *  buf_to  )

virtualinherited

Copy one datablock to buffer.

Definition at line 173 of file RawDataBlockFormat.cc.

{
  memcpy(buf_to, GetBuffer(n), GetBlockNwords(n) * sizeof(int));
  return;
}

CopyReducedBuffer()

int CopyReducedBuffer	(	int	n,
		int *	buf_to
	)

copy data to reduced buffer

Definition at line 1185 of file PreRawCOPPERFormat_v2.cc.

{
  //
  // Make a reduced buffer for one data block which is a part of a RawDataBlock
  //
 
  int* buf_from = NULL;
  int nwords_buf_to = CalcReducedNwords(n);
  int pos_nwords_to = 0;
  int copy_nwords = 0;
 
  unsigned int removed_xor_chksum = 0;
 
  // copyt to ReducedRawCOPPER
  //  ReducedRawCOPPER m_reduced_rawcpr;
  //Header copy
  copy_nwords = tmp_header.RAWHEADER_NWORDS;
  buf_from = GetBuffer(n);
  copyData(buf_to, &pos_nwords_to, buf_from, copy_nwords, nwords_buf_to);
 
 
  //calcurate XOR checksum diff.( depends on data-format )
  removed_xor_chksum ^= buf_from[ tmp_header.POS_VERSION_HDRNWORDS ];
 
  // Unset the PreFormat bit ( 15th bit )
  buf_to[ tmp_header.POS_VERSION_HDRNWORDS ] &= 0xFFFF7FFF;
 
  //calcurate XOR checksum diff.( depends on data-format )
  removed_xor_chksum ^=  buf_to[ tmp_header.POS_VERSION_HDRNWORDS ];
  for (int i = 0; i < SIZE_COPPER_HEADER; i++) {
    removed_xor_chksum ^=  buf_from[ tmp_header.RAWHEADER_NWORDS + i ];
  }
 
  //Check Header
  //  m_reduced_rawcpr.tmp_header.CheckHeader(buf_to + pos_nwords_to - copy_nwords);
 
 
  // copy FINESSE buffer
  int pos_nwords_finesse[ 4 ];
  for (int j = 0; j < 4; j++) {
    pos_nwords_finesse[ j ] = pos_nwords_to;
    if (GetFINESSENwords(n, j) > 0) {
      int* finesse_buf = GetFINESSEBuffer(n, j);
      int finesse_nwords = GetFINESSENwords(n, j);
 
 
      CheckB2LHSLBMagicWords(finesse_buf, finesse_nwords);
      // copy the whole B2LHSLB header (1word)
      buf_to[ pos_nwords_to ] = finesse_buf[ POS_MAGIC_B2LHSLB ];
      pos_nwords_to++;
 
      // copy the last word of B2LFEE and body( DetectorBuffer )
      buf_from =
        finesse_buf
        + SIZE_B2LHSLB_HEADER
        + POS_B2L_CTIME; //the last word of B2LFEE
 
 
      // check finesse buffer size : ( When dumhslb was used, this type of error
      // occured and RecvStream0.py died by Segmentation Fault. ) 2014.12.01.
      if (finesse_nwords - SIZE_B2LHSLB_HEADER - SIZE_B2LFEE_HEADER
          - SIZE_B2LFEE_TRAILER - SIZE_B2LHSLB_TRAILER < 0) {
        char err_buf[500];
        char hostname[128];
        GetNodeName(n, hostname, sizeof(hostname));
        sprintf(err_buf,
                "[FATAL] %s ch=%d : ERROR_EVENT : Finesse buffer size is too small( %d words < %d words). May be the data are corrupted. Exiting...\n %s %s %d\n",
                hostname, j,
                finesse_nwords, static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER,
                __FILE__, __PRETTY_FUNCTION__, __LINE__);
        printf("%s", err_buf); fflush(stdout);
        //        string err_str = err_buf;     throw (err_str);
        B2FATAL(err_buf); // to reduce multiple error messages
      }
 
      //calcurate XOR checksum diff.( depends on data-format )
      for (int k = 1; k <= 4 ; k++) {
        removed_xor_chksum ^=  finesse_buf[ k ];
      }
 
      copy_nwords =
        finesse_nwords
        - SIZE_B2LHSLB_HEADER // already copied
        - POS_B2L_CTIME // only one word copied ( SIZE_B2LFEE_HEADER - 1 = POS_B2L_CTIME )
        - SIZE_B2LFEE_TRAILER // will be copied later
        - SIZE_B2LHSLB_TRAILER; // Not copied
      copyData(buf_to, &pos_nwords_to, buf_from, copy_nwords, nwords_buf_to);
      //      printf("pos %d nwords %d  nwords to %d\n", pos_nwords_to, copy_nwords, nwords_buf_to );
 
      //copy B2LFEE trailer(CRC info)
      buf_to[ pos_nwords_to ] = 0xffff & finesse_buf[ finesse_nwords - SIZE_B2LHSLB_TRAILER - (SIZE_B2LFEE_TRAILER - POS_CHKSUM_B2LFEE) ];
      //copy B2LHSLB trailer(packet CRC error count)
      buf_to[ pos_nwords_to ] |= (finesse_buf[ finesse_nwords - (static_cast<int>(SIZE_B2LHSLB_TRAILER) - POS_MAGIC_B2LHSLB) ] << 16) &
                                 0xFFFF0000;
 
      //calcurate XOR checksum diff. ( depends on data-format )
      for (int k = 0; k <= 2 ; k++) {
        removed_xor_chksum ^=  finesse_buf[ finesse_nwords - SIZE_B2LFEE_TRAILER - SIZE_B2LHSLB_TRAILER + k ];
      }
      removed_xor_chksum ^=  buf_to[ pos_nwords_to ];
 
      pos_nwords_to++;
 
      // check CRC data
      //      CheckCRC16( n, j );
    }
  }
 
  // copy RawCOPPER trailer
  buf_from =
    GetBuffer(n)
    + GetBlockNwords(n)
    - tmp_trailer.GetTrlNwords();
  copy_nwords = tmp_trailer.GetTrlNwords();
  copyData(buf_to, &pos_nwords_to, buf_from, copy_nwords, nwords_buf_to);
 
  //calcurate XOR checksum diff.( depends on data-format )
  unsigned int old_rawcopper_chksum = buf_from[ tmp_trailer.POS_CHKSUM ];
  for (int i = 0; i < SIZE_COPPER_TRAILER; i++) {
    removed_xor_chksum ^= (unsigned int) * (buf_from - SIZE_COPPER_TRAILER + i);
  }
 
 
  // length check
  if (pos_nwords_to != nwords_buf_to) {
    char err_buf[500];
    sprintf(err_buf, "Buffer overflow. Exiting... %d %d\n", pos_nwords_to, nwords_buf_to);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf);
  }
 
 
  // Recalculate XOR checksum in a RawCOPPER trailer
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_NWORDS);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_1ST_FINESSE);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_2ND_FINESSE);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_3RD_FINESSE);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_4TH_FINESSE);
 
  //
  // Apply changes followed by data size reduction
  //
  *(buf_to + m_reduced_rawcpr.tmp_header.POS_NWORDS) = nwords_buf_to;
  *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_1ST_FINESSE) = pos_nwords_finesse[ 0 ];
  *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_2ND_FINESSE) = pos_nwords_finesse[ 1 ];
  *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_3RD_FINESSE) = pos_nwords_finesse[ 2 ];
  *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_4TH_FINESSE) = pos_nwords_finesse[ 3 ];
 
  // Recalculate XOR checksum in a RawCOPPER trailer
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_NWORDS);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_1ST_FINESSE);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_2ND_FINESSE);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_3RD_FINESSE);
  removed_xor_chksum ^= *(buf_to + m_reduced_rawcpr.tmp_header.POS_OFFSET_4TH_FINESSE);
 
  // Recalculate XOR checksum in a RawCOPPER trailer
  unsigned int new_rawcopper_chksum = CalcXORChecksum(buf_to, pos_nwords_to - tmp_trailer.GetTrlNwords());
 
 
  if ((old_rawcopper_chksum ^ removed_xor_chksum) != new_rawcopper_chksum) {
    char err_buf[500];
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : RawCOPPER XOR checksum is inconsistent between before/after data reduction.(%.8x != %.8x ^ %.8x = %.8x ) Exiting...\n %s %s %d\n",
            hostname, -1,
            new_rawcopper_chksum,  old_rawcopper_chksum, removed_xor_chksum, old_rawcopper_chksum ^ removed_xor_chksum,
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  *(buf_to + pos_nwords_to - tmp_trailer.GetTrlNwords() + tmp_trailer.POS_CHKSUM) = new_rawcopper_chksum;
 
 
 
  //
  // data block # check
  //
  m_reduced_rawcpr.SetBuffer(buf_to, nwords_buf_to, 0, GetNumEvents(), GetNumNodes());
  if (m_reduced_rawcpr.GetNumEvents() * m_reduced_rawcpr.GetNumNodes() <= 0) {
    char err_buf[500];
    sprintf(err_buf, "Invalid data block numbers.(# of events %d, # of nodes %d) Exiting...\n",
            m_reduced_rawcpr.GetNumEvents(), m_reduced_rawcpr.GetNumNodes());
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf);
  }
 
  //
  // check no-data buffer
  //
  for (int i = 0; i < m_reduced_rawcpr.GetNumEvents() * m_reduced_rawcpr.GetNumNodes(); i++) {
    int nonzero_finesse_buf = 0;
    for (int j = 0; j < 4; j++) {
 
      if (GetFINESSENwords(n, j) > 0) {
        //        m_reduced_rawcpr.CheckCRC16(i, j);
        nonzero_finesse_buf++;
      }
    }
    if (nonzero_finesse_buf == 0) {
      char err_buf[500];
      sprintf(err_buf, "No non-zero FINESSE buffer. Exiting...\n");
      printf("%s", err_buf); fflush(stdout);
      B2FATAL(err_buf);
    }
  }
 
  //    post_rawcopper_v2.CheckCRC16(0, 0);
  //       printf("fROM =======================================\n");
  //       for (int k = 0; k < nwords_buf_to; k++) {
  //  printf(" %.8x", GetBuffer(n)[ k ]);
  //  if ( ( k + 1 ) % 10 == 0) {
  //    printf("\n");
  //  }
  //       }
  //       printf("\n");
 
  //       printf("tO   =======================================\n");
  //       for (int k = 0; k < nwords_buf_to; k++) {
  //  printf(" %.8x", buf_to[ k ]);
  //  if ( ( k + 1 ) % 10 == 0) {
  //    printf("\n");
  //  }
  //       }
  //       printf("\n");
  //       printf("=============================================\n");
  return pos_nwords_to;
}

CopyReducedData()

void CopyReducedData	(	int *	bufin,
		int	nwords,
		int	num_events,
		int	num_nodes,
		int *	buf_to,
		int *	nwords_to
	)

reduce and merge header/trailer

Definition at line 1109 of file PreRawCOPPERFormat_v2.cc.

{
  //
  // Make a reduced buffer a total RawDataBlock (containing multiple data blocks)
  //
  RawDataBlockFormat radblk_fmt;
  int delete_flag = 0;
  radblk_fmt.SetBuffer(bufin, nwords, delete_flag, num_events, num_nodes);
 
  int pos_nwords_to = 0;
  for (int k = 0; k < radblk_fmt.GetNumEvents(); k++) {
    int num_nodes_in_sendblock = radblk_fmt.GetNumNodes();
    for (int l = 0; l < num_nodes_in_sendblock; l++) {
      int entry_id = l + k * num_nodes_in_sendblock;
      if (radblk_fmt.CheckFTSWID(entry_id) ||
          radblk_fmt.CheckTLUID(entry_id)) {
        radblk_fmt.CopyBlock(entry_id, buf_to + pos_nwords_to);
        pos_nwords_to += radblk_fmt.GetBlockNwords(entry_id);
 
      } else {
        SetBuffer(radblk_fmt.GetBuffer(entry_id),
                  radblk_fmt.GetBlockNwords(entry_id), 0, 1, 1);
 
        pos_nwords_to += CopyReducedBuffer(0, buf_to + pos_nwords_to);
 
 
      }
    }
  }
 
  *nwords_to = pos_nwords_to;
 
  return ;
}

FillTopBlockRawHeader()

unsigned int FillTopBlockRawHeader ( unsigned int  m_node_id, unsigned int  prev_eve32, unsigned int  prev_exprunsubrun_no, unsigned int *  cur_exprunsubrun_no  )

virtual

should be called by DeSerializerCOPPER.cc and fill contents in RawHeader

Implements RawCOPPERFormat.

Definition at line 466 of file PreRawCOPPERFormat_v2.cc.

{
  const int datablock_id = 0;
  //  m_temp_value = 12345678;
  //
  // This function only fills RawHeader contents for the first datablock.
  // # of block should be 1
  if (m_num_nodes * m_num_events != 1) {
    char err_buf[500];
    sprintf(err_buf,
            "[FATAL] This function should be used for PreRawCOPPERFormat_v2 containing only one datablock, while. this object has num_nodes of %d and num_events of %d\n %s %s %d\n",
            m_num_nodes, m_num_events,  __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    //    string err_str = err_buf;    throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  //
  // Fill info in RawHeader
  //
 
  //
  // Initialize a RawHeader part
  //
  memset(m_buffer, 0, sizeof(int) * tmp_header.RAWHEADER_NWORDS);
  m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] = static_cast<int>(tmp_header.RAWHEADER_NWORDS) & tmp_header.HDR_NWORDS_MASK;
  m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] |= (DATA_FORMAT_VERSION << tmp_header.FORMAT_VERSION_SHIFT) &
                                                  tmp_header.FORMAT_VERSION__MASK;
  m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] |= (0x80 << tmp_header.FORMAT_VERSION_SHIFT);   // PreFormat
  m_buffer[ tmp_header.POS_VERSION_HDRNWORDS ] |= tmp_header.MAGIC_WORD;
 
  //
  // Check FINESSEs which containes data
  //
  int* copper_buf = &(m_buffer[ tmp_header.RAWHEADER_NWORDS ]);
  if (copper_buf[ POS_CH_A_DATA_LENGTH ] == 0 &&
      copper_buf[ POS_CH_B_DATA_LENGTH ] == 0 &&
      copper_buf[ POS_CH_C_DATA_LENGTH ] == 0 &&
      copper_buf[ POS_CH_D_DATA_LENGTH ] == 0) {
    char err_buf[500];
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : No FINESSE data in a copper data block. Exiting...\n %s %s %d\n",
            hostname, -1,
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    //    string err_str = err_buf; throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  //
  //   Set total words info
  //
  int datablock_nwords =
    tmp_header.RAWHEADER_NWORDS +
    (copper_buf[ POS_DATA_LENGTH ]
     + SIZE_COPPER_DRIVER_HEADER
     + SIZE_COPPER_DRIVER_TRAILER)
    + tmp_trailer.RAWTRAILER_NWORDS;
  m_buffer[ tmp_header.POS_NWORDS ] = datablock_nwords;
 
 
  //
  // Check the consistency between data length and length in RawHeader
  //
  if (m_buffer[ tmp_header.POS_NWORDS ] != m_nwords) {
    char err_buf[500];
 
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : Data length is inconsistent m_nwords %d : nwords from COPPER data %d\n %s %s %d\n",
            hostname, -1,
            m_nwords, m_buffer[ tmp_header.POS_NWORDS ],
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    //    string err_str = err_buf; throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  //
  // Fill offset values
  //
  int offset_1st_finesse = static_cast<int>(tmp_header.RAWHEADER_NWORDS) + SIZE_COPPER_HEADER;
  int offset_2nd_finesse = offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ];
  int offset_3rd_finesse = offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ];
  int offset_4th_finesse = offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ];
  m_buffer[ tmp_header.POS_OFFSET_1ST_FINESSE ] = offset_1st_finesse;
  m_buffer[ tmp_header.POS_OFFSET_2ND_FINESSE ] = offset_2nd_finesse;
  m_buffer[ tmp_header.POS_OFFSET_3RD_FINESSE ] = offset_3rd_finesse;
  m_buffer[ tmp_header.POS_OFFSET_4TH_FINESSE ] = offset_4th_finesse;
 
  //
  // Fill Exp/Run value
  //
  int* finesse_buf = &
                     (m_buffer[ offset_1st_finesse ]); // In any finesse implementations, the top finesse buffer should be at offset_1st_finesse;
  m_buffer[ tmp_header.POS_EXP_RUN_NO ] = finesse_buf[ static_cast<int>(SIZE_B2LHSLB_HEADER) + POS_EXP_RUN ];
 
 
  //
  // Fill event #
  //
  unsigned int cur_ftsw_eve32 =  finesse_buf[ static_cast<int>(SIZE_B2LHSLB_HEADER) + POS_TT_TAG ];
  m_buffer[ tmp_header.POS_EVE_NO ] = cur_ftsw_eve32;
 
  //
  // Copy FTSW words from B2LFEE header
  //
  m_buffer[ tmp_header.POS_TTCTIME_TRGTYPE ] = finesse_buf[ static_cast<int>(SIZE_B2LHSLB_HEADER) + POS_TT_CTIME_TYPE ];
  m_buffer[ tmp_header.POS_TTUTIME ] = finesse_buf[ static_cast<int>(SIZE_B2LHSLB_HEADER) + POS_TT_UTIME ];
 
  //
  // Set node ID, trunc_mask, data_type
  //
  m_buffer[ tmp_header.POS_NODE_ID ] = m_node_id;
 
  //
  // Check error counts of b2link-packet CRC
  //
  //  m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] = ((m_trunc_mask << 31) & 0x80000000) | (m_data_type & 0x7FFFFFFF);
  //   printf("%.8x %.8x %.8x %.8x : %.8x\n",
  //   copper_buf[ POS_CH_A_DATA_LENGTH ], copper_buf[ POS_CH_B_DATA_LENGTH ],
  //   copper_buf[ POS_CH_C_DATA_LENGTH ], copper_buf[ POS_CH_D_DATA_LENGTH ], m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ] );
 
  m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] = 0;
  unsigned int ff55_higher_bits, ff55_lower_bits;
 
  if (copper_buf[ POS_CH_A_DATA_LENGTH ] != 0) {
    ff55_higher_bits = (unsigned int)(m_buffer[ offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ]) &
                       0xFFFF0000;
 
    ff55_lower_bits = m_buffer[ offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ] & 0xFFFF;
 
    if (ff55_higher_bits != 0xff550000) {
      char err_buf[500];
      char hostname[128];
      GetNodeName(hostname, m_node_id, sizeof(hostname));
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : HSLB slotA's trailer magic word(0xff55) is invalid. : eve %8u run %d foooter %.8x : %s %s %d\n",
              hostname, 0,
              cur_ftsw_eve32, (m_buffer[ tmp_header.POS_EXP_RUN_NO ] >> 8) & 0x3FFF,
              m_buffer[ offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("%s", err_buf); fflush(stdout);
      PrintData(m_buffer, m_nwords); fflush(stdout);
      B2FATAL(err_buf);
    }
 
    if (ff55_lower_bits != 0) {
      const int linkdown_bit = 15;
      //      const int packet_crcerr_bit = 8;
      char err_buf[1000];
      char hostname[128];
      GetNodeName(hostname, m_node_id, sizeof(hostname));
 
      if ((ff55_lower_bits & (1 << linkdown_bit)) != 0) {
        sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link down on slot A eve %8u foooter %.8x : %s %s %d\n",
                hostname, 0,
                cur_ftsw_eve32,
                m_buffer[ offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                __FILE__, __PRETTY_FUNCTION__, __LINE__);
        printf("%s", err_buf); fflush(stdout);
        PrintData(m_buffer, m_nwords);
        fflush(stdout);
        B2FATAL(err_buf);
      } else {
        if (((unsigned int)m_node_id & DETECTOR_MASK) == ARICH_ID) {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x1 << 28);
          sprintf(err_buf,
                  "[WARNING] %s ch=%d : ARICH : B2link packet CRC error slot A eve %8u foooter %.8x : This error is ignored and the error event will be recorded in .sroot file acording to request from ARICH group: %s %s %d\n",
                  hostname, 0,
                  cur_ftsw_eve32,
                  m_buffer[ offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
        } else {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x1 << 28);
          sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link packet CRC error slot A eve %8u foooter %.8x : %s %s %d\n",
                  hostname, 0,
                  cur_ftsw_eve32,
                  m_buffer[ offset_1st_finesse + copper_buf[ POS_CH_A_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
          B2FATAL(err_buf);
        }
      }
    }
  }
 
  if (copper_buf[ POS_CH_B_DATA_LENGTH ] != 0) {
    ff55_higher_bits = (unsigned int)(m_buffer[ offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ]) &
                       0xFFFF0000;
 
    ff55_lower_bits = (m_buffer[ offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ] & 0xFFFF);
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    if (ff55_higher_bits != 0xff550000) {
      char err_buf[500];
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : HSLB slotB's trailer magic word(0xff55) is invalid. : eve %8u run %d foooter %.8x : %s %s %d\n",
              hostname, 1,
              cur_ftsw_eve32, (m_buffer[ tmp_header.POS_EXP_RUN_NO ] >> 8) & 0x3FFF,
              m_buffer[ offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("%s", err_buf); fflush(stdout);
      PrintData(m_buffer, m_nwords); fflush(stdout);
      B2FATAL(err_buf);
    }
 
    if (ff55_lower_bits != 0) {
      char err_buf[1000];
      const int linkdown_bit = 15;
      //      const int packet_crcerr_bit = 8;
      if ((ff55_lower_bits & (1 << linkdown_bit)) != 0) {
        sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link down on slot B eve %8u foooter %.8x : %s %s %d\n",
                hostname, 1,
                cur_ftsw_eve32,
                m_buffer[ offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                __FILE__, __PRETTY_FUNCTION__, __LINE__);
        printf("%s", err_buf); fflush(stdout);
        PrintData(m_buffer, m_nwords);
        fflush(stdout);
        B2FATAL(err_buf);
      } else {
        if (((unsigned int)m_node_id & DETECTOR_MASK) == ARICH_ID) {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x2 << 28);
          sprintf(err_buf,
                  "[WARNING] %s ch=%d : ARICH : B2link packet CRC error slot B eve %8u foooter %.8x : This error is ignored and the error event will be recorded in .sroot file acording to request from ARICH group: %s %s %d\n",
                  hostname, 1,
                  cur_ftsw_eve32,
                  m_buffer[ offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
        } else {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x2 << 28);
          sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link packet CRC error slot B eve %8u foooter %.8x : %s %s %d\n",
                  hostname, 1,
                  cur_ftsw_eve32,
                  m_buffer[ offset_2nd_finesse + copper_buf[ POS_CH_B_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
          B2FATAL(err_buf);
        }
      }
    }
  }
 
  if (copper_buf[ POS_CH_C_DATA_LENGTH ] != 0) {
    ff55_higher_bits = (unsigned int)(m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ]) &
                       0xFFFF0000;
 
    ff55_lower_bits = (m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ] & 0xFFFF);
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    if (ff55_higher_bits != 0xff550000) {
      char err_buf[500];
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : HSLB slotC's trailer magic word(0xff55) is invalid. : eve %8u run %d foooter %.8x : %s %s %d\n",
              hostname, 2,
              cur_ftsw_eve32, (m_buffer[ tmp_header.POS_EXP_RUN_NO ] >> 8) & 0x3FFF,
              m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("%s", err_buf); fflush(stdout);
      PrintData(m_buffer, m_nwords); fflush(stdout);
      B2FATAL(err_buf);
    }
 
    if (ff55_lower_bits != 0) {
      char err_buf[1000];
      const int linkdown_bit = 15;
 
      if ((ff55_lower_bits & (1 << linkdown_bit)) != 0) {
        sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link down on slot C eve %8u foooter %.8x : %s %s %d\n",
                hostname, 2,
                cur_ftsw_eve32,
                m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                __FILE__, __PRETTY_FUNCTION__, __LINE__);
        printf("%s", err_buf); fflush(stdout);
        PrintData(m_buffer, m_nwords);
        fflush(stdout);
        B2FATAL(err_buf);
      } else {
        if (((unsigned int)m_node_id & DETECTOR_MASK) == ARICH_ID) {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x4 << 28);
          sprintf(err_buf,
                  "[WARNING] %s ch=%d : ARICH : B2link packet CRC error slot C eve %8u foooter %.8x : This error is ignored and the error event will be recorded in .sroot file acording to request from ARICH group: %s %s %d\n",
                  hostname, 2,
                  cur_ftsw_eve32,
                  m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
        } else {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x4 << 28);
          sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link packet CRC error slot C eve %8u foooter %.8x : %s %s %d\n",
                  hostname, 2,
                  cur_ftsw_eve32,
                  m_buffer[ offset_3rd_finesse + copper_buf[ POS_CH_C_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
          B2FATAL(err_buf);
        }
      }
 
    }
  }
 
  if (copper_buf[ POS_CH_D_DATA_LENGTH ] != 0) {
    ff55_higher_bits = (unsigned int)(m_buffer[ offset_4th_finesse + copper_buf[ POS_CH_D_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ]) &
                       0xFFFF0000;
 
    ff55_lower_bits = (m_buffer[ offset_4th_finesse + copper_buf[ POS_CH_D_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ] & 0xFFFF);
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    if (ff55_higher_bits != 0xff550000) {
      char err_buf[500];
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : HSLB slotD's trailer magic word(0xff55) is invalid. : eve %8u run %d foooter %.8x : %s %s %d\n",
              hostname, 3,
              cur_ftsw_eve32, (m_buffer[ tmp_header.POS_EXP_RUN_NO ] >> 8) & 0x3FFF,
              m_buffer[ offset_4th_finesse + copper_buf[ POS_CH_D_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("%s", err_buf); fflush(stdout);
      PrintData(m_buffer, m_nwords); fflush(stdout);
      B2FATAL(err_buf);
    }
 
    if (ff55_lower_bits != 0) {
      char err_buf[1000];
      const int linkdown_bit = 15;
 
      if ((ff55_lower_bits & (1 << linkdown_bit)) != 0) {
        sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link down on slot D eve %8u foooter %.8x : %s %s %d\n",
                hostname, 3,
                cur_ftsw_eve32,
                m_buffer[ offset_4th_finesse + copper_buf[ POS_CH_D_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                __FILE__, __PRETTY_FUNCTION__, __LINE__);
        printf("%s", err_buf); fflush(stdout);
        PrintData(m_buffer, m_nwords);
        fflush(stdout);
        B2FATAL(err_buf);
      } else {
        if (((unsigned int)m_node_id & DETECTOR_MASK) == ARICH_ID) {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x8) << 28;
          sprintf(err_buf,
                  "[WARNING] %s ch=%d : ARICH : B2link packet CRC error slot D eve %8u foooter %.8x : This error is ignored and the error event will be recorded in .sroot file acording to request from ARICH group: %s %s %d\n",
                  hostname, 3,
                  cur_ftsw_eve32,
                  m_buffer[ offset_4th_finesse + copper_buf[ POS_CH_D_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
        } else {
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= tmp_header.B2LINK_PACKET_CRC_ERROR;
          m_buffer[ tmp_header.POS_TRUNC_MASK_DATATYPE ] |= (unsigned int)(0x8) << 28;
          sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : B2link packet CRC error slot D eve %8u foooter %.8x : %s %s %d\n",
                  hostname, 3,
                  cur_ftsw_eve32,
                  m_buffer[ offset_4th_finesse + copper_buf[ POS_CH_D_DATA_LENGTH ] - SIZE_B2LHSLB_HEADER ],
                  __FILE__, __PRETTY_FUNCTION__, __LINE__);
          printf("%s", err_buf); fflush(stdout);
          PrintData(m_buffer, m_nwords);
          fflush(stdout);
          B2FATAL(err_buf);
        }
      }
    }
  }
 
 
  //
  // Fill info in RawTrailer
  //
 
  //
  // Calculate XOR checksum
  //
  unsigned int chksum_top = 0, chksum_body = 0, chksum_bottom = 0;
 
  int top_end = tmp_header.RAWHEADER_NWORDS;
  for (int i = 0; i < top_end; i++) {
    chksum_top ^= m_buffer[ i ];
  }
  int body_end = datablock_nwords - SIZE_COPPER_DRIVER_TRAILER - tmp_trailer.RAWTRAILER_NWORDS;
  for (int i = top_end; i < body_end; i++) {
    chksum_body ^= m_buffer[ i ];
  }
 
  int bottom_end = datablock_nwords - tmp_trailer.RAWTRAILER_NWORDS;
  for (int i = body_end; i < bottom_end; i++) {
    chksum_bottom ^= m_buffer[ i ];
  }
 
  //
  // check COPPER driver checksum
  //
  if (chksum_body != (unsigned int)(m_buffer[ body_end ])) {
    char err_buf[500];
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    sprintf(err_buf, "[FATAL] %s ch=%d : ERROR_EVENT : COPPER driver checksum is not consistent.: calcd. %.8x data %.8x\n %s %s %d\n",
            hostname, -1,
            chksum_body, m_buffer[ body_end ],
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  //
  // Fill trailer info (checksum, magic word)
  //
  unsigned int chksum = chksum_top ^ chksum_body ^ chksum_bottom;
  int* trl = &(m_buffer[ datablock_nwords - tmp_trailer.RAWTRAILER_NWORDS ]);
  trl[ tmp_trailer.POS_CHKSUM ] = chksum;
  trl[ tmp_trailer.POS_TERM_WORD ] = tmp_trailer.MAGIC_WORD_TERM_TRAILER;
 
 
  //
  // Data check ( magic word, event incrementation )
  //
 
 
  //
  // check magic words
  //
  int* fpga_trailer_magic = trl - (SIZE_COPPER_TRAILER - POS_MAGIC_COPPER_3);
  int* driver_trailer_magic = trl - (SIZE_COPPER_TRAILER - POS_MAGIC_COPPER_4);
  int err_flag = 0;
  if ((unsigned int)(copper_buf[ POS_MAGIC_COPPER_1 ]) != COPPER_MAGIC_DRIVER_HEADER) {
    err_flag = 1;
  } else if ((unsigned int)(copper_buf[ POS_MAGIC_COPPER_2 ]) != COPPER_MAGIC_FPGA_HEADER) {
    err_flag = 1;
  } else if ((unsigned int)(*fpga_trailer_magic) != COPPER_MAGIC_FPGA_TRAILER) {
    err_flag = 1;
  } else if ((unsigned int)(*driver_trailer_magic) != COPPER_MAGIC_DRIVER_TRAILER) {
    err_flag = 1;
  }
  if (err_flag == 1) {
    char err_buf[500];
    char hostname[128];
    GetNodeName(hostname, m_node_id, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : Invalid Magic word 0x7FFFF0008=%u 0xFFFFFAFA=%u 0xFFFFF5F5=%u 0x7FFF0009=%u\n %s %s %d\n",
            hostname, -1,
            GetMagicDriverHeader(datablock_id),
            GetMagicFPGAHeader(datablock_id),
            GetMagicFPGATrailer(datablock_id),
            GetMagicDriverTrailer(datablock_id),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("[DEBUG] %s\n", err_buf);
#ifndef NO_ERROR_STOP
    B2FATAL(err_buf); // to reduce multiple error messages
#endif
  }
 
  //
  // check incrementation of event #
  //
 
 
  *cur_exprunsubrun_no = GetExpRunSubrun(datablock_id);
 
  //   if ((unsigned int)cur_ftsw_eve32 < 50) {
  //     printf("EVENT OUTPUT ########## %u\n", cur_ftsw_eve32);
  //     PrintData(GetBuffer(datablock_id), TotalBufNwords());
  //   }
  if (prev_exprunsubrun_no == *cur_exprunsubrun_no) {
    if (prev_eve32 + 1 != cur_ftsw_eve32) {
      unsigned int eve[4] = {0xbaadf00d, 0xbaadf00d, 0xbaadf00d, 0xbaadf00d };
#ifndef NO_ERROR_STOP
      if (m_num_nodes * m_num_events != 1) {
        char err_buf[500];
        sprintf(err_buf,
                "[FATAL] This function should be used for PreRawCOPPERFormat_v2 containing only one datablock, while. this object has num_nodes of %d and num_events of %d\n %s %s %d\n",
                m_num_nodes, m_num_events,  __FILE__, __PRETTY_FUNCTION__, __LINE__);
        printf("%s", err_buf); fflush(stdout);
        //    string err_str = err_buf;    throw (err_str);
        B2FATAL(err_buf); // to reduce multiple error messages
      } else {
        for (int i = 0; i < 4 ; i++) {
          // Only one block is in this m_buffer[] when m_num_nodes*m_num_events=1
          // 0 is specified as a block number
          if (GetFINESSENwords(0, i) > 0) {
            int pos_nwords = GetOffsetFINESSE(0, i) + SIZE_B2LHSLB_HEADER + POS_TT_TAG;
            eve[ i ] = m_buffer[ pos_nwords ];
          }
        }
      }
 
      char err_buf[500];
      char hostname[128];
      GetNodeName(hostname, m_node_id, sizeof(hostname));
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : Invalid event_number. Exiting...: cur 32bit eve %u preveve %u ( A:0x%.8x B:0x%.8x C:0x%.8x D:0x%.8x ) prun %u crun %u\n %s %s %d\n",
              hostname, -1,
              cur_ftsw_eve32, prev_eve32,
              eve[ 0 ], eve[ 1 ], eve[ 2 ], eve[ 3 ],
              prev_exprunsubrun_no, *cur_exprunsubrun_no,
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("[DEBUG] %s\n", err_buf);
 
      // string err_str = err_buf;
      printf("[DEBUG] i= %d : num entries %d : Tot words %d\n", 0, GetNumEntries(), TotalBufNwords());
      PrintData(GetBuffer(datablock_id), TotalBufNwords());
 
      for (int i = 0; i < 4; i++) {
        printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", datablock_id, i);
        if (GetFINESSENwords(datablock_id, i) > 0) {
          CheckCRC16(datablock_id, i);
        }
      }
      printf("[DEBUG] ========== No CRC error : block %d =========\n", datablock_id);
      //      throw (err_str);
      B2FATAL(err_buf); // to reduce multiple error messages
#endif
 
    }
  }
 
  return cur_ftsw_eve32;
 
}

GetB2LFEE32bitEventNumber()

unsigned int GetB2LFEE32bitEventNumber ( int  n )

virtual

get b2l block from "FEE b2link header"

Implements RawCOPPERFormat.

Definition at line 113 of file PreRawCOPPERFormat_v2.cc.

{
 
#ifndef READ_OLD_B2LFEE_FORMAT_FILE
 
  int err_flag = 0;
  unsigned int eve_num = 0;
  int flag = 0;
  unsigned int eve[4];
  for (int i = 0; i < 4 ; i++) {
    eve[ i ] = 0xbaadf00d;
    if (GetFINESSENwords(n, i) > 0) {
      int pos_nwords = GetOffsetFINESSE(n, i) + SIZE_B2LHSLB_HEADER + POS_TT_TAG;
      eve[ i ] = m_buffer[ pos_nwords ];
      if (flag != 1) eve_num = eve[ i ];
      if (eve_num != eve[ i ]) err_flag = 1;
      flag = 1;
    }
  }
 
  if (flag == 0) {
    PrintData(m_buffer, m_nwords);
    char err_buf[500];
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : No HSLB data in COPPER data. Exiting... : eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
            hostname, -1,
            GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    //    string err_str = err_buf; throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
 
  if (err_flag == 1) {
    char err_buf[500];
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : CORRUPTED DATA: Different event number over HSLBs : slot A 0x%.8x : B 0x%.8x :C 0x%.8x : D 0x%.8x : eve 0x%x exp %d run %d sub %d\n%s %s %d\n",
            hostname, -1,
            eve[ 0 ], eve[ 1 ], eve[ 2 ], eve[ 3 ],
            GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("[DEBUG] %s\n", err_buf);
    PrintData(m_buffer, m_nwords);
    for (int i = 0; i < 4; i++) {
      printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
      if (GetFINESSENwords(n, i) > 0) {
        CheckCRC16(n, i);
      }
    }
    printf("[DEBUG] ========== No CRC error. : block %d =========\n", n);
#ifndef NO_ERROR_STOP
    //    string err_str = err_buf; throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
#endif //NO_ERROR_STOP
  }
  return eve_num;
 
#else // READ_OLD_B2LFEE_FORMAT_FILE
 
  char err_buf[500];
  sprintf(err_buf, "[FATAL] You need comment out READ_OLD_B2LFEE_FORMAT_FILE if you are handling a new data format\n%s %s %d\n",
          __FILE__, __PRETTY_FUNCTION__, __LINE__);
  printf("%s", err_buf); fflush(stdout);
  B2FATAL(err_buf); // to reduce multiple error messages
#endif // READ_OLD_B2LFEE_FORMAT_FILE
 
}

GetBlockNwords()

int GetBlockNwords ( int  n )

virtualinherited

get size of a data block

Definition at line 107 of file RawDataBlockFormat.cc.

{
  int size;
  if (n == (m_num_events * m_num_nodes) - 1) {
    size =  m_nwords - GetBufferPos(n);
  } else {
    size = GetBufferPos(n + 1) - GetBufferPos(n);
  }
  return size;
}

GetBuffer()

int * GetBuffer ( int  n )

virtualinherited

get nth buffer pointer

Definition at line 124 of file RawDataBlockFormat.cc.

{
  int pos_nwords = GetBufferPos(n);
  return &(m_buffer[ pos_nwords ]);
}

GetBufferPos()

int GetBufferPos ( int  n )

virtualinherited

get position of data block in word

Definition at line 30 of file RawDataBlockFormat.cc.

{
  if (m_buffer == NULL || m_nwords <= 0) {
    char err_buf[500];
    sprintf(err_buf, "[FATAL] RawPacket buffer(%p) is not available or length(%d) is not set.\n %s %s %d\n",
            m_buffer, m_nwords, __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf);
  }
 
  if (n >= (m_num_events * m_num_nodes)) {
    char err_buf[500];
    sprintf(err_buf, "[FATAL] Invalid COPPER block No. (%d : max %d ) is specified. Exiting... \n %s %s %d\n",
            n, (m_num_events * m_num_nodes), __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf);
  }
 
  int pos_nwords = 0;
  for (int i = 1; i <= n ; i++) {
    if (m_buffer[ pos_nwords ] <= 0) {
      char err_buf[500];
      sprintf(err_buf,
              "[FATAL] ERROR_EVENT : length of this data block is strange ( %d words ). Maybe data is corrupted or RawHeader info has not been filled yet. Exiting...",
              m_buffer[ pos_nwords ]);
      printf("%s", err_buf);
      B2FATAL(err_buf);
    } else {
      pos_nwords +=      m_buffer[ pos_nwords ];
    }
    if (pos_nwords >= m_nwords) {
      char err_buf[500];
      sprintf(err_buf, "[FATAL] ERROR_EVENT : value of pos_nwords(%d) is larger than m_nwords(%d). Exiting...\n %s %s %d\n",
              pos_nwords, m_nwords, __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("%s", err_buf); fflush(stdout);
      B2FATAL(err_buf); // to reduce multiple error messages
    }
  }
  return pos_nwords;
 
}

GetDetectorBuffer()

int * GetDetectorBuffer ( int  n, int  finesse_num  )

virtualinherited

get Detector buffer

Reimplemented in PostRawCOPPERFormat_latest, and PreRawCOPPERFormat_latest.

Definition at line 94 of file RawCOPPERFormat.cc.

{
  switch (finesse_num) {
    case 0 :
      return Get1stDetectorBuffer(n);
      break;
    case 1 :
      return Get2ndDetectorBuffer(n);
      break;
    case 2 :
      return Get3rdDetectorBuffer(n);
      break;
    case 3 :
      return Get4thDetectorBuffer(n);
      break;
    default :
      break;
  }
 
  char err_buf[500];
  sprintf(err_buf, "[FATAL] Specifined FINESSE number( = %d ) is invalid. Exiting...\n%s %s %d\n", finesse_num,
          __FILE__, __PRETTY_FUNCTION__, __LINE__);
  printf("%s", err_buf); fflush(stdout);
  B2FATAL(err_buf);
}

GetDetectorNwords()

int GetDetectorNwords ( int  n, int  finesse_num  )

virtual

get Detector buffer length

Implements RawCOPPERFormat.

Definition at line 43 of file PreRawCOPPERFormat_v2.cc.

{
 
  int nwords = 0;
  if (GetFINESSENwords(n, finesse_num) > 0) {
    nwords = GetFINESSENwords(n, finesse_num)
             - (static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LHSLB_TRAILER +  SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER);
  }
  return nwords;
 
}

GetEventCRC16Value()

int GetEventCRC16Value ( int  n, int  finesse_num  )

virtualinherited

Get Event CRC16 value.

Reimplemented in PostRawCOPPERFormat_latest, and PostRawCOPPERFormat_v2.

Definition at line 145 of file RawCOPPERFormat.cc.

{
  char err_buf[500];
  sprintf(err_buf,
          "[FATAL] This function is not supported in the version of  RawCOPPER format that you're using. n=%d fin=%d : %s %s %d: Exiting...\n",
          n, finesse_num, __FILE__, __PRETTY_FUNCTION__, __LINE__);
  printf("%s\n", err_buf); fflush(stdout);
  B2FATAL(err_buf);
  return -1;
}

GetFINESSEBuffer()

int * GetFINESSEBuffer ( int  n, int  finesse_num  )

virtualinherited

get FINESSE buffer pointer

Reimplemented in RawCOPPERFormat_latest.

Definition at line 65 of file RawCOPPERFormat.cc.

{
  switch (finesse_num) {
    case 0 :
      return Get1stFINESSEBuffer(n);
      break;
    case 1 :
      return Get2ndFINESSEBuffer(n);
      break;
    case 2 :
      return Get3rdFINESSEBuffer(n);
      break;
    case 3 :
      return Get4thFINESSEBuffer(n);
      break;
    default :
      break;
  }
 
  char err_buf[500];
  sprintf(err_buf, "[FATAL] Specifined FINESSE number( = %d ) is invalid. Exiting...\n%s %s %d\n", finesse_num,
          __FILE__, __PRETTY_FUNCTION__, __LINE__);
  printf("%s", err_buf); fflush(stdout);
  B2FATAL(err_buf);
}

GetFINESSENwords()

int GetFINESSENwords ( int  n, int  finesse  )

virtual

get data size of FINESSE buffer

Implements RawCOPPERFormat.

Definition at line 56 of file PreRawCOPPERFormat_v2.cc.

{
  if (!CheckCOPPERMagic(n)) {
    char err_buf[500];
    char hostname[128];
    GetNodeName(n, hostname, sizeof(hostname));
    sprintf(err_buf,
            "[FATAL] %s ch=%d : ERROR_EVENT : COPPER's magic word is invalid. Exiting... Maybe it is due to data corruption or different version of the data format. : slot%c eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
            hostname, finesse_num,
            65 + finesse_num, GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("[DEBUG] %s", err_buf); fflush(stdout);
    PrintData(m_buffer, m_nwords);
 
    for (int i = 0; i < 4; i++) {
      printf("[DEBUG] ========== CRC check : block # %d finesse %d ==========\n", n, i);
      if (GetFINESSENwords(n, i) > 0) {
        CheckCRC16(n, i);
      }
    }
    printf("[DEBUG] ========== No CRC error. : block %d =========\n", n);
    // string err_str = err_buf;   throw (err_str);
    B2FATAL(err_buf); // to reduce multiple error messages
  }
  int pos_nwords;
  switch (finesse_num) {
    case 0 :
      pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_A_DATA_LENGTH;
      break;
    case 1 :
      pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_B_DATA_LENGTH;
      break;
    case 2 :
      pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_C_DATA_LENGTH;
      break;
    case 3 :
      pos_nwords = GetBufferPos(n) + tmp_header.RAWHEADER_NWORDS + POS_CH_D_DATA_LENGTH;
      break;
    default :
      char err_buf[500];
      char hostname[128];
      GetNodeName(n, hostname, sizeof(hostname));
      sprintf(err_buf,
              "[FATAL] %s ch=%d : ERROR_EVENT : Specified FINESSE number( = %d ) is invalid. Exiting... : slot%c eve 0x%x exp %d run %d sub %d\n %s %s %d\n",
              hostname, finesse_num,
              finesse_num,
              65 + finesse_num, GetEveNo(n), GetExpNo(n), GetRunNo(n), GetSubRunNo(n),
              __FILE__, __PRETTY_FUNCTION__, __LINE__);
      printf("%s", err_buf); fflush(stdout);
      //      string err_str = err_buf;    throw (err_str);
      B2FATAL(err_buf); // to reduce multiple error messages
  }
  return m_buffer[ pos_nwords ];
 
}

GetNodeName() [1/2]

void GetNodeName ( char *  node_name, unsigned int  node_id, int  bufsize  )

virtualinherited

Get hostname of a node from an argument.

Definition at line 200 of file RawCOPPERFormat.cc.

{
  if (node_name == NULL || node_id == 0 || bufsize < 20) {
    char err_buf[500];
    sprintf(err_buf,
            "[FATAL] Null pointer or strange node_id(%.8x)in an argument of this function. Exiting... : \n%s %s %d\n",
            node_id,
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf); // to reduce multiple error messages
  } else {
    sprintf(node_name, "cpr%u",
            (10 * (node_id >> 28) + (node_id >> 24)) * 1000 +
            (node_id & COPPERID_MASK));
  }
}

GetNodeName() [2/2]

void GetNodeName ( int  n, char *  node_name, int  bufsize  )

virtualinherited

Get hostname of a node from the RawCOPPER header.

Definition at line 182 of file RawCOPPERFormat.cc.

{
  unsigned int node_id = GetNodeID(n);
  if (node_name == NULL || node_id == 0 || bufsize < 20) {
    char err_buf[500];
    sprintf(err_buf,
            "[FATAL] Null pointer or strange node_id(%.8x)in an argument of this function. Exiting... : \n%s %s %d\n",
            node_id,
            __FILE__, __PRETTY_FUNCTION__, __LINE__);
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf); // to reduce multiple error messages
  } else {
    sprintf(node_name, "cpr%u",
            (10 * (node_id >> 28) + (node_id >> 24)) * 1000 +
            (node_id & COPPERID_MASK));
  }
}

GetNumEntries()

virtual int GetNumEntries ( )

inlinevirtualinherited

get # of data blocks = (# of nodes)*(# of events)

Definition at line 49 of file RawDataBlockFormat.h.

{ return m_num_events * m_num_nodes; }

GetNumEvents()

virtual int GetNumEvents ( )

inlinevirtualinherited

get # of events in m_buffer

Definition at line 55 of file RawDataBlockFormat.h.

{ return m_num_events; }

GetNumFINESSEBlock()

int GetNumFINESSEBlock ( int  n )

virtualinherited

get # of FINNESEs which contains data

Implements RawCOPPERFormat.

Definition at line 29 of file RawCOPPERFormat_v2.cc.

{
  int cnt = 0;
  for (int i = 0; i < 4; i++) {
    if (GetFINESSENwords(n, i) > 0) {
      cnt++;
    }
  }
  return cnt;
}

GetNumNodes()

virtual int GetNumNodes ( )

inlinevirtualinherited

get # of data sources(e.g. # of COPPER boards) in m_buffer

Definition at line 52 of file RawDataBlockFormat.h.

{ return m_num_nodes; }

GetOffsetFINESSE()

int GetOffsetFINESSE ( int  n, int  finesse  )

virtualinherited

get # of offset words

Definition at line 36 of file RawCOPPERFormat.cc.

{
  switch (finesse_num) {
    case 0 :
      return GetOffset1stFINESSE(n);
      break;
    case 1 :
      return GetOffset2ndFINESSE(n);
      break;
    case 2 :
      return GetOffset3rdFINESSE(n);
      break;
    case 3 :
      return GetOffset4thFINESSE(n);
      break;
    default :
      break;
  }
 
  char err_buf[500];
  sprintf(err_buf, "[FATAL] Specifined FINESSE number( = %d ) is invalid. Exiting...\n%s %s %d\n", finesse_num,
          __FILE__, __PRETTY_FUNCTION__, __LINE__);
  printf("%s", err_buf); fflush(stdout);
  B2FATAL(err_buf);
}

GetPreAllocFlag()

virtual int GetPreAllocFlag ( )

inlinevirtualinherited

get malloc_flag

Definition at line 58 of file RawDataBlockFormat.h.

{ return m_use_prealloc_buf; }

GetWholeBuffer()

int * GetWholeBuffer ( )

virtualinherited

get pointer to buffer(m_buffer)

Definition at line 119 of file RawDataBlockFormat.cc.

{
  return m_buffer;
}

PackDetectorBuf() [1/2]

int * PackDetectorBuf ( int *  packed_buf_nwords, int *const(&)  detector_buf_ch[MAX_PCIE40_CH], int const(&)  nwords_ch[MAX_PCIE40_CH], RawCOPPERPackerInfo  rawcpr_info  )

virtualinherited

Pack data for PCIe40 data-format.

Reimplemented in PostRawCOPPERFormat_latest, and PreRawCOPPERFormat_latest.

Definition at line 156 of file RawCOPPERFormat.cc.

{
  char err_buf[500];
  sprintf(err_buf,
          "[FATAL] This function is not supported in the version of  RawCOPPER format that you're using. : %s %s %d: Exiting...\n", __FILE__,
          __PRETTY_FUNCTION__, __LINE__);
  printf("%s\n", err_buf); fflush(stdout);
  B2FATAL(err_buf);
  return NULL;
}

PackDetectorBuf() [2/2]

int * PackDetectorBuf ( int *  packed_buf_nwords, 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  )

virtual

Pack data (format ver. = -1 -> Select the latest format version)

Implements RawCOPPERFormat.

Definition at line 1485 of file PreRawCOPPERFormat_v2.cc.

{
  int* packed_buf = NULL;
 
  int poswords_to = 0;
  int* detector_buf[ 4 ] = { detector_buf_1st, detector_buf_2nd, detector_buf_3rd, detector_buf_4th };
  const int nwords[ 4 ] = { nwords_1st, nwords_2nd, nwords_3rd, nwords_4th };
 
  // calculate the event length
  int length_nwords = tmp_header.GetHdrNwords() + SIZE_COPPER_HEADER + SIZE_COPPER_TRAILER + tmp_trailer.GetTrlNwords();
 
  for (int i = 0; i < 4; i++) {
    if (detector_buf[ i ] == NULL || nwords[ i ] <= 0) continue;    // for an empty FINESSE slot
    length_nwords += nwords[ i ];
    length_nwords += static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER
                     + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
  }
 
  // allocate buffer
  packed_buf = new int[ length_nwords ];
  memset(packed_buf, 0, sizeof(int) * length_nwords);
 
  //
  // Fill RawHeader
  //
  tmp_header.SetBuffer(packed_buf);
 
  packed_buf[ tmp_header.POS_NWORDS ] = length_nwords; // total length
  packed_buf[ tmp_header.POS_VERSION_HDRNWORDS ] = 0x7f7f8000
                                                   | ((DATA_FORMAT_VERSION << tmp_header.FORMAT_VERSION_SHIFT) & tmp_header.FORMAT_VERSION__MASK)
                                                   | tmp_header.RAWHEADER_NWORDS; // ver.#, header length
  packed_buf[ tmp_header.POS_EXP_RUN_NO ] = (rawcpr_info.exp_num << tmp_header.EXP_SHIFT)
                                            | (rawcpr_info.run_subrun_num & 0x003FFFFF);   // exp. and run #
  packed_buf[ tmp_header.POS_EVE_NO ] = rawcpr_info.eve_num; // eve #
  packed_buf[ tmp_header.POS_TTCTIME_TRGTYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4;   // tt_ctime
  packed_buf[ tmp_header.POS_TTUTIME ] = rawcpr_info.tt_utime; // tt_utime
  packed_buf[ tmp_header.POS_NODE_ID ] = rawcpr_info.node_id; // node ID
 
 
 
 
  // fill the positions of finesse buffers
  packed_buf[ tmp_header.POS_OFFSET_1ST_FINESSE ] = static_cast<int>(tmp_header.RAWHEADER_NWORDS) + SIZE_COPPER_HEADER;
 
  packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_1ST_FINESSE ];
  if (nwords[ 0 ] > 0) {
    packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ] +=
      nwords[ 0 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER  + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
  }
 
  packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_2ND_FINESSE ];
  if (nwords[ 1 ] > 0) {
    packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ] +=
      nwords[ 1 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER  + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
  }
 
  packed_buf[ tmp_header.POS_OFFSET_4TH_FINESSE ] = packed_buf[ tmp_header.POS_OFFSET_3RD_FINESSE ];
  if (nwords[ 2 ] > 0) {
    packed_buf[ tmp_header.POS_OFFSET_4TH_FINESSE ] += nwords[ 2 ] + SIZE_B2LHSLB_HEADER + SIZE_B2LFEE_HEADER  + SIZE_B2LFEE_TRAILER +
                                                       SIZE_B2LHSLB_TRAILER;
  }
  poswords_to += tmp_header.GetHdrNwords();
 
  // Fill COPPER header
  packed_buf[ poswords_to + POS_MAGIC_COPPER_1 ] = COPPER_MAGIC_DRIVER_HEADER;
  packed_buf[ poswords_to + POS_MAGIC_COPPER_2 ] = COPPER_MAGIC_FPGA_HEADER;
  packed_buf[ poswords_to + POS_EVE_NUM_COPPER ] = rawcpr_info.eve_num;
 
  int size_b2l_hdrtrl = static_cast<int>(SIZE_B2LHSLB_HEADER) + SIZE_B2LFEE_HEADER + SIZE_B2LFEE_TRAILER + SIZE_B2LHSLB_TRAILER;
  if (nwords[ 0 ] != 0)  packed_buf[ poswords_to + POS_CH_A_DATA_LENGTH ] = nwords[ 0 ] + size_b2l_hdrtrl;
  if (nwords[ 1 ] != 0)  packed_buf[ poswords_to + POS_CH_B_DATA_LENGTH ] = nwords[ 1 ] + size_b2l_hdrtrl;
  if (nwords[ 2 ] != 0)  packed_buf[ poswords_to + POS_CH_C_DATA_LENGTH ] = nwords[ 2 ] + size_b2l_hdrtrl;
  if (nwords[ 3 ] != 0)  packed_buf[ poswords_to + POS_CH_D_DATA_LENGTH ] = nwords[ 3 ] + size_b2l_hdrtrl;
 
  packed_buf[ poswords_to + POS_DATA_LENGTH ] =
    packed_buf[ poswords_to + POS_CH_A_DATA_LENGTH ] +
    packed_buf[ poswords_to + POS_CH_B_DATA_LENGTH ] +
    packed_buf[ poswords_to + POS_CH_C_DATA_LENGTH ] +
    packed_buf[ poswords_to + POS_CH_D_DATA_LENGTH ] +
    (static_cast<int>(SIZE_COPPER_HEADER) - SIZE_COPPER_DRIVER_HEADER) +
    (static_cast<int>(SIZE_COPPER_TRAILER) - SIZE_COPPER_DRIVER_TRAILER);
 
  poswords_to += SIZE_COPPER_HEADER;
 
  // Fill FINESSE buffer
  for (int i = 0; i < 4; i++) {
 
    if (detector_buf[ i ] == NULL || nwords[ i ] <= 0) continue;     // for an empty FINESSE slot
 
    // Fill b2link HSLB header
    packed_buf[ poswords_to + POS_MAGIC_B2LHSLB ] = 0xffaa0000 | (0xffff & rawcpr_info.eve_num);
    poswords_to += SIZE_B2LHSLB_HEADER;
    int* crc16_start = &(packed_buf[ poswords_to ]);
 
    // Fill b2link FEE header
 
    packed_buf[ poswords_to + POS_TT_CTIME_TYPE ] = (rawcpr_info.tt_ctime & 0x7FFFFFF) << 4;
    unsigned int temp_ctime_type = packed_buf[ poswords_to + POS_TT_CTIME_TYPE ];
    packed_buf[ poswords_to + POS_TT_TAG ] = rawcpr_info.eve_num;
    packed_buf[ poswords_to + POS_TT_UTIME ] = rawcpr_info.tt_utime;
    packed_buf[ poswords_to + POS_EXP_RUN ] = (rawcpr_info.exp_num << tmp_header.EXP_SHIFT) | (rawcpr_info.run_subrun_num &
                                              0x003FFFFF);   // exp. and run #
    packed_buf[ poswords_to + POS_B2L_CTIME ] = (rawcpr_info.b2l_ctime & 0x7FFFFFF) << 4;
    poswords_to += SIZE_B2LFEE_HEADER;
 
    // copy the 1st Detector Buffer
    memcpy(packed_buf + poswords_to, detector_buf[ i ], nwords[ i ]*sizeof(int));
    poswords_to += nwords[ i ];
 
    // Fill b2link b2tt-tag trailer
    packed_buf[ poswords_to + POS_TT_CTIME_B2LFEE ] = temp_ctime_type;
 
    // Fill b2link FEE trailer
    unsigned short crc16 = CalcCRC16LittleEndian(0xffff, crc16_start, nwords[ i ] + SIZE_B2LFEE_HEADER);
    packed_buf[ poswords_to + POS_CHKSUM_B2LFEE ] = ((0xffff & rawcpr_info.eve_num) << 16) | (crc16 & 0xffff);
    poswords_to += SIZE_B2LFEE_TRAILER;
 
    // Fill b2link HSLB trailer
    packed_buf[ poswords_to + POS_CHKSUM_B2LHSLB ] = 0xff550000;
    poswords_to += SIZE_B2LHSLB_TRAILER;
 
  }
 
  // Fill COPPER trailer
  packed_buf[ poswords_to + POS_MAGIC_COPPER_3 ] = COPPER_MAGIC_FPGA_TRAILER;
  packed_buf[ poswords_to + POS_MAGIC_COPPER_4 ] = COPPER_MAGIC_DRIVER_TRAILER;
  unsigned int chksum = 0;
  for (int i = tmp_header.GetHdrNwords(); i < poswords_to + (static_cast<int>(SIZE_COPPER_TRAILER) - SIZE_COPPER_DRIVER_TRAILER);
       i++) {
    chksum ^= packed_buf[ i ];
  }
  packed_buf[ poswords_to + POS_CHKSUM_COPPER ] = chksum;
  poswords_to += SIZE_COPPER_TRAILER;
 
  // Calculate RawCOPPER checksum and fill RawTrailer
  chksum = 0;
  for (int i = 0; i < poswords_to; i++) {
    chksum ^= packed_buf[ i ];
  }
  packed_buf[ poswords_to + tmp_trailer.POS_CHKSUM ] = chksum;
 
  packed_buf[ poswords_to + tmp_trailer.POS_TERM_WORD ] = tmp_trailer.MAGIC_WORD_TERM_TRAILER;
  poswords_to += tmp_trailer.GetTrlNwords();
 
  *packed_buf_nwords = poswords_to;
  return packed_buf;
}

PrintData()

void PrintData ( int *  buf, int  nwords  )

virtualinherited

print data

Definition at line 161 of file RawDataBlockFormat.cc.

{
  printf("[DEBUG] ");
  for (int i = 0; i < nwords; i++) {
    printf("%.8x ", buf[ i ]);
    if (i % 10 == 9) printf("\n[DEBUG] ");
  }
  printf("\n[DEBUG] ");
  printf("\n");
  return;
}

SetBuffer()

void SetBuffer ( int *  bufin, int  nwords, int  delete_flag, int  num_events, int  num_nodes  )

virtualinherited

set buffer ( delete_flag : m_buffer is freeed( = 0 )/ not freeed( = 1 ) in Destructer )

Definition at line 131 of file RawDataBlockFormat.cc.

{
 
  if (bufin == NULL) {
    char err_buf[500];
    sprintf(err_buf, "[DEBUG] bufin is NULL. Exting...\n");
    printf("%s", err_buf); fflush(stdout);
    B2FATAL(err_buf);
  }
 
  if (!m_use_prealloc_buf && m_buffer != NULL) delete[] m_buffer;
 
  if (delete_flag == 0) {
    m_use_prealloc_buf = true;
  } else {
    m_use_prealloc_buf = false;
  }
 
  m_nwords = nwords;
  m_buffer = bufin;
 
  m_num_nodes = num_nodes;
  m_num_events = num_events;
 
  return;
 
}

TotalBufNwords()

int TotalBufNwords ( )

virtualinherited

Get total length of m_buffer.

Definition at line 101 of file RawDataBlockFormat.cc.

{
  return m_nwords;
}

Member Data Documentation

m_buffer

int* m_buffer

protectedinherited

Buffer.

Definition at line 98 of file RawDataBlockFormat.h.

m_num_events

int m_num_events

protectedinherited

number of events in this object

Definition at line 95 of file RawDataBlockFormat.h.

m_num_nodes

int m_num_nodes

protectedinherited

number of nodes in this object

Definition at line 92 of file RawDataBlockFormat.h.

m_nwords

int m_nwords

protectedinherited

number of words of buffer

Definition at line 89 of file RawDataBlockFormat.h.

m_reduced_rawcpr

PostRawCOPPERFormat_v2 m_reduced_rawcpr

data fromat after size reduction

Definition at line 287 of file PreRawCOPPERFormat_v2.h.

m_use_prealloc_buf

int m_use_prealloc_buf

protectedinherited

not recorded

flag for deleting m_buffer in destructer( 0:delete, 1: not delete) When using pre-allocated buffer, the buffer should be reused and not deleted in the destructer

Definition at line 102 of file RawDataBlockFormat.h.

tmp_header

RawHeader_v2 tmp_header

inherited

header ( not recorded )

Definition at line 192 of file RawCOPPERFormat_v2.h.

tmp_trailer

RawTrailer_v2 tmp_trailer

inherited

trailer ( not recorded )

Definition at line 195 of file RawCOPPERFormat_v2.h.

---

The documentation for this class was generated from the following files:

• rawdata/dataobjects/include/PreRawCOPPERFormat_v2.h
• rawdata/dataobjects/src/PreRawCOPPERFormat_v2.cc