SAMPAProcessing.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_TPC_SAMPAProcessing_H_
#define ALICEO2_TPC_SAMPAProcessing_H_
 
#include <Vc/Vc>
 
#include "TPCBase/PadPos.h"
#include "TPCBase/CalDet.h"
#include "TPCBase/CRU.h"
#include "MathUtils/RandomRing.h"
#include "TPCBase/ParameterDetector.h"
#include "TPCBase/ParameterElectronics.h"
#include "TPCBase/ParameterGas.h"
 
#include "TSpline.h"
 
namespace o2
{
namespace tpc
{
 
 
class SAMPAProcessing
{
 public:
  static SAMPAProcessing& instance()
  {
    static SAMPAProcessing sampaProcessing;
    return sampaProcessing;
  }
  ~SAMPAProcessing() = default;
 
  void updateParameters(float vdrift = 0);
 
  template <typename T>
  T getADCvalue(T nElectrons) const;
 
  float getADCSaturation(const float signal) const;
 
  template <DigitzationMode MODE>
  float makeSignal(float ADCcounts, const int sector, const int globalPadInSector, const float commonMode, float& pedestal, float& noise, float tot = 0);
 
  void getShapedSignal(float ADCsignal, float driftTime, std::vector<float>& signalArray) const;
 
  template <typename T>
  T getGamma4(T time, T startTime, T ADC) const;
 
  TimeBin getTimeBin(float zPos) const;
 
  float getZfromTimeBin(float timeBin, Side s) const;
 
  TimeBin getTimeBinFromTime(float time) const;
 
  float getTimeFromBin(TimeBin timeBin) const;
 
  float getTimeBinTime(float time) const;
 
  float getNoise(const int sector, const int globalPadInSector);
 
  float getZeroSuppression(const int sector, const int globalPadInSector) const;
 
  float getPedestal(const int sector, const int globalPadInSector) const;
 
  float getPedestalCRU(const int sector, const int globalPadInSector) const;
 
