In This Package:

PmtCalibLeadingEdgeWithCuts.h

Go to the documentation of this file.

/*
 *  PmtCalibLeadingEdge.h
 *  
 *  Generate calibration fit parameters from PMT data
 *
 *  This method uses the leading edge of the signals on each channel
 *  to determine timing offsets.
 * 
 * dandwyer@caltech.edu 2009/01/08
 * 
 *
 ********************************************************************************
 *
 *  PmtCalibLeadingEdgeWithCuts.h
 *
 * calibrate the pmt gain, time offset and mianly the PMT relative efficiency
 * with some ADC and TDC cuts
 * after the firstly PmtCalibLeadingEdge calibration
 *
 * added by wangzhm@ihep.ac.cn 2009/11/28
 */

#ifndef PMTCALIBLEADINGEDGEWITHCUTS_H
#define PMTCALIBLEADINGEDGEWITHCUTS_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>

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 PmtCalibLeadingEdgeWithCuts : public GaudiTool, virtual public IPmtCalibParamTool
{
 public:
  PmtCalibLeadingEdgeWithCuts(const std::string& type,
                      const std::string& name,
                      const IInterface* parent);

  virtual ~PmtCalibLeadingEdgeWithCuts();

  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);

  virtual StatusCode calibrateRaw();


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

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

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

  // CableSvc
  ICableSvc *m_cableSvc;

  // CalibSvc
  ICalibDataSvc *m_calibSvc;

  // IStatisticsSvc
  IStatisticsSvc *m_statsSvc;

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


  // added for buffer the first events of total run
  // to avoid to access the TES again after scan of all events
  // wangzhm@ihep.ac.cn 2009/11/29
  #define max_PMT_number 300
  #define max_event_number 1000
  #define max_FEE_hit  10
        
  int adc_buffer[max_PMT_number][max_event_number][max_FEE_hit]; //max_PMT_number<=300; max_event_number<=2000; max_FEE_hit<=10;
  int tdc_buffer[max_PMT_number][max_event_number][max_FEE_hit]; //max_PMT_number<=300; max_event_number<=2000; max_FEE_hit<=10;
  int adc_clock_buffer[max_PMT_number][max_event_number][max_FEE_hit]; //max_PMT_number<=300; max_event_number<=2000; max_FEE_hit<=10;
  double adc_baseline_buffer[max_PMT_number][max_event_number]; //max_PMT_number<=300; max_event_number<=2000; max_FEE_hit<=10;

  // the ADC cut for each channel
  // in ratio to single PE
  // which should can be input from the run job
  // -1 means no limitation
  // wangzhm@ihep.ac.cn 2009/11/28
  double m_ADC_Cut_Min; //default is 0.25 (0.25PE)
  double m_ADC_Cut_Max; //default is -1 (no limitation)


  //used for each channel
    std::map<int,double> m_ADC_Cut_Min_Channel;
    std::map<int,double> m_ADC_Cut_Max_Channel;

  // the TDC cut for each channel TDC mean
  // in relative to the mean
  // which should can be input from the run job
  // -1 means no limitation
  // wangzhm@ihep.ac.cn 2009/11/28
  double m_TDC_Cut_Min; //default is 15ns
  double m_TDC_Cut_Max; //default is 15ns
  
  //used for each channel
    std::map<int,double> m_TDC_Cut_Min_Channel;
    std::map<int,double> m_TDC_Cut_Max_Channel;


};

#endif  // PMTCALIBLEADINGEDGEWITHCUTS_H

---