StaticSimDataSvc.cc

Go to the documentation of this file.

#include "StaticSimDataSvc.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/SystemOfUnits.h"
#include <sstream>
#include <fstream>
#include <string>
#include <stdlib.h>

using namespace Gaudi;

StaticSimDataSvc::StaticSimDataSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
{
  std::string path = getenv ("DATASVCROOT");

  declareProperty("PmtDataFile",m_pmtDataFileName = path + "/share/pmtDataTable.txt",
                  "Optional filename for loading pmt simulation input data");
  declareProperty("RpcDataFile",m_rpcDataFileName="",
                  "Optional filename for loading rpc simulation input data");
  declareProperty("FeeDataFile",m_feeDataFileName = path + "/share/feeDataTable.txt",
                  "Optional filename for loading FEE simulation input data");
  declareProperty("FecDataFile",m_fecDataFileName="",
                  "Optional filename for loading FEC simulation input data");
}

StaticSimDataSvc::~StaticSimDataSvc()
{
}

StatusCode StaticSimDataSvc::initialize()
{
  this->Service::initialize();
  
  IMessageSvc* msg = msgSvc();
  if( !msg ){    
    return StatusCode::FAILURE;
  }

  if(m_pmtDataFileName!=""){
    std::ifstream input( m_pmtDataFileName.c_str() );
    if( !input.is_open() ){
      std::ostringstream msgStr;
      msgStr << "Failed to open input file: " << m_pmtDataFileName;
      msg->reportMessage("StaticSimDataSvc",MSG::ERROR,msgStr.str());
      return StatusCode::FAILURE;
    }
    else {
      std::ostringstream msgStr;
      msgStr << "Opened input file: " << m_pmtDataFileName;
      msg->reportMessage("StaticSimDataSvc",MSG::INFO,msgStr.str());
    }
    int sensorId;
    std::string description;
    double gain, sigmaGain, timeOffset, timeSpread, efficiency;
    double prePulseProb, afterPulseProb, darkRate;
    std::string line;
    while( std::getline(input,line) ){
      std::ostringstream msgStr;
      msgStr << "Got line: " << line;
      msg->reportMessage("StaticSimDataSvc",MSG::VERBOSE,msgStr.str());
      msgStr.str("");
      std::stringstream streamLine(line);
      if( streamLine.peek() == '#' ){
        continue;
      }
      streamLine >> sensorId >> description
                 >> gain >> sigmaGain >> timeOffset >> timeSpread 
                 >> efficiency >> prePulseProb >> afterPulseProb 
                 >> darkRate;
      msgStr << "Adding PMT: " << description;
      msg->reportMessage("StaticSimDataSvc",MSG::VERBOSE,msgStr.str());
    
      DayaBay::DetectorSensor pmtId(sensorId); 
      DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
      DayaBay::PmtSimData pmt;
      pmt.m_pmtId = pmtId;
      pmt.m_gain = gain;
      pmt.m_sigmaGain = sigmaGain;
      pmt.m_timeOffset = timeOffset * Units::ns;
      pmt.m_timeSpread = timeSpread * Units::ns;
      pmt.m_efficiency = efficiency;
      pmt.m_prePulseProb = prePulseProb;
      pmt.m_afterPulseProb = afterPulseProb;
      pmt.m_darkRate = darkRate * 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];
    }
  }

  if(m_feeDataFileName!=""){
    std::ifstream input( m_feeDataFileName.c_str() );
    if( !input.is_open() ){
      std::ostringstream msgStr;
      msgStr << "Failed to open input file: " << m_feeDataFileName;
      msg->reportMessage("StaticSimDataSvc",MSG::ERROR,msgStr.str());
      return StatusCode::FAILURE;
    }
    else {
      std::ostringstream msgStr;
      msgStr << "Opening input file: " << m_feeDataFileName;
      msg->reportMessage("StaticSimDataSvc",MSG::INFO,msgStr.str());
    }
    int channelId;
    std::string description;
    double channelThreshold, adcRangeHigh, adcRangeLow; 
    double adcBaselineHigh, adcBaselineLow;
    std::string line;
    while( std::getline(input,line) ){
      std::ostringstream msgStr;
      msgStr << "Got line: " << line;
      msg->reportMessage("StaticSimDataSvc",MSG::VERBOSE,msgStr.str());
      msgStr.str("");
      std::stringstream streamLine(line);
      if( streamLine.peek() == '#' ){
        continue;
      }
      streamLine >> channelId >> description
                 >> channelThreshold >> adcRangeHigh >> adcRangeLow 
                 >> adcBaselineHigh >> adcBaselineLow;

      msgStr << "Adding FEE Channel: " << description;
      msg->reportMessage("StaticSimDataSvc",MSG::VERBOSE,msgStr.str());
    
      DayaBay::FeeChannelId feeChannelId(channelId); 
      DayaBay::Detector detector(feeChannelId.site(),feeChannelId.detectorId());
      DayaBay::FeeSimData fee;
      fee.m_channelId = feeChannelId;
      fee.m_channelThreshold = channelThreshold * Units::volt;
      fee.m_adcRangeHigh = adcRangeHigh * Units::volt;
      fee.m_adcRangeLow = adcRangeLow * Units::volt;
      fee.m_adcBaselineHigh = adcBaselineHigh;
      fee.m_adcBaselineLow = adcBaselineLow;
      std::vector<DayaBay::FeeSimData>& feeList = m_feeData[detector];
      feeList.push_back(fee);
      // Add lookup by channel ID
      m_feeDataByChannel[feeChannelId] = feeList[feeList.size()-1];
    }
  }

  if(m_rpcDataFileName!=""){
    // FIXME: Add RPC data file
    std::ostringstream msgStr;
    msgStr << "RPC simulation data file not yet implemented!";
    msg->reportMessage("StaticSimDataSvc",MSG::ERROR,msgStr.str());
    return StatusCode::FAILURE;
  }

  if(m_fecDataFileName!=""){
    // FIXME: Add FEC data file
    std::ostringstream msgStr;
    msgStr << "FEC simulation data file not yet implemented!";
    msg->reportMessage("StaticSimDataSvc",MSG::ERROR,msgStr.str());
    return StatusCode::FAILURE;
  }

  return StatusCode::SUCCESS;
}

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

StatusCode StaticSimDataSvc::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* StaticSimDataSvc::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* StaticSimDataSvc::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* StaticSimDataSvc::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);
  }
  // FIXME: Temporarily return a default FEE channel until cabling settles down
  DayaBay::FeeChannelId tmpId(1,1,Site::kDayaBay,DetectorId::kAD1);
  result = m_feeDataByChannel.find(tmpId); 
  if(result != m_feeDataByChannel.end()){
    return &(result->second);
  }
  return 0;
}

const DayaBay::FecSimData* StaticSimDataSvc::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>& StaticSimDataSvc::pmtSimList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& /*svcMode*/)
{
  return m_pmtData[detectorId];
}

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

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

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


// Local Variables: **
// c-basic-offset:2 **
// End: **