In This Package:

StaticCableSvc.cc

Go to the documentation of this file.

#include "StaticCableSvc.h"
#include "Conventions/Hardware.h"
#include "Conventions/Electronics.h"
#include "GaudiKernel/IMessageSvc.h"
#include <sstream>
#include <fstream>
#include "Context/ContextRange.h"
#include <stdlib.h>

DayaBay::Detector StaticCableSvc::s_unknownSiteDet = 
  DayaBay::Detector(Site::kUnknown,DetectorId::kUnknown);

DayaBay::Detector StaticCableSvc::s_allSiteDet = 
  DayaBay::Detector(Site::kAll,DetectorId::kAll);

StaticCableSvc::StaticCableSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
    , m_first(true)
{
  msg = 0;
  declareProperty("FeeCableMap",m_feeCableFileName="",
                  "Filename for loading the FEE cabling map.");
  declareProperty("FecCableMap",m_fecCableFileName="",
                  "Filename for loading the FEC cabling map");
}

StaticCableSvc::~StaticCableSvc()
{
}

StatusCode StaticCableSvc::initialize()
{
    this->Service::initialize();

    return StatusCode::SUCCESS;
}


StatusCode StaticCableSvc::initMap(const ServiceMode& svcMode)
{
    // Prepare the message service for reporting
    msg = msgSvc();
    if( !msg ){    
      return StatusCode::FAILURE;
    }
    MsgStream log(msgSvc(), "StaticCableSvc");

    if(m_feeCableFileName=="")  {
      msg->reportMessage("StaticCableSvc",MSG::INFO,
                         "No FeeCableMap file specified. Loading one based on Master.CableMap.txt");
      
      std::string MasterCableMapFile = "Master.CableMap.txt";
      std::string Path = getenv ("DATASVCROOT");
      std::ifstream m_masterCableMap( (Path+"/share/"+MasterCableMapFile).c_str() );
      
      if( !m_masterCableMap.is_open() ){
        msg->reportMessage("StaticCableSvc",MSG::ERROR,"Fail to open Master.CableMap.txt");
        return StatusCode::FAILURE;
      }
      
      int StartRun,EndRun;
      int Sites;
      int SimFlag, StartTimeSec, StartTimeNanoSec, EndTimeSec, EndTimeNanoSec;
      std::string MapFile;

      std::string line;

      while( std::getline( m_masterCableMap, line ) ){
        std::stringstream streamLine(line);
        if( streamLine.peek() == '#' ){
          continue;
        }
        streamLine >>StartRun >>EndRun >>Sites
          >>SimFlag >>StartTimeSec>> StartTimeNanoSec >>EndTimeSec >>EndTimeNanoSec
          >>MapFile;
        
        ContextRange CRange( Sites, SimFlag, 
                             TimeStamp( StartTimeSec, StartTimeNanoSec ),
                             TimeStamp( EndTimeSec, EndTimeNanoSec ) );
        
        const Context &cont = svcMode.context();

        /*
        std::cout<< "Searching: "<<cont.GetSite()<<" "<<cont.GetSimFlag()<<std::endl;
        std::cout<< cont.GetTimeStamp().AsString()<<std::endl;
        std::cout<<"Start: "<<TimeStamp( StartTimeSec, StartTimeNanoSec ).AsString()<<std::endl;
        std::cout<<"End:   "<<TimeStamp( EndTimeSec, EndTimeNanoSec ).AsString()<<std::endl;
        */

        if( CRange.IsCompatible( cont ) ) {
          m_feeCableFileName = Path + "/share/" + MapFile;
        }

      }
        
    }

    if(m_fecCableFileName=="")  {
    }


    if(m_feeCableFileName!=""){

      msg->reportMessage("StaticCableSvc",MSG::INFO,("FeeCableMap: "+m_feeCableFileName).c_str());

      std::ifstream input( m_feeCableFileName.c_str() );
      if( !input.is_open() ){
        std::ostringstream msgStr;
        msgStr << "Failed to open input file: " << m_feeCableFileName;
        msg->reportMessage("StaticCableSvc",MSG::ERROR,msgStr.str());
        return StatusCode::FAILURE;
      }
      int site, detectorId, feeBoard, feeBoardSerial, feeConnector; 
      int adPmtRing, adPmtColumn, poolPmtWallNumber, poolPmtWallSpot;
      int poolPmtInwardFacing, pmtHardwareType, pmtSerialNumber;
      std::string line;
      while( std::getline(input,line) ){
        std::stringstream streamLine(line);
        if( streamLine.peek() == '#' ){
          continue;
        }
        streamLine >> site >> detectorId >> feeBoard >> feeBoardSerial 
                   >> feeConnector >> adPmtRing >> adPmtColumn 
                   >> poolPmtWallNumber >> poolPmtWallSpot 
                   >> poolPmtInwardFacing >> pmtHardwareType 
                   >> pmtSerialNumber;
        DayaBay::FeeChannelId feeChannel(feeBoard, feeConnector,
                                         (Site::Site_t)site,
                                         (DetectorId::DetectorId_t)detectorId);
        DayaBay::FeeHardwareId feeHardware(feeBoardSerial, feeConnector);
        DayaBay::PmtHardwareId pmtHardware(pmtSerialNumber, 
                                           (DayaBay::Hardware::Hardware_t)pmtHardwareType);
        // Make map by site / detector
        DayaBay::Detector siteId((Site::Site_t)site, DetectorId::kAll);
        DayaBay::Detector detector((Site::Site_t)site, 
                                   (DetectorId::DetectorId_t)detectorId);
        m_elecChannelIdsBySiteDet[s_allSiteDet].push_back(feeChannel);
        m_elecChannelIdsBySiteDet[siteId].push_back(feeChannel);
        m_elecChannelIdsBySiteDet[detector].push_back(feeChannel);
        m_feeChannelIdsBySiteDet[s_allSiteDet].push_back(feeChannel);
        m_feeChannelIdsBySiteDet[siteId].push_back(feeChannel);
        m_feeChannelIdsBySiteDet[detector].push_back(feeChannel);
        // Make hardware connections
        m_channelByHardware[feeHardware] = feeChannel;
        m_hardwareByChannel[feeChannel] = feeHardware;

        // Make PMT connections
        int sensorId = 0; 
        if( adPmtColumn!=0 ){
          // AD PMT
          DayaBay::AdPmtSensor pmtId(adPmtRing, adPmtColumn, 
                                     (Site::Site_t)site,
                                     (DetectorId::DetectorId_t)detectorId);
          sensorId = pmtId.fullPackedData();
        }else if( poolPmtWallNumber!=0 ){
          // Pool PMT
          DayaBay::PoolPmtSensor pmtId(poolPmtWallNumber, poolPmtWallSpot,
                                       poolPmtInwardFacing, 
                                       (Site::Site_t)site,
                                       (DetectorId::DetectorId_t)detectorId);
          sensorId = pmtId.fullPackedData();
        }
        if( sensorId == 0 ){
          // Unconnected FEE channel
          continue;
        }
        DayaBay::DetectorSensor sensor(sensorId);

        m_sensorsBySiteDet[s_allSiteDet].push_back(sensor);
        m_sensorsBySiteDet[siteId].push_back(sensor);
        m_sensorsBySiteDet[detector].push_back(sensor);
        m_channelBySensor[sensor] = feeChannel;
        m_sensorByChannel[feeChannel] = sensor;
        m_hardwareBySensor[sensor] = pmtHardware;
        m_sensorByHardware[pmtHardware] = sensor;
        if(sensor.detectorId() == DetectorId::kIWS
           || sensor.detectorId() == DetectorId::kOWS){
          DayaBay::PoolPmtSensor poolPmt(sensorId);
          if (poolPmt.bogus()) {
              log << "Warning: got bogus Pool PMT ID: " << poolPmt 
                  << " while parsing line:\"" << line << "\""
                  << endreq;
          }
          m_poolPmtSensorsBySiteDet[s_allSiteDet].push_back(poolPmt);
          m_poolPmtSensorsBySiteDet[siteId].push_back(poolPmt);
          m_poolPmtSensorsBySiteDet[detector].push_back(poolPmt);
        }else{
          DayaBay::AdPmtSensor adPmt(sensorId);
          if (adPmt.bogus()) {
              log << "Warning: got bogus AD PMT ID: " << adPmt
                  << " while parsing line:\"" << line << "\""
                  << endreq;
          }
          m_adPmtSensorsBySiteDet[s_allSiteDet].push_back(adPmt);
          m_adPmtSensorsBySiteDet[siteId].push_back(adPmt);
          m_adPmtSensorsBySiteDet[detector].push_back(adPmt);
        }
      }
    }
    
    if(m_fecCableFileName!=""){
      
      msg->reportMessage("StaticCableSvc",MSG::INFO,("FecCableMap: "+m_fecCableFileName).c_str());

      std::ostringstream msgStr;
      msgStr << "FEC Cable mapping not yet implemented! " << m_fecCableFileName;
      msg->reportMessage("StaticCableSvc",MSG::ERROR,msgStr.str());
      return StatusCode::FAILURE;
    }

    m_first = false;
    
    return StatusCode::SUCCESS;
}

