In This Package:

DbiCableSvc.cc

Go to the documentation of this file.

#include "DbiCableSvc.h"
#include "GaudiKernel/IMessageSvc.h"

#include "genDbi/GFeeCableMap.h"

#include "Conventions/Hardware.h"
#include "Conventions/Electronics.h"
#include "DatabaseInterface/Dbi.h"
#include "DatabaseInterface/DbiResultAgg.h"
#include "DatabaseInterface/DbiCascader.h"
#include "DatabaseInterface/DbiConfigSet.h"
#include "DatabaseInterface/DbiLogEntry.h"
#include "DatabaseInterface/DbiResultKey.h"
#include "DatabaseInterface/DbiResultNonAgg.h"
#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiResultSet.h"
#include "DatabaseInterface/DbiServices.h"
#include "DatabaseInterface/DbiValRecSet.h"
#include "DatabaseInterface/DbiLog.h"
#include "DatabaseInterface/DbiCache.h"
#include "DatabaseInterface/DbiSqlContext.h"
#include <sstream>
#include <fstream>

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

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

DbiCableSvc::DbiCableSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
{
}

DbiCableSvc::~DbiCableSvc()
{
}

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

    // Prepare the message service for reporting
/*  IMessageSvc* msg = msgSvc();//cxs 2010-12-7
    if( !msg ){    
      return StatusCode::FAILURE;
    }
*/
    MsgStream msg(msgSvc(),name());
    feeLastResult = 0;   //cxs 2010-10-28.
    return StatusCode::SUCCESS;
}

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

StatusCode DbiCableSvc::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>& DbiCableSvc::hardwareIds(const ServiceMode& serviceMode)
{
  readFeeTable(serviceMode);
  return m_hardwareIds;
}

const std::vector<DayaBay::PmtHardwareId>& DbiCableSvc::pmtHardwareIds(const ServiceMode& serviceMode)
{
  readFeeTable(serviceMode);
  return m_pmtHardwareIds;
}

const std::vector<DayaBay::RpcHardwareId>& DbiCableSvc::rpcHardwareIds(const ServiceMode& serviceMode)
{
  readFeeTable(serviceMode);
  return m_rpcHardwareIds;
}

const std::vector<DayaBay::FeeHardwareId>& DbiCableSvc::feeHardwareIds(const ServiceMode& serviceMode)
{
  readFeeTable(serviceMode);
  return m_feeHardwareIds;
}

const std::vector<DayaBay::FecHardwareId>& DbiCableSvc::fecHardwareIds(const ServiceMode& serviceMode)
{
  readFeeTable(serviceMode);
  return m_fecHardwareIds;
}

const std::vector<DayaBay::DetectorSensor>& DbiCableSvc::sensors(const ServiceMode& svcMode)
{
  readFeeTable(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
    return iter->second;
  }
  std::ostringstream msgStr;
/*msgStr << "sensors(): No sensors for site / detector ID: " << siteDetId; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_sensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::AdPmtSensor>& DbiCableSvc::adPmtSensors(const ServiceMode& svcMode)
{
  readFeeTable(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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_adPmtSensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::PoolPmtSensor>& DbiCableSvc::poolPmtSensors(const ServiceMode& svcMode)
{
  readFeeTable(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;//cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_poolPmtSensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::RpcSensor>& DbiCableSvc::rpcSensors(const ServiceMode& svcMode)
{
  readFeeTable(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;//cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_rpcSensorsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::ElecChannelId>& DbiCableSvc::elecChannelIds(const ServiceMode& svcMode)
{
  readFeeTable(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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_elecChannelIdsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::FeeChannelId>& DbiCableSvc::feeChannelIds(const ServiceMode& svcMode)
{
  readFeeTable(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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_feeChannelIdsBySiteDet[s_unknownSiteDet];
}

const std::vector<DayaBay::FecChannelId>& DbiCableSvc::fecChannelIds(const ServiceMode& 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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return m_fecChannelIdsBySiteDet[s_unknownSiteDet];
}

DayaBay::ElecChannelId DbiCableSvc::elecChannelId(
                                          const DayaBay::DetectorSensor& sensId,
                                          const ServiceMode& svcMode)
{
  readFeeTable(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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return DayaBay::ElecChannelId(0);
}

DayaBay::FeeChannelId DbiCableSvc::feeChannelId(
                                            const DayaBay::AdPmtSensor& sensId,
                                            const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::FeeChannelId(elecChannelId(sensId,svcMode).fullPackedData());
}

DayaBay::FeeChannelId DbiCableSvc::feeChannelId(
                                          const DayaBay::PoolPmtSensor& sensId,
                                          const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::FeeChannelId(elecChannelId(sensId,svcMode).fullPackedData());
}

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

DayaBay::DetectorSensor DbiCableSvc::sensor(
                                     const DayaBay::ElecChannelId& elecChannel,
                                     const ServiceMode& svcMode)
{
  readFeeTable(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: " //cxs 2010-12-8
         << elecChannel;
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return DayaBay::DetectorSensor(0);
}

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

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

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

DayaBay::HardwareId DbiCableSvc::hardwareId(
                                         const DayaBay::DetectorSensor& sensId,
                                         const ServiceMode& svcMode)
{
  readFeeTable(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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return DayaBay::HardwareId(0);
}

DayaBay::PmtHardwareId DbiCableSvc::pmtHardwareId(
                                            const DayaBay::AdPmtSensor& sensId,
                                            const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::PmtHardwareId(hardwareId(sensId,svcMode).fullPackedData());
}

DayaBay::PmtHardwareId DbiCableSvc::pmtHardwareId(
                                          const DayaBay::PoolPmtSensor& sensId,
                                          const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::PmtHardwareId(hardwareId(sensId,svcMode).fullPackedData());
}

DayaBay::RpcHardwareId DbiCableSvc::rpcHardwareId(
                                              const DayaBay::RpcSensor& sensId,
                                              const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::RpcHardwareId(hardwareId(sensId,svcMode).fullPackedData());
}

DayaBay::DetectorSensor DbiCableSvc::sensor(
                                         const DayaBay::HardwareId& hardwareId,
                                         const ServiceMode& svcMode)
{
  readFeeTable(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; //cxs 2010-12-8
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return DayaBay::DetectorSensor(0);
}

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

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

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

DayaBay::HardwareId DbiCableSvc::hardwareId(
                                     const DayaBay::ElecChannelId& elecChannel,
                                     const ServiceMode& svcMode)
{
  readFeeTable(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: " //cxs 2010-12-8
         << elecChannel;
  msg->reportMessage("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return DayaBay::HardwareId(0);
}

DayaBay::FeeHardwareId DbiCableSvc::feeHardwareId(
                                       const DayaBay::FeeChannelId& feeChannel,
                                       const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::FeeHardwareId(hardwareId(feeChannel,svcMode).fullPackedData());
}

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

DayaBay::ElecChannelId DbiCableSvc::elecChannelId(
                                         const DayaBay::HardwareId& hardwareId,
                                         const ServiceMode& svcMode)
{
  readFeeTable(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("DbiCableSvc",MSG::WARNING,msgStr.str());
*/
  return DayaBay::ElecChannelId(0);
}

