SVDShaperDigit.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <vxd/dataobjects/VxdID.h>
#include <framework/dataobjects/DigitBase.h>
#include <cstdint>
#include <sstream>
#include <string>
#include <algorithm>
#include <limits>
 
namespace Belle2 {
  class SVDShaperDigit : public DigitBase {
 
  public:
 
    static const std::size_t c_nAPVSamples = 6;
 
    typedef uint8_t APVRawSampleType;
    typedef std::array<APVRawSampleType, c_nAPVSamples> APVRawSamples; 
    typedef float APVFloatSampleType;
    typedef std::array<APVFloatSampleType, c_nAPVSamples> APVFloatSamples; 
    template<typename T>
    SVDShaperDigit(VxdID sensorID, bool isU, short cellID,
                   T samples[c_nAPVSamples], int8_t FADCTime = 0
                  ):
      m_sensorID(sensorID), m_isU(isU), m_cellID(cellID), m_FADCTime(FADCTime)
    {
      std::transform(samples, samples + c_nAPVSamples, m_samples.begin(),
                     [](T x)->APVRawSampleType { return trimToSampleRange(x); }
                    );
    }
 
    template<typename T>
    SVDShaperDigit(VxdID sensorID, bool isU, short cellID, T samples,
                   int8_t FADCTime = 0):
      m_sensorID(sensorID), m_isU(isU), m_cellID(cellID), m_FADCTime(FADCTime)
    {
      std::transform(samples.begin(), samples.end(), m_samples.begin(),
                     [](typename T::value_type x)->APVRawSampleType
      { return trimToSampleRange(x); }
                    );
    }
 
    SVDShaperDigit() : SVDShaperDigit(
        0, true, 0, APVRawSamples({{0, 0, 0, 0, 0, 0}})
    )
    { }
 
    VxdID getSensorID() const { return m_sensorID; }
 
    VxdID::baseType getRawSensorID() const { return m_sensorID; }
 
    bool isUStrip() const { return m_isU; }
 
    short int getCellID() const { return m_cellID; }
 
    APVFloatSamples getSamples() const
    {
      APVFloatSamples returnSamples;
      std::transform(m_samples.begin(), m_samples.end(), returnSamples.begin(),
      [](APVRawSampleType x) { return static_cast<APVFloatSampleType>(x); });
      return returnSamples;
    }
 
 
    int getMaxTimeBin() const
    {
      APVFloatSamples samples =  this->getSamples();
      const auto maxBinIterator = std::max_element(begin(samples), end(samples));
      const int maxBin = std::distance(begin(samples), maxBinIterator);
      return maxBin;
    }
 
    int getMaxADCCounts() const
    {
      APVFloatSamples samples =  this->getSamples();
      const float amplitude = *std::max_element(begin(samples), end(samples));
      return amplitude;
    }
 
    float getFADCTime() const { return static_cast<float>(m_FADCTime); }
 
 
    template<typename T> static SVDShaperDigit::APVRawSampleType trimToSampleRange(T x)
    {
      T trimmedX = std::min(
                     static_cast<T>(std::numeric_limits<SVDShaperDigit::APVRawSampleType>::max()),
                     std::max(
                       static_cast<T>(std::numeric_limits<SVDShaperDigit::APVRawSampleType>::lowest()),
                       x));
      return static_cast<SVDShaperDigit::APVRawSampleType>(trimmedX);
    }
 
    std::string toString() const
    {
      VxdID thisSensorID(m_sensorID);
 
      std::ostringstream os;
      os << "VXDID : " << m_sensorID << " = " << std::string(thisSensorID) << " strip: "
         << ((m_isU) ? "U-" : "V-") << m_cellID << " samples: ";
      std::copy(m_samples.begin(), m_samples.end(),
                std::ostream_iterator<unsigned int>(os, " "));
      os << "FADC time: " << (unsigned int)m_FADCTime << std::endl;
      return os.str();
    }
 
    unsigned int getUniqueChannelID() const override
    { return m_cellID + ((m_isU ? 1 : 0) << 11) + (m_sensorID << 12); }
 
    DigitBase::EAppendStatus addBGDigit(const DigitBase* bg) override
    {
      // Don't modify and don't append when bg points nowhere.
      if (!bg) return DigitBase::c_DontAppend;
 
      const auto& bgSamples = dynamic_cast<const SVDShaperDigit*>(bg)->getSamples();
 
      // Add background samples to the digit's and trim back to range
      if (s_APVSampleMode == 3) {
        std::transform(m_samples.begin(), m_samples.end() - 3, bgSamples.begin() + s_APVSampleBegin,
                       m_samples.begin(),
                       [](APVRawSampleType x, APVFloatSampleType y)->APVRawSampleType
        { return trimToSampleRange(x + y); }
                      );
      } else {
        std::transform(m_samples.begin(), m_samples.end(), bgSamples.begin(),
                       m_samples.begin(),
                       [](APVRawSampleType x, APVFloatSampleType y)->APVRawSampleType
        { return trimToSampleRange(x + y); }
                      );
      }
 
      // FIXME: Reset FADC time flag in mode byte.
      return DigitBase::c_DontAppend;
    }
 
    void adjustAppendedBGDigit() override
    {
      if (s_APVSampleMode != 3) return;
      if (s_APVSampleBegin > 0) {
        for (size_t i = 0; i < 3; i++) m_samples[i] = m_samples[i + s_APVSampleBegin];
      }
      for (size_t i = 3; i < 6; i++) m_samples[i] = 0;
    }
 
    bool operator < (const SVDShaperDigit&   x)const
    {
      if (getSensorID() != x.getSensorID())
        return getSensorID() < x. getSensorID();
      if (isUStrip() != x.isUStrip())
        return isUStrip();
      else
        return getCellID() < x.getCellID();
    }
 
    bool passesZS(int nSamples, float cutMinSignal) const
    {
      int nOKSamples = 0;
      Belle2::SVDShaperDigit::APVFloatSamples samples_vec = this->getSamples();
      for (size_t k = 0; k < c_nAPVSamples; k++)
        if (samples_vec[k] >= cutMinSignal)
          nOKSamples++;
 
      if (nOKSamples >= nSamples)
        return true;
 
      return false;
    }
 
    static void setAPVMode(size_t mode, size_t firstSample)
    {
      s_APVSampleMode =  mode;
      s_APVSampleBegin = firstSample;
    }
 
 
  private:
 
    VxdID::baseType m_sensorID = 0; 
    bool m_isU = false; 
    short m_cellID = 0; 
    APVRawSamples m_samples; 
    int8_t m_FADCTime = 0; 
    static size_t s_APVSampleMode; 
    static size_t s_APVSampleBegin; 
    ClassDefOverride(SVDShaperDigit, 5)
 
  }; // class SVDShaperDigit
 
} // end namespace Belle2