TRGECLFAMPara.h

//-----------------------------------------------------------
// $Id$
//-----------------------------------------------------------
// Filename : TRGECLFAMPara.h
// Section  : TRG ECL
// Owner    : HanEol Cho/InSu Lee/Yuuji Unno
// Email    : hecho@hep.hanyang.ac.kr / islee@hep.hanyang.ac.kr / yunno@post.kek.jp
//-----------------------------------------------------------
// Description : A class to represent ECL.
//-----------------------------------------------------------
// $Log$
//-----------------------------------------------------------
 
#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,
      std::vector<double>  SignalPDF,
      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(std::vector<double> SignalPDF) { m_SignalPDF = SignalPDF;}
    void setNoiseCovarianceMatrix(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