In This Package:

PmtCalibFullModel.h

Go to the documentation of this file.

/*
 *  PmtCalibFullModel.h
 *  
 *  Generate calibration fit parameters from PMT data
 *
 *  This method uses the leading edge of the signals on each channel
 *  to determine timing offsets.
 *  and use the PMT full response model to get the PMT gain, from NIM A339 (1994) 468-476  
 *  and to determine the relative efficiency of each channel
 *
 * wangzhm@ihep.ac.cn 2009/11/29
 */

#ifndef PMTCALIBFULLMODEL_H
#define PMTCALIBFULLMODEL_H

#include "CalibParam/IPmtCalibParamTool.h"
#include "GaudiAlg/GaudiTool.h"
#include "Conventions/Electronics.h"
#include "Conventions/Detectors.h"
#include "Context/Context.h"
#include <string>
#include <vector>
#include "FloatingFeePedestalSvc/IFloatingFeePedestalSvc.h"

namespace DayaBay{
  class ReadoutHeader;
}

class IStatisticsSvc;
class ICableSvc;
class ICalibDataSvc;

/*
// Statistics container class for one PMT channel
class PmtStatsOneChannelLE {
 public:
  PmtStatsOneChannelLE(const DayaBay::FeeChannelId& channelId)
    { m_channelId = channelId; m_nHits = 0; m_tdcRaw=0; m_tdcByMedian=0; 
      m_adcRaw=0; m_adc=0; m_adcByClock=0;}
  ~PmtStatsOneChannelLE(){;}
 public:
  DayaBay::FeeChannelId m_channelId;
  DayaBay::AdPmtSensor m_pmtId;
  int m_nHits;
  TH1F* m_tdcRaw;
  TH1F* m_tdcByMedian;
  TH1F* m_adcRaw;
  TH1F* m_adc;
  TH1F* m_adcByClock;
};

// Statistics container class for one detector
class PmtStatsLE {
 public:
  PmtStatsLE(const DayaBay::Detector& detector){m_detector=detector; 
    m_nReadouts=0;}
  ~PmtStatsLE(){;}
 public:
  DayaBay::Detector m_detector;
  std::map<DayaBay::FeeChannelId,PmtStatsOneChannelLE*> m_channel;
  int m_nReadouts;
  TH1F* m_adcSum;
  TH1F* m_tdcMedian;
  std::map<int, TH1F*> m_occupancy;
  std::map<int, TH1F*> m_tdcOffset;
  std::map<int, TH1F*> m_adcMedian;
  std::map<int, TH1F*> m_adcSigma;
};
*/

class PmtCalibFullModel : public GaudiTool, virtual public IPmtCalibParamTool
{
 public:
  PmtCalibFullModel(const std::string& type,
                      const std::string& name,
                      const IInterface* parent);

  virtual ~PmtCalibFullModel();

  virtual StatusCode initialize();
  virtual StatusCode finalize();

  
  virtual StatusCode process(const DayaBay::ReadoutHeader& readout);
  
  virtual StatusCode calibrate();
  
 private:
  bool hasStats(const DayaBay::Detector& detector);
  StatusCode prepareStats(const Context& context);

  // Format path to detector statistics
  std::string getPath(const DayaBay::Detector& detector);
  // Format path to detector, ring statistics
  std::string getPath(const DayaBay::Detector& detector, int ring);
  // Format path to channel statistics
  std::string getPath(const DayaBay::FeeChannelId& channelId);

 private:
    
  // Property CableSvcName - Name of the cable service
  std::string m_cableSvcName;

  // Property CalibSvcName - Name of the calibration service
  std::string m_calibSvcName;

  // Property FloatingFeePedesSvcName - Name of floating fee pedestal service
  std::string m_floatFeePedesSvcName;

  // Property FilePath - File path of registered histograms
  std::string m_filepath;

  // CableSvc
  ICableSvc *m_cableSvc;

  // CalibSvc
  ICalibDataSvc *m_calibSvc;

  // IStatisticsSvc
  IStatisticsSvc *m_statsSvc;

  // IFloatingFeePedestalSvc;
  IFloatingFeePedestalSvc *m_floatFeePedesSvc;

  // Use FloatFeePedes or not? In case of flase, it will use CalibSvc.
  bool m_useFloatFeePedes;

  // Cached list of processed detectors
  std::vector<DayaBay::Detector> m_processedDetectors;
};

#endif  // PMTCALIBFULLMODEL_H

---