SVDRecoDigit.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.                  *
 **************************************************************************/
 
#ifndef SVD_RECODIGIT_H
#define SVD_RECODIGIT_H
 
#include <vxd/dataobjects/VxdID.h>
#include <framework/datastore/RelationsObject.h>
 
#include <vector>
#include <cstdint>
#include <sstream>
#include <string>
#include <algorithm>
#include <numeric>
 
namespace Belle2 {

 
  class SVDRecoDigit : public RelationsObject {
 
  public:

    typedef uint16_t StoredProbType;
    typedef std::vector<StoredProbType> StoredProbArray; 
    static const uint16_t storedProbArrayNorm = UINT16_MAX; 

    typedef double OutputProbType;
    typedef std::vector<OutputProbType> OutputProbArray; 

    template<typename T>
    SVDRecoDigit(VxdID sensorID, bool isU, short cellID, float fittedAmplitude,
                 float fittedAmplitudeError, float fittedTime, float fittedTimeError,
                 const T& probabilities, float chi2):
      m_fittedAmplitude(fittedAmplitude), m_fittedAmplitudeError(fittedAmplitudeError),
      m_fittedTime(fittedTime), m_fittedTimeError(fittedTimeError), m_fitChi2Ndf(chi2),
      m_cellID(cellID), m_sensorID(sensorID), m_isU(isU)
    {
      // Expecting input array normalized to 1, but don't rely on it.
      double inputNorm = std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
      if (inputNorm < 0.1) inputNorm = 1.0;
      double normCoef = static_cast<double>(storedProbArrayNorm) / inputNorm;
      std::transform(probabilities.begin(), probabilities.end(),
                     std::back_inserter(m_probabilities),
                     [normCoef](typename T::value_type x)->StoredProbType
      { return static_cast<StoredProbType>(normCoef * x); }
                    );
    }

    SVDRecoDigit() : SVDRecoDigit(
        0, true, 0, 0.0, 10.0, 0.0, 100.0, std::vector<double>({1.0}), 100.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; }

    float getAmplitude() const { return m_fittedAmplitude; }

    float getCharge() const { return m_fittedAmplitude; }

    float getAmplitudeError() const { return m_fittedAmplitudeError; }

    float getTime() const { return m_fittedTime; }

    float getTimeError() const { return m_fittedTimeError; }

    OutputProbArray getProbabilities() const
    {
      OutputProbArray outputPdf;
      // We need to get the norm, may be different
      int storeNorm = std::accumulate(m_probabilities.begin(), m_probabilities.end(), 0.0,
                                      [](int x, StoredProbType y) -> int { return x + y; });
      double normCoef = static_cast<double>(1.0 / storeNorm);
      if (normCoef < 1.0e-15) normCoef = 1.0;
      std::transform(m_probabilities.begin(), m_probabilities.end(),
                     std::back_inserter(outputPdf),
                     [normCoef](StoredProbType x)-> OutputProbType
      { return static_cast<OutputProbType>(normCoef * x); }
                    );
      return outputPdf;
    }

    float getChi2Ndf() const { return m_fitChi2Ndf; }

    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
         << " Amplitude: " << m_fittedAmplitude << " +/- " << m_fittedAmplitudeError
         << " Time: " << m_fittedTime << " +/- " << m_fittedTimeError << std::endl
         << " probabilities: ";
      std::copy(m_probabilities.begin(), m_probabilities.end(),
                std::ostream_iterator<StoredProbType>(os, " "));
      os << "Chi2/ndf: " << m_fitChi2Ndf << std::endl;
      return os.str();
    }
 
  private:
 
    StoredProbArray m_probabilities; 
    //    float m_stripNoise; /**< Noise of the strip, from calibration. */
    float m_fittedAmplitude; 
    float m_fittedAmplitudeError; 
    float m_fittedTime; 
    float m_fittedTimeError; 
    float m_fitChi2Ndf; 
    short m_cellID; 
    VxdID::baseType m_sensorID; 
    bool m_isU; 
 
    ClassDef(SVDRecoDigit, 4)
 
  }; // class SVDRecoDigit

} // end namespace Belle2
 
#endif // SVD_RECODIGIT_H