PulseHistory.hpp

Go to the documentation of this file.

#ifndef PULSE_HISTORY_HPP
#define PULSE_HISTORY_HPP

#include "BinaryUtils.hpp"
#include <Rtypes.h>
#include <TString.h>
#include <vector>
 
class TH1D;
class TH2D;
class TProfile;
 
namespace PulseHistory {

const UInt_t kFlagClamped = 0x2000;
const Int_t kNBins = 30;
const Double_t kLogLo = -6.0; 
const Double_t kLogHi =
    -3.5; 
const Int_t kMAX_AMP_BINS = 6;
const Long64_t kMinPairsPerChannel = 2000;
const Int_t kNTauGrid = 21;
const Double_t kTauGridLoUs = 4.0;
const Double_t kTauGridHiUs = 64.0;
const Double_t kTauFitLoUs = 8.0;
const Double_t kTauFitHiUs = 130.0;
const Int_t kTauFitMinEntries = 100;

enum ChannelGroup {
  kNONE = 0,        
  kLONG_LEFT = 1,   
  kLONG_RIGHT = 2,  
  kSHORT_LEFT = 3,  
  kSHORT_RIGHT = 4, 
  kSTRIP0 = 5,      
  kSTRIP17 = 6,     
  kGRID = 7,        
  kNGROUPS = 8      
};

const char *GroupName(Int_t g);
const char *GroupTag(Int_t g);
Int_t ChainOf(Int_t g);
Bool_t IsLongGroup(Int_t g);
Bool_t GroupEnabled(Int_t g);
Bool_t GroupWantsForm(Int_t g);
Double_t GroupTauUs(Int_t g);

struct Kernel {
  Bool_t ok = kFALSE; 
  Bool_t from_group = kFALSE;
  TString why_group;
  Int_t n_amp = 1; 
  Double_t k[kMAX_AMP_BINS][kNBins];
  Double_t k_binned[kMAX_AMP_BINS][kNBins];

  Bool_t form = kFALSE;
  Bool_t form_ok = kFALSE;
  Int_t j_tau = -1;      
  Double_t tau_us = 0.0; 
  Bool_t tau_given = kFALSE; 
  Double_t tau_free_us = 0.0;
  Double_t r2_form_free = 0.0;
  Double_t
      c[kMAX_AMP_BINS]; 
  Double_t cb[kMAX_AMP_BINS];            
  Double_t k_low[kMAX_AMP_BINS][kNBins]; 
  Int_t n_free = 0;       
  Double_t t_m_us = 0.0;  
  Double_t t_f_us = 0.0;  
  Double_t t_lo_us = 0.0; 
  Double_t intercept_form = 0.0; 
  Double_t r2_form = 0.0;        
  Double_t rms_after_form = 0.0; 
  Double_t r2_binned = 0.0;      
  Double_t r2_group = 0.0;
  Double_t rms_after_binned = 0.0;
  Double_t FormAt(Int_t a, Double_t dt_us) const;
  Double_t EffectiveWindowUs(Int_t a) const;
  struct TauFit {
    Bool_t ok = kFALSE;   
    Bool_t flat = kTRUE;  
    Double_t p0 = 0.0;    
    Double_t p1 = 0.0;    
    Double_t p1err = 0.0; 
    Double_t p2 = 0.0;    
    Double_t p2err = 0.0; 
    Double_t p3 = 0.0;    
    Double_t chi2 = 0.0;  
    Int_t ndf = 0;        
  };
  TauFit tau;                
  Double_t intercept = 0.0;  
  Double_t r2 = 0.0;         
  Double_t rms_before = 0.0; 
  Double_t rms_after = 0.0;  
  Long64_t n = 0;            
  Long64_t n_beam = 0; 

  Kernel();
};

struct Result {
  Kernel kernel[kNGROUPS];
  std::vector<Kernel> kernel_ch;
  std::vector<Int_t> group_of;  
  std::vector<TString> name_ch; 
  Bool_t
      enabled[kNGROUPS]; 
  Long64_t n_hits = 0;   
  Long64_t n_seeds = 0;  
  Long64_t n_beam_events = 0; 
  Long64_t n_corrected = 0;   
  Long64_t n_clamped = 0; 
  Long64_t n_clamped_group[kNGROUPS]; 
  Double_t mean_shift[kNGROUPS];      
  Bool_t sorted_input = kTRUE; 
  std::vector<Double_t> mode;
  TH2D *dev_vs_pred[kNGROUPS]; 
  TH1D *dev_before[kNGROUPS];  
  TH1D *dev_after[kNGROUPS];   
  TH1D *shift[kNGROUPS];       
  TProfile
      *dtprev_before[kNGROUPS]; 
  TProfile *dtprev_after[kNGROUPS]; 
  std::vector<TProfile *> dtprev_before_ch;
  std::vector<TProfile *> dtprev_after_ch;
 
  Result();  
  ~Result(); 
  void FreeDiagnostics();
};

Int_t BinOf(Double_t dt_s);
Double_t BinCentreUs(Int_t b);
Int_t AmpBinOf(Double_t e_prev, Double_t mode, Int_t n_amp);

std::vector<Int_t> BuildGroupMap();

Bool_t Measure(std::vector<RawHit> &hits, const std::vector<Int_t> &group_of,
               Result &res, const TString &file_label);

void Apply(std::vector<RawHit> &hits, const std::vector<Int_t> &group_of,
           Result &res);

TString Report(const Result &res, const TString &file_label,
               Bool_t detail = kTRUE);
void SavePlots(Result &res, const TString &file_label);
void WriteToEventsFile(const TString &events_subpath, const Result &res);
 
} // namespace PulseHistory
 
#endif