LArBadChanBitPackingBase.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
 
template<class T>
void TLArBadChanBitPackingBase<T>::addBit( typename T::ProblemType pb, const std::string& name, 
                   GainDependence gaindep)
{
  m_enumVec.push_back( std::make_pair( pb, gaindep));
  m_nameVec.push_back(name);
}
 
 
template<class T>
const std::string& TLArBadChanBitPackingBase<T>::stringName( typename T::ProblemType pb) const 
{
  return m_nameVec.at(index(pb));
}
 
template<class T>
std::pair<bool, typename T::ProblemType>
TLArBadChanBitPackingBase<T>::enumName( const std::string& str) const
{
  typename std::map<std::string, typename T::ProblemType>::const_iterator i = m_nameMap.find( str);
  if (i != m_nameMap.end()) { return std::make_pair(true,i->second);}
  else return std::make_pair(false, (typename T::ProblemType) 0);
}
 
 
template<class T>
void TLArBadChanBitPackingBase<T>::setBit( typename T::ProblemType pb, LArBadChannel::BitWord& word, bool value) const {
  LArBadChannel::BitWord mask = 1;
  mask = mask << m_bitPos[static_cast<LArBadChannel::PosType>(pb)]; // all at 0 except pb bit
  if (value) word |= mask;
  else word &= ~mask;
}
 
template<class T>
bool TLArBadChanBitPackingBase<T>::setBit( const std::string& name, 
                   LArBadChannel::BitWord& word, bool value) const
{
  std::pair<bool, typename T::ProblemType> res = enumName( name);
  if (res.first) { // name corresponds to enum
    setBit( res.second, word, value);
    return true;
  }
  else return false; // name not recognized
}
 
template<class T>
void TLArBadChanBitPackingBase<T>::setBit( typename T::ProblemType pb, LArBadChannel& word, bool value) const
{
  setBit( pb, word.packedDataRef(), value);
}
 
template<class T>
bool TLArBadChanBitPackingBase<T>::setBit( const std::string& name, LArBadChannel& word, bool value) const
{
  return setBit( name, word.packedDataRef(), value);
}
 
template<class T>
std::string TLArBadChanBitPackingBase<T>::stringStatus( const LArBadChannel& bc) const
{
  std::string res;
  for (unsigned int i=0; i<m_enumVec.size(); ++i) {
    if ( ! bc.statusOK( m_enumVec.at(i).first  )) {
      if (!res.empty()) res += " ";
      res += m_nameVec.at(i);
    }
  }
  return res;
}
 
template<class T>
void TLArBadChanBitPackingBase<T>::initMasks()
{
  for( typename std::vector< std::pair<typename T::ProblemType, GainDependence> >::const_iterator iter = m_enumVec.begin();
       iter != m_enumVec.end(); ++iter)  //loop over all problems
  {
    // set the appropriate bits in each mask according to the GainDependence of the T::ProblemType
    if(iter->second == independent)
    {
      setBit(iter->first, m_highGainMask);
      setBit(iter->first, m_mediumGainMask);
      setBit(iter->first, m_lowGainMask);
    }
    else if(iter->second == high)
      setBit(iter->first, m_highGainMask);
    else if(iter->second == medium)
      setBit(iter->first, m_mediumGainMask);
    else if(iter->second == low)
      setBit(iter->first, m_lowGainMask);
  }
}