In This Package:

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/GCalibFeeSpec.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 <list>
#include <map>
#include <memory>
using std::auto_ptr;

using namespace Gaudi;

DbiCalibDataSvc::DbiCalibDataSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
{
  declareProperty("CableSvcName",m_cableSvcName="StaticCableSvc",
                  "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("StaticCableSvc",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
  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::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 std::vector<DayaBay::PmtCalibData>& DbiCalibDataSvc::pmtCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& serviceMode)
{
  readCalibPmtTable(serviceMode);
  return m_pmtData[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];
}








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;
}


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;
}

---