StatusCode StaticCableSvc::finalize()
{
    return this->Service::finalize();
}

StatusCode StaticCableSvc::queryInterface(const InterfaceID& riid, 
                                          void** ppvInterface)
{
    StatusCode sc = StatusCode::FAILURE;
    if (ppvInterface) {
        *ppvInterface = 0;
    
        if (ICableSvc::interfaceID().versionMatch(riid)) {
            *ppvInterface = static_cast<ICableSvc*>(this);
            sc = StatusCode::SUCCESS;
            addRef();
        }
        else sc = Service::queryInterface( riid, ppvInterface );    
    }
    return sc;
}

const std::vector<DayaBay::HardwareId>& StaticCableSvc::hardwareIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return m_hardwareIds;
}

const std::vector<DayaBay::PmtHardwareId>& StaticCableSvc::pmtHardwareIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return m_pmtHardwareIds;
}

const std::vector<DayaBay::RpcHardwareId>& StaticCableSvc::rpcHardwareIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return m_rpcHardwareIds;
}

const std::vector<DayaBay::FeeHardwareId>& StaticCableSvc::feeHardwareIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return m_feeHardwareIds;
}

const std::vector<DayaBay::FecHardwareId>& StaticCableSvc::fecHardwareIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return m_fecHardwareIds;
}

