LArBadChannelState.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LArBadChannelState_H
#define LArBadChannelState_H
 
#include "Identifier/HWIdentifier.h"
#include "LArRecConditions/LArBadChannel.h"
 
#include <vector>
#include <string>
 
 
class LArBadChannelState {
 public:
 
  typedef std::pair<HWIdentifier, LArBadChannel>                BadChanEntry;
 
  enum {NCoolChannels=8};
  enum CaloPartEnum {EMB, EMEC, HEC, FCAL};
  enum PosNegEnum { NEG, POS};
  enum CoolChannelEnum { EMBA, EMBC, EMECA, EMECC, HECA, HECC, FCALA, FCALC, MAXCOOLCHAN};
 
  class CoolChannelData {
  public:
 
    typedef std::vector<BadChanEntry>       BadChanVec;

    CoolChannelData( CoolChannelEnum cc, const BadChanVec& entries) :
      m_number(cc), m_entries( entries), m_changed(false) {}

    explicit CoolChannelData( CoolChannelEnum cc) :
    m_number(cc), m_entries(), m_changed(false) {}
 
    void reset() {
      m_entries.clear();
      m_changed = false;
    }

    void add( const BadChanEntry& e) {
      m_entries.push_back(e);
      m_changed = true;
    }
 
    void setFromDB( const BadChanVec& stateVec) {
      m_entries = stateVec;
      m_changed = false;  
    }
 
    void addFromDB( const BadChanVec& stateVec);
 
    void addUpdate( const BadChanVec& stateVec) {
      m_entries.insert( m_entries.end(), stateVec.begin(), stateVec.end());
      m_changed = true;  
    }
 
    void resolveDuplicateEntries();
 
    CoolChannelEnum number() const { return m_number;}
 
    bool changed() const { return m_changed;}
 
    BadChanVec::const_iterator begin() const {
      return m_entries.begin();
    }
    BadChanVec::iterator begin() {
      return m_entries.begin();
    }
 
    BadChanVec::const_iterator end() const {
      return m_entries.end();
    }
    BadChanVec::iterator end() {
      return m_entries.end();
    }
 
    BadChanVec::size_type size() const {
      return m_entries.size();
    }
 
    bool empty() const {
      return m_entries.empty();
    }
 
    const BadChanVec& stateVector() const { return m_entries;}
 
  private:
    CoolChannelEnum             m_number;
    BadChanVec                  m_entries;
    bool                        m_changed;
  };
 
 
  typedef CoolChannelData::BadChanVec         BadChanVec;
 
  LArBadChannelState();
 
  int nCoolChannels() const { return m_DataVec.size();}

  bool empty() const {
    for (const CoolChannelData& cd : m_DataVec) {
      if (!cd.empty()) return false;
    }
    return true;
  }

  void reset();

  void addFromDB( const BadChanVec& stateVec, 
          CoolChannelEnum chan);

  void add( const BadChanEntry& entry, CoolChannelEnum chan);

  void setFromDB( const BadChanVec& stateVec, 
          CoolChannelEnum chan);

  void addUpdate( const BadChanVec& stateVec, 
          CoolChannelEnum chan) {
    m_DataVec[chan].addUpdate( stateVec);
  }
 
  const CoolChannelData& coolChannel( CoolChannelEnum chan) const {
    return m_DataVec.at(chan);
  }
 
  static std::string coolChannelName( CoolChannelEnum chan);
 
  static CoolChannelEnum coolChannelEnum( CaloPartEnum part, PosNegEnum side) {
    return static_cast<CoolChannelEnum>( 2 * static_cast<unsigned int>(part) +
                     1 - static_cast<unsigned int>(side));
  }
 
  static int barrelEndcap(  CoolChannelEnum chan) {
    if (chan == EMBA || chan == EMBC) return 0;
    else return 1;
  }
 
  static CaloPartEnum caloPart( CoolChannelEnum chan) {
    return static_cast<CaloPartEnum>(static_cast<int>(chan)/2);
  }
 
  static int posNeg( CoolChannelEnum chan) {
    return (static_cast<int>(chan)+1) % 2;
  }
 
  static void mergeFlags( BadChanEntry& a, const BadChanEntry& b) {
    a.second = LArBadChannel( a.second.packedData() | b.second.packedData());
  }
 
  //void CurrentState
 private:
 
  std::vector< CoolChannelData> m_DataVec;
 
  // Non-const access to channel data
  CoolChannelData& coolChannel( int i) {
    return m_DataVec.at( static_cast<CoolChannelEnum>(i));
  }
 
};
 
#endif