LArBadChannelDecoder Class Reference

#include <LArBadChannelDecoder.h>

Collaboration diagram for LArBadChannelDecoder:

Public Types
typedef LArBadChannelState	State
typedef LArBadChannelState::BadChanEntry	BadChanEntry
typedef std::pair< HWIdentifier, LArBadFeb >	BadFebEntry

Public Member Functions
	LArBadChannelDecoder (const LArOnlineID_Base *onlineID, bool isSC=false)
std::vector< BadChanEntry >	readASCII (const std::string &name, State::CoolChannelEnum coolChan, MsgStream &log) const
std::vector< BadFebEntry >	readFebASCII (const std::string &fname, MsgStream &log) const

Private Types
enum	{   barrel_ec , pos_neg , feedthrough , slot ,   channel }

Private Member Functions
HWIdentifier	constructChannelId (const std::vector< int > &intVec, State::CoolChannelEnum coolChan, MsgStream &log) const
std::pair< bool, LArBadChannel >	constructStatus (const std::vector< std::string > &vecvec, MsgStream &log) const
std::pair< bool, LArBadFeb >	constructFebStatus (const std::vector< std::string > &vecvec, MsgStream &log) const
bool	checkId (const HWIdentifier &, int be, int pn, State::CoolChannelEnum) const
std::vector< HWIdentifier >	constructFebId (const std::vector< int > &intVec, MsgStream &log) const
HWIdentifier	constructSingleFebId (const std::vector< int > &v, MsgStream &log) const

Static Private Member Functions
static MsgStream &	insertExpandedID (const std::vector< int > &intVec, MsgStream &log)

Private Attributes
const LArOnlineID_Base *	m_onlineID
LArBadChanBitPacking	m_packing
LArBadChanSCBitPacking	m_SCpacking
LArBadFebBitPacking	m_febPacking
bool	m_isSC

Detailed Description

Definition at line 21 of file LArBadChannelDecoder.h.

Member Typedef Documentation

BadChanEntry

typedef LArBadChannelState::BadChanEntry LArBadChannelDecoder::BadChanEntry

Definition at line 28 of file LArBadChannelDecoder.h.

BadFebEntry

typedef std::pair< HWIdentifier, LArBadFeb> LArBadChannelDecoder::BadFebEntry

Definition at line 29 of file LArBadChannelDecoder.h.

State

typedef LArBadChannelState LArBadChannelDecoder::State

Definition at line 27 of file LArBadChannelDecoder.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
barrel_ec
pos_neg
feedthrough
slot
channel

Definition at line 40 of file LArBadChannelDecoder.h.

{barrel_ec, pos_neg, feedthrough, slot, channel}; // for local use only

Constructor & Destructor Documentation

LArBadChannelDecoder()

LArBadChannelDecoder::LArBadChannelDecoder ( const LArOnlineID_Base * onlineID, bool isSC = false )

inline

Definition at line 24 of file LArBadChannelDecoder.h.

                                                                            :
    m_onlineID( onlineID), m_isSC(isSC) {}

Member Function Documentation

checkId()

bool LArBadChannelDecoder::checkId ( const HWIdentifier & id, int be, int pn, State::CoolChannelEnum coolCh ) const

private

Definition at line 202 of file LArBadChannelDecoder.cxx.

{
  if (barrel_ec != State::barrelEndcap(coolCh)) return false; // first check barrel/ec (faster)
  if (pos_neg != State::posNeg(coolCh)) return false;         // then check side (faster)
  if (m_onlineID->isEMBchannel(id) && State::caloPart(coolCh)==State::EMB) return true;
  if (m_onlineID->isEMECchannel(id) && State::caloPart(coolCh)==State::EMEC) return true;
  if (m_onlineID->isHECchannel(id) && State::caloPart(coolCh)==State::HEC) return true;
  if (m_onlineID->isFCALchannel(id) && State::caloPart(coolCh)==State::FCAL) return true;
  return false;
}

constructChannelId()

HWIdentifier LArBadChannelDecoder::constructChannelId ( const std::vector< int > & intVec, State::CoolChannelEnum coolChan, MsgStream & log ) const

private

Definition at line 77 of file LArBadChannelDecoder.cxx.