const std::vector<DayaBay::DetectorSensor>& StaticCableSvc::sensors(const ServiceMode& svcMode)
{
  MsgStream log(msgSvc(), "StaticCableSvc");

  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::DetectorSensor> >::iterator iter;
  iter = m_sensorsBySiteDet.find(siteDetId);
  if( iter != m_sensorsBySiteDet.end() ){
    // Found site / det

      const std::vector<DayaBay::DetectorSensor>& detSensors = iter->second;
      for (size_t idet = 0; idet < detSensors.size(); ++idet) {
          DayaBay::DetectorSensor detSens = detSensors[idet];      
          if (detSens.isAD() ) {
              DayaBay::AdPmtSensor pmtid(detSens.fullPackedData());
              if (pmtid.bogus()) {
                  log << MSG::WARNING << "bogus AD PMT id: " << pmtid << endreq;
              }
          }
          else {
              DayaBay::PoolPmtSensor pmtid(detSens.fullPackedData());
              if (pmtid.bogus()) {
                  log << MSG::WARNING << "bogus Pool PMT id: " << pmtid << endreq;
              }
          }
      }

    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "sensors(): No sensors for site / detector ID: " << siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_sensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::AdPmtSensor>& StaticCableSvc::adPmtSensors(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::AdPmtSensor> >::iterator iter;
  iter = m_adPmtSensorsBySiteDet.find(siteDetId);
  if( iter != m_adPmtSensorsBySiteDet.end() ){
    // Found site / det
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "adPmtSensors(): No sensors for site / detector ID: " << siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_adPmtSensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::PoolPmtSensor>& StaticCableSvc::poolPmtSensors(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::PoolPmtSensor> >::iterator iter;
  iter = m_poolPmtSensorsBySiteDet.find(siteDetId);
  if( iter != m_poolPmtSensorsBySiteDet.end() ){
    // Found site / det
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "poolPmtSensors(): No sensors for site / detector ID: "<< siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_poolPmtSensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::RpcSensor>& StaticCableSvc::rpcSensors(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::RpcSensor> >::iterator iter;
  iter = m_rpcSensorsBySiteDet.find(siteDetId);
  if( iter != m_rpcSensorsBySiteDet.end() ){
    // Found site / det
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "rpcSensors(): No sensors for site / detector ID: "<< siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_rpcSensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::ElecChannelId>& StaticCableSvc::elecChannelIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::ElecChannelId> >::iterator iter;
  iter = m_elecChannelIdsBySiteDet.find(siteDetId);
  if( iter != m_elecChannelIdsBySiteDet.end() ){
    // Found site / det
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "elecChannelIds(): No sensors for site / detector ID: "<< siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_elecChannelIdsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::FeeChannelId>& StaticCableSvc::feeChannelIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::FeeChannelId> >::iterator iter;
  iter = m_feeChannelIdsBySiteDet.find(siteDetId);
  if( iter != m_feeChannelIdsBySiteDet.end() ){
    // Found site / det
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "feeChannelIds(): No sensors for site / detector ID: " << siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_feeChannelIdsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::FecChannelId>& StaticCableSvc::fecChannelIds(const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  DayaBay::Detector siteDetId(svcMode.context().GetSite(), 
                              svcMode.context().GetDetId());
  std::map<DayaBay::Detector,std::vector<DayaBay::FecChannelId> >::iterator iter;
  iter = m_fecChannelIdsBySiteDet.find(siteDetId);
  if( iter != m_fecChannelIdsBySiteDet.end() ){
    // Found site / det
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "fecChannelIds(): No sensors for site / detector ID: " << siteDetId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return m_fecChannelIdsBySiteDet[s_unknownSiteDet];
}

DayaBay::ElecChannelId StaticCableSvc::elecChannelId(
                                          const DayaBay::DetectorSensor& sensId,
                                          const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  std::map<DayaBay::DetectorSensor,DayaBay::ElecChannelId>::iterator iter;
  iter = m_channelBySensor.find(sensId);
  if( iter != m_channelBySensor.end() ){
    // Found channel
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "elecChannelId(): No electronics channel for sensor ID: " << sensId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return DayaBay::ElecChannelId(0);
}

DayaBay::FeeChannelId StaticCableSvc::feeChannelId(
                                            const DayaBay::AdPmtSensor& sensId,
                                            const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FeeChannelId(elecChannelId(sensId,svcMode).fullPackedData());
}

DayaBay::FeeChannelId StaticCableSvc::feeChannelId(
                                          const DayaBay::PoolPmtSensor& sensId,
                                          const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FeeChannelId(elecChannelId(sensId,svcMode).fullPackedData());
}

DayaBay::FecChannelId StaticCableSvc::fecChannelId(
                                              const DayaBay::RpcSensor& sensId,
                                              const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FecChannelId(elecChannelId(sensId,svcMode).fullPackedData());
}

DayaBay::DetectorSensor StaticCableSvc::sensor(
                                     const DayaBay::ElecChannelId& elecChannel,
                                     const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  std::map<DayaBay::ElecChannelId,DayaBay::DetectorSensor>::iterator iter;
  iter = m_sensorByChannel.find(elecChannel);
  if( iter != m_sensorByChannel.end() ){
    // Found sensor
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "elecChannelId(): No sensor ID for electronics channel: " 
         << elecChannel;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return DayaBay::DetectorSensor(0);
}

DayaBay::AdPmtSensor StaticCableSvc::adPmtSensor(
                                       const DayaBay::FeeChannelId& feeChannel,
                                       const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::AdPmtSensor(sensor(feeChannel,svcMode).fullPackedData());
}

DayaBay::PoolPmtSensor StaticCableSvc::poolPmtSensor(
                                       const DayaBay::FeeChannelId& feeChannel,
                                       const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::PoolPmtSensor(sensor(feeChannel,svcMode).fullPackedData());
}

DayaBay::RpcSensor StaticCableSvc::rpcSensor(
                                       const DayaBay::FecChannelId& fecChannel,
                                       const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::RpcSensor(sensor(fecChannel,svcMode).fullPackedData());
}

DayaBay::HardwareId StaticCableSvc::hardwareId(
                                         const DayaBay::DetectorSensor& sensId,
                                         const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  std::map<DayaBay::DetectorSensor,DayaBay::HardwareId>::iterator iter;
  iter = m_hardwareBySensor.find(sensId);
  if( iter != m_hardwareBySensor.end() ){
    // Found hardware
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "hardwareId(): No hardware ID for sensor ID: " << sensId; 
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return DayaBay::HardwareId(0);
}

DayaBay::PmtHardwareId StaticCableSvc::pmtHardwareId(
                                            const DayaBay::AdPmtSensor& sensId,
                                            const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::PmtHardwareId(hardwareId(sensId,svcMode).fullPackedData());
}

DayaBay::PmtHardwareId StaticCableSvc::pmtHardwareId(
                                          const DayaBay::PoolPmtSensor& sensId,
                                          const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::PmtHardwareId(hardwareId(sensId,svcMode).fullPackedData());
}

DayaBay::RpcHardwareId StaticCableSvc::rpcHardwareId(
                                              const DayaBay::RpcSensor& sensId,
                                              const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::RpcHardwareId(hardwareId(sensId,svcMode).fullPackedData());
}

DayaBay::DetectorSensor StaticCableSvc::sensor(
                                         const DayaBay::HardwareId& hardwareId,
                                         const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  std::map<DayaBay::HardwareId,DayaBay::DetectorSensor>::iterator iter;
  iter = m_sensorByHardware.find(hardwareId);
  if( iter != m_sensorByHardware.end() ){
    // Found sensor
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "sensor(): No sensor for hardware ID: " << hardwareId; 
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return DayaBay::DetectorSensor(0);
}

DayaBay::AdPmtSensor StaticCableSvc::adPmtSensor(
                                           const DayaBay::PmtHardwareId& pmtId,
                                           const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::AdPmtSensor(sensor(pmtId,svcMode).fullPackedData());
}

DayaBay::PoolPmtSensor StaticCableSvc::poolPmtSensor(
                                           const DayaBay::PmtHardwareId& pmtId,
                                           const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::PoolPmtSensor(sensor(pmtId,svcMode).fullPackedData());
}

DayaBay::RpcSensor StaticCableSvc::rpcSensor(
                                           const DayaBay::RpcHardwareId& rpcId,
                                           const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::RpcSensor(sensor(rpcId, svcMode).fullPackedData());
}

DayaBay::HardwareId StaticCableSvc::hardwareId(
                                     const DayaBay::ElecChannelId& elecChannel,
                                     const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  std::map<DayaBay::ElecChannelId,DayaBay::HardwareId>::iterator iter;
  iter = m_hardwareByChannel.find(elecChannel);
  if( iter != m_hardwareByChannel.end() ){
    // Found hardware
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "hardwareId(): No hardware ID for electronics channel: " 
         << elecChannel;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return DayaBay::HardwareId(0);
}

DayaBay::FeeHardwareId StaticCableSvc::feeHardwareId(
                                       const DayaBay::FeeChannelId& feeChannel,
                                       const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FeeHardwareId(hardwareId(feeChannel,svcMode).fullPackedData());
}

DayaBay::FecHardwareId StaticCableSvc::fecHardwareId(
                                       const DayaBay::FecChannelId& fecChannel,
                                       const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FecHardwareId(hardwareId(fecChannel,svcMode).fullPackedData());
}

DayaBay::ElecChannelId StaticCableSvc::elecChannelId(
                                         const DayaBay::HardwareId& hardwareId,
                                         const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  std::map<DayaBay::HardwareId,DayaBay::ElecChannelId>::iterator iter;
  iter = m_channelByHardware.find(hardwareId);
  if( iter != m_channelByHardware.end() ){
    // Found channel
    return iter->second;
  }
  std::ostringstream msgStr;
  msgStr << "elecChannelId(): No electronics channel for hardware ID: " 
         << hardwareId;
  msg->reportMessage("StaticCableSvc",MSG::WARNING,msgStr.str());
  return DayaBay::ElecChannelId(0);
}

DayaBay::FeeChannelId StaticCableSvc::feeChannelId(
                                   const DayaBay::FeeHardwareId& feeHardwareId,
                                   const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FeeChannelId(elecChannelId(feeHardwareId,svcMode).fullPackedData());
}

DayaBay::FecChannelId StaticCableSvc::fecChannelId(
                                   const DayaBay::FecHardwareId& fecHardwareId,
                                   const ServiceMode& svcMode)
{
  if( m_first ) initMap(svcMode);
  return DayaBay::FecChannelId(elecChannelId(fecHardwareId,svcMode).fullPackedData());
}

---