DbiCalibDataSvc.cc

Go to the documentation of this file.

#include "DbiCalibDataSvc.h"
#include "DataSvc/ICableSvc.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/SystemOfUnits.h"

#include "genDbi/GCalibPmtSpec.h"
#include "genDbi/GCalibPmtPedBias.h"
#include "genDbi/GCalibPmtHighGain.h"
//#include "genDbi/GCalibPmtTiming.h"
//#include "genDbi/GCalibFeeGainConv.h"
#include "genDbi/GCalibFeeSpec.h"
#include "genDbi/GCalibSrcEnergy.h"

#include "Conventions/Site.h"
#include "Conventions/SimFlag.h"
#include "Conventions/Electronics.h"
#include "Context/TimeStamp.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 <iostream>
#include <list>
#include <map>
#include <memory>
using std::auto_ptr;
using namespace std;
using namespace Gaudi;

DbiCalibDataSvc::DbiCalibDataSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
{
  declareProperty("CableSvcName",m_cableSvcName="CableSvc",
                  "Name of service which provides the list of sensors to calibration");
}

DbiCalibDataSvc::~DbiCalibDataSvc()
{
}

StatusCode DbiCalibDataSvc::initialize()
{
  this->Service::initialize();
/*  IMessageSvc* msg = msgSvc();//cxs 2010-12-7
  if( !msg ){    
    return StatusCode::FAILURE;
  }
*/
  MsgStream msg(msgSvc(),name());
  // Initialize the data with a static table of numbers
  ICableSvc* cableSvc = 0;
  StatusCode sc = service("CableSvc",cableSvc,true);
  if( sc != StatusCode::SUCCESS ){
    std::ostringstream msgStr;
    msgStr << "Failed to access cable service: " << m_cableSvcName;
    //msg->reportMessage("DbiCalibDataSvc",MSG::ERROR,msgStr.str());
    return sc;    
  }
  feeLastResult = 0;   //cxs 2010-10-28
  fecLastResult = 0;   //cxs 2010-10-28
  pmtLastResult = 0;   //cxs 2010-10-28
  pmtPedBiasLastResult = 0; //jpochoa 2011-06-15
  pmtHighGainLastResult = 0; //jpochoa 2011-06-15
  //pmtTimingLastResult = 0; //jpochoa 2011-06-24
  //feeGainConvLastResult = 0;//jpochoa 2011-07-08
  
  return StatusCode::SUCCESS;
}

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

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

const DayaBay::PmtCalibData* DbiCalibDataSvc::pmtCalibData(
                                       const DayaBay::DetectorSensor& pmtId,
                                       const ServiceMode& serviceMode)
{
/*
  if(serviceMode.context() != lastContext){  //XiaoSu Chen 2010/7/10
    readCalibPmtTable(serviceMode.context());//XiaoSu Chen 2010/6/30
    lastContext = serviceMode.context();
  }
*/

  readCalibPmtTable(serviceMode);
  std::map<DayaBay::DetectorSensor, DayaBay::PmtCalibData>::iterator result = 
    m_pmtDataBySensor.find(pmtId); 
  if(result != m_pmtDataBySensor.end()){
    return &(result->second);
  }
  return 0;
}

const DayaBay::PedBiasCalibData* DbiCalibDataSvc::pedBiasCalibData(
                                       const DayaBay::DetectorSensor& pmtId,
                                       const ServiceMode& serviceMode)
{  
  readCalibPmtPedBiasTable(serviceMode);
  std::map<DayaBay::DetectorSensor, DayaBay::PedBiasCalibData>::iterator result = 
    m_pedBiasDataBySensor.find(pmtId);  
  if(result != m_pedBiasDataBySensor.end()){
    return &(result->second);
  }
  return 0;
}

const DayaBay::HighGainCalibData* DbiCalibDataSvc::highGainCalibData(
                                       const DayaBay::DetectorSensor& pmtId,
                                       const ServiceMode& serviceMode)
{  
  readCalibPmtHighGainTable(serviceMode);
  std::map<DayaBay::DetectorSensor, DayaBay::HighGainCalibData>::iterator result = 
    m_highGainDataBySensor.find(pmtId);  
  if(result != m_highGainDataBySensor.end()){
    return &(result->second);
  }
  return 0;
}

