TOPTemplateFitter.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <top/dataobjects/TOPRawWaveform.h>
#include <top/dbobjects/TOPSampleTimes.h>
 
#include <vector>
 
namespace Belle2 {
  namespace TOP {
 
    using Point = std::pair<double, double>;
 
    class TOPTemplateFitter {
 
    public:
 
      struct TemplateParameters {
        double amplitude = 100.;
        double risingEdge = 32.;
      };
 
      struct FitResult {
        double amplitude = 0; 
        double amplitudeError = 0; 
        double backgroundOffset = 0;
        double backgroundOffsetError = 0; 
        double risingEdge = 0;
        void clear()
        {
          amplitude = 0;
          amplitudeError = 0;
          backgroundOffset = 0;
          backgroundOffsetError = 0;
          risingEdge = 0;
        }
      };
 
      struct MinimizationSums {
        double S1 = 0; 
        double Sx = 0; 
        double Sxx = 0;
        double Sy = 0; 
        double Sxy = 0;
        double Syy = 0;
        void clear()
        {
          S1 = 0;
          Sx = 0;
          Sxx = 0;
          Sy = 0;
          Sxy = 0;
          Syy = 0;
        }
      };
 
      TOPTemplateFitter(const TOPRawWaveform& wf,
                        const TOPSampleTimes& sampleTimes,
                        const double averageRMS);
      ~TOPTemplateFitter() {};
 
      double getChisq() const {return m_chisq;}
 
      const std::vector<double>& getChisqVector() const {return m_chisq_vec;}
 
      const FitResult& getFitResult() const {return m_result;}
 
      static TemplateParameters& getTemplateParameters() {return s_templateParameters;}
 
      static int getTemplateSamples() {return s_totalTemplateSamples;}
 
      static int getTemplateResolution() {return s_templateResolution;}
 
      static bool getUseParabola() {return s_useParabola;}
 
      static void setTemplateParameters(const TemplateParameters& params);
 
      static void setTemplateSamples(int nSamples);
 
      static void setTemplateResolution(int resolution);
 
      static void setUseParabola(bool use) {s_useParabola = use;}
 
      static void InitializeTemplateFit();
 
      void performTemplateFit(const double risingEdgeStart,
                              const double fitRange);
 
    private:
 
      void PerformTemplateFitMinimize(const std::vector<short>& samples, const std::vector<short>& pedestals,
                                      const std::vector<float>& timingCorrection, const double risingEdgeCFD,
                                      const double fitRange);
 
      double ComputeMinimizedParametersAndChisq(const MinimizationSums& sums, FitResult& result);
 
      void CalculateParabolaVertex(const Point& p1, const Point& p2, const Point& p3,
                                   Point& vertex);
 
      const TOPRawWaveform m_wf; 
      const TOPSampleTimes m_sampleTimes; 
      const double m_averageRMS; 
      static int s_totalTemplateSamples;
      static int s_templateResolution;
      static TemplateParameters s_templateParameters;
      static std::vector<double> s_templateSamples;
      static int s_fineOffsetRange;
      static bool s_templateReInitialize;
      static bool s_useParabola; 
      //fit results
      FitResult m_result;
      double m_chisq = 0;
      std::vector<double> m_chisq_vec;
    };
 
  }
}