In This Package:

DbiSimDataSvc.cc

Go to the documentation of this file.

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

#include "genDbi/GSimPmtSpec.h"

#include "Conventions/Site.h"
#include "Conventions/SimFlag.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 <sstream>

#include <list>
#include <map>
#include <memory>
using std::auto_ptr;

using namespace Gaudi;

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

DbiSimDataSvc::~DbiSimDataSvc()
{
}

StatusCode DbiSimDataSvc::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("DbiSimDataSvc",MSG::ERROR,msgStr.str());
    return sc;    
  }

  // Use a dummy service mode for initialization
/*  Context context;
  context.SetSite(Site::kAll);
  context.SetDetId(DetectorId::kAll);
  ServiceMode svcMode(context,0);
  const std::vector<DayaBay::DetectorSensor> sensors = 
    cableSvc->sensors(svcMode);
*/
  // =======================================================
  // FIXME: since there's only one context range, hard coding context for now
  // =======================================================
  //TimeStamp tstamp(2007, 1, 15, 0, 0, 1);
  //Context vc(Site::kDayaBay, SimFlag::kMC, tstamp);
  Context vc(Site::kAll, SimFlag::kMC);
  DbiResultPtr<GSimPmtSpec> pr("SimPmtSpec",vc);
  //pr.NewQuery(vc);

  // Delete any residual objects and check for leaks.

  DbiTableProxyRegistry::Instance().ShowStatistics();
  

  // Check number of entires in result set
  unsigned int numRows = pr.GetNumRows();
  std::cout << "CJSLIN: Database rows = " << numRows << std::endl;
  const GSimPmtSpec* row ;
//  int site, detectorID, ring, column;
  
  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::PmtSimData pmt;
    DayaBay::DetectorSensor pmtId(row->GetPmtId());
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
//    pmt.m_pmtId = pmtId.fullPackedData();
    pmt.m_pmtId = pmtId;
    pmt.m_gain = row->GetGain();
    pmt.m_sigmaGain = row->GetSigmaGain();
    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::vector<DayaBay::PmtSimData>& pmtList = m_pmtData[detector];
    pmtList.push_back(pmt);
    // Add lookup by sensor ID
    m_pmtDataBySensor[pmtId] = pmtList[pmtList.size()-1];

  }

  //FIXME: leaving out RPC stuff for now


  return StatusCode::SUCCESS;
}

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

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

const DayaBay::PmtSimData* DbiSimDataSvc::pmtSimData(
                                       const DayaBay::DetectorSensor& pmtId,
                                       const ServiceMode& /*svcMode*/)
{
  std::map<DayaBay::DetectorSensor, DayaBay::PmtSimData>::iterator result = 
    m_pmtDataBySensor.find(pmtId); 
  if(result != m_pmtDataBySensor.end()){
    return &(result->second);
  }
  return 0;
}

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


const DayaBay::FeeSimData* DbiSimDataSvc::feeSimData(
                                       const DayaBay::FeeChannelId& channelId,
                                       const ServiceMode& /*svcMode*/)
{
  std::map<DayaBay::FeeChannelId, DayaBay::FeeSimData>::iterator result = 
    m_feeDataByChannel.find(channelId); 
  if(result != m_feeDataByChannel.end()){
    return &(result->second);
  }
  return 0;
}

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


const std::vector<DayaBay::PmtSimData>& DbiSimDataSvc::pmtSimList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*svcMode*/)
{
  return m_pmtData[detectorId];
}

const std::vector<DayaBay::RpcSimData>& DbiSimDataSvc::rpcSimList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*svcMode*/)
{
  return m_rpcData[detectorId];
}


const std::vector<DayaBay::FeeSimData>& DbiSimDataSvc::feeSimList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*svcMode*/)
{
  return m_feeData[detectorId];
}

const std::vector<DayaBay::FecSimData>& DbiSimDataSvc::fecSimList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*svcMode*/)
{
  return m_fecData[detectorId];
}

---