/*const DayaBay::TimingCalibData* DbiCalibDataSvc::timingCalibData(
                                       const DayaBay::DetectorSensor& pmtId,
                                       const ServiceMode& serviceMode)
{  
  readCalibPmtTimingTable(serviceMode);
  std::map<DayaBay::DetectorSensor, DayaBay::TimingCalibData>::iterator result = 
    m_timingDataBySensor.find(pmtId);  
  if(result != m_timingDataBySensor.end()){
    return &(result->second);
  }
  return 0;
  }*/

 /*const DayaBay::GainConvCalibData* DbiCalibDataSvc::gainConvCalibData(
                                       const DayaBay::FeeChannelId& channelId,
                                       const ServiceMode& serviceMode)
{  
  readCalibFeeGainConvTable(serviceMode);
  std::map<DayaBay::FeeChannelId, DayaBay::GainConvCalibData>::iterator result = 
    m_gainConvDataByChannel.find(channelId);  
  if(result != m_gainConvDataByChannel.end()){
    return &(result->second);
  }
  return 0;
  }*/

const DayaBay::RpcCalibData* DbiCalibDataSvc::rpcCalibData(
                                              const DayaBay::RpcSensor& rpcId,
                                              const ServiceMode& /*serviceMode*/)
{
  std::map<DayaBay::RpcSensor, DayaBay::RpcCalibData>::iterator result = 
    m_rpcDataBySensor.find(rpcId); 
  if(result != m_rpcDataBySensor.end()){
    return &(result->second);
  }
  return 0;
}

const DayaBay::FeeCalibData* DbiCalibDataSvc::feeCalibData(
                                       const DayaBay::FeeChannelId& channelId,
                                       const ServiceMode& serviceMode)
{
/*
  if(serviceMode.context() != lastContext){  //XiaoSu Chen 2010/7/10
    readCalibFeeTable(serviceMode.context());//XiaoSu Chen 2010/6/30
    lastContext = serviceMode.context();
  }
*/
  readCalibFeeTable(serviceMode);
  std::map<DayaBay::FeeChannelId, DayaBay::FeeCalibData>::iterator result = 
    m_feeDataByChannel.find(channelId); 
  if(result != m_feeDataByChannel.end()){
    return &(result->second);
  }
  return 0;
}

const DayaBay::FecCalibData* DbiCalibDataSvc::fecCalibData(
                                       const DayaBay::FecChannelId& channelId,
                                       const ServiceMode& /*serviceMode*/)
{
  std::map<DayaBay::FecChannelId, DayaBay::FecCalibData>::iterator result = 
    m_fecDataByChannel.find(channelId); 
  if(result != m_fecDataByChannel.end()){
    return &(result->second);
  }
  return 0;
}

const DayaBay::SrcEnergyData* DbiCalibDataSvc::srcEnergyData( int type,
                                                                const ServiceMode& svcMode)
{
  //error
  readCalibSrcEnergyTable(svcMode);
  DayaBay::Detector detector(svcMode.context().GetSite(),svcMode.context().GetDetId());
  std::vector<DayaBay::SrcEnergyData> energyList = m_srcEnergyData[detector];
  std::vector<DayaBay::SrcEnergyData>::iterator be = energyList.begin(), en = energyList.end();
  for(;be!=en;be++){
        if((*be).m_sourcePeakType==type)
                return &(*be);
  }
  //Not implemented for StaticCalibDataSvc (jpochoa)
  return 0;

}

const std::vector<DayaBay::PmtCalibData>& DbiCalibDataSvc::pmtCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibPmtTable(serviceMode);
  return m_pmtData[detectorId];
}

const std::vector<DayaBay::PedBiasCalibData>& DbiCalibDataSvc::pedBiasCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibPmtPedBiasTable(serviceMode);
  return m_pedBiasData[detectorId];
}

