GBTFrameContainer.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_GBTFRAMECONTAINER_H_
#define ALICEO2_TPC_GBTFRAMECONTAINER_H_
 
#include "DataFormatsTPC/Digit.h"
#include "TPCBase/Mapper.h"
#include "TPCReconstruction/AdcClockMonitor.h"
#include "TPCReconstruction/GBTFrame.h"
#include "TPCReconstruction/HalfSAMPAData.h"
#include "TPCReconstruction/SyncPatternMonitor.h"
 
#include <iterator>
#include <vector>
#include <queue>
#include <array>
#include <mutex>
 
#include <thread>
 
#include <fstream>
#include <iosfwd>
#include <iomanip>
 
#include <fairlogger/Logger.h>
 
namespace o2
{
namespace tpc
{
 
 
class GBTFrameContainer
{
 public:
  GBTFrameContainer();
 
  GBTFrameContainer(int cru, int link);
 
  GBTFrameContainer(int size, int cru, int link, int sampaVersion = -1);
 
  ~GBTFrameContainer();
 
  void reset();
 
  int getSize() { return mGBTFrames.size(); };
 
  int getNentries();
 
  void addGBTFrame(GBTFrame& frame);
 
  void addGBTFrame(unsigned word3, unsigned word2, unsigned word1, unsigned word0);
 
