In This Package:

StaticCalibDataSvc.cc

Go to the documentation of this file.

#include "StaticCalibDataSvc.h"
#include "GaudiKernel/IMessageSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/SystemOfUnits.h"
#include <sstream>
#include <fstream>
#include <stdlib.h>

using namespace Gaudi;
using namespace std;

StaticCalibDataSvc::StaticCalibDataSvc(const std::string& name, ISvcLocator *svc)
    : Service(name,svc)
{
  // User specified file. If not present, load the default ones from Master.CalibMap.txt
  declareProperty("PmtDataFile",m_pmtDataFileName="",
                  "Filename for loading pmt simulation input data");
  declareProperty("RpcDataFile",m_rpcDataFileName="",
                  "Filename for loading rpc simulation input data");
  declareProperty("FeeDataFile",m_feeDataFileName="",
                  "Filename for loading FEE simulation input data");
  declareProperty("FecDataFile",m_fecDataFileName="",
                  "Filename for loading FEC simulation input data");

  m_masterPmtDataFileName = "Master.pmtCalibMap.txt";
  m_masterFeeDataFileName = "Master.feeCalibMap.txt";

  m_pmtDataMap.clear();
  m_rpcDataMap.clear();
  m_feeDataMap.clear();
  m_fecDataMap.clear();

  m_pmtDataBySensorMap.clear();
  m_rpcDataBySensorMap.clear();

  m_feeDataByChannelMap.clear();
  m_fecDataByChannelMap.clear();
}

StaticCalibDataSvc::~StaticCalibDataSvc()
{
}

StatusCode StaticCalibDataSvc::initialize()
{
  this->Service::initialize();
  
  IMessageSvc* msg = msgSvc();
  if( !msg ){    
    return StatusCode::FAILURE;
  }
  MsgStream log(msg,"StaticCalibSvc");

  //  ---------------  Here is a separator  -------------------------------
  if(m_pmtDataFileName!="")  {
    msg->reportMessage( "StaticCalibSvc", MSG::INFO, ("Loading " + m_pmtDataFileName).c_str() );
    readPmtDataFile( m_pmtDataFileName,
                     m_pmtDataUser,
                     m_pmtDataBySensorUser );
  }

  if(m_feeDataFileName!=""){
    msg->reportMessage( "StaticCalibSvc", MSG::INFO, ("Loading " + m_feeDataFileName).c_str() );
    readFeeDataFile( m_feeDataFileName,
                     m_feeDataUser,
                     m_feeDataByChannelUser );
  }

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

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

  //  ---------------  Here is a separator  -------------------------------
  FileNameList::iterator it, itend;

  msg->reportMessage( "StaticCalibSvc", MSG::INFO, ("Loading " + m_masterPmtDataFileName).c_str() );
  FileNameList PmtDataFileList;
  readMasterFile( m_masterPmtDataFileName, PmtDataFileList );

  itend = PmtDataFileList.end();
  for( it=PmtDataFileList.begin(); it!=itend; it++ ) {
    PmtData aPmtData;
    PmtDataBySensor aPmtDataBySensor;
    readPmtDataFile( it->second,                    // file name
                     aPmtData,
                     aPmtDataBySensor );
    
    m_pmtDataMap[ it->first ] = aPmtData;
    m_pmtDataBySensorMap[ it->first ] = aPmtDataBySensor;
  }
  
  // use the first one to start
  m_currentPmtContextRange  = PmtDataFileList.begin()->first;
  m_currentPmtData          = &(m_pmtDataMap.begin()->second);
  m_currentPmtDataBySensor  = &(m_pmtDataBySensorMap.begin()->second);

  msg->reportMessage( "StaticCalibSvc", MSG::INFO, ("Loading " + m_masterFeeDataFileName).c_str() );
  FileNameList FeeDataFileList;
  readMasterFile( m_masterFeeDataFileName, FeeDataFileList );

  itend = FeeDataFileList.end();
  for( it=FeeDataFileList.begin(); it!=itend; it++ ) {
    FeeData aFeeData;
    FeeDataByChannel aFeeDataByChannel;
    readFeeDataFile( it->second,                    // file name
                     aFeeData,
                     aFeeDataByChannel );

    m_feeDataMap[ it->first ] = aFeeData;
    m_feeDataByChannelMap[ it->first ] = aFeeDataByChannel;
  }
  
  // use the first one to start
  m_currentFeeContextRange  = FeeDataFileList.begin()->first;
  m_currentFeeData          = &(m_feeDataMap.begin()->second);
  m_currentFeeDataByChannel = &(m_feeDataByChannelMap.begin()->second);


  return StatusCode::SUCCESS;
}

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

