StaticCalibDataSvc.h

Go to the documentation of this file.

/*
 *  StaticCalibDataSvc.h
 *
 *  Temporary Calibration Data service
 *
 *  Created by Dan Dwyer on 2009/02/04
 *
 *  Updated to be smarter to be able to pick the right calib file by itself.
 *  (PMT, FEE)
 *  For every query request, firstly check whether user supplied any file.
 *  If they do, then use the user specified one.
 *  If not, check whether it can be found in Master map list.
 *  Secondly, compare the requested data's context with current context range,
 *  If compatible, then return.
 *  If not, find the right one with ContextRange indexed map until the end.
 *
 *  2010/03/01  Zhe Wang
 *
 */

#ifndef DATASVC_STATICCALIBDATASVC_H
#define DATASVC_STATICCALIBDATASVC_H

#include "DataSvc/ICalibDataSvc.h"
#include "GaudiKernel/Service.h"
#include "Context/ContextRange.h"
#include <map>

class StaticCalibDataSvc : public Service,
                           virtual public ICalibDataSvc
{
 public:
  // Service interface implementation
  StaticCalibDataSvc(const std::string& name, ISvcLocator *svc);
  ~StaticCalibDataSvc();
  virtual StatusCode initialize();
  virtual StatusCode finalize();
  virtual StatusCode queryInterface(const InterfaceID& riid, 
                                    void** ppvInterface);

  // ICalibDataSvc interface implementation
  // Return the PMT Calibration data
  const DayaBay::PmtCalibData* pmtCalibData(
                                          const DayaBay::DetectorSensor& pmtId,
                                          const ServiceMode& svcMode);

  // Return the PMT Calibration data
  const DayaBay::PedBiasCalibData* pedBiasCalibData(
                                  const DayaBay::DetectorSensor& pmtId,
                                          const ServiceMode& svcMode);

  // Return the PMT (high-gain) Calibration data
  const DayaBay::HighGainCalibData* highGainCalibData(
                                  const DayaBay::DetectorSensor& pmtId,
                                          const ServiceMode& svcMode);

  // Return the PMT (timing) Calibration data
  const DayaBay::TimingCalibData* timingCalibData(
                                  const DayaBay::DetectorSensor& pmtId,
                                          const ServiceMode& svcMode);

  // Return the FEE gain conversion calibration data
  const DayaBay::GainConvCalibData* gainConvCalibData(
                                  const DayaBay::FeeChannelId& channelId,
                                          const ServiceMode& svcMode);

  // Return the RPC Calibration data
  const DayaBay::RpcCalibData* rpcCalibData(const DayaBay::RpcSensor& rpcId,
                                            const ServiceMode& svcMode);

  // Return the FEE Calibration data
  const DayaBay::FeeCalibData* feeCalibData(
                                         const DayaBay::FeeChannelId& channelId,
                                         const ServiceMode& svcMode);

  // Return the FEC Calibration data
  const DayaBay::FecCalibData* fecCalibData(
                                         const DayaBay::FecChannelId& channelId,
                                         const ServiceMode& svcMode);

  // Return calibration source peak data
  const DayaBay::SrcEnergyData* srcEnergyData(int type, const ServiceMode& svcMode);


  // Return the array of Calibration data by detector
  const std::vector<DayaBay::PmtCalibData>& pmtCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of PedBias data by detector
  const std::vector<DayaBay::PedBiasCalibData>& pedBiasCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of HighGain data by detector
  const std::vector<DayaBay::HighGainCalibData>& highGainCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of Timing data by detector
  const std::vector<DayaBay::TimingCalibData>& timingCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of GainConv data by detector
  const std::vector<DayaBay::GainConvCalibData>& gainConvCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of Calibration data by detector
  const std::vector<DayaBay::RpcCalibData>& rpcCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of Calibration data by detector
  const std::vector<DayaBay::FeeCalibData>& feeCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of Calibration data by detector
  const std::vector<DayaBay::FecCalibData>& fecCalibList(
                                           const DayaBay::Detector& detectorId,
                                           const ServiceMode& svcMode);

  // Return the array of SrcEnergy data by detector
  const std::vector<DayaBay::SrcEnergyData>& srcEnergyList(
                                                           const ServiceMode& svcMode);

 private:
  //  ---------------  Here is a separator  -------------------------------
  // Lists of PMT/RPC/channel data by detector
  typedef std::map<DayaBay::Detector, std::vector<DayaBay::PmtCalibData> > PmtData;
  typedef std::map<DayaBay::Detector, std::vector<DayaBay::RpcCalibData> > RpcData;
  typedef std::map<DayaBay::Detector, std::vector<DayaBay::FeeCalibData> > FeeData;
  typedef std::map<DayaBay::Detector, std::vector<DayaBay::FecCalibData> > FecData;

  // Lookup map by Sensor ID
  typedef std::map<DayaBay::DetectorSensor, DayaBay::PmtCalibData> PmtDataBySensor;
  typedef std::map<DayaBay::RpcSensor,      DayaBay::RpcCalibData> RpcDataBySensor;

  // Lookup map by Channel ID
  typedef std::map<DayaBay::FeeChannelId, DayaBay::FeeCalibData> FeeDataByChannel;
  typedef std::map<DayaBay::FecChannelId, DayaBay::FecCalibData> FecDataByChannel;

  //  ---------------  Here is a separator  -------------------------------
  // All above data types have to be context sensitive
  typedef std::map< ContextRange, PmtData > PmtDataMap;
  typedef std::map< ContextRange, RpcData > RpcDataMap;
  typedef std::map< ContextRange, FeeData > FeeDataMap;
  typedef std::map< ContextRange, FecData > FecDataMap;

  typedef std::map< ContextRange, PmtDataBySensor > PmtDataBySensorMap;
  typedef std::map< ContextRange, RpcDataBySensor > RpcDataBySensorMap;

  typedef std::map< ContextRange, FeeDataByChannel > FeeDataByChannelMap;
  typedef std::map< ContextRange, FecDataByChannel > FecDataByChannelMap;

  //  ---------------  Here is a separator  -------------------------------
  // Hold all available maps according to context range
  PmtDataMap m_pmtDataMap;
  RpcDataMap m_rpcDataMap;
  FeeDataMap m_feeDataMap;
  FecDataMap m_fecDataMap;

  PmtDataBySensorMap m_pmtDataBySensorMap;
  RpcDataBySensorMap m_rpcDataBySensorMap;

  FeeDataByChannelMap m_feeDataByChannelMap;
  FecDataByChannelMap m_fecDataByChannelMap;

  //  ---------------  Here is a separator  -------------------------------
  // current context range
  ContextRange m_currentPmtContextRange;
  ContextRange m_currentRpcContextRange;
  ContextRange m_currentFeeContextRange;
  ContextRange m_currentFecContextRange;
  

  // Lists of PMT/RPC/channel data by detector pointed by Current Context Range
  PmtData * m_currentPmtData;
  RpcData * m_currentRpcData;
  FeeData * m_currentFeeData;
  FecData * m_currentFecData;

  // Lookup map by Sensor ID pointed by Current Context Range
  PmtDataBySensor * m_currentPmtDataBySensor;
  RpcDataBySensor * m_currentRpcDataBySensor;

  // Lookup map by Channel ID pointed by Current Context Range
  FeeDataByChannel * m_currentFeeDataByChannel;
  FecDataByChannel * m_currentFecDataByChannel;

  //  ---------------  Here is a separator  -------------------------------

  // Property: Text file of pmt data
  std::string m_masterPmtDataFileName;
  // Property: Text file of rpc data
  // to do: std::string m_rpcDataFileName;
  // Property: Text file of FEE data
  std::string m_masterFeeDataFileName;
  // Property: Text file of FEC data
  // to do: std::string m_fecDataFileName;

  //              < ContextRange, FileName >
  typedef std::map< ContextRange, std::string > FileNameList;


  //  ---------------  Here is a separator  -------------------------------

  // Property: Text file of pmt data
  std::string m_pmtDataFileName;
  // Property: Text file of rpc data
  std::string m_rpcDataFileName;
  // Property: Text file of FEE data
  std::string m_feeDataFileName;
  // Property: Text file of FEC data
  std::string m_fecDataFileName;

  //  ---------------  Here is a separator  -------------------------------
  // Lists of PMT/RPC/channel data by detector specified by user
  PmtData m_pmtDataUser;
  RpcData m_rpcDataUser;
  FeeData m_feeDataUser;
  FecData m_fecDataUser;

  // Lookup map by Sensor ID specified by user
  PmtDataBySensor m_pmtDataBySensorUser;
  RpcDataBySensor m_rpcDataBySensorUser;

  // Lookup map by Channel ID specified by user
  FeeDataByChannel m_feeDataByChannelUser;
  FecDataByChannel m_fecDataByChannelUser;

  //  ---------------  Here is a separator  -------------------------------

  // read master files
  StatusCode readMasterFile( std::string masterFileName, FileNameList &subFileNameList );

  // Functions to read data file
  StatusCode readPmtDataFile( std::string pmtDataFileName, PmtData &pmtData, PmtDataBySensor &pmtDataBySensor );
  // to do: StatusCode readRpcDataFile( ... );
  StatusCode readFeeDataFile( std::string feeDataFileName, FeeData &feeData, FeeDataByChannel &feeDataByChannel );
  // to do: StatusCode readFecDataFile( ... );
};

#endif  // DATASVC_STATICCALIBDATASVC_H