const std::vector<DayaBay::HighGainCalibData>& DbiCalibDataSvc::highGainCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibPmtHighGainTable(serviceMode);
  return m_highGainData[detectorId];
}

/*const std::vector<DayaBay::TimingCalibData>& DbiCalibDataSvc::timingCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibPmtTimingTable(serviceMode);
  return m_timingData[detectorId];
  }*/

 /*const std::vector<DayaBay::GainConvCalibData>& DbiCalibDataSvc::gainConvCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibFeeGainConvTable(serviceMode);
  return m_gainConvData[detectorId];
}*/

const std::vector<DayaBay::RpcCalibData>& DbiCalibDataSvc::rpcCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*serviceMode*/)
{
  return m_rpcData[detectorId];
}

const std::vector<DayaBay::FeeCalibData>& DbiCalibDataSvc::feeCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibFeeTable(serviceMode);
  return m_feeData[detectorId];
}

const std::vector<DayaBay::FecCalibData>& DbiCalibDataSvc::fecCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*serviceMode*/)
{
  return m_fecData[detectorId];
}

const std::vector<DayaBay::SrcEnergyData>& DbiCalibDataSvc::srcEnergyList(
                                                                          const ServiceMode& serviceMode)
{
 // readCalibSrcEnergyTable(serviceMode);
  //return m_srcEnergyData;
}


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

  DbiResultPtr<GCalibPmtSpec> pr("CalibPmtSpec",pmtLastContext,pmtLastContext.GetDetId());
  // Check whether the result is the same as the last one
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(pmtLastResult == 0){                       //XiaoSu Chen 2010/7/8
    pmtLastResult = thisResult;
  }else if(thisResult->IsEqualTo(pmtLastResult))
  {
    return 2;
  }else{
    pmtLastResult = thisResult;
  }

  //DbiTableProxyRegistry::Instance().ShowStatistics();
  // Check number of entires in result set
  unsigned int numRows = pr.GetNumRows();

  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibPmtSpec* row ;
//  int site, detectorID, ring, column;
  //DayaBay::Detector lastDetector;
  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx);  
//    site = row->GetSite();
//    detectorID = row->GetAD();
//    ring = row->GetRing();
//    column = row->GetColumn();
//    DayaBay::Detector detector((Site::Site_t)site, 
//                         (DetectorId::DetectorId_t)detectorID);
//    DayaBay::AdPmtSensor pmtId(ring, column, (Site::Site_t)site, 
//                             (DetectorId::DetectorId_t)detectorID);
    DayaBay::PmtCalibData pmt;
    DayaBay::DetectorSensor pmtId(row->GetPmtId());
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
    pmt.m_pmtId = pmtId;
    pmt.m_status = DayaBay::PmtCalibData::Status_t(row->GetStatus());               // rewrited by ChenXiaosu
    pmt.m_speHigh = row->GetSpeHigh();
    pmt.m_sigmaSpeHigh = row->GetSigmaSpeHigh();
    pmt.m_speLow = row->GetSpeLow();
    pmt.m_timeOffset = row->GetTimeOffset() * Units::ns;
    pmt.m_timeSpread = row->GetTimeSpread() * Units::ns;
    pmt.m_efficiency = row->GetEfficiency();
    pmt.m_prePulseProb = row->GetPrePulseProb();
    pmt.m_afterPulseProb = row->GetAfterPulseProb();
    pmt.m_darkRate = row->GetDarkRate() * Units::hertz;
    //std::cout << "Adding PMT = " << pmtId.fullPackedData() << std::endl;
    //std::vector<DayaBay::PmtCalibData>& pmtList = m_pmtData[detector];
    //Add lookup by sensor ID
    m_pmtDataBySensor[pmtId] = pmt;
  }
  for(std::map<DayaBay::Detector, std::vector<DayaBay::PmtCalibData> >::iterator pmtData = m_pmtData.begin(); pmtData != m_pmtData.end(); pmtData++)//Xiaosu Chen 2010/7/8
  {
    std::vector<DayaBay::PmtCalibData>& pmtList = pmtData->second;
    pmtList.clear();
  }

  for(std::map<DayaBay::DetectorSensor, DayaBay::PmtCalibData>::iterator pmtDataBySensor = m_pmtDataBySensor.begin(); pmtDataBySensor != m_pmtDataBySensor.end(); pmtDataBySensor++)//Xiaosu Chen 2010/7/8
  {
    DayaBay::DetectorSensor pmtId = pmtDataBySensor->first;
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
    std::vector<DayaBay::PmtCalibData>& pmtList = m_pmtData[detector];
    pmtList.push_back(pmtDataBySensor->second);
  }
  return 1;
}

