WCSimWCDigitizer.hh

Go to the documentation of this file.

#ifndef WCSimWCDigitizer_h
#define WCSimWCDigitizer_h 1

#include "WCSimRootOptions.hh"
#include "WCSimDarkRateMessenger.hh"
#include "WCSimWCDAQMessenger.hh"
#include "WCSimDetectorConstruction.hh"
#include "WCSimEnumerations.hh"
#include "G4VDigitizerModule.hh"
#include "WCSimWCDigi.hh"
#include "WCSimWCHit.hh"
#include "globals.hh"
#include "Randomize.hh"
#include <map>
#include <vector>
#include <limits>


// *******************************************
// BASE CLASS
// *******************************************

class WCSimWCDigitizerBase : public G4VDigitizerModule
{
public:
  
  WCSimWCDigitizerBase(G4String name, WCSimDetectorConstruction*, WCSimWCDAQMessenger*, DigitizerType_t, G4String detectorElement);
  virtual ~WCSimWCDigitizerBase();
  
  bool AddNewDigit(int tube, int gate, double digihittime, double peSmeared, std::vector<int> digi_comp);
  virtual void DigitizeHits(WCSimWCDigitsCollection* WCHCPMT) = 0;
  void DigitizeGate(WCSimWCDigitsCollection* WCHC,G4int G);
  void Digitize();

  //.mac file option setting methods
  void SetDigitizerDeadTime         (int deadtime) { DigitizerDeadTime = deadtime;         }; 
  void SetDigitizerIntegrationWindow(int inttime ) { DigitizerIntegrationWindow = inttime; }; 
  void SetDigitizerTimingPrecision  (double precision) { DigitizerTimingPrecision = precision; }; 
  void SetDigitizerPEPrecision      (double precision) { DigitizerPEPrecision     = precision; }; 

  double Truncate(double value, double precision) {
    if(precision < 1E-10) return value;
    double ratio=value / precision;
    // Result of cast is undefined if value is outside range of int. Just do nothing in that case.
    if(ratio>std::numeric_limits<int64_t>::max() || ratio<std::numeric_limits<int64_t>::min() ) return value;
    return precision * (int64_t)(value / precision);
  }

  void SaveOptionsToOutput(WCSimRootOptions * wcopt);
  
protected:
  void ReInitialize() { DigiStoreHitMap.clear(); }

  G4double peSmeared;

  WCSimDetectorConstruction* myDetector; 
  WCSimWCDAQMessenger* DAQMessenger;     

  WCSimWCDigitsCollection*  DigiStore;
  std::map<int,int> DigiStoreHitMap;   

  //generic digitizer properties. Defaults set with the GetDefault*() methods. Overidden by .mac options
  G4String DigitizerClassName;    
  int DigitizerDeadTime;          
  int DigitizerIntegrationWindow; 
  double DigitizerTimingPrecision; 
  double DigitizerPEPrecision;     

  DigitizerType_t DigitizerType; 

  virtual int GetDefaultDeadTime() = 0;          
  virtual int GetDefaultIntegrationWindow() = 0; 
  virtual double GetDefaultTimingPrecision() = 0;   
  virtual double GetDefaultPEPrecision() = 0;       

  void GetVariables(); 

  G4String detectorElement;
};



// *******************************************
// DERIVED CLASSES
// *******************************************


// SKI-based digitizer class
class WCSimWCDigitizerSKI : public WCSimWCDigitizerBase 
{
public:
  
  WCSimWCDigitizerSKI(G4String name, WCSimDetectorConstruction*, WCSimWCDAQMessenger*, G4String detectorElement);
  ~WCSimWCDigitizerSKI();

  void DigitizeHits(WCSimWCDigitsCollection* WCHCPMT);

private:
  int GetDefaultDeadTime()          { return 0; }   
  int GetDefaultIntegrationWindow() { return 200; } 
  double GetDefaultTimingPrecision()   { return 0.4; } 
  double GetDefaultPEPrecision()       { return 0;   } 

  static void Threshold(double& pe,int& iflag){
    //   CLHEP::HepRandom::setTheSeed(pe+2014);
    double x = pe+0.1; iflag=0;
    double thr; double RDUMMY,err;
    if ( x<1.1) {
      thr = std::min(1.0,
                     -0.06374+x*(3.748+x*(-63.23+x*(452.0+x*(-1449.0+x*(2513.0
                                                                        +x*(-2529.+x*(1472.0+x*(-452.2+x*(51.34+x*2.370))))))))));
    } else {
      thr = 1.0;
    }
    RDUMMY = G4UniformRand();
    if (thr < RDUMMY) {
      pe = 0.0;
      iflag = 1;
    }
    else {
      err = G4RandGauss::shoot(0.0,0.03);
      pe = pe+err;
    }
  }
};


#endif //WCSimWCDigitizer_h