 private:
  SAMPAProcessing();
  const ParameterGas* mGasParam;             
  const ParameterDetector* mDetParam;        
  const ParameterElectronics* mEleParam;     
  const CalPad* mNoiseMap;                   
  const CalPad* mPedestalMap;                
  const CalPad* mPedestalMapCRU;             
  const CalPad* mZeroSuppression;            
  math_utils::RandomRing<> mRandomNoiseRing; 
  float mVDrift = 0;                         
};
 
template <typename T>
inline T SAMPAProcessing::getADCvalue(T nElectrons) const
{
  T conversion = mEleParam->ElectronCharge * 1.e15 * mEleParam->ChipGain * mEleParam->ADCsaturation /
                 mEleParam->ADCdynamicRange; // 1E-15 is to convert Coulomb in fC
  return nElectrons * conversion;
}
 
template <DigitzationMode MODE>
inline float SAMPAProcessing::makeSignal(float ADCcounts, const int sector, const int globalPadInSector, const float commonMode,
                                         float& pedestal, float& noise, float tot)
{
  pedestal = getPedestal(sector, globalPadInSector);
  noise = getNoise(sector, globalPadInSector);
 
  const float signal = ADCcounts;
  const float pedestalCRU = getPedestalCRU(sector, globalPadInSector);
  const float fullSignal = signal - commonMode + noise + pedestal + (tot > 0 ? 80 : 0); // TODO: improve to also add tail
 
  switch (MODE) {
    case DigitzationMode::FullMode: {
      return getADCSaturation(fullSignal);
      break;
    }
    case DigitzationMode::ZeroSuppression: {
      const float signalSubtractPedestal = getADCSaturation(signal) - pedestalCRU;
      const float zeroSuppression = getZeroSuppression(sector, globalPadInSector);
      if (signalSubtractPedestal < zeroSuppression) {
        return 0.f;
      }
      return signalSubtractPedestal;
      break;
    }
    case DigitzationMode::ZeroSuppressionCMCorr: {
      // TODO: this is not really a common mode correction, since the common mode is simply not treated.
      // Instead, the full common mode algorithm should be implemented and used
      const float signalNoCM = signal + noise + pedestal + (tot > 0 ? 80 : 0); // TODO: improve to also add tail
      const float signalSubtractPedestal = getADCSaturation(signalNoCM) - pedestalCRU;
      const float zeroSuppression = getZeroSuppression(sector, globalPadInSector);
      if (signalSubtractPedestal < zeroSuppression) {
        return 0.f;
      }
      return signalSubtractPedestal;
      break;
    }
    case DigitzationMode::SubtractPedestal: {
      const float signalSubtractPedestal = getADCSaturation(fullSignal) - pedestalCRU;
      return signalSubtractPedestal;
      break;
    }
    case DigitzationMode::NoSaturation: {
      return fullSignal;
      break;
    }
    case DigitzationMode::PropagateADC: {
      return signal;
      break;
    }
  }
  return signal;
}
 
inline float SAMPAProcessing::getADCSaturation(const float signal) const
{
  const float adcSaturation = mEleParam->ADCsaturation;
  if (signal > adcSaturation - 1) {
    return adcSaturation - 1;
  }
  return signal;
}
 
template <typename T>
inline T SAMPAProcessing::getGamma4(T time, T startTime, T ADC) const
{
  const auto tmp0 = (time - startTime) / mEleParam->PeakingTime;
  const auto cond = (tmp0 > 0);
  T tmp{};
  if constexpr (std::is_floating_point_v<T>) {
    if (!cond) {
      return T{};
    }
    tmp = tmp0;
  } else {
    tmp(cond) = tmp0;
  }
  const auto tmp2 = tmp * tmp;
  return 55.f * ADC * std::exp(-4.f * tmp) * tmp2 * tmp2; 
}
 
inline TimeBin SAMPAProcessing::getTimeBin(float zPos) const
{
  return static_cast<TimeBin>((mDetParam->TPClength - std::abs(zPos)) / (mVDrift * mEleParam->ZbinWidth));
}
 
inline float SAMPAProcessing::getZfromTimeBin(float timeBin, Side s) const
{
  const float zSign = (s == 0) ? 1 : -1;
  return zSign * (mDetParam->TPClength - (timeBin * mVDrift * mEleParam->ZbinWidth));
}
 
inline TimeBin SAMPAProcessing::getTimeBinFromTime(float time) const
{
  if (time < 0.f) {
    // protection and convention for negative times (otherwise overflow)
    return 0;
  }
  return static_cast<TimeBin>(time / mEleParam->ZbinWidth);
}
 
inline float SAMPAProcessing::getTimeFromBin(TimeBin timeBin) const
{
  return static_cast<float>(timeBin) * mEleParam->ZbinWidth;
}
 
inline float SAMPAProcessing::getTimeBinTime(float time) const
{
  return getTimeFromBin(getTimeBinFromTime(time));
}
 
inline float SAMPAProcessing::getNoise(const int sector, const int globalPadInSector)
{
  return mRandomNoiseRing.getNextValue() * mNoiseMap->getValue(sector, globalPadInSector);
}
 
inline float SAMPAProcessing::getZeroSuppression(const int sector, const int globalPadInSector) const
{
  return mZeroSuppression->getValue(sector, globalPadInSector);
}
 
inline float SAMPAProcessing::getPedestal(const int sector, const int globalPadInSector) const
{
  return mPedestalMap->getValue(sector, globalPadInSector);
}
 
inline float SAMPAProcessing::getPedestalCRU(const int sector, const int globalPadInSector) const
{
  return mPedestalMapCRU->getValue(sector, globalPadInSector);
}
} // namespace tpc
} // namespace o2
 
#endif // ALICEO2_TPC_SAMPAProcessing_H_