// J. Pedro Ochoa 2011/05/22 
// Inspired from Xiaosu's readCalibPmtTable 
inline int DbiCalibDataSvc::readCalibPmtPedBiasTable(const ServiceMode& serviceMode){
 
  if(serviceMode.context() == pmtPedBiasLastContext){  
    return 2;    
  }
  pmtPedBiasLastContext = serviceMode.context();       

  DbiResultPtr<GCalibPmtPedBias> pr("CalibPmtPedBias",pmtPedBiasLastContext,pmtPedBiasLastContext.GetDetId());
  // Check whether the result is the same as the last one
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(pmtPedBiasLastResult == 0){                       
    pmtPedBiasLastResult = thisResult;
  }else if(thisResult->IsEqualTo(pmtPedBiasLastResult))
  {
    return 2;
  }else{
    pmtPedBiasLastResult = thisResult;
  }

  // Check number of entries in result set
  unsigned int numRows = pr.GetNumRows();

  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibPmtPedBias* row ;

  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx);  
    DayaBay::PedBiasCalibData pedbias;  
    DayaBay::DetectorSensor pmtId(row->GetSensorId());
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );

    pedbias.m_pmtId = pmtId;
    pedbias.m_amp.b=row->GetAmp_b();
    pedbias.m_amp.m=row->GetAmp_m();
    pedbias.m_mean.amp = row->GetMean_amp();
    pedbias.m_mean.mean = row->GetMean_mean();
    pedbias.m_mean.sigma = row->GetMean_sigma();
    pedbias.m_mean.offset = row->GetMean_offset();
    pedbias.m_mean.b = row->GetMean_b();
    pedbias.m_mean.m = row->GetMean_m();
    pedbias.m_sigma.amp = row->GetSigma_amp();
    pedbias.m_sigma.mean = row->GetSigma_mean();
    pedbias.m_sigma.sigma = row->GetSigma_sigma();
    pedbias.m_sigma.offset = row->GetSigma_offset();
    pedbias.m_sigma.b = row->GetSigma_b();
    pedbias.m_sigma.m = row->GetSigma_m();
    pedbias.m_a0.b = row->GetA0_b();
    pedbias.m_a0.m = row->GetA0_m();
    pedbias.m_a1.b = row->GetA1_b();
    pedbias.m_a1.m = row->GetA1_m();
    pedbias.m_a2.b = row->GetA2_b();
    pedbias.m_a2.m = row->GetA2_m();
    pedbias.m_a3.b = row->GetA3_b();
    pedbias.m_a3.m = row->GetA3_m();
   
    m_pedBiasDataBySensor[pmtId] = pedbias;
  }
  for(std::map<DayaBay::Detector, std::vector<DayaBay::PedBiasCalibData> >::iterator pedBiasData = m_pedBiasData.begin(); pedBiasData != m_pedBiasData.end(); pedBiasData++)
  {
    std::vector<DayaBay::PedBiasCalibData>& pmtList = pedBiasData->second;
    pmtList.clear();
  }

  for(std::map<DayaBay::DetectorSensor, DayaBay::PedBiasCalibData>::iterator pedBiasDataBySensor = m_pedBiasDataBySensor.begin(); pedBiasDataBySensor != m_pedBiasDataBySensor.end(); pedBiasDataBySensor++)
  {
    DayaBay::DetectorSensor pmtId = pedBiasDataBySensor->first;
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
    std::vector<DayaBay::PedBiasCalibData>& pmtList = m_pedBiasData[detector];
    pmtList.push_back(pedBiasDataBySensor->second);
  }
  return 1;
}