{
  HWIdentifier invalid;
  if (intVec.size() < 5) { //  redundant error check
    log << MSG::WARNING << "Failed to produce a channel HWIdentifier for ";
    for (unsigned int i=0; i<intVec.size(); i++) log << intVec[i] << " ";
    log << "not enough identifiers" << endmsg;
    return invalid;
  }
  try {
    HWIdentifier hwid( m_onlineID->channel_Id( intVec[barrel_ec], intVec[pos_neg], intVec[feedthrough],
                           intVec[slot], intVec[channel], true));
    if (coolChan<LArBadChannelState::MAXCOOLCHAN && !checkId( hwid, intVec[barrel_ec], intVec[pos_neg], coolChan)) {
      log << MSG::WARNING << "Channel "; insertExpandedID( intVec, log);
      log << " does not belong to COOL channel " << State::coolChannelName( coolChan) 
      << ". Skipped" <<  endmsg;
      return invalid;
    }
    log << MSG::DEBUG << "Translating id ";  insertExpandedID( intVec, log);
    log << " to 0x" << MSG::hex << hwid << MSG::dec << endmsg;   
    return hwid;
  } 
  catch( LArOnlID_Exception& idException) {
    log << MSG::ERROR << "Failed to produce a HWIdentifier for ";  insertExpandedID( intVec, log) << endmsg;
  }
  return invalid;
}

constructFebId()

std::vector< HWIdentifier > LArBadChannelDecoder::constructFebId ( const std::vector< int > & intVec, MsgStream & log ) const

private

Definition at line 107 of file LArBadChannelDecoder.cxx.

{
  const int maxFebPerFT = 15; // hard-wired number of slots per feed-through
 
  std::vector<HWIdentifier> result;
  if (intVec.size() != 4) { // redundant error check
    log << MSG::WARNING << "Failed to produce a FEB HWIdentifier for ";
    for (unsigned int i=0; i<intVec.size(); i++) log << intVec[i] << " ";
    log << "not enough identifiers" << endmsg;
    return result;
  }
  
  // expand wildcard
  if (intVec[slot] == -1) {
    std::vector<int> vec( intVec); // modifiable copy
 
    // FEB slot counting starts at 1
    for (vec[slot]=1; vec[slot] <= maxFebPerFT; vec[slot]++) {
 
      HWIdentifier hwid = constructSingleFebId( vec, log);
      if (hwid.is_valid()) result.push_back( hwid);
    }
  }
  else{
    HWIdentifier hwid = constructSingleFebId( intVec, log);
    if (hwid.is_valid()) result.push_back( hwid);
  }
  return result;
}

constructFebStatus()

std::pair< bool, LArBadFeb > LArBadChannelDecoder::constructFebStatus ( const std::vector< std::string > & vec, MsgStream & log ) const

private

Definition at line 176 of file LArBadChannelDecoder.cxx.

{
  LArBadFeb result;
  for(std::vector<std::string>::const_iterator it = vec.begin(); it != vec.end(); ++it) {
    bool ok = m_febPacking.setBit( *it, result);
    if (!ok) { 
      log << MSG::WARNING << "LArBadChannelDecoder REJECTED line with " 
      << ":\t unrecognized problem status: " << *it << endmsg;
       return std::pair<bool,LArBadFeb>(false,result); // exit on error
    }
  }
  return std::pair<bool,LArBadFeb>(true,result);
}

constructSingleFebId()

HWIdentifier LArBadChannelDecoder::constructSingleFebId ( const std::vector< int > & v, MsgStream & log ) const

private

Definition at line 138 of file LArBadChannelDecoder.cxx.

{
  HWIdentifier invalid;
  if (v.size() != 4) return invalid;
  try {
    HWIdentifier hwid( m_onlineID->feb_Id( v[barrel_ec], v[pos_neg], v[feedthrough], v[slot], true));
    log << MSG::DEBUG << "Translating FEB id ";  insertExpandedID( v, log);
    log << " to 0x" << MSG::hex << hwid << MSG::dec << endmsg;   
    return hwid;
  } 
  catch( LArOnlID_Exception& idException) {
    log << MSG::ERROR << "Failed to produce a FEB HWIdentifier for ";  insertExpandedID( v, log);
    log << endmsg;
  }
  return invalid;
}

constructStatus()

std::pair< bool, LArBadChannel > LArBadChannelDecoder::constructStatus ( const std::vector< std::string > & vec, MsgStream & log ) const

private

Definition at line 157 of file LArBadChannelDecoder.cxx.

{
  LArBadChannel result;
  for(std::vector<std::string>::const_iterator it = vec.begin(); it != vec.end(); ++it) {
    bool ok = false;
    if(m_isSC)
       ok = m_SCpacking.setBit( *it, result);
    else
       ok = m_packing.setBit( *it, result);
    if (!ok) { 
      log << MSG::WARNING << "LArBadChannelDecoder REJECTED line with " 
      << ":\t unrecognized problem status: " << *it << endmsg;
       return std::pair<bool,LArBadChannel>(false,result); // exit on error
    }
  }
  return std::pair<bool,LArBadChannel>(true,result);
}

