ARICHFebTest.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.                  *
 **************************************************************************/
 
#pragma once
 
#include <TObject.h>
#include <string>
#include <vector>
#include <utility>
#include <TTimeStamp.h>
#include <TH2F.h>
#include <TH3F.h>
 
#include <TClass.h>
 
namespace Belle2 {

  class ARICHFebTest: public TObject {
  public:

    ARICHFebTest(): m_serial(0), m_dna(""), m_runSlowC(""), m_timeSlowC(), m_tmon0(0.0), m_tmon1(0.0), m_vdd(0.0), m_v2p(0.0),
      m_v2n(0.0), m_vss(0.0), m_vth1(0.0), m_vth2(0.0), m_vcc12(0.0), m_vcc15(0.0), m_vcc25(0.0), m_v38p(0.0), m_runLV(""), m_timeLV(),
      m_currentV20p(0.0), m_currentV21n(0.0), m_currentV38p(0.0), m_runHV(""), m_timeHV(), m_currentV99p(0.0), m_deadChannel(),
      m_testPulse(NULL), m_offsetRough(NULL),  m_offsetFine(NULL),  m_slopesRough(), m_slopesFine(), m_fwhm(), m_comment("") {};
    ARICHFebTest(): m_serial(0), m_dna(""), m_runSlowC(""), m_timeSlowC(), m_tmon0(0.0), m_tmon1(0.0), m_vdd(0.0), m_v2p(0.0), {…}
 

    explicit ARICHFebTest(int serial): m_serial(serial), m_dna(""), m_runSlowC(""), m_timeSlowC(), m_tmon0(0.0), m_tmon1(0.0),
      m_vdd(0.0), m_v2p(0.0), m_v2n(0.0), m_vss(0.0), m_vth1(0.0), m_vth2(0.0), m_vcc12(0.0), m_vcc15(0.0), m_vcc25(0.0), m_v38p(0.0),
      m_runLV(""), m_timeLV(), m_currentV20p(0.0), m_currentV21n(0.0), m_currentV38p(0.0), m_runHV(""), m_timeHV(), m_currentV99p(0.0),
      m_deadChannel(), m_testPulse(NULL), m_offsetRough(NULL), m_offsetFine(NULL), m_slopesRough(), m_slopesFine(), m_fwhm(),
      m_comment("") {};
    explicit ARICHFebTest(int serial): m_serial(serial), m_dna(""), m_runSlowC(""), m_timeSlowC(), m_tmon0(0.0), m_tmon1(0.0), {…}

    ~ARICHFebTest() {};

    int getFebSerial() const {return m_serial; }

    void setFebSerial(int serial) {m_serial = serial; }

    std::string getFebDna() const {return m_dna; }

    void setFebDna(const std::string& dna) {m_dna = dna; }

    std::string getRunSlowC() const {return m_runSlowC; }

    void setRunSlowC(const std::string& runSlowC) {m_runSlowC = runSlowC; }

    TTimeStamp getTimeSlowC() const {return m_timeSlowC; }

    void setTimeSlowC(TTimeStamp timeSlowC) {m_timeSlowC = timeSlowC; }

    float getTemperature0() const {return m_tmon0; }

    void setTemperature0(float tmon0) {m_tmon0 = tmon0; }

    float getTemperature1() const {return m_tmon1; }

    void setTemperature1(float tmon1) {m_tmon1 = tmon1; }

    float getVdd() const {return m_vdd; }

    void setVdd(float vdd) {m_vdd = vdd; }

    float getV2p() const {return m_v2p; }

    void setV2p(float v2p) {m_v2p = v2p; }

    float getV2n() const {return m_v2n; }

    void setV2n(float v2n) {m_v2n = v2n; }

    float getVss() const {return m_vss; }

    void setVss(float vss) {m_vss = vss; }

    float getVth1() const {return m_vth1; }

    void setVth1(float vth1) {m_vth1 = vth1; }

    float getVth2() const {return m_vth2; }

    void setVth2(float vth2) {m_vth2 = vth2; }

    float getVcc12() const {return m_vcc12; }

    void setVcc12(float vcc12) {m_vcc12 = vcc12; }

    float getVcc15() const {return m_vcc15; }

    void setVcc15(float vcc15) {m_vcc15 = vcc15; }

    float getVcc25() const {return m_vcc25; }

    void setVcc25(float vcc25) {m_vcc25 = vcc25; }

    float getV38p() const {return m_v38p; }

