KLMLikelihoodParameters.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: KLM group                                                *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
**************************************************************************/
#pragma once
 
/* KLM headers. */
#include <klm/muid/MuidElementNumbers.h>
 
/* ROOT headers. */
#include <TObject.h>
 
/* C++ headers. */
#include <map>
 
namespace Belle2 {
  class KLMLikelihoodParameters : public TObject {
 
  public:
 
    KLMLikelihoodParameters()
    {
    }
 
    ~KLMLikelihoodParameters()
    {
    }
 
    void setLongitudinalPDF(int hypothesis, int outcome, int lastLayer, const std::vector<double>& params)
    {
      const int id =  MuidElementNumbers::getLongitudinalID(hypothesis, outcome, lastLayer);
      setLongitudinalPDF(id, params);
    }
 
    void setTransversePDF(int hypothesis, int detector, int degreesOfFreedom, const std::vector<double>& params)
    {
      int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      setTransversePDF(id, params);
    }
 
    void setTransverseThreshold(int hypothesis, int detector, int degreesOfFreedom, const double threshold)
    {
      int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      setTransverseThreshold(id, threshold);
    }
 
    void setTransverseScaleX(int hypothesis, int detector, int degreesOfFreedom, const double scaleX)
    {
      int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      setTransverseScaleX(id, scaleX);
    }
 
    void setTransverseScaleY(int hypothesis, int detector, int degreesOfFreedom, const double scaleY)
    {
      int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      setTransverseScaleY(id, scaleY);
    }
 
    const std::vector<double>& getLongitudinalPDF(int hypothesis, int outcome, int lastLayer) const
    {
      const int id = MuidElementNumbers::getLongitudinalID(hypothesis, outcome, lastLayer);
      return getLongitudinalPDF(id);
    }
 
    const std::vector<double>& getTransversePDF(int hypothesis, int detector, int degreesOfFreedom) const
    {
      const int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      return getTransversePDF(id);
    }
 
    double getTransverseThreshold(int hypothesis, int detector, int degreesOfFreedom) const
    {
      const int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      return getTransverseThreshold(id);
    }
 
    double getTransverseScaleX(int hypothesis, int detector, int degreesOfFreedom) const
    {
      const int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      return getTransverseScaleX(id);
    }
 
    double getTransverseScaleY(int hypothesis, int detector, int degreesOfFreedom) const
    {
      const int id = MuidElementNumbers::getTransverseID(hypothesis, detector, degreesOfFreedom);
      return getTransverseScaleY(id);
    }
 
  private:
 
    void setLongitudinalPDF(const int id, const std::vector<double>& params)
    {
      m_LongitudinalPDF.insert(std::pair<int, std::vector<double>>(id, params));
    }
 
    void setTransversePDF(const int id, const std::vector<double>& params)
    {
      m_TransversePDF.insert(std::pair<int, std::vector<double>>(id, params));
    }
 
    void setTransverseThreshold(const int id, const double threshold)
    {
      m_TransverseThreshold.insert(std::pair<int, double>(id, threshold));
    }
 
    void setTransverseScaleX(const int id, const double scaleX)
    {
      m_TransverseScaleX.insert(std::pair<int, double>(id, scaleX));
    }
 
    void setTransverseScaleY(const int id, const double scaleY)
    {
      m_TransverseScaleY.insert(std::pair<int, double>(id, scaleY));
    }
 
    const std::vector<double>& getLongitudinalPDF(const int id) const;
 
    const std::vector<double>& getTransversePDF(const int id) const;
 
    double getTransverseThreshold(const int id) const;
 
    double getTransverseScaleX(const int id) const;
 
    double getTransverseScaleY(const int id) const;
 
    std::map<int, std::vector<double>> m_LongitudinalPDF;
 
    std::map<int, std::vector<double>> m_TransversePDF;
 
    std::map<int, double> m_TransverseThreshold;
 
    std::map<int, double> m_TransverseScaleX;
 
    std::map<int, double> m_TransverseScaleY;
 
    ClassDef(KLMLikelihoodParameters, 1);
 
  };
 
}