  void addGBTFrame(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 addGBTFramesFromFile(std::string fileName);
 
  void addGBTFramesFromBinaryFile(std::string fileName, std::string type = "grorc", int frames = -1);
 
  //    /// Fill output TClonesArray
  //    /// @param output Output container
  //    void fillOutputContainer(TClonesArray* output);
 
  void setEnableAdcClockWarning(bool val) { mEnableAdcClockWarning = val; };
 
  void setEnableSyncPatternWarning(bool val) { mEnableSyncPatternWarning = val; };
 
  void setEnableCompileAdcValues(bool val) { mEnableCompileAdcValues = val; };
 
  void setEnableStoreGBTFrames(bool val)
  {
    mEnableStoreGBTFrames = val;
    if (!mEnableStoreGBTFrames) {
      mGBTFrames.resize(2);
    }
  };
 
  bool getData(std::vector<Digit>& container);
 
  bool getData(std::vector<HalfSAMPAData>& container);
 
  int getNFramesAnalyzed() const { return mGBTFramesAnalyzed; };
 
  GBTFrame getGBTFrame(int index) const { return mGBTFrames[index]; };
  GBTFrame operator[](int index) const { return mGBTFrames[index]; };
  GBTFrame& operator[](int index) { return mGBTFrames[index]; };
 
  std::vector<GBTFrame>::iterator begin() { return mGBTFrames.begin(); };
  std::vector<GBTFrame>::const_iterator begin() const { return mGBTFrames.begin(); };
  std::vector<GBTFrame>::const_iterator cbegin() const { return mGBTFrames.cbegin(); };
  std::vector<GBTFrame>::iterator end() { return mGBTFrames.end(); };
  std::vector<GBTFrame>::const_iterator end() const { return mGBTFrames.end(); };
  std::vector<GBTFrame>::const_iterator cend() const { return mGBTFrames.cend(); };
 
  std::vector<GBTFrame>::reverse_iterator rbegin() { return mGBTFrames.rbegin(); };
  std::vector<GBTFrame>::const_reverse_iterator rbegin() const { return mGBTFrames.rbegin(); };
  std::vector<GBTFrame>::const_reverse_iterator crbegin() const { return mGBTFrames.crbegin(); };
  std::vector<GBTFrame>::reverse_iterator rend() { return mGBTFrames.rend(); };
  std::vector<GBTFrame>::const_reverse_iterator rend() const { return mGBTFrames.rend(); };
  std::vector<GBTFrame>::const_reverse_iterator crend() const { return mGBTFrames.crend(); };
 
  void setTimebin(int val) { mTimebin = val; };
 
  int getTimebin() const { return mTimebin; };
 
  void reProcessAllFrames();
 
  void overwriteAdcClock(int sampa, unsigned short phase);
 
 private:
  void processAllFrames();
 
  void processFrame(std::vector<GBTFrame>::iterator iFrame);
 
  void checkAdcClock(std::vector<GBTFrame>::iterator iFrame);
 
  void searchSyncPattern(std::vector<GBTFrame>::iterator iFrame);
 
  // Compiles the ADC values
  void compileAdcValues(std::vector<GBTFrame>::iterator iFrame);
 
  void resetAdcClock();
  void resetSyncPattern();
  void resetAdcValues();
 
  std::mutex mAdcMutex;
 
  std::vector<GBTFrame> mGBTFrames;               
  std::array<AdcClockMonitor, 3> mAdcClock;       
  std::array<SyncPatternMonitor, 5> mSyncPattern; 
  std::array<short, 10> mPositionForHalfSampa;    
  std::array<std::queue<short>*, 5> mAdcValues;   
 
  bool mEnableAdcClockWarning;    
  bool mEnableSyncPatternWarning; 
  bool mEnableStoreGBTFrames;     
  bool mEnableCompileAdcValues;   
  int mCRU;                       
  int mLink;                      
  int mSampaVersion;              
  int mTimebin;                   
  int mGBTFramesAnalyzed;
 
  std::array<std::array<short, 16>, 5> mTmpData;
};
 
//template<typename... Args>
//inline
//void GBTFrameContainer::addGBTFrame(Args&&... args)
//{
//  if (!mEnableStoreGBTFrames && (mGBTFrames.size() > 1)) {
//    mGBTFrames[0] = mGBTFrames[1];
//    mGBTFrames[1].setData(std::forward<Args>(args)...);
//  } else {
//    mGBTFrames.emplace_back(std::forward<Args>(args)...);
//  }
//  processFrame(mGBTFrames.end()-1);
//};
 
inline void GBTFrameContainer::addGBTFrame(unsigned word3, unsigned word2, unsigned word1, unsigned word0)
{
  if (!mEnableStoreGBTFrames && (mGBTFrames.size() > 1)) {
    mGBTFrames[0] = mGBTFrames[1];
    mGBTFrames[1].setData(word3, word2, word1, word0);
  } else {
    mGBTFrames.emplace_back(word3, word2, word1, word0);
  }
  processFrame(mGBTFrames.end() - 1);
};
 
inline void GBTFrameContainer::addGBTFrame(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)
{
  if (!mEnableStoreGBTFrames && (mGBTFrames.size() > 1)) {
    mGBTFrames[0] = mGBTFrames[1];
    mGBTFrames[1].setData(s0hw0l, s0hw1l, s0hw2l, s0hw3l, s0hw0h, s0hw1h, s0hw2h, s0hw3h,
                          s1hw0l, s1hw1l, s1hw2l, s1hw3l, s1hw0h, s1hw1h, s1hw2h, s1hw3h,
                          s2hw0, s2hw1, s2hw2, s2hw3, s0adc, s1adc, s2adc, marker);
  } else {
    mGBTFrames.emplace_back(s0hw0l, s0hw1l, s0hw2l, s0hw3l, s0hw0h, s0hw1h, s0hw2h, s0hw3h,
                            s1hw0l, s1hw1l, s1hw2l, s1hw3l, s1hw0h, s1hw1h, s1hw2h, s1hw3h,
                            s2hw0, s2hw1, s2hw2, s2hw3, s0adc, s1adc, s2adc, marker);
  }
  processFrame(mGBTFrames.end() - 1);
};
 
inline void GBTFrameContainer::addGBTFrame(GBTFrame& frame)
{
  if (!mEnableStoreGBTFrames && (mGBTFrames.size() > 1)) {
    mGBTFrames[0] = mGBTFrames[1];
    mGBTFrames[1] = frame;
  } else {
    mGBTFrames.emplace_back(frame);
  }
 
  processFrame(mGBTFrames.end() - 1);
};
 
} // namespace tpc
} // namespace o2
 
#endif