ARICHFebTest.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Manca Mrvar                                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#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("") {};
 
 
    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("") {};
 
    ~ARICHFebTest() {};
 
    int getFebSerial() const {return m_serial; }
 
    void setFebSerial(int serial) {m_serial = serial; }
 
    std::string getFebDna() const {return m_dna; }
 
    void setRunSlowC(const std::string& runSlowC) {m_runSlowC = runSlowC; }
 
    std::string getRunSlowC() const {return m_runSlowC; }
 
    void setFebDna(const std::string& dna) {m_dna = dna; }
 
    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; }
 
    void setRunLV(const std::string& runLV) {m_runLV = runLV; }
 
    std::string getRunLV() const {return m_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; }
 
    void setRunHV(const std::string& runHV) {m_runHV = runHV; }
 
    std::string getRunHV() const {return m_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;
 
    void setComment(const std::string& comment) {m_comment = comment; }
 
    std::string getComment() const {return m_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);  
  };
} // end namespace Belle2