SACDecoder.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_SACDECODER_H
#define ALICEO2_SACDECODER_H
 
#include <algorithm>
#include <array>
#include <deque>
#include <unordered_map>
#include <vector>
#include <bitset>
#include <gsl/span>
 
#include "CommonUtils/TreeStreamRedirector.h"
#include "CommonConstants/LHCConstants.h"
 
#include "DataFormatsTPC/Defs.h"
#include "DataFormatsTPC/SAC.h"
 
using o2::constants::lhc::LHCBunchSpacingMUS;
 
namespace o2::tpc::sac
{
 
constexpr float ADCtoNanoAmp = 125000.f / 8388608.f;     
constexpr uint32_t ChannelsPerFE = 8;                    
constexpr size_t Instances = 2;                          
constexpr size_t NumberFEs = FEsPerInstance * Instances; 
 
struct DecodedDataFE {
  uint32_t timeStamp{};
  std::array<int32_t, 8> currents{};
 
  void resetCurrent()
  {
    std::fill(currents.begin(), currents.end(), 0);
  }
 
  void reset()
  {
    timeStamp = 0;
    resetCurrent();
  }
};
 
struct DataPoint {
  uint32_t time{};               
  int32_t currents[GEMSTACKS]{}; 
 
  void reset()
  {
    time = 0;
    std::fill(&currents[0], &currents[GEMSTACKS], 0);
  }
 
  ClassDefNV(DataPoint, 2);
};
 
struct DecodedData {
  double referenceTime{-1.};               
  std::vector<DataPoint> data;             
  std::vector<std::bitset<NumberFEs>> fes; 
 
  void resize(size_t newSize)
  {
    data.resize(newSize);
    fes.resize(newSize);
  }
 
  size_t getNGoodEntries() const
  {
    size_t posGood = 0;
    while (posGood < fes.size()) {
      if (!fes[posGood].all()) {
        break;
      }
      ++posGood;
    }
    return posGood;
  }
 
  gsl::span<const DataPoint> getGoodData() const
  {
    return gsl::span<const DataPoint>(data.data(), data.data() + getNGoodEntries());
  }
 
  void clearGoodData()
  {
    const auto pos = getNGoodEntries();
    data.erase(data.begin(), data.begin() + pos);
    fes.erase(fes.begin(), fes.begin() + pos);
  }
 
  void clear()
  {
    data.clear();
    fes.clear();
  }
 
  void insertFront(const size_t entries)
  {
    data.insert(data.begin(), entries, DataPoint());
    fes.insert(fes.begin(), entries, std::bitset<NumberFEs>());
  }
 
  void setData(const size_t pos, uint32_t time, const DecodedDataFE& decdata, const int feid);
 
  ClassDefNV(DecodedData, 1);
};
 
class Decoder
{
 public:
  static constexpr std::string_view AllowedAdditionalStreams{"MRLIX"};          
  static constexpr uint32_t SampleDistance = 16;                                
  static constexpr double SampleTimeMS = LHCBunchSpacingMUS * 2.5;              
  static constexpr double SampleDistanceTimeMS = SampleTimeMS * SampleDistance; 
 
  enum class DebugFlags {
    PacketInfo = 0x01,       
    TimingInfo = 0x02,       
    ProcessingInfo = 0x04,   
    DumpFullStream = 0x10,   
    StreamSingleFE = 0x100,  
    StreamFinalData = 0x200, 
  };
 
  enum class ReAlignType {
    None = 0,                      
    AlignOnly = 1,                 
    AlignAndFillMissing = 2,       
    MaxType = AlignAndFillMissing, 
  };
 
  bool process(const char* data, size_t size);
 
  void runDecoding();
 
  void finalize();
 
  void setReferenceTime(double time)
  {
    mDecodedData.referenceTime = time;
  }
 
  double getReferenceTime() const
  {
    return mDecodedData.referenceTime;
  }
 
  void setDecodeAdditional(std::string_view additional)
  {
    mDecodeAdditional.clear();
    for (const auto c : additional) {
      if (AllowedAdditionalStreams.find(c) != std::string_view::npos) {
        mDecodeAdditional += c;
      }
    }
  }
 
  void enableDebugTree()
  {
    if (!mDebugStream) {
      mDebugStream = std::make_unique<o2::utils::TreeStreamRedirector>(mDebugOutputName.data(), "recreate");
    }
  }
 
  void setDebugLevel(uint32_t level = (uint32_t)DebugFlags::PacketInfo)
  {
    mDebugLevel = level;
    if ((level & (uint32_t)DebugFlags::StreamSingleFE) || (level & (uint32_t)DebugFlags::StreamFinalData)) {
      enableDebugTree();
    }
  }
 
  void clearDecodedData();
  void streamDecodedData(bool streamAll = false);
 
  const DecodedData& getDecodedData() const { return mDecodedData; }
 
  void setReAlignType(ReAlignType type = ReAlignType::AlignOnly) { mReAlignType = type; }
  ReAlignType getReAlignType() const { return mReAlignType; }
 
  static void setNThreads(const int nThreads) { sNThreads = nThreads; }
 
  static int getNThreads() { return sNThreads; }
 
 private:
  inline static int sNThreads{1};                                   
  size_t mCollectedDataPackets{};                                   
  std::array<uint32_t, Instances> mPktCountInstance{};              
  std::array<uint32_t, NumberFEs> mPktCountFEs{};                   
  std::array<std::pair<uint32_t, uint32_t>, NumberFEs> mTSCountFEs; 
  std::array<std::string, NumberFEs> mDataStrings;                  
  DecodedData mDecodedData;                                         
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStream;    
  std::string mDecodeAdditional;                                    
  std::string mDebugOutputName{"SAC_debug.root"};                   
  ReAlignType mReAlignType{ReAlignType::None};                      
 
  uint32_t mDebugLevel{0}; 
 
  uint32_t decodeTimeStamp(const char* data);
 
  int decodeChannels(DecodedDataFE& sacs, size_t& carry, int feid);
  void decode(int feid);
 
  void printPacketInfo(const sac::packet& sac);
 
  void dumpStreams();
 
  ClassDefNV(Decoder, 0);
};
 
} // namespace o2::tpc::sac
#endif