WCSimWCTrigger.hh

Go to the documentation of this file.

#ifndef WCSimWCTrigger_h
#define WCSimWCTrigger_h 1

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

class WCSimWCDigiTrigger;
typedef G4TDigiCollection<WCSimWCDigiTrigger> WCSimWCTriggeredDigitsCollection;

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

class WCSimWCTriggerBase : public G4VDigitizerModule
{
  
public:

  WCSimWCTriggerBase(G4String name, WCSimDetectorConstruction*, WCSimWCDAQMessenger*, G4String);

  virtual ~WCSimWCTriggerBase();

  void Digitize();

  int NumberOfGatesInThisEvent() { return TriggerTimes.size(); }
  Double_t             GetTriggerTime(int i) { return TriggerTimes[i];}
  TriggerType_t        GetTriggerType(int i) { return TriggerTypes[i];}
  std::vector<Float_t> GetTriggerInfo(int i) { return TriggerInfos[i];}
  G4String GetTriggerClassName(){ return triggerClassName; }

  //
  // Trigger algorithm option set methods
  //

  void SetMultiDigitsPerTrigger(G4bool allow_multi) { multiDigitsPerTrigger = allow_multi; }
  G4bool GetMultiDigitsPerTrigger() { return multiDigitsPerTrigger; }

  // NDigits options
  void SetNDigitsThreshold(G4int threshold) { ndigitsThreshold = threshold; }
  void SetNDigitsWindow(G4int window) { ndigitsWindow = window; }
  void SetNDigitsAdjustForNoise    (G4bool adjust)      { ndigitsAdjustForNoise = adjust; }
  void SetNDigitsPreTriggerWindow(G4int window)  { ndigitsPreTriggerWindow  = - abs(window); }
  void SetNDigitsPostTriggerWindow(G4int window) { ndigitsPostTriggerWindow = + abs(window); }

  // Save trigger failures options
  void SetSaveFailuresMode       (G4int mode )        { saveFailuresMode = mode; }
  void SetSaveFailuresTime       (G4double time )     { saveFailuresTime = time; }
  void SetSaveFailuresPreTriggerWindow(G4int window)  { saveFailuresPreTriggerWindow  = - abs(window); }
  void SetSaveFailuresPostTriggerWindow(G4int window) { saveFailuresPostTriggerWindow = + abs(window); }
  
  void SetDarkRate(double idarkrate){ PMTDarkRate = idarkrate; }

  void SaveOptionsToOutput(WCSimRootOptions * wcopt);
  
protected:

  virtual void DoTheWork(WCSimWCDigitsCollection* WCDCPMT) = 0;

  void GetVariables();

  virtual bool GetDefaultMultiDigitsPerTrigger()   { return true; }
  virtual int GetDefaultNDigitsWindow()            { return 200; }
  virtual int GetDefaultNDigitsThreshold()         { return 25; }
  virtual int GetDefaultNDigitsPreTriggerWindow()  { return -400; }
  virtual int GetDefaultNDigitsPostTriggerWindow() { return 950; }

  double GetPreTriggerWindow(TriggerType_t t);
  double GetPostTriggerWindow(TriggerType_t t);

  //these are the algorithms that perform triggering
  //they are stored here so that different trigger classes can use the same algorithms without copying code
  void AlgNDigits(WCSimWCDigitsCollection* WCDCPMT, bool remove_hits, bool test=false);
  void AlgNoTrigger(WCSimWCDigitsCollection* WCDCPMT, bool remove_hits, bool test=false);


  WCSimWCTriggeredDigitsCollection*   DigitsCollection; 
  std::map<int,int>          DigiHitMap; 

  std::vector<Double_t>               TriggerTimes; 
  std::vector<TriggerType_t>          TriggerTypes; 
  std::vector< std::vector<Float_t> > TriggerInfos; 

  WCSimWCDAQMessenger*       DAQMessenger; 
  WCSimDetectorConstruction* myDetector;   
  G4String detectorElement;

  void ReInitialize() {
    TriggerTimes.clear(); 
    TriggerTypes.clear(); 
    TriggerInfos.clear(); 
    DigiHitMap.clear();
  }

  double PMTDarkRate;    

  // Trigger algorithm options
  G4bool multiDigitsPerTrigger;    
  //NDigits
  G4int  ndigitsThreshold;         
  G4int  ndigitsWindow;            
  G4bool ndigitsAdjustForNoise;    
  G4int  ndigitsPreTriggerWindow;  
  G4int  ndigitsPostTriggerWindow; 
  //Save failures
  G4int    saveFailuresMode;              
  G4double saveFailuresTime;              
  G4int    saveFailuresPreTriggerWindow;  
  G4int    saveFailuresPostTriggerWindow; 

  G4String triggerClassName; 

private:
  void AdjustNDigitsThresholdForNoise();

  void FillDigitsCollection(WCSimWCDigitsCollection* WCDCPMT, bool remove_hits, TriggerType_t save_triggerType);

  void SortTriggersByTime() {
    int i, j;
    TriggerType_t index_type;
    double index_time;
    std::vector<float> index_info;
    for (i = 1; i < (int) TriggerTimes.size(); ++i) {
      index_time = TriggerTimes[i];
      index_type = TriggerTypes[i];
      index_info = TriggerInfos[i];
      for (j = i; j > 0 && TriggerTimes[j-1] > index_time; j--) {
        TriggerTimes[j] = TriggerTimes[j-1];
        TriggerTypes[j] = TriggerTypes[j-1];
        TriggerInfos[j] = TriggerInfos[j-1];
      }//j
      TriggerTimes[j] = index_time;
      TriggerTypes[j] = index_type;
      TriggerInfos[j] = index_info;
    }//i
  }
  
  static const double offset;        
  static const double LongTime;      

