CbmMcbm2018UnpackerAlgoTrdR.h

Go to the documentation of this file.

/* Copyright (C) 2020-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Dennis Spicker, Florian Uhlig [committer], Pascal Raisig */
 
#ifndef CbmMcbm2018UnpackerAlgoTrdR_H
#define CbmMcbm2018UnpackerAlgoTrdR_H
 
#include "CbmStar2019Algo.h"
#include "CbmTrdDigi.h"
#include "CbmTrdParSetAsic.h"
#include "CbmTrdParSetDigi.h"
#include "CbmTrdParSetGain.h"
#include "CbmTrdParSetGas.h"
#include "CbmTrdRawMessageSpadic.h"
 
#include "TH1.h"
#include "TH2.h"
#include "TObjArray.h"
#include "TProfile.h"
#include "TString.h"
 
class CbmMcbm2018UnpackerAlgoTrdR : public CbmStar2019Algo<CbmTrdDigi> {
public:
  CbmMcbm2018UnpackerAlgoTrdR();
  ~CbmMcbm2018UnpackerAlgoTrdR();
 
  CbmMcbm2018UnpackerAlgoTrdR(const CbmMcbm2018UnpackerAlgoTrdR&) = delete;
  CbmMcbm2018UnpackerAlgoTrdR& operator=(const CbmMcbm2018UnpackerAlgoTrdR&) = delete;
 
  virtual Bool_t Init();
  virtual void Reset();
  virtual void Finish();
 
  Bool_t InitContainers();
  Bool_t ReInitContainers();
  TList* GetParList();
 
  Bool_t InitParameters();
 
  Bool_t ProcessTs(const fles::Timeslice& ts);
  Bool_t ProcessTs(const fles::Timeslice& ts, size_t /*component*/) { return ProcessTs(ts); }
 
  Bool_t ProcessMs(const fles::Timeslice& ts, size_t uMsCompIdx, size_t uMsIdx);
 
  void AddMsComponentToList(size_t component, UShort_t usDetectorId);
  void SetNbMsInTs(size_t uCoreMsNb, size_t uOverlapMsNb);
 
  enum ECbmTrdUnpackerHistograms : Int_t
  {
    kBeginDefinedHistos         = 0,
    kRawMessage_Signalshape_all = 0,
    kRawMessage_Signalshape_St,
    kRawMessage_Signalshape_Nt,
    kRawMessage_Signalshape_filtered,
    kRawDistributionMapModule5,
    kRawHitType,
    kRawPulserDeltaT,
    kSpadic_Info_Types,
    kBeginDigiHistos,
    kDigiPulserDeltaT = kBeginDigiHistos,
    kDigiDeltaT  // Heavy histogram add with care
      ,
    kDigiMeanHitFrequency  // Heavy histogram add with care
      ,
    kDigiHitFrequency,
    kDigiRelativeTimeMicroslice,
    kDigiDistributionMap,
    kDigiDistributionMapSt,
    kDigiDistributionMapNt,
    kDigiChargeSpectrum,
    kDigiChargeSpectrumSt,
    kDigiChargeSpectrumNt,
    kDigiTriggerType,
    kEndDefinedHistos
  };
  void SetActiveHistograms(std::vector<bool> isActiveHistoVec) { fIsActiveHistoVec = isActiveHistoVec; }
  Bool_t CreateHistograms();  
  Bool_t CreateHistogram(ECbmTrdUnpackerHistograms iHisto);  
 
  Bool_t FillHistograms();
  Bool_t FillHistograms(CbmTrdDigi const& digi);
  Bool_t FillHistograms(CbmTrdRawMessageSpadic const& raw);
  Bool_t ResetHistograms();
 
 
  std::vector<CbmTrdRawMessageSpadic> GetRawMessageVector() { return *(fTrdRawMessageVector); }
  TString GetRefGeoTag() { return fRefGeoTag; }
 
  void SetMonitorMode(Bool_t bFlagIn = kTRUE) { fbMonitorMode = bFlagIn; }
  void SetDebugMonitorMode(Bool_t bFlagIn = kTRUE) { fbDebugMonitorMode = bFlagIn; }
  void SetWriteOutput(Bool_t bFlagIn = kTRUE) { fbWriteOutput = bFlagIn; }
  void SetDebugWriteOutput(Bool_t bFlagIn = kTRUE) { fbDebugWriteOutput = bFlagIn; }
  void SetDebugSortOutput(Bool_t bFlagIn = kTRUE) { fbDebugSortOutput = bFlagIn; }
  inline void SetTimeOffsetNs(Double_t dOffsetIn = 0.0) { fdTimeOffsetNs = dOffsetIn; }
 
