WaveformAnalysisRAVEN.hh

#ifndef __RAT_WaveformAnalysisRAVEN__
#define __RAT_WaveformAnalysisRAVEN__
 
#include <TMatrixDfwd.h>
#include <TObject.h>
 
#include <RAT/DB.hh>
#include <RAT/DS/DigitPMT.hh>
#include <RAT/Digitizer.hh>
#include <RAT/Processor.hh>
#include <RAT/WaveformAnalyzerBase.hh>
#include <utility>
#include <vector>
 
namespace RAT {
 
class WaveformAnalysisRAVEN : public WaveformAnalyzerBase {
 public:
  WaveformAnalysisRAVEN() : WaveformAnalysisRAVEN("RAVEN"){};
 
  WaveformAnalysisRAVEN(std::string config_name) : WaveformAnalyzerBase("WaveformAnalysisRAVEN", config_name) {
    Configure(config_name);
  };
 
  virtual ~WaveformAnalysisRAVEN(){};
 
  void BuildDictionaryMatrix(int nsamples, double digitizer_period);
 
  void Configure(const std::string &config_name) override;
 
  void SetD(std::string param, double value) override;
  void SetI(std::string param, int value) override;
 
 protected:
  DBLinkPtr fDigit;
 
  bool process_threshold_crossing;  
  double voltage_threshold;         
  int threshold_region_padding;     
 
  int template_type;  
 
  // LogNormal template parameters
  double lognormal_scale;  
  double lognormal_shape;  
 
  // Gaussian template parameters
  double gaussian_width;  
 
  double vpe_charge;  
 
  // Algorithm configuration
  TMatrixD fW;             
  double epsilon;          
  size_t max_iterations;   
  double upsample_factor;  
 
  // Thresholding parameters
  double weight_threshold;     
  double weight_merge_window;  
 
  // NPE estimation parameters
  bool npe_estimate;                 
  double npe_estimate_charge_width;  
  size_t npe_estimate_max_pes;       
 
  // Dictionary management
  bool dictionary_built;           
  int cached_nsamples;             
  double cached_digitizer_period;  
 
  void DoAnalysis(DS::DigitPMT *digitpmt, const std::vector<UShort_t> &digitWfm) override;
 
  TVectorD Thresholded_rsNNLS(const TMatrixD &W_region, const TVectorD &voltVec, const double threshold,
                              double &chi2ndf_out, int &iterations_out);
 
  std::vector<std::pair<int, int>> FindThresholdRegions(const std::vector<double> &voltWfm, double threshold,
                                                        int region_padding);
 
  void ProcessThresholdRegion(const std::vector<double> &voltWfm, int start_sample, int end_sample,
                              DS::WaveformAnalysisResult *fit_result, double gain_calibration);
 
  void ExtractPhotoelectrons(const TVectorD &region_weights, int dict_start, int dict_cols, int start_sample,
                             int end_sample, double chi2ndf, int iterations_ran, DS::WaveformAnalysisResult *fit_result,
                             double gain_calibration);
 
  std::vector<std::pair<double, double>> MergeNearbyWeights(const TVectorD &region_weights, int dict_start,
                                                            int dict_cols, double merge_window);
};
 
}  // namespace RAT
 
#endif