CbmStsUnpackConfig.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 CbmStsUnpackConfig_H
#define CbmStsUnpackConfig_H
 
#include "CbmErrorMessage.h"  // REMARK this should become a Sts specific container I Would propose PR
#include "CbmRecoUnpackConfig.tmpl"
#include "CbmStsDigi.h"
#include "CbmStsParModule.h"
#include "CbmStsUnpackAlgo.h"
#include "CbmStsUnpackMonitor.h"
 
#include <Rtypes.h>
#include <RtypesCore.h>
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
 
class CbmStsUnpackConfig : public CbmRecoUnpackConfig<CbmStsUnpackAlgoBase, CbmStsDigi, CbmStsDigi, CbmErrorMessage> {
 
 public:
  CbmStsUnpackConfig(std::string detGeoSetupTag, UInt_t runid = 0);
 
  virtual ~CbmStsUnpackConfig();
 
  CbmStsUnpackConfig(const CbmStsUnpackConfig&) = delete;
 
  CbmStsUnpackConfig& operator=(const CbmStsUnpackConfig&) = delete;
 
  struct FebChanMaskReco {
    UInt_t uFeb;
    UInt_t uChan;
    Bool_t bMasked;
  };
 
  // Getters
  std::shared_ptr<CbmStsUnpackMonitor> GetMonitor() { return fMonitor; }
 
  void InitAlgo();
 
  void MaskNoisyChannel(UInt_t uFeb, UInt_t uChan, Bool_t bMasked = kTRUE)
  {
    fvChanMasks.emplace_back(FebChanMaskReco{uFeb, uChan, bMasked});
  }
 
  // Setters
  void SetAsicTimeOffset(size_t asicid, double value)
  {
    if (fvdTimeOffsetNsAsics.size() < (asicid + 1)) fvdTimeOffsetNsAsics.resize(asicid + 1);
    fvdTimeOffsetNsAsics.at(asicid) = value;
  }
  void SetWalkMap(const std::map<uint32_t, CbmStsParModule>& mapIn) { fWalkMap = mapIn; }
 
  void SetDuplicatesRejection(bool bIn = true, bool bDiffAdc = true)
  {
    fbRejectDuplicateDigis = bIn;
    fbDupliWithoutAdc      = bDiffAdc;
  }
 
  void SetMinAdcCut(uint32_t value) { fdAdcCut = value; }
 
  void SetMinAdcCut(uint32_t febid, uint32_t value) { fdAdcCut_perFeb[febid] = value; }
 
  void SetMonitor(std::shared_ptr<CbmStsUnpackMonitor> value) { fMonitor = value; }
 
  void SetFwBinning(bool useFwBinning) { fbUseFwBinning = useFwBinning; }
 
 protected:
  virtual std::shared_ptr<CbmStsUnpackAlgoBase> chooseAlgo();
 
  std::shared_ptr<CbmStsUnpackMonitor> fMonitor = nullptr;
 
  uint32_t fdAdcCut = 0;
 
  std::map<uint32_t, uint32_t> fdAdcCut_perFeb;
 
  std::vector<double> fvdTimeOffsetNsAsics = {};
 
  bool fbUseTimeWalkCorrection = false;
 
  std::map<uint32_t, CbmStsParModule> fWalkMap = {};
 
  bool fbRejectDuplicateDigis = false;
 
  bool fbDupliWithoutAdc = true;
 
  bool fbUseFwBinning = true;
 
  std::vector<FebChanMaskReco> fvChanMasks = {};
 
 private:
  ClassDef(CbmStsUnpackConfig, 3)
};
 
#endif  // CbmStsUnpackConfig_H