SVDRecoDigit.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2010 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Peter Kvasnicka                                          *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#ifndef SVD_RECODIGIT_H
#define SVD_RECODIGIT_H
 
#include <vxd/dataobjects/VxdID.h>
#include <svd/dataobjects/SVDModeByte.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, SVDModeByte mode = SVDModeByte()):
      m_sensorID(sensorID), m_isU(isU), m_cellID(cellID),
      m_fittedAmplitude(fittedAmplitude), m_fittedAmplitudeError(fittedAmplitudeError),
      m_fittedTime(fittedTime), m_fittedTimeError(fittedTimeError), m_fitChi2Ndf(chi2),
      m_mode(mode.getID())
    {
      // 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; }
 
    SVDModeByte getModeByte() const
    { return m_mode; }
 
    std::string toString() const
    {
      VxdID thisSensorID(m_sensorID);
      SVDModeByte thisMode(m_mode);
 
      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 << " " << thisMode << std::endl;
      return os.str();
    }
 
  private:
 
    VxdID::baseType m_sensorID; 
    bool m_isU; 
    short m_cellID; 
    //    float m_stripNoise; /**< Noise of the strip, from calibration. */
    float m_fittedAmplitude; 
    float m_fittedAmplitudeError; 
    float m_fittedTime; 
    float m_fittedTimeError; 
    StoredProbArray m_probabilities; 
    float m_fitChi2Ndf; 
    SVDModeByte::baseType m_mode; 
    ClassDef(SVDRecoDigit, 2)
 
  }; // class SVDRecoDigit
 
} // end namespace Belle2
 
#endif // SVD_RECODIGIT_H