DayaBay::FeeChannelId DbiCableSvc::feeChannelId(
                                   const DayaBay::FeeHardwareId& feeHardwareId,
                                   const ServiceMode& svcMode)
{
  readFeeTable(svcMode);
  return DayaBay::FeeChannelId(elecChannelId(feeHardwareId,svcMode).fullPackedData());
}

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


inline int DbiCableSvc::readFeeTable(const ServiceMode& serviceMode){  //XiaoSu Chen 2010/10/28
  if(serviceMode.context() == feeLastContext){  
    return 2;    
  }
  feeLastContext = serviceMode.context();      

  DbiResultPtr<GFeeCableMap> pr("FeeCableMap",feeLastContext,feeLastContext.GetDetId());
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(feeLastResult == 0){                      
    feeLastResult = thisResult;
  }else if(thisResult->IsEqualTo(feeLastResult))
  {
    return 2;
  }else{
    feeLastResult = thisResult;
  }
  m_elecChannelIdsBySiteDet.clear();
  m_feeChannelIdsBySiteDet.clear();
  m_channelByHardware.clear();
  m_hardwareByChannel.clear();
  m_sensorsBySiteDet.clear();
  m_channelBySensor.clear();
  m_sensorByChannel.clear();
  m_hardwareBySensor.clear();
  m_sensorByHardware.clear();
  m_poolPmtSensorsBySiteDet.clear();
  m_adPmtSensorsBySiteDet.clear();
  unsigned int numRows = pr.GetNumRows();
  std::cout << "Database rows = " << numRows << std::endl;
  const GFeeCableMap* row ;
  for (unsigned int idx=0; idx < numRows; idx++) {
        row = pr.GetRowByIndex(idx);
        int sensorId = row->GetSensorId().fullPackedData();
        DayaBay::FeeChannelId feeChannel(row->GetFeeChannelId());
        DayaBay::FeeHardwareId feeHardware(row->GetFeeHardwareId());
        DayaBay::PmtHardwareId pmtHardware(row->GetPmtHardwareId());
        // Make map by site / detector
        DayaBay::Detector siteId(feeChannel.site(), DetectorId::kAll);
        DayaBay::Detector detector(feeChannel.site(), feeChannel.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
        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);
          m_poolPmtSensorsBySiteDet[s_allSiteDet].push_back(poolPmt);
          m_poolPmtSensorsBySiteDet[siteId].push_back(poolPmt);
          m_poolPmtSensorsBySiteDet[detector].push_back(poolPmt);
        }else{
          DayaBay::AdPmtSensor adPmt(sensorId);
          m_adPmtSensorsBySiteDet[s_allSiteDet].push_back(adPmt);
          m_adPmtSensorsBySiteDet[siteId].push_back(adPmt);
          m_adPmtSensorsBySiteDet[detector].push_back(adPmt);
        }
  }
}

---