CbmTrdSpadic.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 CBMTRDSPADIC_H
#define CBMTRDSPADIC_H
 
#include "CbmTrdDefs.h"  // for MIP dEdx value
#include "CbmTrdDigi.h"  // for ClockCycle
#include "CbmTrdParSpadic.h"
#include "CbmTrddEdxUtils.h"  // for MIP dEdx
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Double_t, Int_t, Bool_t, Option_t
#include <TF1.h>         // for response functions
#include <TObject.h>     // for TObject inheritence
 
#include <cstdint>
#include <vector>
 
#include <MessageTypes.h>
#include <cmath>
 
class CbmTrdSpadic {
 
public:
  CbmTrdSpadic();
 
  CbmTrdSpadic(const CbmTrdSpadic&) = delete;
 
  CbmTrdSpadic& operator=(const CbmTrdSpadic&);
 
  virtual ~CbmTrdSpadic();
 
 
  enum class eResponsePars : size_t
  {
    kShapingTime = 0,
    kShapingOrder,
    kInputCharge,
    kBinTimeshift,
    kNrPresamples,
    kChargeToMaxAdcCal,
    kMipCal
  };
  Double_t GetParameter(eResponsePars partype) { return fvecResponsePars[static_cast<size_t>(partype)]; }
 
  static UInt_t GetNrChannels() { return NSPADICCH; }
 
  static std::shared_ptr<TF1> GetResponseFunc();
 
  static constexpr UInt_t GetNrOfAdcSamples() { return fgNrOfAdcSamples; }
 
  static constexpr UInt_t GetNrOfPresamples() { return fgNrOfPresamples; }
 
  static constexpr UInt_t GetShapingOrder() { return fgShapingOrder; }
 
  static Float_t GetShapingTime() { return fgShapingTime; }
 
  static Double_t GetClockCycle() { return fgClockCycleLength; }
 
  static Double_t GetChargeToMaxAdcCal() { return fgChargeToMaxAdcCal; }
 
  static Double_t Response(Double_t* samplenr, Double_t* par);
 
  std::vector<std::int16_t> GetAnalogResponsePulse(Double_t inputCharge, Double_t binTimeshift = 0.0);
 
  Int_t GetNoise(Double_t sigmaNoise);
 
  UInt_t GetBaselineLvl() { return fBaselineLvl; }
 
  template<class Pulse>
  void ApplyClipping(Pulse* pulse)
  {
    for (auto& sample : *pulse) {
      if (sample > fClippingStart) sample = fClippingStart;
    }
  }
 
  Double_t GetAnalyticTimeshift(Double_t absolutetime);
 
  UInt_t GetDynamicRange() { return fDynamicRange; }
 
  UInt_t GetPeakingSamplePos();
 
  Int_t GetClippingStart() { return fClippingStart; }
 
  Float_t GetAdcNoiseLevel() { return fNoiseLvl; }
 
  Float_t GetMaxAdcToEnergyCal() { return fMaxAdcToEnergyCal; }
 
  Double_t GetMipCalibration() { return fMaxAdcToMipCal; }
 
 
  Float_t GetModuleThickness() { return fModuleThickness; }
 
  bool GetUseBaselineAvg() { return fDoUseBaselineAvg; }
 