// J. Pedro Ochoa 2011/06/15 
// Inspired from Xiaosu's readCalibPmtTable 
inline int DbiCalibDataSvc::readCalibPmtHighGainTable(const ServiceMode& serviceMode){
 
  if(serviceMode.context() == pmtHighGainLastContext){  
    return 2;    
  }
  pmtHighGainLastContext = serviceMode.context();       

  DbiResultPtr<GCalibPmtHighGain> pr("CalibPmtHighGain",pmtHighGainLastContext,pmtHighGainLastContext.GetDetId());
  // Check whether the result is the same as the last one
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(pmtHighGainLastResult == 0){                       
    pmtHighGainLastResult = thisResult;
  }else if(thisResult->IsEqualTo(pmtHighGainLastResult))
  {
    return 2;
  }else{
    pmtHighGainLastResult = thisResult;
  }

  // Check number of entries in result set
  unsigned int numRows = pr.GetNumRows();

  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibPmtHighGain* row ;

  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx);  
    DayaBay::HighGainCalibData highgain;  
    DayaBay::DetectorSensor pmtId(row->GetSensorId());
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );

    highgain.m_pmtId = pmtId;
    highgain.m_speHigh = row->GetSpeHigh();
    highgain.m_speHighError = row->GetSpeHighError();
    highgain.m_sigmaSpeHigh = row->GetSigmaSpeHigh();
    highgain.m_speHighFitQual = row->GetSpeHighFitQual();
   
    m_highGainDataBySensor[pmtId] = highgain;
  }
  for(std::map<DayaBay::Detector, std::vector<DayaBay::HighGainCalibData> >::iterator highGainData = m_highGainData.begin(); highGainData != m_highGainData.end(); highGainData++)
  {
    std::vector<DayaBay::HighGainCalibData>& pmtList = highGainData->second;
    pmtList.clear();
  }

  for(std::map<DayaBay::DetectorSensor, DayaBay::HighGainCalibData>::iterator highGainDataBySensor = m_highGainDataBySensor.begin(); highGainDataBySensor != m_highGainDataBySensor.end(); highGainDataBySensor++)
  {
    DayaBay::DetectorSensor pmtId = highGainDataBySensor->first;
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
    std::vector<DayaBay::HighGainCalibData>& pmtList = m_highGainData[detector];
    pmtList.push_back(highGainDataBySensor->second);
  }
  return 1;
}

// J. Pedro Ochoa 2011/06/24 
// Inspired from Xiaosu's readCalibPmtTable 
/*inline int DbiCalibDataSvc::readCalibPmtTimingTable(const ServiceMode& serviceMode){
 
  if(serviceMode.context() == pmtTimingLastContext){  
    return 2;    
  }
  pmtTimingLastContext = serviceMode.context();       

  DbiResultPtr<GCalibPmtTiming> pr("CalibPmtTiming",pmtTimingLastContext,pmtTimingLastContext.GetDetId());
  // Check whether the result is the same as the last one
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(pmtTimingLastResult == 0){                       
    pmtTimingLastResult = thisResult;
  }else if(thisResult->IsEqualTo(pmtTimingLastResult))
  {
    return 2;
  }else{
    pmtTimingLastResult = thisResult;
  }

  // Check number of entries in result set
  unsigned int numRows = pr.GetNumRows();

  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibPmtTiming* row ;

  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx);  
    DayaBay::TimingCalibData timepars;  
    DayaBay::DetectorSensor chanId(row->GetChannelId());
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );

    timepars.m_channelId = chanId;
    timepars.m_par0 = row->GetPar0();
    timepars.m_par1 = row->GetPar1();
    timepars.m_par2 = row->GetPar2();
    timepars.m_par3 = row->GetPar3();
   
    m_timingDataBySensor[pmtId] = timepars;
  }
  for(std::map<DayaBay::Detector, std::vector<DayaBay::TimingCalibData> >::iterator timingData = m_timingData.begin(); timingData != m_timingData.end(); timingData++)
  {
    std::vector<DayaBay::TimingCalibData>& pmtList = timingData->second;
    pmtList.clear();
  }

  for(std::map<DayaBay::DetectorSensor, DayaBay::TimingCalibData>::iterator timingDataBySensor = m_timingDataBySensor.begin(); timingDataBySensor != m_timingDataBySensor.end(); timingDataBySensor++)
  {
    DayaBay::DetectorSensor pmtId = timingDataBySensor->first;
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
    std::vector<DayaBay::TimingCalibData>& pmtList = m_timingData[detector];
    pmtList.push_back(timingDataBySensor->second);
  }
  return 1;
  }*/

