ARICHBadChannels.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Rok Pestotnik, Manca Mrvar                               *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
#include <TObject.h>
#include <vector>
 
namespace Belle2 {
  class ARICHBadChannels: public TObject {
  public:
 
    ARICHBadChannels(): m_id(-1), m_hapdSerial(""), m_febSerial(0), m_hapdCutChannels(), m_hapdBadChannels(), m_febDeadChannels(),
      m_asicDeadChannels(), m_asicBadConnChannels(), m_asicBadOffsetChannels(), m_asicBadLinChannels() {};
 
    ~ARICHBadChannels() {};
 
    int getID() const {return m_id; }
 
    void setID(const int id) {m_id = id; }
 
    std::string getHapdSerial() const {return m_hapdSerial; }
 
    void setHapdSerial(const std::string& serial) {m_hapdSerial = serial; }
 
    int getFebSerial() const {return m_febSerial; }
 
    void setFebSerial(const int serial) {m_febSerial = serial; }
 
    int getHapdCutChannel(unsigned int i) const;
 
    std::vector<int> getHapdCutChannels() const {return m_hapdCutChannels; }
 
    void appendHapdCutChannel(int channel) {m_hapdCutChannels.push_back(channel); }
 
    void setHapdCutChannel(std::vector<int> channels);
 
    int getHapdCutChannelsSize() const {return m_hapdCutChannels.size(); }
 
    int getHapdBadChannel(unsigned int i) const;
 
    std::vector<int> getHapdBadChannels() const {return m_hapdBadChannels; }
 
    void appendHapdBadChannel(int ichannel) { m_hapdBadChannels.push_back(ichannel); }
 
    void setHapdBadChannel(std::vector<int> channels);
 
    int getHapdBadChannelsSize() const {return m_hapdBadChannels.size();}
 
    int getHapdListOfBadChannel(unsigned int i) const;
 
    std::vector<int> getHapdListOfBadChannels() const { return m_hapdListOfBadChannels; }
 
    int getHapdListOfBadChannelsSize() const { return m_hapdListOfBadChannels.size(); }
 
    int getFebDeadChannel(unsigned int i) const;
 
    std::vector<int> getFebDeadChannels() const {return m_febDeadChannels; }
 
    void appendFebDeadChannel(int channel) {m_febDeadChannels.push_back(channel); }
 
    void setFebDeadChannels(std::vector<int> deadChannels);
 
    int getFebDeadChannelsSize() const {return m_febDeadChannels.size();}
 
    int getAsicDeadChannel(unsigned int i) const;
 
    std::vector<int> getAsicDeadChannels() const {return m_asicDeadChannels; }
 
    void appendAsicDeadChannel(int channel) {m_asicDeadChannels.push_back(channel); }
 
    void setAsicDeadChannels(std::vector<int> deadChannels);
 
    int getAsicDeadChannelsSize() const {return m_asicDeadChannels.size();}
 
    int getAsicBadConnChannel(unsigned int i) const;
 
    std::vector<int> getAsicBadConnChannels() const {return m_asicBadConnChannels; }
 
    void appendAsicBadConnChannel(int ichannel) { m_asicBadConnChannels.push_back(ichannel); }
 
    int getAsicBadConnChannelsSize() const {return m_asicBadConnChannels.size();}
 
    void setAsicBadConnChannels(std::vector<int> badConnChannels);
 
    int getAsicBadOffsetChannel(unsigned int i) const;
 
    std::vector<int> getAsicBadOffsetChannels() const {return m_asicBadOffsetChannels; }
 
    void appendAsicBadOffsetChannel(int ichannel) { m_asicBadOffsetChannels.push_back(ichannel); }
 
    int getAsicBadOffsetChannelsSize() const {return m_asicBadOffsetChannels.size();}
 
    void setAsicBadOffsetChannels(std::vector<int> badOffsetChannels);
 
    int getAsicBadLinChannel(unsigned int i) const;
 
    std::vector<int> getAsicBadLinChannels() const {return m_asicBadLinChannels; }
 
    void appendAsicBadLinChannel(int ichannel) { m_asicBadLinChannels.push_back(ichannel); }
 
    int getAsicBadLinChannelsSize() const {return m_asicBadLinChannels.size();}
 
    void setAsicBadLinChannels(std::vector<int> badLinChannels);
 
    int getFebListOfBadChannel(unsigned int i) const;
 
    std::vector<int> getFebListOfBadChannels() const { return m_febListOfBadChannels; }
 
    int getFebListOfBadChannelsSize() const { return m_febListOfBadChannels.size(); }
 
 
  private:
    int m_id;                   
    std::string m_hapdSerial;   
    int m_febSerial;            
    std::vector<int> m_hapdCutChannels;       
    std::vector<int> m_hapdBadChannels;       
    std::vector<int> m_febDeadChannels;       
    std::vector<int> m_asicDeadChannels;      
    std::vector<int> m_asicBadConnChannels;   
    std::vector<int> m_asicBadOffsetChannels; 
    std::vector<int> m_asicBadLinChannels;    
    std::vector<int> m_hapdListOfBadChannels; 
    std::vector<int> m_febListOfBadChannels;  
    ClassDef(ARICHBadChannels, 1); 
  };
} // end namespace Belle2