CbmTrdUnpackAlgoBaseR.h

Go to the documentation of this file.

/* Copyright (C) 2021 Goethe-University Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pascal Raisig [committer] */
 
#ifndef CbmTrdUnpackAlgoBaseR_H
#define CbmTrdUnpackAlgoBaseR_H
 
#include "CbmMcbm2020TrdTshiftPar.h"
#include "CbmRecoUnpackAlgo.tmpl"
#include "CbmTrdDigi.h"
#include "CbmTrdParSetAsic.h"
#include "CbmTrdRawMessageSpadic.h"
#include "CbmTrdRawToDigiBaseR.h"
#include "CbmTrdSpadic.h"
#include "CbmTrdUnpackMonitor.h"
#include "Timeslice.hpp"  // timeslice
 
#include <FairTask.h>  // for InitStatus
 
#include <Rtypes.h>  // for types
#include <RtypesCore.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
 
class CbmTrdUnpackAlgoBaseR : public CbmRecoUnpackAlgo<CbmTrdDigi, CbmTrdRawMessageSpadic, std::pair<size_t, size_t>> {
 public:
  CbmTrdUnpackAlgoBaseR(std::string name);
 
  virtual ~CbmTrdUnpackAlgoBaseR();
 
  CbmTrdUnpackAlgoBaseR(const CbmTrdUnpackAlgoBaseR&) = delete;
 
  CbmTrdUnpackAlgoBaseR& operator=(const CbmTrdUnpackAlgoBaseR&) = delete;
 
  // Setters
  void SetMonitor(std::shared_ptr<CbmTrdUnpackMonitor> monitor) { fMonitor = monitor; }
 
  void SetRawToDigiMethod(std::shared_ptr<CbmTrdRawToDigiBaseR> value) { fRTDMethod = value; }
 
  void SetSpadicObject(std::shared_ptr<CbmTrdSpadic> value) { fSpadic = value; }
 
  void SetElinkTimeOffsetMap(std::map<std::uint32_t, std::vector<std::int32_t>> map) { fElinkTimeOffsetMap = map; }
 
  std::int32_t GetElinkTimeOffset(std::uint32_t criid, std::uint8_t elinkid)
  {
    return (fElinkTimeOffsetMap.find(criid) == fElinkTimeOffsetMap.end() ? 0 : fElinkTimeOffsetMap[criid].at(elinkid));
  }
 
 protected:
  void digestOutput(std::unique_ptr<CbmTrdDigi> digi, CbmTrdRawMessageSpadic raw);
 
  void finish()
  {
    finishDerived();
    // Finish the monitor if we have one
    if (fMonitor) fMonitor->Finish();
  }
 
  virtual void finishDerived() = 0;
 
  virtual std::uint32_t getAsicAddress(std::uint32_t criid, std::uint32_t crobid, std::uint32_t elinkid);
 
  std::uint32_t getChannelId(std::uint32_t asicaddress, std::uint32_t elinkid, std::uint32_t elinkchannelid);
 
  virtual Bool_t init();
 
  // Initialise par set, the base function handles the casting to distribute the pointers to their explicit functions
 
  Bool_t initParSet(FairParGenericSet* parset);
 
  Bool_t initParSet(CbmTrdParSetAsic* parset);
 
  Bool_t initParSet(CbmTrdParSetDigi* parset);
 
  Bool_t initParSet(CbmMcbm2020TrdTshiftPar* parset);
 
 
  // Monitoring
  std::shared_ptr<CbmTrdUnpackMonitor> fMonitor = nullptr;
 
  // Parameter storage members
  std::shared_ptr<CbmTrdSpadic> fSpadic = nullptr;
 
  std::shared_ptr<CbmTrdRawToDigiBaseR> fRTDMethod = nullptr;
 
  std::map<size_t, Int_t> fSpadicAddressMap = {};
 
  std::map<Int_t, std::vector<Int_t>> fAsicChannelMap = {};
 
  std::map<size_t, std::vector<Int_t>> fTimeshiftsMap = {};
 
  Bool_t fIsFirstChannelsElinkEven = kFALSE;
 
  size_t fNrWildRda = 0;
 
  size_t fNrWildEom = 0;
 
  size_t fNrMissingEom = 0;
 
  size_t fNrWildNul = 0;
 
  size_t fNrUnknownWords = 0;
 
  static constexpr std::uint16_t fTsMsbLength = 16000;
 
  size_t fTsMsbLengthCC = fTsMsbLength / CbmTrdSpadic::GetClockCycle();
 
  std::map<std::uint32_t, std::vector<std::int32_t>> fElinkTimeOffsetMap;
 
 private:
  ClassDef(CbmTrdUnpackAlgoBaseR, 2)
};
 
#endif  // CbmTrdUnpackAlgoBaseR_H