CbmMuchUnpackAlgo.h

Go to the documentation of this file.

/* Copyright (C) 2022 Fair GmbH, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */

 
#ifndef CbmMuchUnpackAlgo_H
#define CbmMuchUnpackAlgo_H
 
 
#include "CbmErrorMessage.h"  // REMARK see remark in CbmMuchUnpackConfig
#include "CbmMuchDigi.h"
#include "CbmMuchUnpackMonitor.h"
#include "CbmMuchUnpackPar.h"
#include "CbmRecoUnpackAlgo.tmpl"
#include "Timeslice.hpp"  // timeslice
 
#include <FairTask.h>  // for InitStatus
 
#include <Rtypes.h>  // for types
#include <RtypesCore.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <set>
#include <utility>
 
class CbmMuchUnpackAlgo : public CbmRecoUnpackAlgo<CbmMuchDigi, CbmMuchDigi, CbmErrorMessage> {
 public:
  CbmMuchUnpackAlgo();

  CbmMuchUnpackAlgo(std::string name);

  virtual ~CbmMuchUnpackAlgo();

  CbmMuchUnpackAlgo(const CbmMuchUnpackAlgo&) = delete;

  CbmMuchUnpackAlgo& operator=(const CbmMuchUnpackAlgo&) = delete;
 
  // Setters

  void SetMinAdcCut(uint32_t value) { fdAdcCut = value; }
 
  void SetMinAdcCut(uint32_t febid, uint32_t value) { fdAdcCut_perFeb[febid] = value; }

  void SetAsicTimeOffsetVec(std::vector<double> value) { fvdTimeOffsetNsAsics.swap(value); }

  void SetDuplicatesRejection(bool bIn = true, bool bDiffAdc = true)
  {
    fbRejectDuplicateDigis = bIn;
    fbDupliWithoutAdc      = bDiffAdc;
  }

  virtual std::vector<std::pair<std::string, std::shared_ptr<FairParGenericSet>>>*
  GetParContainerRequest(std::string geoTag, uint32_t runId);

  void MaskNoisyChannel(const uint32_t uFeb, const uint32_t uChan, const bool bMasked = true);

  void SetMonitor(std::shared_ptr<CbmMuchUnpackMonitor> monitor) { fMonitor = monitor; }

  void SetParFileName(std::string sNewName) { fParFileName = sNewName; }
 
  void SetInactiveChannel(uint32_t channel) { fInactiveChannels.insert(channel); }
 
  void SetElinkFebMap2022(Bool_t bFlag = kTRUE) { fbElinkFebMap2022 = bFlag; }
 
 protected:
  uint32_t getFebIndex(uint32_t dpbidx, uint32_t crobidx, uint16_t elinkidx);
  virtual void finish()
  {
    if (fMonitor) fMonitor->Finish();
    LOG(info) << "Missed messages:  wrong address generated: " << fuSkippMessNoValidAddress;
    LOG(info) << "Missed messages: wrong FEB Position inPar: " << fuSkippMessNoValidFebPosition;
    LOG(info) << "Missed messages:  wrong Elink   generated: " << fuSkippMessNoValidElink;
    return;
  }

  uint64_t getFullTimeStamp(const uint16_t usRawTs);

  Bool_t init();

  void initDpbIdIndexMap(CbmMuchUnpackPar* parset);

  void initInternalStatus(CbmMuchUnpackPar* parset);

  Bool_t initParSet(FairParGenericSet* parset);

  Bool_t initParSet(CbmMuchUnpackPar* parset);


  void loopMsMessages(const uint8_t* msContent, const uint32_t uSize, const size_t uMsIdx);

  void printActiveCrobs(CbmMuchUnpackPar* parset, const std::vector<std::vector<bool>>& vbCrobActiveFlag);

  void printAddressMaps(CbmMuchUnpackPar* 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);
  uint32_t CreateMuchAddress(uint32_t dpbidx, int32_t febId, uint32_t usChan);

  bool setDerivedTsParameters(size_t /*itimeslice*/) { return true; }

  bool unpack(const fles::Timeslice* ts, uint16_t icomp, UInt_t imslice);
 
 
  // Settings
  uint32_t fdAdcCut = 0;

  std::map<uint32_t, uint32_t> fdAdcCut_perFeb;

  std::vector<double> fvdTimeOffsetNsAsics = {};

  bool fbRejectDuplicateDigis = false;

  bool fbDupliWithoutAdc = true;

  bool fbUseChannelMask = false;

  std::vector<std::vector<bool>> fvvbMaskedChannels = {};  
 
 
  // 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 = {};

  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;  
 
  // Internal variables
  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 = {};  
 
  // Monitoring
  std::shared_ptr<CbmMuchUnpackMonitor> fMonitor = nullptr;

  uint64_t fMsStartTime = 0;
 
  std::set<uint32_t> fInactiveChannels = {};
 
  uint64_t fMaskedNoisyHitsFromCbmMuchAddress = 0;
 
 private:
  CbmMuchUnpackPar* fUnpackPar           = nullptr;  
  uint64_t fuSkippMessNoValidAddress     = 0;
  uint64_t fuSkippMessNoValidFebPosition = 0;
  uint64_t fuSkippMessNoValidElink       = 0;
  std::string fParFileName = "mMuchPar.par";

  Bool_t fbElinkFebMap2022 = kFALSE;
 
  ClassDef(CbmMuchUnpackAlgo, 2)
};
 
#endif  // CbmMuchUnpackAlgo_H