  Float_t MaxAdcToEnergyCal(Float_t maxadc);
 
 
  template<class precision>
  CbmTrdDigi::eTriggerType GetTriggerDecision(std::vector<precision>* pulse, UInt_t* sndtriggersample = nullptr)
  {
    if (pulse->empty()) return CbmTrdDigi::eTriggerType::kNTrg;
 
    if (sndtriggersample) *sndtriggersample = 0;
    Int_t slopeFst   = 0;
    Int_t slopeSnd   = 0;
    bool selftrigger = false;
    bool falling     = false;
    bool multihit    = false;
 
 
    // Loop from the pulse beginning to last sample which could release a trigger.
    // Since, we need two positive sloapes in a row, the last two samples can not release a trigger alone
    for (auto sampleIt = pulse->begin(); sampleIt < pulse->end() - 2; ++sampleIt) {
      slopeFst = *(sampleIt + 1) - *sampleIt;
      if (slopeFst < fTriggerSlopeConditionFst && !selftrigger) continue;
 
      slopeSnd = *(sampleIt + 1) - *sampleIt;
      if (slopeSnd < 0 && !selftrigger) continue;
 
      if (!selftrigger) {
        if (slopeFst >= 2 * fTriggerSlopeConditionFst) selftrigger = true;
        if (slopeFst >= fTriggerSlopeConditionFst && slopeSnd >= fTriggerSlopeConditionSnd) selftrigger = true;
      }
      else {
        if (falling) {
          if (slopeFst >= 2 * fTriggerSlopeConditionFst) multihit = true;
          if (slopeFst >= fTriggerSlopeConditionFst && slopeSnd >= fTriggerSlopeConditionSnd) multihit = true;
          if (sndtriggersample) *sndtriggersample = sampleIt - pulse->begin();
        }
        if (slopeFst < 0 && slopeSnd < 0) falling = true;
      }
      if (multihit) break;
    }
    CbmTrdDigi::eTriggerType triggerType = CbmTrdDigi::eTriggerType::kNeighbor;
    if (selftrigger && !multihit) triggerType = CbmTrdDigi::eTriggerType::kSelf;
    if (selftrigger && multihit) triggerType = CbmTrdDigi::eTriggerType::kMulti;
 
    return triggerType;
  }
  void SetDynamicRange(UInt_t value) { fDynamicRange = value; }
 
  void SetClippingStart(Int_t value) { fClippingStart = value; }
 
  void SetNoiseLevel(Double_t value) { fNoiseLvl = value; }
 
  void SetFstTriggerSlopeCondition(Double_t value) { fTriggerSlopeConditionFst = value; }
 
  void SetSndTriggerSlopeCondition(Double_t value) { fTriggerSlopeConditionSnd = value; }
 
  void SetMaxAdcToEnergyCal(Double_t value) { fMaxAdcToEnergyCal = value; }
 
  void SetMipCalibration(Double_t value) { fMaxAdcToMipCal = value; }
 
 
  void SetModuleThickness(Double_t value) { fModuleThickness = value; }
 
  void SetBaselineLvl(UInt_t value) { fBaselineLvl = value; }
 
  void SetUseBaselineAverage(bool value = true) { fDoUseBaselineAvg = value; }
 
  Double_t Response(UInt_t samplenr);
 
  void SetParameter(eResponsePars ipar, Double_t value) { fvecResponsePars.at(static_cast<size_t>(ipar)) = value; }
 
private:
  static const Double_t fgClockCycleLength;
 
  std::vector<Double_t> fvecResponsePars = {fgShapingTime,          fgShapingOrder,   0.0,
                                            fgClockCycleLength / 2, fgNrOfPresamples, fgChargeToMaxAdcCal};
 
  static constexpr UInt_t fgNrOfAdcSamples = 32;
 
  static const Double_t fgShapingTime;
 
  static constexpr UInt_t fgShapingOrder = 1;
 
  static constexpr UInt_t fgNrOfPresamples = 1;
 
  static const Double_t fgChargeToMaxAdcCal;
 
  UInt_t fDynamicRange = std::pow(2, 9);
 
  Int_t fClippingStart = fDynamicRange;
 
  Int_t fTriggerSlopeConditionFst = 15;
 
  Int_t fTriggerSlopeConditionSnd = 9;
 
  Float_t fModuleThickness = 1.20;
 
  // UInt_t fBaselineLvl = 10;
  UInt_t fBaselineLvl = 0;
 
  Float_t fMaxAdcToMipCal = (CbmTrddEdxUtils::MipDeDx() * fModuleThickness * CbmTrddEdxUtils::MeanChargeCentrPadPRF())
                            / (CbmTrddEdxUtils::MipCaliTarget() * (fDynamicRange - fBaselineLvl));
  // Float_t fMaxAdcToMipCal = 1;
 
  Float_t fMaxAdcToEnergyCal = fMaxAdcToMipCal;
 
  Float_t fNoiseLvl = 1;
 
  bool fDoUseBaselineAvg = false;
 
public:
  ClassDef(CbmTrdSpadic, 2);
};
#endif