/*
// J. Pedro Ochoa 2011/06/24 
// Inspired from Xiaosu's readCalibPmtTable 
inline int DbiCalibDataSvc::readCalibFeeGainConvTable(const ServiceMode& serviceMode){
 
  if(serviceMode.context() == feeGainConvLastContext){  
    return 2;    
  }
  feeGainConvLastContext = serviceMode.context();       

  DbiResultPtr<GCalibFeeGainConv> pr("CalibFeeGainConv",feeGainConvLastContext,feeGainConvLastContext.GetDetId());
  // Check whether the result is the same as the last one
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(feeGainConvLastResult == 0){                       
    feeGainConvLastResult = thisResult;
  }else if(thisResult->IsEqualTo(feeGainConvLastResult))
  {
    return 2;
  }else{
    feeGainConvLastResult = thisResult;
  }

  // Check number of entries in result set
  unsigned int numRows = pr.GetNumRows();

  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibFeeGainConv* row ;

  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx);  
    DayaBay::GainConvCalibData gcpars;  
    DayaBay::FeeChannelId channelId(row->GetChannelId());
    DayaBay::Detector detector( channelId.site(), channelId.detectorId() );

    gcpars.m_channelId = channelId;
    gcpars.m_gainConv = row->GetGainConv();
    gcpars.m_gainConvError = row->GetGainConvError();
    gcpars.m_frline.slope = row->GetFRLineSlope();
    gcpars.m_frline.offset = row->GetFRLineOffset();
    gcpars.m_frline.uncert = row->GetFRLineUncert();
    gcpars.m_crline.slope = row->GetCRLineSlope();
    gcpars.m_crline.offset = row->GetCRLineOffset();
    gcpars.m_crline.uncert = row->GetCRLineUncert();
   
    m_gainConvDataByChannel[channelId] = gcpars;
  }
  for(std::map<DayaBay::Detector, std::vector<DayaBay::GainConvCalibData> >::iterator gainConvData = m_gainConvData.begin(); gainConvData != m_gainConvData.end(); gainConvData++)
  {
    std::vector<DayaBay::GainConvCalibData>& feeList = gainConvData->second;
    feeList.clear();
  }

  for(std::map<DayaBay::FeeChannelId, DayaBay::GainConvCalibData>::iterator gainConvDataByChannel = m_gainConvDataByChannel.begin(); gainConvDataByChannel != m_gainConvDataByChannel.end(); gainConvDataByChannel++)
  {
    DayaBay::FeeChannelId channelId = gainConvDataByChannel->first;
    DayaBay::Detector detector( channelId.site(), channelId.detectorId() );
    std::vector<DayaBay::GainConvCalibData>& feeList = m_gainConvData[detector];
    feeList.push_back(gainConvDataByChannel->second);
  }
  return 1;
}
*/

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

  DbiResultPtr<GCalibFeeSpec> pr("CalibFeeSpec",feeLastContext,feeLastContext.GetDetId());
  const DbiResultKey* thisResult= pr.GetKey(); 
  if(feeLastResult == 0){                       //XiaoSu Chen 2010/7/8
    feeLastResult = thisResult;
  }else if(thisResult->IsEqualTo(feeLastResult))
  {
    return 2;
  }else{
    feeLastResult = thisResult;
  }

  //DbiTableProxyRegistry::Instance().ShowStatistics();
  // Check number of entires in result set
  unsigned int numRows = pr.GetNumRows();
  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibFeeSpec* row;
  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx); 
    DayaBay::FeeChannelId feeId(row->GetChannelId());
    DayaBay::FeeCalibData fee;
    fee.m_channelId = row->GetChannelId();  
    fee.m_status = DayaBay::FeeCalibData::Status_t(row->GetStatus());         
    fee.m_adcThresholdHigh = row->GetAdcThresholdHigh(); 
    fee.m_adcThresholdLow = row->GetAdcThresholdLow(); 
    fee.m_adcBaselineHigh = row->GetAdcPedestalHigh();  
    fee.m_adcBaselineLow = row->GetAdcPedestalLow(); 
    m_feeDataByChannel[feeId] = fee;  
  }
  for(std::map<DayaBay::Detector, std::vector<DayaBay::FeeCalibData> >::iterator feeData = m_feeData.begin(); feeData != m_feeData.end(); feeData++)//Xiaosu Chen 2010/7/8
  {
    std::vector<DayaBay::FeeCalibData>& feeList = feeData->second;
    feeList.clear();
  }
  for(std::map<DayaBay::FeeChannelId, DayaBay::FeeCalibData>::iterator feeDataByChannel = m_feeDataByChannel.begin(); feeDataByChannel != m_feeDataByChannel.end(); feeDataByChannel++)//Xiaosu Chen 2010/7/8
  {
    DayaBay::FeeChannelId feeId = feeDataByChannel->first;
    DayaBay::Detector detector( feeId.site(), feeId.detectorId() );
    std::vector<DayaBay::FeeCalibData>& feeList = m_feeData[detector];
    feeList.push_back(feeDataByChannel->second);
  }

  return 1;
}