insertExpandedID()

MsgStream & LArBadChannelDecoder::insertExpandedID ( const std::vector< int > & intVec, MsgStream & log )

staticprivate

Definition at line 192 of file LArBadChannelDecoder.cxx.

{
  log << " b/e " << intVec[barrel_ec] 
      << " p/n " << intVec[pos_neg] 
      << " ft " <<  intVec[feedthrough] 
      << " slot " << intVec[slot];
  if (intVec.size() >= 5) log << " ch " <<  intVec[channel]; // no endmsg, 
  return log;
}

readASCII()

std::vector< LArBadChannelDecoder::BadChanEntry > LArBadChannelDecoder::readASCII	(	const std::string &	name,
		State::CoolChannelEnum	coolChan,
		MsgStream &	log ) const

Definition at line 13 of file LArBadChannelDecoder.cxx.

{
  std::vector<BadChanEntry> result;
 
  // set up parsing with exactly 6 ints and >= 1 string, for reading channels
  LArBadChannelParser parser(fname, &log, 6, -1);
  if (!parser.fileStatusGood()) {
    log << MSG::ERROR << "Failed to open file " << fname
    << " for COOL channel " << State::coolChannelName( coolChan) << endmsg;
    return result;
  }
 
  typedef std::string ParseType;
  typedef std::pair<std::vector<int>, std::vector<ParseType> > ParsedLine;
  std::vector<ParsedLine> parsed = parser.parseFile<ParseType>();
  log << MSG::INFO << "Parsed " << parsed.size() << " lines from file " << fname << endmsg;
 
  for (std::vector<ParsedLine>::const_iterator i=parsed.begin();
       i != parsed.end(); ++i) {
    HWIdentifier hwid = constructChannelId( i->first, coolChan, log);
    if (hwid.is_valid()) {
      std::pair<bool,LArBadChannel> badCh = constructStatus( i->second, log);
      if (badCh.first) {
    result.emplace_back( hwid, badCh.second);
      }
    }
  }
  return result;
}

readFebASCII()

std::vector< LArBadChannelDecoder::BadFebEntry > LArBadChannelDecoder::readFebASCII	(	const std::string &	fname,
		MsgStream &	log ) const

Definition at line 46 of file LArBadChannelDecoder.cxx.

{
  std::vector<BadFebEntry> result;
 
 // set up a parser to read 4 ints (the 4th of which can be a wildcard) and >=1 strings
  LArBadChannelParser parser(fname, &log, 4, -1, 4);
  if (!parser.fileStatusGood()) {
    log << MSG::ERROR << "Failed to open missing FEBs file " << fname << endmsg;
    return result;
  }
  
  typedef std::string ParseType;
  typedef std::pair<std::vector<int>, std::vector<ParseType> > ParsedLine;
  std::vector<ParsedLine> parsed = parser.parseFile<ParseType>();
  for (std::vector<ParsedLine>::const_iterator i=parsed.begin();
       i != parsed.end(); ++i) {
    std::vector<HWIdentifier> hwid = constructFebId( i->first, log);
    if (!hwid.empty()) {
      // BEFORE: result.insert( result.end(), hwid.begin(), hwid.end());
      std::pair<bool,LArBadFeb> badFeb = constructFebStatus( i->second, log);
      if (badFeb.first) {
    for (std::vector<HWIdentifier>::const_iterator i=hwid.begin(); i!=hwid.end(); ++i) {
      result.emplace_back( *i, badFeb.second);
    }
      }
    }
  }
  return result;
}

Member Data Documentation

m_febPacking

LArBadFebBitPacking LArBadChannelDecoder::m_febPacking

private

Definition at line 45 of file LArBadChannelDecoder.h.

m_isSC

bool LArBadChannelDecoder::m_isSC

private

Definition at line 47 of file LArBadChannelDecoder.h.

m_onlineID

const LArOnlineID_Base* LArBadChannelDecoder::m_onlineID

private

Definition at line 42 of file LArBadChannelDecoder.h.

m_packing

LArBadChanBitPacking LArBadChannelDecoder::m_packing

private

Definition at line 43 of file LArBadChannelDecoder.h.

m_SCpacking

LArBadChanSCBitPacking LArBadChannelDecoder::m_SCpacking

private

Definition at line 44 of file LArBadChannelDecoder.h.

---

The documentation for this class was generated from the following files:

• LArBadChannelDecoder.h
• LArBadChannelDecoder.cxx