StatusCode StaticCalibDataSvc::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* StaticCalibDataSvc::pmtCalibData(
                                       const DayaBay::DetectorSensor& pmtId,
                                       const ServiceMode& svcMode)
{
  /*
  cout<<svcMode.context()<<endl;
  cout<<m_currentPmtContextRange.GetTimeStart().AsString()<<endl;
  cout<<m_currentPmtContextRange.GetTimeEnd().AsString()<<endl;
  */
  PmtDataBySensor* pPmtDataBySensor = 0;

  if (m_pmtDataFileName.size() != 0)  {
    pPmtDataBySensor = &m_pmtDataBySensorUser;
  } else {
    const Context &cont = svcMode.context();
    if ( m_currentPmtContextRange.IsCompatible( cont ) )  {
      pPmtDataBySensor = m_currentPmtDataBySensor;
    } else {
      PmtDataBySensorMap::iterator it, itend=m_pmtDataBySensorMap.end();
      for( it = m_pmtDataBySensorMap.begin(); it!=itend; it++ )  {
        if( it->first.IsCompatible( cont ) )  {
          m_currentPmtContextRange = it->first;
          m_currentPmtDataBySensor = &(it->second);
          pPmtDataBySensor = m_currentPmtDataBySensor;
          m_currentPmtData = &(m_pmtDataMap[m_currentPmtContextRange]);
          break;
        }
      }
    }
  }
  
  if( pPmtDataBySensor!=0 )  {
    std::map<DayaBay::DetectorSensor, DayaBay::PmtCalibData>::iterator result =
      pPmtDataBySensor->find(pmtId);
    if(result != pPmtDataBySensor->end()){
      return &(result->second);
    }
    return 0;
  }

  return 0;
}

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

const DayaBay::FeeCalibData* StaticCalibDataSvc::feeCalibData(
                                       const DayaBay::FeeChannelId& channelId,
                                       const ServiceMode& svcMode)
{
  FeeDataByChannel * pFeeDataByChannel = 0;
  
  if (m_feeDataFileName.size() != 0)  {
    pFeeDataByChannel = &m_feeDataByChannelUser;
  } else {
    const Context &cont = svcMode.context();
    if ( m_currentFeeContextRange.IsCompatible( cont ) )  {
      pFeeDataByChannel = m_currentFeeDataByChannel;
    } else {
      FeeDataByChannelMap::iterator it, itend=m_feeDataByChannelMap.end();
      for( it = m_feeDataByChannelMap.begin(); it!=itend; it++ )  {
        if( it->first.IsCompatible( cont ) )  {
          m_currentFeeContextRange = it->first;
          m_currentFeeDataByChannel = &(it->second);
          pFeeDataByChannel = m_currentFeeDataByChannel;
          m_currentFeeData = &(m_feeDataMap[m_currentFeeContextRange]);
          break;
        }
      }
    }
  }

  if( pFeeDataByChannel!=0 )  {
    std::map<DayaBay::FeeChannelId, DayaBay::FeeCalibData>::iterator result = 
      pFeeDataByChannel->find(channelId); 
    if(result != pFeeDataByChannel->end()){
      return &(result->second);
    }
    return 0;
  }
  
  return 0;
}

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

const std::vector<DayaBay::PmtCalibData>& StaticCalibDataSvc::pmtCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& svcMode)
{
  PmtData* pPmtData = 0;

  if (m_pmtDataFileName.size() != 0)  {
    pPmtData = &m_pmtDataUser;
  } else {
    const Context &cont = svcMode.context();
    if ( m_currentPmtContextRange.IsCompatible( cont ) )  {
      pPmtData = m_currentPmtData;
    } else {
      PmtDataMap::iterator it, itend=m_pmtDataMap.end();
      for( it = m_pmtDataMap.begin(); it!=itend; it++ )  {
        if( it->first.IsCompatible( cont ) )  {
          m_currentPmtContextRange = it->first;
          m_currentPmtData = &(it->second);
          pPmtData = m_currentPmtData;
          m_currentPmtDataBySensor = &(m_pmtDataBySensorMap[m_currentPmtContextRange]);
          break;
        }
      }
    }
  }

  if( pPmtData!=0 )  {
    return (*pPmtData)[detectorId];
  }
  
  cout<<"No available PmtCalibData found"<<endl;
  cout<<"No CalibData file specified, or wrong time range in Master.pmtCalibMap.txt, or no such data file at all"<<endl;
  abort();
}

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