    void setV38p(float v38p) {m_v38p = v38p; }

    std::string getRunLV() const {return m_runLV; }

    void setRunLV(const std::string& runLV) {m_runLV = runLV; }

    TTimeStamp getTimeLV() const {return m_timeLV; }

    void setTimeLV(TTimeStamp timeLV) {m_timeLV = timeLV; }

    float getCurrentV20p() const {return m_currentV20p; }

    void setCurrentV20p(float currentV20p) {m_currentV20p = currentV20p; }

    float getCurrentV21n() const {return m_currentV21n; }

    void setCurrentV21n(float currentV21n) {m_currentV21n = currentV21n; }

    float getCurrentV38p() const {return m_currentV38p; }

    void setCurrentV38p(float currentV38p) {m_currentV38p = currentV38p; }

    std::string getRunHV() const {return m_runHV; }

    void setRunHV(const std::string& runHV) {m_runHV = runHV; }

    TTimeStamp getTimeHV() const {return m_timeHV; }

    void setTimeHV(TTimeStamp timeHV) {m_timeHV = timeHV; }

    float getCurrentV99p() const {return m_currentV99p; }

    void setCurrentV99p(float currentV99p) {m_currentV99p = currentV99p; }

    int getDeadChannel(unsigned int i) const;

    void appendDeadChannel(int channel) {m_deadChannel.push_back(channel); }

    void setDeadChannels(const std::vector<int>& deadChannels) {m_deadChannel = deadChannels; }

    int getDeadChannelsSize() const {return m_deadChannel.size();}

    TH2F* getTestPulse2D() const {return m_testPulse;}

    void setTestPulse2D(TH2F* testPulse) { m_testPulse = testPulse;}

    TH3F* getOffsetRough3D() const {return m_offsetRough;}

    void setOffsetRough3D(TH3F* offsetRough) { m_offsetRough = offsetRough;}

    TH3F* getOffsetFine3D() const {return m_offsetFine;}

    void setOffsetFine3D(TH3F* offsetFine) { m_offsetFine = offsetFine;}

    float getSlopeRough(unsigned int i) const;

    void appendSlopeRough(float slope) {m_slopesRough.push_back(slope); }

    void setSlopesRough(const std::vector<float>& slopesRough) {m_slopesRough = slopesRough; }

    int getSlopesRoughSize() const {return m_slopesRough.size();}

    float getSlopeFine(unsigned int i) const;

    void appendSlopeFine(float slope) {m_slopesFine.push_back(slope); }

    void setSlopesFine(const std::vector<float>& slopesFine) {m_slopesFine = slopesFine; }

    int getSlopesFineSize() const {return m_slopesFine.size();}

    std::pair<float, float> getFWHM(unsigned int i) const;

    void appendFWHM(const std::pair<float, float>& fwhm) {m_fwhm.push_back(fwhm); }

    void setFWHM(const std::vector<std::pair<float, float>>& fwhm) {m_fwhm = fwhm; }

    int getFWHMSize() const {return m_fwhm.size();}

    float getFWHMvalue(unsigned int i) const;

    float getFWHMsigma(unsigned int i) const;

    std::string getComment() const {return m_comment; }

    void setComment(const std::string& comment) {m_comment = comment; }
 
  private:
 
    int m_serial;                    
    std::string m_dna;               
    std::string m_runSlowC;          
    TTimeStamp m_timeSlowC;          
    float m_tmon0;                   
    float m_tmon1;                   
    float m_vdd;                     
    float m_v2p;                     
    float m_v2n;                     
    float m_vss;                     
    float m_vth1;                    
    float m_vth2;                    
    float m_vcc12;                   
    float m_vcc15;                   
    float m_vcc25;                   
    float m_v38p;                    
    std::string m_runLV;             
    TTimeStamp m_timeLV;             
    float m_currentV20p;             
    float m_currentV21n;             
    float m_currentV38p;             
    std::string m_runHV;             
    TTimeStamp m_timeHV;             
    float m_currentV99p;             
    std::vector<int> m_deadChannel;  
    TH2F* m_testPulse;               
    TH3F* m_offsetRough;             
    TH3F* m_offsetFine;              
    std::vector<float> m_slopesRough;           
    std::vector<float> m_slopesFine;            
    std::vector<std::pair<float, float>> m_fwhm; 
    std::string m_comment;           
 
    ClassDef(ARICHFebTest, 2);  
  };
  class ARICHFebTest: public TObject {…};

} // end namespace Belle2