  void SetTimeshiftsMap(std::map<size_t, std::vector<Int_t>>* setvalue)
  {
    fmapTimeshifts.clear();
    fmapTimeshifts.insert(setvalue->begin(), setvalue->end());
  }
 
  void SetBaselineAvg(Bool_t bFlagIn = kTRUE) { fbBaselineAvg = bFlagIn; }
 
  Bool_t SetDigiOutputPointer(std::vector<CbmTrdDigi>* const pVector);
 
  Bool_t SetRawOutputPointer(std::vector<CbmTrdRawMessageSpadic>* const pVector,
                             std::vector<std::pair<size_t, size_t>>* const qVector = nullptr);
 
  void SetRefGeoTag(TString geoTag) { fRefGeoTag = geoTag; }
  void SetFirstChannelsElinkEven(bool isEven) { fIsFirstChannelsElinkEven = isEven; }
  void SetMsSizeInNs(Double_t msSizeInNs) { fdMsSizeInNs = msSizeInNs; }  // TODO handle this with asic parameter files
 
private:
  UInt_t fdMsSizeInCC;
  std::shared_ptr<CbmTrdDigi> MakeDigi(CbmTrdRawMessageSpadic raw);
 
  Spadic::MsMessageType GetMessageType(const uint64_t msg);
 
  Spadic::MsInfoType GetInfoType(const uint64_t msg);
 
  CbmTrdRawMessageSpadic CreateRawMessage(const uint64_t word, fles::MicrosliceDescriptor msDesc);
 
  Int_t GetNumRda(Int_t nsamples);
 
  int16_t ExtractSample(const uint64_t word, uint8_t sample, Bool_t multihit = kFALSE);
 
  // Control flags
  Bool_t fbMonitorMode;              
  Bool_t fbDebugMonitorMode;         
  Bool_t fbWriteOutput;              
  Bool_t fbDebugWriteOutput;         
  Bool_t fbDebugSortOutput = kTRUE;  
  Bool_t fbBaselineAvg;              
 
  Double_t fdTimeOffsetNs = 0.0;
 
  std::vector<CbmTrdDigi>* fTrdDigiVector;
 
  std::vector<CbmTrdRawMessageSpadic>* fTrdRawMessageVector;
 
  std::vector<std::pair<size_t, size_t>>* fSpadicInfoMsgVector;
 
  //std::map< TString, std::shared_ptr<TH1> > fHistoMap ;
 
  std::vector<bool> fIsActiveHistoVec;
  TObjArray fHistoArray;
  std::vector<size_t> fLastDigiTimeVec;
 
  //CbmTrdRawToDigiR *fRawToDigi ;
 
  ULong64_t fNbTimeslices;   
  ULong64_t fCurrTsIdx;      
  UInt_t fMsIndex;           
  Double_t fTsStartTime;     
  Double_t fTsStopTimeCore;  
  Double_t fMsTime;          
  ULong64_t fSpadicEpoch;    
 
  ULong64_t fLastFulltime;
 
  ULong64_t fNbSpadicRawMsg;    
  ULong64_t fNbWildRda;         
  ULong64_t fNbSpadicErrorMsg;  
  ULong64_t fNbUnkownWord;      
  ULong64_t fNbSpadicEpochMsg;  
 
  TList* fParContList;         
  TString fRefGeoTag;          
  CbmTrdParSetAsic* fAsicPar;  
  CbmTrdParSetDigi* fDigiPar;  
  CbmTrdParSetGas* fGasPar;    
  CbmTrdParSetGain* fGainPar;  
 
  std::map<size_t, Int_t> fSpadicMap;
 
  std::map<Int_t, std::vector<Int_t>> fAsicChannelMap;
 
  std::map<size_t, std::vector<Int_t>> fmapTimeshifts = {};
 
  std::vector<Int_t>* fvecTimeshiftsPar = nullptr;
 
  bool
    fIsFirstChannelsElinkEven;  
 
  static const UInt_t kBytesPerWord = 8;
 
  ClassDef(CbmMcbm2018UnpackerAlgoTrdR, 1)
};
 
#endif