// B. Littlejohn 2011/07/25
// Extension/Simplification of Above for Calibration Peak Database Readout
inline int DbiCalibDataSvc::readCalibSrcEnergyTable(const ServiceMode& serviceMode){

  if(serviceMode.context() == srcEnergyLastContext){
    return 2;
  }
  srcEnergyLastContext = serviceMode.context();

  DbiResultPtr<GCalibSrcEnergy> pr("CalibSrcEnergy",srcEnergyLastContext,srcEnergyLastContext.GetDetId());
  // Check whether the result is the same as the last one
  const DbiResultKey* thisResult= pr.GetKey();
  if(srcEnergyLastResult == 0){
    srcEnergyLastResult = thisResult;
  }else if(thisResult->IsEqualTo(srcEnergyLastResult))
    {
      return 2;
    }else{
      srcEnergyLastResult = thisResult;
    }

  // Check number of entries in result set
  unsigned int numRows = pr.GetNumRows();

  std::cout << "Database rows = " << numRows << std::endl;
  const GCalibSrcEnergy* row ;
  for(std::map<DayaBay::Detector, std::vector<DayaBay::SrcEnergyData> >::iterator energyData = m_srcEnergyData.begin(); energyData != m_srcEnergyData.end(); energyData++)//Xiaosu Chen 2010/7/8
  {
    std::vector<DayaBay::SrcEnergyData>& energyList = energyData->second;
    energyList.clear();
  }

  for (unsigned int idx=0; idx < numRows; idx++) {
    row = pr.GetRowByIndex(idx);
    DayaBay::SrcEnergyData srcenergy;

    srcenergy.m_sourcePeakType = row->GetSourcePeakType();
    srcenergy.m_xSrcPosition = row->GetXSrcPosition();
    srcenergy.m_ySrcPosition = row->GetYSrcPosition();
    srcenergy.m_zSrcPosition = row->GetZSrcPosition();
    srcenergy.m_pePeak = row->GetPEPeak();
    srcenergy.m_pePeakUnc = row->GetPEPeakUnc();
    srcenergy.m_pePeakFitQuality = row->GetPEPeakFitQuality();
    DayaBay::Detector detector(serviceMode.context().GetSite(),serviceMode.context().GetDetId());
    std::vector<DayaBay::SrcEnergyData>& energyList = m_srcEnergyData[detector];
    energyList.push_back(srcenergy);
   // m_srcEnergyData.push_back(srcenergy);
  }
  
  return 1;
}