TileDCSState.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TILECONDITIONS_TILEDCSSTATE_H
#define TILECONDITIONS_TILEDCSSTATE_H
 
#include "TileConditions/Exception.h"
 
#include <vector>
#include <string>

 
class TileDCSState {
 
  public:

    enum TileDCSStatus {NON_EXISTING = 0, UNKNOWN = 1,
                        OK_DRAWER = 10, OK_KNOWNBADPMT, OK,
                        WARNING_DRAWER = 20, WARNING_KNOWNBADPMT, WARNING,
                        ALERT_DRAWER = 30, ALERT_KNOWNBADPMT, ALERT};
 
    TileDCSState();
    virtual ~TileDCSState() {};

    float getChannelHV(unsigned int ros,  unsigned int drawer,  unsigned int channel) const;

    void setChannelHV(unsigned int ros,  unsigned int drawer,  unsigned int channel, float hv);

    float getChannelHVSet(unsigned int ros,  unsigned int drawer,  unsigned int channel) const;

    void setChannelHVSet(unsigned int ros,  unsigned int drawer,  unsigned int channel, float hvSet);

    int getDrawerStates(unsigned int ros,  unsigned int drawer) const;

    void setDrawerStates(unsigned int ros,  unsigned int drawer, int states);

    TileDCSStatus getDCSHVStatus(unsigned int ros, unsigned int drawer, unsigned int channel) const;

    void setDCSHVStatus(unsigned int ros, unsigned int drawer, unsigned int channel, TileDCSStatus status);

    TileDCSStatus getDCSStatus(unsigned int ros, unsigned int drawer) const;

    TileDCSStatus getDCSStatus(unsigned int ros, unsigned int drawer, unsigned int channel) const;

    TileDCSStatus setDCSStatus(unsigned int ros, unsigned int drawer, unsigned int channel, TileDCSStatus status);

    bool isStatusHVBad(unsigned int ros, unsigned int drawer, unsigned int channel) const;

 
    bool isStatusBad (unsigned int ros, unsigned int drawer) const;

    bool isStatusBad(unsigned int ros, unsigned int drawer, unsigned int channel) const;

    void setGoodDrawer(int goodDrawer);

    void setWarningDrawer(const std::vector<int>& warningDrawer);
 
  private:
 
    enum TileLimits {
      NUMBER_OF_ROSES = 4, 
      NUMBER_OF_CHANNELS = 48, 
      NUMBER_OF_HV_CHANNELS = 55, 
      NUMBER_OF_HVSET_CHANNELS = 68, 
      NUMBER_OF_DRAWERS = 64 
    };
 
    void checkDrawer(const std::string& description, unsigned int ros, unsigned int drawer) const;
    void checkChannel(const std::string& description, unsigned int ros, unsigned int drawer,
                     unsigned int channel, unsigned int maxChannel) const;
 
    int m_states[NUMBER_OF_ROSES][NUMBER_OF_DRAWERS];
    float m_hv[NUMBER_OF_ROSES][NUMBER_OF_DRAWERS][NUMBER_OF_HV_CHANNELS];
    float m_hvSet[NUMBER_OF_ROSES][NUMBER_OF_DRAWERS][NUMBER_OF_HVSET_CHANNELS];
    TileDCSStatus m_status[NUMBER_OF_ROSES][NUMBER_OF_DRAWERS][NUMBER_OF_CHANNELS];
    TileDCSStatus m_hvStatus[NUMBER_OF_ROSES][NUMBER_OF_DRAWERS][NUMBER_OF_CHANNELS];
 
    int m_goodDrawer;
    std::vector<int> m_warningDrawer;
    int m_unknownValue;
 
};
 
 
#include "AthenaKernel/CLASS_DEF.h"
#include "AthenaKernel/CondCont.h"
 
CLASS_DEF(TileDCSState, 125804125, 0)
CONDCONT_MIXED_DEF(TileDCSState, 38603143);
 
// inlines
 
inline
float TileDCSState::getChannelHV(unsigned int ros,  unsigned int drawer,  unsigned int channel) const {
 
  checkChannel("TileDCSState::getChannelHV()", ros, drawer, channel, NUMBER_OF_HV_CHANNELS);
 
  return m_hv[ros - 1][drawer][channel];
}
 
inline
void TileDCSState::setChannelHV(unsigned int ros,  unsigned int drawer,  unsigned int channel, float hv) {
 
  checkChannel("TileDCSState::setChannelHV()", ros, drawer, channel, NUMBER_OF_HV_CHANNELS);
 
  m_hv[ros - 1][drawer][channel] = hv;
}
 
