WFOperations.hpp

Go to the documentation of this file.

#include "WFPlotter.h"
 
 
 
template <class T >  float WFOperations::
                                 estimateBaseline(T*   a_wf,
                                                  uint a_num
                                                 )
{
  //sum the samples
  float sum = std::accumulate(a_wf, a_wf+a_num,0.0);
  float numFl = a_num;
  return sum / numFl;
}
 
 
template <class T>  float WFOperations::
                                      estimateBaseline(T*   a_wf,
                                                       uint a_num,
                                                       float& a_sigma
                                                      )
{
  float mean = estimateBaseline(a_wf,a_num);
  float accum = 0.0;
  for(uint iS = 0; iS < a_num;iS++)
  {
    float sampleVal = static_cast<float>( a_wf[iS] );
    accum+=(sampleVal-mean)*(sampleVal-mean);
  }
  a_sigma=sqrt(accum/static_cast<float>(a_num));
  return mean;
}
 
template <class T>  void WFOperations::
                                      estimateBaselineDel(T*   a_wf,
                                                          uint a_num,
                                                          float a_baseline,
                                                          float& a_Dmax
                                                         )
{
  float mean = a_baseline;
  float maxDel = 0.0;
  for(uint iS = 0; iS < a_num;iS++)
  {
    float sampleVal = static_cast<float>( a_wf[iS] );
    float diff = sampleVal-mean;
    if(diff>maxDel)
    {
      maxDel = diff;
    }
  }
  a_Dmax = maxDel;
  return;
}
 
template <class T>  float WFOperations::
                                      estimateBaselineDel(T*   a_wf,
                                                          uint a_num,
                                                          float& a_Dmax
                                                         )
{
  float mean = estimateBaseline(a_wf,a_num);
  estimateBaselineDel(a_wf,a_num,mean,a_Dmax);
  return mean;
}
//this function  returns the interpolated sample value that occurs before the
//max at the specified fractional height
template <class T>  float WFOperations::
                                       getCFD(T*   a_wf,
                                              uint a_num,
                                              float a_mean,
                                              float a_frac,
                                              bool a_negPulse
                                             )
{
  return 0;
}
 
//this function returns the sample number corresponding to a leading edge 
//trigger
template <class T> int WFOperations::findSampleLeadingEdgeTrig(T*   a_wf,
                                                      uint a_num,
                                                      float a_baseline,
                                                      float a_threshold
                                                      )
{
  for(uint iS=0; iS<a_num; iS++)
  {
    float sampleVal = static_cast<float>( a_wf[iS] );
    if(abs(sampleVal-a_baseline)>a_threshold)
    {
      return iS;
    }
  }
  return 0;
}
 
template <class T> float WFOperations::integrateTrace(T*   a_wf,
                                       float a_baseline,
                                       int a_startSample,
                                       int a_stopSample,
                                       bool a_negPulse)
{
  float returnIntegral=0;
  for(int iS=a_startSample; iS<a_stopSample+1; iS++)
  {
    float sampleVal = static_cast<float>( a_wf[iS] );
    returnIntegral += sampleVal-a_baseline;
  }
  if(a_negPulse)
  {
    returnIntegral = -returnIntegral;
  }
  return returnIntegral;
}
 
 
  template <class T> std::vector<std::pair<int,int>>
                                         WFOperations::overThreshold(T*   a_wf,
                                         uint a_num, 
                                         float a_baseline,
                                         float a_max
                                         )
{
  std::vector<std::pair<int,int>> results;
  int start = 0;
  int stop  = 0;
  //-1 on the stop condition to allow for checking the next sample
  for(int iS = 0; iS < a_num-1;iS++)
  {
    if(a_wf[iS] - a_baseline> a_max)
    {
      start = iS;
      int iSOv = iS+1;
      for(;iSOv<a_num;iSOv++)
      {
        if(a_wf[iSOv] - a_baseline < a_max)
        {
          break;
        }
      }
      stop = iSOv;
      iS = iSOv;
      results.push_back(std::make_pair(start,stop));
    }
  }
  return results;
}
  template <class T> std::vector<std::pair<int,int>>
                                         WFOperations::underThreshold(T*   a_wf,
                                         uint a_num, 
                                         float a_baseline,
                                         float a_max
                                         )
{
  std::vector<std::pair<int,int>> results;
  int start = 0;
  int stop  = 0;
  //-1 on the stop condition to allow for checking the next sample
  for(int iS = 0; iS < a_num-1;iS++)
  {
    //magnitude of the negative deviation (positve )
    if(a_baseline - a_wf[iS] > a_max)
    {
      start = iS;
      int iSOv = iS+1;
      for(;iSOv<a_num;iSOv++)
      {
        if(a_baseline - a_wf[iSOv] < a_max)
        {
          break;
        }
      }
      stop = iSOv;
      iS = iSOv;
      results.push_back(std::make_pair(start,stop));
    }
  }
  return results;
}
 
 template <class T> std::vector<std::complex<double>> WFOperations::
    getWfFFT(T* a_wf,  
            int a_range)
{
  std::vector<double> wfVec(a_wf, a_wf+a_range);
 
  unsigned long n = a_range;
  n = NSDPhysicsCalcs::GenExtraCalcs::upper_power_of_two(n);
  int m = log2(n);
  std::vector< std::complex < double > > f(n);
  std::vector< std::complex < double > > fHat(n);
 
  for(int i = 0; i < a_range; i++)
  {
    f[i] = {wfVec[i], 0};
  }
  FFT1DBRI op(m);
  op.forwardFFTCC(fHat,f);
  double norm = 1.0/(double)sqrt(n);
  for( auto & eL : fHat )
  {
    eL*=norm;
  }
  return fHat;
}