In This Package:

PmtCalibLeadingEdge.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
 */

#ifndef PMTCALIBLEADINGEDGE_H
#define PMTCALIBLEADINGEDGE_H

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

using namespace std;

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

  virtual ~PmtCalibLeadingEdge();

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

  // Tdc cut
  bool GoodTdc(int Tdc)
    {
      if(Tdc>900&&Tdc<1050) return true;
      else return false;
    };

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

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

  // Property FloatFeePedesSvcName - 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 false, it will use CalibSvc.
  bool m_useFloatFeePedes;

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

  // text output
  ofstream m_textFile;
  string m_textFileName;
};

#endif  // PMTCALIBLEADINGEDGE_H

---