inline
float TileDCSState::getChannelHVSet(unsigned int ros,  unsigned int drawer,  unsigned int channel) const {
 
  checkChannel("TileDCSState::getChannelHVSet()", ros, drawer, channel, NUMBER_OF_HVSET_CHANNELS);
 
  return m_hvSet[ros - 1][drawer][channel];  // Return the HVSET
}
 
inline
void TileDCSState::setChannelHVSet(unsigned int ros,  unsigned int drawer,  unsigned int channel, float hvSet) {
 
  checkChannel("TileDCSState::setChannelHVSet()", ros, drawer, channel, NUMBER_OF_HVSET_CHANNELS);
 
  m_hvSet[ros - 1][drawer][channel] = hvSet;  // Set the HVSET
}
 
inline
int TileDCSState::getDrawerStates(unsigned int ros,  unsigned int drawer) const {
 
  checkDrawer("TileDCSState::getDrawerStates()", ros, drawer);
 
  return m_states[ros - 1][drawer];
}
 
inline
void TileDCSState::setDrawerStates(unsigned int ros,  unsigned int drawer, int states) {
 
  checkDrawer("TileDCSState::setDrawerStates()", ros, drawer);
 
  m_states[ros - 1][drawer] = states;  // Set the drawer state
}
 
inline
TileDCSState::TileDCSStatus TileDCSState::getDCSHVStatus(unsigned int ros,
                                                         unsigned int drawer,
                                                         unsigned int channel) const {
 
  checkChannel("TileDCSState::getDCSHVStatus()", ros, drawer, channel, NUMBER_OF_CHANNELS);
 
  return m_hvStatus[ros - 1][drawer][channel];
}
 
inline
void TileDCSState::setDCSHVStatus(unsigned int ros, unsigned int drawer, unsigned int channel,
                                  TileDCSState::TileDCSStatus status) {
 
  checkChannel("TileDCSState::setDCSHVStatus()", ros, drawer, channel, NUMBER_OF_CHANNELS);
 
  m_hvStatus[ros - 1][drawer][channel] = status;
}
 
inline
TileDCSState::TileDCSStatus TileDCSState::getDCSStatus(unsigned int ros,
                                                       unsigned int drawer,
                                                       unsigned int channel) const {
 
  checkChannel("TileDCSState::getDCSStatus()", ros, drawer, channel, NUMBER_OF_CHANNELS);
 
  return m_status[ros - 1][drawer][channel]; // final status - the worst of 2 statuses above
}
 
inline
TileDCSState::TileDCSStatus TileDCSState::setDCSStatus(unsigned int ros,
                                                       unsigned int drawer,
                                                       unsigned int channel,
                                                       TileDCSState::TileDCSStatus status) {
 
  checkChannel("TileDCSState::setDCSStatus()", ros, drawer, channel, NUMBER_OF_CHANNELS);
 
  return m_status[ros - 1][drawer][channel] = status; // final status - the worst of 2 statuses above
}
 
inline
bool TileDCSState::isStatusHVBad(unsigned int ros, unsigned int drawer, unsigned int channel) const {
  return getDCSHVStatus(ros, drawer, channel) > WARNING;
}
 
inline
bool TileDCSState::isStatusBad (unsigned int ros, unsigned int drawer) const {
  return getDCSStatus(ros, drawer) > WARNING;
}
 
inline
bool TileDCSState::isStatusBad(unsigned int ros, unsigned int drawer, unsigned int channel) const {
 
  checkChannel("TileDCSState::isStatusBad()", ros, drawer, channel, NUMBER_OF_CHANNELS);
 
  return m_status[ros - 1][drawer][channel] > WARNING;
}
 
inline
void TileDCSState::setGoodDrawer(int goodDrawer) { m_goodDrawer = goodDrawer;}
 
inline
void TileDCSState::setWarningDrawer(const std::vector<int>& warningDrawer) {
  m_warningDrawer = warningDrawer;
}
 
inline
void TileDCSState::checkDrawer(const std::string& description,
                               unsigned int ros, unsigned int drawer) const {
 
  if (ros > NUMBER_OF_ROSES) {
    throw TileCalib::IndexOutOfRange(description, ros, NUMBER_OF_ROSES);
  }
 
  if (drawer >= NUMBER_OF_DRAWERS) {
    throw TileCalib::IndexOutOfRange(description, drawer, NUMBER_OF_DRAWERS);
  }
 
}
 
 
inline
void TileDCSState::checkChannel(const std::string& description,
                                unsigned int ros, unsigned int drawer,
                                unsigned int channel, unsigned int maxChannel) const {
 
  checkDrawer(description, ros, drawer);
 
  if (channel >= maxChannel) {
    throw TileCalib::IndexOutOfRange(description, channel, maxChannel);
  }
 
}
 
#endif // TILECONDITIONS_TILEDCSSTATE_H