DATCONSVDDigit.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Christian Wessel                                         *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <vxd/dataobjects/VxdID.h>
 
#include <cstdint>
#include <sstream>
#include <algorithm>
#include <limits>
 
namespace Belle2 {
//     class DATCONSVDDigit : public DigitBase {
  class DATCONSVDDigit : public RelationsObject {
 
  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>
    DATCONSVDDigit(VxdID sensorID, bool isU, short cellID,
                   T samples[c_nAPVSamples]):
      m_sensorID(sensorID), m_isU(isU), m_cellID(cellID), m_totalCharge(0), m_maxSampleCharge(0), m_maxSampleIndex(0)
    {
      std::transform(samples, samples + c_nAPVSamples, m_samples.begin(),
                     [this](T x)->APVRawSampleType { return trimToSampleRange(x); }
                    );
    }
 
    template<typename T>
    DATCONSVDDigit(VxdID sensorID, bool isU, short cellID, T samples) :
      m_sensorID(sensorID), m_isU(isU), m_cellID(cellID), m_totalCharge(0), m_maxSampleCharge(0), m_maxSampleIndex(0)
    {
      std::transform(samples.begin(), samples.end(), m_samples.begin(),
                     [](typename T::value_type x)->APVRawSampleType
      { return trimToSampleRange(x); }
                    );
    }
 
    // cppcheck does not recognize initialization through other constructor
    // cppcheck-suppress uninitMemberVar
    DATCONSVDDigit() : DATCONSVDDigit(
        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 getFloatSamples() const
    {
      APVFloatSamples returnSamples;
      std::transform(m_samples.begin(), m_samples.end(), returnSamples.begin(),
      [](APVRawSampleType x) { return static_cast<APVFloatSampleType>(x); });
      return returnSamples;
    }
 
    APVRawSamples getRawSamples() const
    {
      return m_samples;
    }
 
    unsigned short getTotalCharge()
    {
      if (m_totalCharge > 0)
        return m_totalCharge;
      else {
        m_totalCharge = 0;
        for (unsigned int i = 0; i < c_nAPVSamples; i++) {
          m_totalCharge += m_samples[i];
        }
      }
      return m_totalCharge;
    }
 
    unsigned short getMaxSampleCharge()
    {
      unsigned short maxCharge = 0;
      for (unsigned int i = 0; i < c_nAPVSamples; i++) {
        if (m_samples[i] > maxCharge) {
          maxCharge = m_samples[i];
        }
      }
      return maxCharge;
    }
 
    unsigned short getMaxSampleIndex()
    {
      if (m_maxSampleIndex > 0)
        return m_maxSampleIndex;
      else {
        unsigned short maxCharge = 0;
        for (unsigned int i = 0; i < c_nAPVSamples; i++) {
          if (m_samples[i] > maxCharge) {
            maxCharge = m_samples[i];
            m_maxSampleIndex = i;
          }
        }
      }
      return m_maxSampleIndex;
    }
 
    template<typename T> static DATCONSVDDigit::APVRawSampleType trimToSampleRange(T x)
    {
      T trimmedX = std::min(
                     static_cast<T>(std::numeric_limits<DATCONSVDDigit::APVRawSampleType>::max()),
                     std::max(
                       static_cast<T>(std::numeric_limits<DATCONSVDDigit::APVRawSampleType>::lowest()),
                       x));
      return static_cast<DATCONSVDDigit::APVRawSampleType>(trimmedX);
    }
 
 
    void setSensorID(VxdID sensorid) { m_sensorID = sensorid; }
 
    void setUStrip(bool isU) { m_isU = isU; }
 
    void setCellID(short cellID) { m_cellID = cellID; }
 
    void setAPVRawSamples(APVFloatSamples apvInputSamples)
    {
      //       m_samples = apvSamples;
      std::transform(apvInputSamples.begin(), apvInputSamples.end(), m_samples.begin(),
      [](APVFloatSampleType x) { return static_cast<APVRawSampleType>(x); });
    }
 
  private:
 
    VxdID::baseType m_sensorID;       
    bool m_isU;                       
    short m_cellID;                   
    APVRawSamples m_samples;          
    unsigned short m_totalCharge;     
    unsigned short m_maxSampleCharge; 
    unsigned short m_maxSampleIndex;  
    ClassDef(DATCONSVDDigit, 1)
 
  }; // class DATCONSVDDigit
 
} // end namespace Belle2