const std::vector<DayaBay::FeeCalibData>& StaticCalibDataSvc::feeCalibList(
                                          const DayaBay::Detector& detectorId,
                                          const ServiceMode& svcMode)
{
  FeeData * pFeeData = 0;

  if (m_feeDataFileName.size() != 0)  {
    pFeeData = &m_feeDataUser;
  } else {
    const Context &cont = svcMode.context();
    if ( m_currentFeeContextRange.IsCompatible( cont ) )  {
      pFeeData = m_currentFeeData;
    } else {
      FeeDataMap::iterator it, itend=m_feeDataMap.end();
      for( it = m_feeDataMap.begin(); it!=itend; it++ )  {
        if( it->first.IsCompatible( cont ) )  {
          m_currentFeeContextRange = it->first;
          m_currentFeeData = &(it->second);
          pFeeData = m_currentFeeData;
          m_currentFeeDataByChannel = &(m_feeDataByChannelMap[m_currentFeeContextRange]);
          break;
        }
      }
    }
  }

  if( pFeeData!=0 )  {
    return (*pFeeData)[detectorId];
  }

  cout<<"No available FeeCalibData found"<<endl;
  cout<<"No CalibData file specified, or wrong time range in Master.feeCalibMap.txt, or no such data file at all"<<endl;
  abort();
}

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


// Functions to read data file
StatusCode StaticCalibDataSvc::readPmtDataFile( std::string pmtDataFileName, PmtData &pmtData, PmtDataBySensor &pmtDataBySensor )
{
  IMessageSvc* msg = msgSvc();
  if( !msg ){
    return StatusCode::FAILURE;
  }
  MsgStream log(msg,"StaticCalibSvc");

  std::ifstream input( pmtDataFileName.c_str() );
  std::ostringstream prtStr;
  prtStr<<"PmtCalibMap "<<pmtDataFileName;
  msg->reportMessage("StaticCalibDataSvc",MSG::DEBUG,prtStr.str());
  if( !input.is_open() ){
    std::ostringstream msgStr;
    msgStr << "Failed to open input file: " << pmtDataFileName;
    msg->reportMessage("StaticCalibDataSvc",MSG::ERROR,msgStr.str());
    return StatusCode::FAILURE;
  }
  int sensorId;
  std::string description;
  int status;
  double speHigh, sigmaSpeHigh, speLow, timeOffset, timeSpread, efficiency;
  double prePulseProb, afterPulseProb, darkRate;
  std::string line;
  while( std::getline(input,line) ){
    std::ostringstream msgStr;
    msgStr << "Got line: " << line;
    msg->reportMessage("StaticCalibDataSvc",MSG::VERBOSE,msgStr.str());
    msgStr.str("");
    std::stringstream streamLine(line);
    if( streamLine.peek() == '#' ){
      continue;
    }
    streamLine >> sensorId >> description
               >> status >> speHigh >> sigmaSpeHigh >> speLow
               >> timeOffset >> timeSpread >> efficiency >> prePulseProb
               >> afterPulseProb >> darkRate;
    msgStr << "Adding PMT: " << description;
    msg->reportMessage("StaticCalibDataSvc",MSG::VERBOSE,msgStr.str());

    DayaBay::DetectorSensor pmtId(sensorId);
    DayaBay::Detector detector( pmtId.site(), pmtId.detectorId() );
    DayaBay::PmtCalibData pmt;
    pmt.m_pmtId = pmtId;
    pmt.m_status = (DayaBay::PmtCalibData::Status_t)status;
    pmt.m_speHigh = speHigh;
    pmt.m_sigmaSpeHigh = sigmaSpeHigh;
    pmt.m_speLow = speLow;
    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::PmtCalibData>& pmtList = pmtData[detector];
    pmtList.push_back(pmt);
    // Add lookup by sensor ID                                                                                                           
    pmtDataBySensor[pmtId] = pmtList[pmtList.size()-1];
  }

  return StatusCode::SUCCESS;

}


