SVDHitTimeSelectionFunction.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Giulia Casarosa                                          *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <TObject.h>
 
#include <cmath>
#include <vector>
 
namespace Belle2 {
  class SVDHitTimeSelectionFunction : public TObject {
 
  public:
 
    typedef bool (SVDHitTimeSelectionFunction::*selFunction)(double, double, double, double) const;
 
    bool isInTime(double svdTime, double svdTimeError = 0, double t0 = 0 , double t0Error = 0) const
    {
      selFunction f = m_implementations[m_current];
      return (this->*f)(svdTime, svdTimeError, t0, t0Error) ;
    }
 
    bool areClustersInTime(double uTime, double vTime) const
    {
      if (abs(uTime - vTime) > m_maxUVTimeDifference)
        return false;
      return true;
    }
    float m_maxUVTimeDifference = 100; 
    SVDHitTimeSelectionFunction()
    {
      // The m_implementations vector is static.
      // We have to initialize it just once.
      if (m_implementations.size() == 0) {
        m_implementations.push_back(&SVDHitTimeSelectionFunction::firstVersion);
        m_implementations.push_back(&SVDHitTimeSelectionFunction::secondVersion);
        m_implementations.push_back(&SVDHitTimeSelectionFunction::thirdVersion);
      }
 
      m_current = 0; //firstVersion is the default //m_implementations.size() - 1;
      m_deltaT = 100; //ns
      m_nSigma = 100;
      m_tMin = -999; //ns
    };
 
    //    SVDHitTimeSelectionFunction(const Belle2::SVDHitTimeSelectionFunction& a);
 
    //implementation: function version
    void setFunctionID(int user_current) {m_current = user_current;}
    int getFunctionID() const {return m_current;}
 
    //implementation firstVersion, setters and getters
    void setMinTime(double tMin) { m_tMin = tMin; }
    float getMinTime() const { return m_tMin; };
 
    //implementation secondVersion, setters and getters
    void setDeltaTime(double deltaT) { m_deltaT = deltaT; }
    float getDeltaTime() const { return m_deltaT; };
 
    //implementation thirdVersion, setters and getters
    void setNsigma(double nSigma) { m_nSigma = nSigma; }
    float getNsigma() const { return m_nSigma; };
 
    //max U-V time difference
    void setMaxUVTimeDifference(double timeDiff) { m_maxUVTimeDifference = timeDiff; }
    float getMaxUVTimeDifference() const { return m_maxUVTimeDifference; }
  private:
 
    bool firstVersion(double svdTime, double /* svdTimeError */, double /* t0 */, double /* t0Error */) const
    {
      return svdTime > m_tMin;
    };
    double m_tMin; 
    bool secondVersion(double svdTime, double /* svdTimeError */, double t0, double /* t0Error */) const
    {
      return fabs(svdTime - t0) < m_deltaT;
    };
    double m_deltaT; 
    bool thirdVersion(double svdTime, double svdTimeError, double t0, double t0Error) const
    {
      float err2 = svdTimeError * svdTimeError + t0Error * t0Error;
      return (svdTime - t0) * (svdTime - t0) < m_nSigma * m_nSigma * err2;
    };
    double m_nSigma; 
    int m_current;
    static std::vector < selFunction > m_implementations; 
 
 
    ClassDef(SVDHitTimeSelectionFunction, 3) 
  };
 
}