GBTFrame.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
#ifndef ALICEO2_TPC_GBTFRAME_H_
#define ALICEO2_TPC_GBTFRAME_H_
 
#include <iosfwd>
#include <iomanip>
#include <vector>
#include <array>
 
namespace o2
{
namespace tpc
{
 
#define BIT00(x) ((x & 0x1) >> 0)
#define BIT01(x) ((x & 0x2) >> 1)
#define BIT02(x) ((x & 0x4) >> 2)
#define BIT03(x) ((x & 0x8) >> 3)
#define BIT04(x) ((x & 0x10) >> 4)
#define BIT05(x) ((x & 0x20) >> 5)
#define BIT06(x) ((x & 0x40) >> 6)
#define BIT07(x) ((x & 0x80) >> 7)
#define BIT08(x) ((x & 0x100) >> 8)
#define BIT09(x) ((x & 0x200) >> 9)
#define BIT10(x) ((x & 0x400) >> 10)
#define BIT11(x) ((x & 0x800) >> 11)
#define BIT12(x) ((x & 0x1000) >> 12)
#define BIT13(x) ((x & 0x2000) >> 13)
#define BIT14(x) ((x & 0x4000) >> 14)
#define BIT15(x) ((x & 0x8000) >> 15)
#define BIT16(x) ((x & 0x10000) >> 16)
#define BIT17(x) ((x & 0x20000) >> 17)
#define BIT18(x) ((x & 0x40000) >> 18)
#define BIT19(x) ((x & 0x80000) >> 19)
#define BIT20(x) ((x & 0x100000) >> 20)
#define BIT21(x) ((x & 0x200000) >> 21)
#define BIT22(x) ((x & 0x400000) >> 22)
#define BIT23(x) ((x & 0x800000) >> 23)
#define BIT24(x) ((x & 0x1000000) >> 24)
#define BIT25(x) ((x & 0x2000000) >> 25)
#define BIT26(x) ((x & 0x4000000) >> 26)
#define BIT27(x) ((x & 0x8000000) >> 27)
#define BIT28(x) ((x & 0x10000000) >> 28)
#define BIT29(x) ((x & 0x20000000) >> 29)
#define BIT30(x) ((x & 0x40000000) >> 30)
#define BIT31(x) ((x & 0x80000000) >> 31)
 
class GBTFrame
{
 public:
  GBTFrame();
 
  GBTFrame(unsigned word3, unsigned word2, unsigned word1, unsigned word0);
 
  GBTFrame(short s0hw0l, short s0hw1l, short s0hw2l, short s0hw3l,
           short s0hw0h, short s0hw1h, short s0hw2h, short s0hw3h,
           short s1hw0l, short s1hw1l, short s1hw2l, short s1hw3l,
           short s1hw0h, short s1hw1h, short s1hw2h, short s1hw3h,
           short s2hw0, short s2hw1, short s2hw2, short s2hw3,
           short s0adc, short s1adc, short s2adc, unsigned marker = 0);
 
  GBTFrame(const GBTFrame& other);
 
  ~GBTFrame() = default;
 
  short getMarker() const { return (mWords[3] >> 16) & 0xFFFF; };
 
  short getHalfWord(const short sampa, const short halfword, const short chan = 0) const { return mHalfWords[sampa][chan][halfword]; };
 
  short getAdcClock(short sampa) const { return mAdcClock[sampa]; };
 
  void setAdcClock(int sampa, int clock);
 
  //    void setData(const GBTFrame& other);
 
  void setData(unsigned word3, unsigned word2, unsigned word1, unsigned word0);
 
  void setData(short s0hw0l, short s0hw1l, short s0hw2l, short s0hw3l,
               short s0hw0h, short s0hw1h, short s0hw2h, short s0hw3h,
               short s1hw0l, short s1hw1l, short s1hw2l, short s1hw3l,
               short s1hw0h, short s1hw1h, short s1hw2h, short s1hw3h,
               short s2hw0, short s2hw1, short s2hw2, short s2hw3,
               short s0adc, short s1adc, short s2adc, unsigned marker = 0);
 
