SVDPositionErrorFunction.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 <framework/logging/Logger.h>
#include <TObject.h>
 
#include <cmath>
#include <vector>
 
namespace Belle2 {
  class SVDPositionErrorFunction : public TObject {
 
  public:
 
    typedef double (SVDPositionErrorFunction::*posErrFunction)(double, int) const;
 
    double getPositionError(double snr, int size) const
    {
      posErrFunction f = m_implementations[m_current];
      return (this->*f)(snr, size) ;
    }
 
    SVDPositionErrorFunction()
    {
      // The m_implementations vector is static.
      // We have to initialize it just once.
      if (m_implementations.size() == 0) {
        m_implementations.push_back(&SVDPositionErrorFunction::v0);
        //m_implementations.push_back(
        //  &SVDPositionErrorFunction::betterVersion);
      }
 
      m_current = m_implementations.size() - 1;
 
    };
 
    void set_current(int current)
    {
      m_current = current;
    }
 
    //SETTERS FOR function ID = 0 (v0, CoGOnly)
    void set_a1(double a1_1, double a1_2, double a1_3, double a1_4, double a1_5)
    {
      m_a1[0] = a1_1;
      m_a1[1] = a1_2;
      m_a1[2] = a1_3;
      m_a1[3] = a1_4;
      m_a1[4] = a1_5;
    }
    void set_a2(double a2_1, double a2_2, double a2_3, double a2_4, double a2_5)
    {
      m_a2[0] = a2_1;
      m_a2[1] = a2_2;
      m_a2[2] = a2_3;
      m_a2[3] = a2_4;
      m_a2[4] = a2_5;
    }
    void set_b1(double b1_1, double b1_2, double b1_3, double b1_4, double b1_5)
    {
      m_b1[0] = b1_1;
      m_b1[1] = b1_2;
      m_b1[2] = b1_3;
      m_b1[3] = b1_4;
      m_b1[4] = b1_5;
    }
 
    void set_c1(double c1_1, double c1_2, double c1_3, double c1_4, double c1_5)
    {
      m_c1[0] = c1_1;
      m_c1[1] = c1_2;
      m_c1[2] = c1_3;
      m_c1[3] = c1_4;
      m_c1[4] = c1_5;
    }
 
 
    SVDPositionErrorFunction(const Belle2::SVDPositionErrorFunction& a);
 
    SVDPositionErrorFunction& operator=(const Belle2::SVDPositionErrorFunction& a);
 
  private:
 
    static const int maxClusterSize = 5;
 
    double m_a1[ maxClusterSize ] = {3, 3, 3, 3, 3}; 
    double m_a2[ maxClusterSize ] = {3, 0, 0, 0, 0}; 
    double m_b1[ maxClusterSize ] = {0}; 
    double m_c1[ maxClusterSize ] = {0}; 
    double v0(double clSNR, int clSize) const
    {
 
      double x = sqrt(clSize) * clSNR;
 
      if (clSize > maxClusterSize)
        clSize = maxClusterSize;
 
      double A = m_a1[clSize - 1] / (x + m_a2[clSize - 1]);
      double B = m_b1[clSize - 1] * x;
      double C = m_c1[clSize - 1];
 
      return sqrt(A * A + B * B + C * C);
    };
 
    int m_current;
 
    static std::vector < posErrFunction > m_implementations; 
 
    ClassDef(SVDPositionErrorFunction, 2);
  };
 
}