StatusCode StaticCalibDataSvc::readFeeDataFile( std::string feeDataFileName, FeeData &feeData, FeeDataByChannel &feeDataByChannel )
{
  IMessageSvc* msg = msgSvc();
  if( !msg ){
    return StatusCode::FAILURE;
  }
  MsgStream log(msg,"StaticCalibSvc");

  std::ifstream input( feeDataFileName.c_str() );
  if( !input.is_open() ){
    std::ostringstream msgStr;
    msgStr << "Failed to open input file: " << feeDataFileName;
    msg->reportMessage("StaticCalibDataSvc",MSG::ERROR,msgStr.str());
    return StatusCode::FAILURE;
  }
  int channelId;
  std::string description;
  int status;
  double adcThresholdHigh, adcThresholdLow, adcBaselineHigh, adcBaselineLow;
  std::string line;
  while( std::getline(input,line) ){
    std::ostringstream msgStr;
    msgStr << "Got line: " << line;
    msg->reportMessage("StaticCalibDataSvc",MSG::VERBOSE,msgStr.str());
    msgStr.str("");
    std::stringstream streamLine(line);
    if( streamLine.peek() == '#' ){
      continue;
    }
    streamLine >> channelId >> description
               >> status >> adcThresholdHigh >> adcThresholdLow
               >> adcBaselineHigh >> adcBaselineLow;
    msgStr << "Adding PMT: " << description;
    msg->reportMessage("StaticCalibDataSvc",MSG::VERBOSE,msgStr.str());

    DayaBay::FeeChannelId feeChannelId(channelId);
    DayaBay::Detector detector(feeChannelId.site(),feeChannelId.detectorId());
    DayaBay::FeeCalibData fee;
    fee.m_channelId = feeChannelId;
    fee.m_status = (DayaBay::FeeCalibData::Status_t)status;
    fee.m_adcThresholdHigh = adcThresholdHigh;
    fee.m_adcThresholdLow = adcThresholdLow;
    fee.m_adcBaselineHigh = adcBaselineHigh;
    fee.m_adcBaselineLow = adcBaselineLow;
    std::vector<DayaBay::FeeCalibData>& feeList = feeData[detector];
    feeList.push_back(fee);
    // Add lookup by channel ID                                                                                                          
    feeDataByChannel[feeChannelId] = feeList[feeList.size()-1];
  }

  return StatusCode::SUCCESS;

}


StatusCode StaticCalibDataSvc::readMasterFile( std::string masterFileName, FileNameList &subFileNameList )
{
  IMessageSvc* msg = msgSvc();
  if( !msg ){
    return StatusCode::FAILURE;
  }
  MsgStream log(msg,"StaticCalibSvc");

  std::string Path = getenv ("DATASVCROOT");
  std::ifstream masterFileStream( (Path+"/share/"+masterFileName).c_str() );

  if( !masterFileStream.is_open() ){
    msg->reportMessage( "StaticCalibSvc", MSG::ERROR, ("Fail to open" + masterFileName).c_str() );
    return StatusCode::FAILURE;
  }

  int StartRun,EndRun;
  int Sites;
  int SimFlag, StartTimeSec, StartTimeNanoSec, EndTimeSec, EndTimeNanoSec;
  std::string MapFileName;

  std::string line;

  while( std::getline( masterFileStream, line ) ){
    std::stringstream streamLine(line);
    if( streamLine.peek() == '#' ){
      continue;
    }
    streamLine >>StartRun >>EndRun >>Sites
               >>SimFlag >>StartTimeSec>> StartTimeNanoSec >>EndTimeSec >>EndTimeNanoSec
               >>MapFileName;

    ContextRange CRange( Sites, SimFlag,
                         TimeStamp( StartTimeSec, StartTimeNanoSec ),
                         TimeStamp( EndTimeSec, EndTimeNanoSec ) );
    /*
    std::cout<<TimeStamp( StartTimeSec, StartTimeNanoSec ).AsString()<<std::endl;
    std::cout<<TimeStamp( EndTimeSec, EndTimeNanoSec ).AsString()<<std::endl;
    */
    MapFileName = Path + "/share/" + MapFileName;
    subFileNameList[ CRange ] = MapFileName ;
  }

  return StatusCode::SUCCESS;
}

---