  void getGBTFrame(unsigned& word3, unsigned& word2, unsigned& word1, unsigned& word0) const;
 
  std::ostream& Print(std::ostream& output) const;
  friend std::ostream& operator<<(std::ostream& out, const GBTFrame& f) { return f.Print(out); }
 
 private:
  void calculateHalfWords();
  void calculateAdcClock();
 
  std::array<unsigned, 4> mWords;
  // Word 3 of GBT frame contains bits [127: 96], [127:112] are reserved for marker
  // Word 2 of GBT frame contains bits [ 95: 64]
  // Word 1 of GBT frame contains bits [ 63: 32]
  // Word 0 of GBT frame contains bits [ 31:  0]
 
  std::array<std::array<std::array<short, 4>, 2>, 3> mHalfWords;
  //                           halfWord
  //                               channels (low or high)
  //                                   sampa
 
  std::array<short, 3> mAdcClock;
};
 
inline void GBTFrame::calculateHalfWords()
{
 
  mHalfWords[0][0][0] = (BIT19(mWords[0]) << 4) | (BIT15(mWords[0]) << 3) | (BIT11(mWords[0]) << 2) | (BIT07(mWords[0]) << 1) | BIT03(mWords[0]);
  mHalfWords[0][0][1] = (BIT18(mWords[0]) << 4) | (BIT14(mWords[0]) << 3) | (BIT10(mWords[0]) << 2) | (BIT06(mWords[0]) << 1) | BIT02(mWords[0]);
  mHalfWords[0][0][2] = (BIT17(mWords[0]) << 4) | (BIT13(mWords[0]) << 3) | (BIT09(mWords[0]) << 2) | (BIT05(mWords[0]) << 1) | BIT01(mWords[0]);
  mHalfWords[0][0][3] = (BIT16(mWords[0]) << 4) | (BIT12(mWords[0]) << 3) | (BIT08(mWords[0]) << 2) | (BIT04(mWords[0]) << 1) | BIT00(mWords[0]);
 
  mHalfWords[0][1][0] = (BIT07(mWords[1]) << 4) | (BIT03(mWords[1]) << 3) | (BIT31(mWords[0]) << 2) | (BIT27(mWords[0]) << 1) | BIT23(mWords[0]);
  mHalfWords[0][1][1] = (BIT06(mWords[1]) << 4) | (BIT02(mWords[1]) << 3) | (BIT30(mWords[0]) << 2) | (BIT26(mWords[0]) << 1) | BIT22(mWords[0]);
  mHalfWords[0][1][2] = (BIT05(mWords[1]) << 4) | (BIT01(mWords[1]) << 3) | (BIT29(mWords[0]) << 2) | (BIT25(mWords[0]) << 1) | BIT21(mWords[0]);
  mHalfWords[0][1][3] = (BIT04(mWords[1]) << 4) | (BIT00(mWords[1]) << 3) | (BIT28(mWords[0]) << 2) | (BIT24(mWords[0]) << 1) | BIT20(mWords[0]);
 
  mHalfWords[1][0][0] = (BIT31(mWords[1]) << 4) | (BIT27(mWords[1]) << 3) | (BIT23(mWords[1]) << 2) | (BIT19(mWords[1]) << 1) | BIT15(mWords[1]);
  mHalfWords[1][0][1] = (BIT30(mWords[1]) << 4) | (BIT26(mWords[1]) << 3) | (BIT22(mWords[1]) << 2) | (BIT18(mWords[1]) << 1) | BIT14(mWords[1]);
  mHalfWords[1][0][2] = (BIT29(mWords[1]) << 4) | (BIT25(mWords[1]) << 3) | (BIT21(mWords[1]) << 2) | (BIT17(mWords[1]) << 1) | BIT13(mWords[1]);
  mHalfWords[1][0][3] = (BIT28(mWords[1]) << 4) | (BIT24(mWords[1]) << 3) | (BIT20(mWords[1]) << 2) | (BIT16(mWords[1]) << 1) | BIT12(mWords[1]);
 
  mHalfWords[1][1][0] = (BIT19(mWords[2]) << 4) | (BIT15(mWords[2]) << 3) | (BIT11(mWords[2]) << 2) | (BIT07(mWords[2]) << 1) | BIT03(mWords[2]);
  mHalfWords[1][1][1] = (BIT18(mWords[2]) << 4) | (BIT14(mWords[2]) << 3) | (BIT10(mWords[2]) << 2) | (BIT06(mWords[2]) << 1) | BIT02(mWords[2]);
  mHalfWords[1][1][2] = (BIT17(mWords[2]) << 4) | (BIT13(mWords[2]) << 3) | (BIT09(mWords[2]) << 2) | (BIT05(mWords[2]) << 1) | BIT01(mWords[2]);
  mHalfWords[1][1][3] = (BIT16(mWords[2]) << 4) | (BIT12(mWords[2]) << 3) | (BIT08(mWords[2]) << 2) | (BIT04(mWords[2]) << 1) | BIT00(mWords[2]);
 
  mHalfWords[2][0][0] = (BIT11(mWords[3]) << 4) | (BIT07(mWords[3]) << 3) | (BIT03(mWords[3]) << 2) | (BIT31(mWords[2]) << 1) | BIT27(mWords[2]);
  mHalfWords[2][0][1] = (BIT10(mWords[3]) << 4) | (BIT06(mWords[3]) << 3) | (BIT02(mWords[3]) << 2) | (BIT30(mWords[2]) << 1) | BIT26(mWords[2]);
  mHalfWords[2][0][2] = (BIT09(mWords[3]) << 4) | (BIT05(mWords[3]) << 3) | (BIT01(mWords[3]) << 2) | (BIT29(mWords[2]) << 1) | BIT25(mWords[2]);
  mHalfWords[2][0][3] = (BIT08(mWords[3]) << 4) | (BIT04(mWords[3]) << 3) | (BIT00(mWords[3]) << 2) | (BIT28(mWords[2]) << 1) | BIT24(mWords[2]);
 
  //  mHalfWords[2][1][0] = mHalfWords[2][0][0];
  //  mHalfWords[2][1][1] = mHalfWords[2][0][1];
  //  mHalfWords[2][1][2] = mHalfWords[2][0][2];
  //  mHalfWords[2][1][3] = mHalfWords[2][0][3];
 
  calculateAdcClock();
};
 
inline void GBTFrame::calculateAdcClock()
{
  mAdcClock[0] = (mWords[1] >> 8) & 0xF;
  mAdcClock[1] = (mWords[2] >> 20) & 0xF;
  mAdcClock[2] = (mWords[3] >> 12) & 0xF;
};
 
inline void GBTFrame::setData(unsigned word3, unsigned word2, unsigned word1, unsigned word0)
{
  mWords[3] = word3;
  mWords[2] = word2;
  mWords[1] = word1;
  mWords[0] = word0;
 
  calculateHalfWords();
};
 
inline GBTFrame::GBTFrame()
  : GBTFrame(0, 0, 0, 0){};
 
inline GBTFrame::GBTFrame(unsigned word3, unsigned word2, unsigned word1, unsigned word0)
{
  mWords[3] = word3;
  mWords[2] = word2;
  mWords[1] = word1;
  mWords[0] = word0;
 
  calculateHalfWords();
};
 
inline GBTFrame::GBTFrame(const GBTFrame& other) = default;
 
inline void GBTFrame::getGBTFrame(unsigned& word3, unsigned& word2, unsigned& word1, unsigned& word0) const
{
  word3 = mWords[3];
  word2 = mWords[2];
  word1 = mWords[1];
  word0 = mWords[0];
};
 
} // namespace tpc
} // namespace o2
 
#endif // ALICEO2_TPC_GBTFRAME_H_