TRGECLFAMPara.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 TRGECLFAMPARA_H
#define TRGECLFAMPARA_H
 
#include <TObject.h>
 
namespace Belle2 {
  class TRGECLFAMPara : public TObject {
  public:
    TRGECLFAMPara() :
      m_FPGAversion(1),
      m_TCId(0),
      m_FAMId(0),
      m_ChannelId(0),
      m_TEreconstruct(0),
      m_ConversionFactor(0),
      m_Toffset(0),
      m_Threshold(0),
      m_Wavemean(0),
      m_Wavesigma(0)
    {
      m_SignalPDF.clear();
 
      m_NoiseCovarianceMatrix.clear();
 
    }
    TRGECLFAMPara(
      int FPGAversion,
      int TCId,
      int FAMId,
      int ChannelId,
      int TEreconstruct,
      double ConversionFactor,
      int Toffset,
      int Threshold,
      int Wavemean,
      int Wavesigma,
      const std::vector<double>&  SignalPDF,
      const std::vector<double>&  NoiseCovarianceMatrix
 
    ):
      m_FPGAversion(FPGAversion),
      m_TCId(TCId),
      m_FAMId(FAMId),
      m_ChannelId(ChannelId),
      m_TEreconstruct(TEreconstruct),
      m_ConversionFactor(ConversionFactor),
      m_Toffset(Toffset),
      m_Threshold(Threshold),
      m_Wavemean(Wavemean),
      m_Wavesigma(Wavesigma),
      m_SignalPDF(SignalPDF),
      m_NoiseCovarianceMatrix(NoiseCovarianceMatrix)
    { }
 
    void setFPGAversion(int FPGAversion) { m_FPGAversion = FPGAversion; }
 
    void setTCId(int TCId) { m_TCId = TCId; }
 
    void setFAMId(int FAMId) { m_FAMId = FAMId; }
 
    void setChannelId(int ChannelId) { m_ChannelId = ChannelId; }
 
    void setTEreconstruct(int TEreconstruct) { m_TEreconstruct = TEreconstruct; }
 
    void setConversionFactor(double ConversionFactor) { m_ConversionFactor = ConversionFactor; }
 
    void setToffset(int Toffset) { m_Toffset = Toffset; }
 
    void setThreshold(int Threshold) { m_Threshold = Threshold; }
 
    void setWavemean(int Wavemean) { m_Wavemean = Wavemean; }
 
    void setWavesigma(int Wavesigma) { m_Wavesigma = Wavesigma; }
 
    void setSignalPDF(const std::vector<double>& SignalPDF) { m_SignalPDF = SignalPDF;}
    void setNoiseCovarianceMatrix(const std::vector<double>& NoiseCovarianceMatrix) { m_NoiseCovarianceMatrix = NoiseCovarianceMatrix;}
 
    int getFPGAversion() const
    { return m_FPGAversion ; }
 
    int getTCId() const
    { return m_TCId ; }
 
    int getFAMId() const
    { return m_FAMId ; }
 
    int getChannelId() const
    { return m_ChannelId ; }
 
    int getTEreconstruct() const
    { return m_TEreconstruct ; }
 
    int getConversionFactor() const
    { return m_ConversionFactor ; }
 
    int getToffset() const
    { return m_Toffset ; }
 
    int getThreshold() const
    { return m_Threshold ; }
 
    int getWavemean() const
    { return m_Wavemean ; }
 
    int getWavesigma() const
    { return m_Wavesigma ; }
    std::vector<double>  setSignalPDF() { return m_SignalPDF ;}
    std::vector<double>  setNoiseCovarianceMatrix() { return m_NoiseCovarianceMatrix ;}
 
 
    //  private :
 
    int m_FPGAversion;
 
    int m_TCId;
 
    int m_FAMId;
    int m_ChannelId;
    int m_TEreconstruct;
 
    double m_ConversionFactor;
 
    int m_Toffset;
 
    int m_Threshold;
 
    int m_Wavemean;
 
    int m_Wavesigma;
    std::vector<double> m_SignalPDF;
    std::vector<double> m_NoiseCovarianceMatrix;
 
 
    ClassDef(TRGECLFAMPara, 2); /*< the class title */
  };
} 
 
#endif