ARICHModuleTest.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 <TH1D.h>
#include <TH2D.h>
#include <TGraph.h>
 
#include <TClass.h>
 
namespace Belle2 {
  class ARICHModuleTest: public TObject {
  public:
 
    ARICHModuleTest(): m_febSN(0), m_hapdSN(""), m_hvbSN(0), m_run(0), m_runposition(0), m_isOK(false), m_deadCh(), m_strangeCh(),
      m_guardBias_th(NULL), m_HV_th(NULL), m_guardBias_2Dx(NULL), m_HV_2Dx(NULL), m_guardBias_2Dy(NULL), m_HV_2Dy(NULL), m_gain(NULL),
      m_charge(NULL), m_th(NULL), m_scanX(NULL), m_scanY(NULL), m_comment("")
    {
      for (unsigned i = 0; i < 4; i++) m_chipVdiff_th[i] = NULL;
      for (unsigned i = 0; i < 4; i++) m_chipLeak_th[i] = NULL;
      for (unsigned i = 0; i < 4; i++) m_chipVdiff_2Dx[i] = NULL;
      for (unsigned i = 0; i < 4; i++) m_chipLeak_2Dx[i] = NULL;
      for (unsigned i = 0; i < 4; i++) m_chipVdiff_2Dy[i] = NULL;
      for (unsigned i = 0; i < 4; i++) m_chipLeak_2Dy[i] = NULL;
    };
 
    ~ARICHModuleTest() {};
 
    int getFebSN() const {return m_febSN; }
 
    void setFebSN(int serial) {m_febSN = serial; }
 
    std::string getHapdSN() const {return m_hapdSN; }
 
    void setHapdSN(const std::string& hapd) {m_hapdSN = hapd; }
 
    int getHvbSN() const {return m_hvbSN; }
 
    void setHvbSN(int serial) {m_hvbSN = serial; }
 
    int getRun() const {return m_run; }
 
    void setRun(int run) {m_run = run; }
 
    int getRunPosition() const {return m_runposition; }
 
    void setRunPosition(int runposition) {m_runposition = runposition; }
 
    bool getOK() const {return m_isOK; }
 
    void setOK(bool isOK) {m_isOK = isOK; }
 
    int getDeadCh(unsigned int i) const;
 
    void appendDeadCh(int channel) {m_deadCh.push_back(channel); }
 
    void setDeadChs(const std::vector<int>& deadChs) {m_deadCh = deadChs; }
 
    int getDeadChsSize() const {return m_deadCh.size();}
 
    int getStrangeCh(unsigned int i) const;
 
    void appendStrangeCh(int channel) {m_strangeCh.push_back(channel); }
 
    void setStrangeChs(const std::vector<int>& strangeChs) {m_strangeCh = strangeChs; }
 
    int getStrangeChsSize() const {return m_strangeCh.size();}
 
    TGraph* getGuardBiasTH() const {return m_guardBias_th;}
 
    void setGuardBiasTH(TGraph* guardBias_th) { m_guardBias_th = guardBias_th;}
 
    TGraph* getChipVdiffTH(unsigned int i) const;
 
    void setChipVdiffTH(unsigned int i, TGraph* chipVdiff_th);
 
    TGraph* getChipLeakTH(unsigned int i) const;
 
    void setChipLeakTH(unsigned int i, TGraph* chipLeak_th);
 
    TGraph* getHighVoltageTH() const {return m_HV_th;}
 
    void setHighVoltageTH(TGraph* HV_th) { m_HV_th = HV_th;}
 
    TGraph* getGuardBias2Dx() const {return m_guardBias_2Dx;}
 
    void setGuardBias2Dx(TGraph* guardBias_2Dx) { m_guardBias_2Dx = guardBias_2Dx;}
 
    TGraph* getChipVdiff2Dx(unsigned int i) const;
 
    void setChipVdiff2Dx(unsigned int i, TGraph* chipVdiff_2Dx);
 
    TGraph* getChipLeak2Dx(unsigned int i) const;
 
    void setChipLeak2Dx(unsigned int i, TGraph* chipLeak_2Dx);
 
    TGraph* getHighVoltage2Dx() const {return m_HV_2Dx;}
 
    void setHighVoltage2Dx(TGraph* HV_2Dx) { m_HV_2Dx = HV_2Dx;}
 
    TGraph* getGuardBias2Dy() const {return m_guardBias_2Dy;}
 
    TGraph* getChipVdiff2Dy(unsigned int i) const;
 
    void setChipVdiff2Dy(unsigned int i, TGraph* chipVdiff_2Dy);
 
    void setGuardBias2Dy(TGraph* guardBias_2Dy) { m_guardBias_2Dy = guardBias_2Dy;}
 
    TGraph* getChipLeak2Dy(unsigned int i) const;
 
    void setChipLeak2Dy(unsigned int i, TGraph* chipLeak_2Dy);
 
    TGraph* getHighVoltage2Dy() const {return m_HV_2Dy;}
 
    void setHighVoltage2Dy(TGraph* HV_2Dy) { m_HV_2Dy = HV_2Dy;}
 
    TH1F* getGain() const {return m_gain;}
 
    void setGain(TH1F* gain) { m_gain = gain;}
 
    TH2D* getChargeScan() const {return m_charge;}
 
    void setChargeScan(TH2D* charge) { m_charge = charge;}
 
    TH2D* getTresholdScan() const {return m_th;}
 
    void setTresholdScan(TH2D* th) { m_th = th;}
 
    TH2D* getLaserScanX() const {return m_scanX;}
 
    void setLaserScanX(TH2D* scanX) { m_scanX = scanX;}
 
    TH2D* getLaserScanY() const {return m_scanY;}
 
    void setLaserScanY(TH2D* scanY) { m_scanY = scanY;}
 
    void setComment(const std::string& comment) {m_comment = comment; }
 
    std::string getComment() const {return m_comment; }
 
  private:
 
    int m_febSN;                   
    std::string m_hapdSN;          
    int m_hvbSN;                   
    int m_run;                     
    int m_runposition;             
    bool m_isOK;                   
    std::vector<int> m_deadCh;     
    std::vector<int> m_strangeCh;  
    TGraph* m_guardBias_th;        
    TGraph* m_chipVdiff_th[4];     
    TGraph* m_chipLeak_th[4];      
    TGraph* m_HV_th;               
    TGraph* m_guardBias_2Dx;       
    TGraph* m_chipVdiff_2Dx[4];    
    TGraph* m_chipLeak_2Dx[4];     
    TGraph* m_HV_2Dx;              
    TGraph* m_guardBias_2Dy;       
    TGraph* m_chipVdiff_2Dy[4];    
    TGraph* m_chipLeak_2Dy[4];     
    TGraph* m_HV_2Dy;              
    TH1F* m_gain;                  
    TH2D* m_charge;                
    TH2D* m_th;                    
    TH2D* m_scanX;                 
    TH2D* m_scanY;                 
    std::string m_comment;         
    ClassDef(ARICHModuleTest, 2);  
  };
} // end namespace Belle2