CbmStsUnpackAlgo.h

Go to the documentation of this file.

/* Copyright (C) 2021 Goethe-University, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau, Pascal Raisig [committer], Dominik Smith */
 
#ifndef CbmStsUnpackAlgo_H
#define CbmStsUnpackAlgo_H
 
#include "CbmMcbm2018StsPar.h"
#include "CbmStsUnpackAlgoBase.h"
 
 
class CbmStsUnpackAlgo : public CbmStsUnpackAlgoBase {
 public:
  CbmStsUnpackAlgo();
 
  virtual ~CbmStsUnpackAlgo();
 
  CbmStsUnpackAlgo(const CbmStsUnpackAlgo&) = delete;
 
  CbmStsUnpackAlgo& operator=(const CbmStsUnpackAlgo&) = delete;
 
  virtual void MaskNoisyChannel(const uint32_t uFeb, const uint32_t uChan, const bool bMasked = true);
 
  void SetMonitor(std::shared_ptr<CbmStsUnpackMonitor> monitor) { fMonitor = monitor; }
 
 protected:
  uint32_t getAsicIndex(uint32_t dpbidx, uint32_t crobidx, uint16_t elinkidx);
 
  uint64_t getFullTimeStamp(const uint16_t usRawTs);
 
  Bool_t init();
 
  void initDpbIdIndexMap(CbmMcbm2018StsPar* parset);
 
  void initInternalStatus(CbmMcbm2018StsPar* parset);
 
  Bool_t initParSet(FairParGenericSet* parset);
 
  Bool_t initParSet(CbmMcbm2018StsPar* parset);
 
  void initTempVectors(CbmMcbm2018StsPar* parset, std::vector<int32_t>* viModuleType,
                       std::vector<int32_t>* viModAddress,
                       std::vector<std::vector<std::vector<int32_t>>>* viFebModuleIdx,
                       std::vector<std::vector<bool>>* vbCrobActiveFlag,
                       std::vector<std::vector<std::vector<int32_t>>>* viFebModuleSide);
  void loopMsMessages(const uint8_t* msContent, const uint32_t uSize, const size_t uMsIdx);
 
  void printActiveCrobs(CbmMcbm2018StsPar* parset, const std::vector<std::vector<bool>>& vbCrobActiveFlag);
 
  void printAddressMaps(CbmMcbm2018StsPar* parset, const std::vector<std::vector<std::vector<int32_t>>>& viFebModuleIdx,
                        const std::vector<std::vector<std::vector<int32_t>>>& viFebModuleSide);
 
  void processEpochInfo(const stsxyter::Message& /*mess*/) { return; };
 
  void processErrorInfo(const stsxyter::Message& mess);
 
  void processHitInfo(const stsxyter::Message& mess);
 
  void processStatusInfo(const stsxyter::Message& mess, uint32_t uIdx);
 
  void processTsMsbInfo(const stsxyter::Message& mess, uint32_t uMessIdx, uint32_t uMsIdx);
 
  void refreshTsMsbFields(const uint32_t imslice, const size_t mstime);
 
  bool setDerivedTsParameters(size_t /*itimeslice*/) { return true; }
 
  bool unpack(const fles::Timeslice* ts, std::uint16_t icomp, UInt_t imslice);
 
  // Monitoring
  uint64_t fMsStartTime = 0;
 
  // Parameter members
  std::map<uint32_t, uint32_t> fDpbIdIndexMap = {};  
 
  uint32_t fuCurrDpbIdx = 0;
 
  std::vector<bool> fvbMaskedComponents;
 
  uint32_t fuNbFebs = 0;  
 
  std::vector<uint32_t> fvbFebAdcCut = {};
 
  uint32_t fNrElinksPerCrob = 0;  
 
  uint32_t fNrAsicsPerCrob = 0;  
 
  uint32_t fNrAsicsPerFeb = 0;  
 
  uint32_t fNrChsPerAsic = 0;  
 
  uint32_t fNrChsPerFeb = 0;  
 
  uint32_t fNrCrobPerDpb = 0;  
 
  uint32_t fNrFebsPerCrob = 0;  
 
  std::vector<int> fElinkIdxToFebIdxVec = {};
 
  std::vector<std::pair<uint32_t, uint32_t>> fElinkIdxToAsicIdxVec = {};
 
  bool fbUseChannelMask = false;
 
  std::vector<std::vector<bool>> fvvbMaskedChannels = {};  
 
  std::vector<std::vector<std::vector<int32_t>>> fviFebType = {};  
 
  std::vector<bool> fvbFebPulser;  
  std::vector<int32_t> fviFebAddress;  
  std::vector<int32_t> fviFebSide;  
  std::vector<double> fvdFebAdcGain;  
  std::vector<double> fvdFebAdcOffs;  
 
  std::vector<uint64_t> fvulCurrentTsMsb = {};  
  std::vector<uint32_t> fvuCurrentTsMsbCycle = {};  
 
  uint64_t fulTsStartInTsMsb = 0;
  std::vector<uint64_t> fulTsMsbIndexInTs = {};
 
  static const uint32_t kuMaxTsMsbDiffDuplicates = 8;
  std::vector<std::vector<uint16_t>> fvvusLastTsChan = {};  
  std::vector<std::vector<uint16_t>> fvvusLastAdcChan = {};  
  std::vector<std::vector<uint64_t>> fvvulLastTsMsbChan = {};  
 
 private:
  ClassDef(CbmStsUnpackAlgo, 2)
};
 
#endif  // CbmStsUnpackAlgo_H