WFOperations.h

Go to the documentation of this file.

#ifndef _WF_OPERATIONS_H_
#define _WF_OPERATIONS_H_
//project includes
#include "FFT1DBRI.H"
#include "NSDPhysicsCalcs.h"
#include "SignalProcessing.h"
//c++includes
#include <iostream>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <vector>
 
 
class WFOperations 
{
public:
  WFOperations();
  template <class T> static inline float estimateBaseline(T*   a_wf,
                                                         uint a_num
                                                        );
  template <class T> static inline float estimateBaseline(T*   a_wf,
                                                         uint a_num,
                                                         float& a_sigma
                                                        );
  template <class T> static inline void estimateBaselineDel(T*   a_wf,
                                                             uint a_num,
                                                             float a_baseline,
                                                             float& a_Dmax
                                                            );
  template <class T> static inline float estimateBaselineDel(T*   a_wf,
                                                                uint a_num,
                                                                float& a_Dmax
                                                               );
 
  //this function  returns the interpolated sample value that occurs before the
  //max at the specified fractional height
  template <class T> static inline float getCFD(T*   a_wf,
                                                uint a_num,
                                                float a_mean,
                                                float a_frac,
                                                bool a_negPulse
                                               );
 
  //this function returns the sample number corresponding to a leading edge 
  //trigger (either positive or negative deviation from baseline)
  template <class T> static inline int findSampleLeadingEdgeTrig(T*   a_wf,
                                         uint a_num, 
                                         float a_baseline,
                                         float a_threshold
                                         );
 
  //this function integrates the waveform between provided sample numbers
  template <class T> static inline float integrateTrace(T*   a_wf,
                                         float a_baseline,
                                         int a_startSample,
                                         int a_stopSample,
                                         bool a_negPulse);
  template <class T> static inline std::vector<std::pair<int,int>>
                                         overThreshold(T*   a_wf,
                                         uint a_num, 
                                         float a_baseline,
                                         float a_max
                                         );
  template <class T> static inline std::vector<std::pair<int,int>> 
                                         underThreshold(
                                         T*    a_wf,
                                         uint  a_num, 
                                         float a_baseline,
                                         float a_max
                                         );
  template <class T> static 
                std::vector< std::complex<double> > getWfFFT(T* a_wf,
                                                            int a_range);
 
 
private:
 
  SignalProcessing<double> m_sigProcDbl;
};
 
#include "WFOperations.hpp"
#endif