  bool   digitizeCalled; 
};

// *******************************************
// CONTAINER CLASS
// *******************************************

class WCSimWCDigiTrigger : public G4VDigi
{
public:

  WCSimWCDigiTrigger();
  ~WCSimWCDigiTrigger();
  WCSimWCDigiTrigger(const WCSimWCDigiTrigger&);
  const WCSimWCDigiTrigger& operator=(const WCSimWCDigiTrigger&);
  int operator==(const WCSimWCDigiTrigger&) const;

  inline void* operator new(size_t);
  inline void  operator delete(void*);

  void Draw() {}
  void Print();

  inline void SetTubeID(G4int tube) { tubeID = tube; }
  inline void AddGate  (G4int gate) { Gates.insert(gate); }
  inline void AddPe    ()           { totalPe++; }
  inline void SetPe    (G4int gate, G4double Q) {   pe.insert(std::pair<int,double>(gate,Q)); }
  inline void SetTime  (G4int gate, G4double T) { time.insert(std::pair<int,double>(gate,T)); }

  void AddDigiCompositionInfo(G4int gate, std::vector<int> &digi_comp){
    fDigiComp.insert(std::pair<int, std::vector<int> >(gate, digi_comp));
    digi_comp.clear();
  }

  inline G4int   GetTubeID() {return tubeID;}
  inline std::vector<G4double> GetPe      (int gate) { return FindInMultimap(gate, pe); }
  inline std::vector<G4double> GetTime    (int gate) { return FindInMultimap(gate, time); }
  std::vector<std::vector<int> > GetDigiCompositionInfo(int gate)
  {
    std::vector<std::vector<int> > v;
    std::multimap<int, std::vector<int> >::iterator it = fDigiComp.begin();
    for (; it != fDigiComp.end(); ++it) {
      if((it->first) == gate)
        v.push_back(it->second);
    }
    return v;
  }

  inline int NumberOfGates()     { return Gates.size();      }
  inline int NumberOfSubEvents() { return Gates.size() - 1;  }
  inline bool HasHitsInGate(int gate) { return Gates.count(gate) > 0; }

private:
  G4int tubeID; 

  std::set<int> Gates;  

  //lists (meaning multimap) of information for each digit created on the PMT
  std::multimap<int,double> pe;   
  std::multimap<int,double> time; 
  std::multimap<int, std::vector<int> > fDigiComp;   

  //integrated hit/digit parameters
  G4int                 totalPe; 

  template <typename T> std::vector<T> FindInMultimap(const int compare, typename std::multimap<int,T> &map)
  {
    typename std::vector<T> v;
    typename std::multimap<int,T>::iterator it = map.begin();
    for (; it != map.end(); ++it) {
      if((it->first) == compare)
        v.push_back(it->second);
    }
    return v;
  }

};

extern G4Allocator<WCSimWCDigiTrigger> WCSimWCDigiTriggerAllocator;

inline void* WCSimWCDigiTrigger::operator new(size_t)
{
  void* aDigi;
  aDigi = (void*) WCSimWCDigiTriggerAllocator.MallocSingle();
  return aDigi;
}

inline void WCSimWCDigiTrigger::operator delete(void* aDigi)
{
  WCSimWCDigiTriggerAllocator.FreeSingle((WCSimWCDigiTrigger*) aDigi);
}



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


class WCSimWCTriggerNDigits : public WCSimWCTriggerBase
{
public:

  WCSimWCTriggerNDigits(G4String name, WCSimDetectorConstruction*, WCSimWCDAQMessenger*, G4String detectorElement);

  ~WCSimWCTriggerNDigits();
  
private:
  void DoTheWork(WCSimWCDigitsCollection* WCDCPMT);

  bool GetDefaultMultiDigitsPerTrigger()    { return false; } 
  int  GetDefaultNDigitsWindow()            { return 200;   } 
  int  GetDefaultNDigitsThreshold()         { return 25;    } 
  int  GetDefaultNDigitsPreTriggerWindow()  { return -400;  } 
  int  GetDefaultNDigitsPostTriggerWindow() { return 950;   } 
};

class WCSimWCTriggerNoTrigger : public WCSimWCTriggerBase
{
public:
  
  WCSimWCTriggerNoTrigger(G4String name, WCSimDetectorConstruction*, WCSimWCDAQMessenger*,  G4String detectorElement);
  
  ~WCSimWCTriggerNoTrigger();
  
private:
  void DoTheWork(WCSimWCDigitsCollection* WCDCPMT);
  
  bool GetDefaultMultiDigitsPerTrigger()    { return true;  } 
  int  GetDefaultNDigitsWindow()            { return 0;     } 
  int  GetDefaultNDigitsThreshold()         { return 0;     } 
  int  GetDefaultNDigitsPreTriggerWindow()  { return 0;     } 
  int  GetDefaultNDigitsPostTriggerWindow() { return 0;     } 
};

class WCSimWCTriggerNDigits2 : public WCSimWCTriggerBase
{
public:

  //not recommended to override these methods
  WCSimWCTriggerNDigits2(G4String name, WCSimDetectorConstruction*, WCSimWCDAQMessenger*, G4String detectorElement);
  ~WCSimWCTriggerNDigits2();
  
private:
  void DoTheWork(WCSimWCDigitsCollection* WCDCPMT);

  bool GetDefaultMultiDigitsPerTrigger()    { return false; } 
  int  GetDefaultNDigitsWindow()            { return 200;   } 
  int  GetDefaultNDigitsThreshold()         { return 50;    } 
  int  GetDefaultNDigitsPreTriggerWindow()  { return -400;  } 
  int  GetDefaultNDigitsPostTriggerWindow() { return 950;   } 
};


#endif //WCSimWCTrigger_h