KLMMuidLikelihood.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
 
/* KLM headers. */
#include <klm/dataobjects/bklm/BKLMElementNumbers.h>
#include <klm/dataobjects/eklm/EKLMElementNumbers.h>
 
/* Basf2 headers. */
#include <framework/datastore/RelationsObject.h>
#include <framework/gearbox/Const.h>
 
namespace Belle2 {
  class KLMMuidLikelihood : public RelationsObject {
 
  public:
 
    KLMMuidLikelihood();
 
    ~KLMMuidLikelihood();
 
    int getPDGCode() const
    {
      return m_PDGCode;
    }
 
    int getCharge() const;
 
    double getPDFValue(int pdg) const
    {
      return m_PDFValue[Const::ChargedStable(pdg).getIndex()];
    }
 
    double getMuonPDFValue() const
    {
      return getPDFValue(Const::muon.getPDGCode());
    }
 
    double getPionPDFValue() const
    {
      return getPDFValue(Const::pion.getPDGCode());
    }
 
    double getKaonPDFValue() const
    {
      return getPDFValue(Const::kaon.getPDGCode());
    }
 
    double getProtonPDFValue() const
    {
      return getPDFValue(Const::proton.getPDGCode());
    }
 
    double getDeuteronPDFValue() const
    {
      return getPDFValue(Const::deuteron.getPDGCode());
    }
 
    double getElectronPDFValue() const
    {
      return getPDFValue(Const::electron.getPDGCode());
    }
 
    bool getJunkPDFValue() const
    {
      return m_JunkPDFValue;
    }
 
    double getLogL(int pdg) const
    {
      return m_LogL[Const::ChargedStable(pdg).getIndex()];
    }
 
    double getLogL_mu() const
    {
      return getLogL(Const::muon.getPDGCode());
    }
 
    double getLogL_pi() const
    {
      return getLogL(Const::pion.getPDGCode());
    }
 
    double getLogL_K() const
    {
      return getLogL(Const::kaon.getPDGCode());
    }
 
    double getLogL_p() const
    {
      return getLogL(Const::proton.getPDGCode());
    }
 
    double getLogL_d() const
    {
      return getLogL(Const::deuteron.getPDGCode());
    }
 
    double getLogL_e() const
    {
      return getLogL(Const::electron.getPDGCode());
    }
 
    double getChiSquared() const
    {
      return m_ChiSquared;
    }
 
    int getDegreesOfFreedom() const
    {
      return m_DegreesOfFreedom;
    }
 
    unsigned int getOutcome() const
    {
      return m_Outcome;
    }
 
    bool getIsForward() const
    {
      return m_IsForward;
    }
 
    int getBarrelExtLayer() const
    {
      return m_BarrelExtLayer;
    }
 
    int getEndcapExtLayer() const
    {
      return m_EndcapExtLayer;
    }
 
    int getExtLayer() const
    {
      return m_ExtLayer;
    }
 
    int getBarrelHitLayer() const
    {
      return m_BarrelHitLayer;
    }
 
    int getEndcapHitLayer() const
    {
      return m_EndcapHitLayer;
    }
 
    int getHitLayer() const
    {
      return m_HitLayer;
    }
 
    unsigned int getExtLayerPattern() const
    {
      return m_ExtLayerPattern;
    }
 
    unsigned int getHitLayerPattern() const
    {
      return m_HitLayerPattern;
    }
 
    unsigned int getTotalBarrelHits() const;
 
    unsigned int getTotalEndcapHits() const;
 
    float getExtBKLMEfficiencyValue(int layer) const
    {
      return m_ExtBKLMEfficiencyValue[layer];
    }
 
    float getExtEKLMEfficiencyValue(int layer) const
    {
      return m_ExtEKLMEfficiencyValue[layer];
    }
 
    void setPDGCode(int pdg)
    {
      m_PDGCode = pdg;
    }
 
    void setPDFValue(double pdfValue, int pdg)
    {
      m_PDFValue[Const::ChargedStable(pdg).getIndex()] = pdfValue;
    }
 
    void setMuonPDFValue(double pdfValue)
    {
      setPDFValue(pdfValue, Const::muon.getPDGCode());
    }
 
    void setPionPDFValue(double pdfValue)
    {
      setPDFValue(pdfValue, Const::pion.getPDGCode());
    }
 
    void setKaonPDFValue(double pdfValue)
    {
      setPDFValue(pdfValue, Const::kaon.getPDGCode());
    }
 
    void setProtonPDFValue(double pdfValue)
    {
      setPDFValue(pdfValue, Const::proton.getPDGCode());
    }
 
    void setDeuteronPDFValue(double pdfValue)
    {
      setPDFValue(pdfValue, Const::deuteron.getPDGCode());
    }
 
    void setElectronPDFValue(double pdfValue)
    {
      setPDFValue(pdfValue, Const::electron.getPDGCode());
    }
 
    void setJunkPDFValue(bool flag)
    {
      m_JunkPDFValue = flag;
    }
 
    void setLogL(double logL, int pdg)
    {
      m_LogL[Const::ChargedStable(pdg).getIndex()] = logL;
    }
 
    void setLogL_mu(double logL)
    {
      setLogL(logL, Const::muon.getPDGCode());
    }
 
    void setLogL_pi(double logL)
    {
      setLogL(logL, Const::pion.getPDGCode());
    }
 
    void setLogL_K(double logL)
    {
      setLogL(logL, Const::kaon.getPDGCode());
    }
 
    void setLogL_p(double logL)
    {
      setLogL(logL, Const::proton.getPDGCode());
    }
 
    void setLogL_d(double logL)
    {
      setLogL(logL, Const::deuteron.getPDGCode());
    }
 
    void setLogL_e(double logL)
    {
      setLogL(logL, Const::electron.getPDGCode());
    }
 
    void setChiSquared(double chiSquared)
    {
      m_ChiSquared = chiSquared;
    }
 
    void setDegreesOfFreedom(int dof)
    {
      m_DegreesOfFreedom = dof;
    }
 
    void setOutcome(unsigned int outcome)
    {
      m_Outcome = outcome;
    }
 
    void setIsForward(bool isForward)
    {
      m_IsForward = isForward;
    }
 
    void setBarrelExtLayer(int layer)
    {
      m_BarrelExtLayer = layer;
    }
 
    void setEndcapExtLayer(int layer)
    {
      m_EndcapExtLayer = layer;
    }
 
    void setExtLayer(int layer)
    {
      m_ExtLayer = layer;
    }
 
    void setBarrelHitLayer(int layer)
    {
      m_BarrelHitLayer = layer;
    }
 
    void setEndcapHitLayer(int layer)
    {
      m_EndcapHitLayer = layer;
    }
 
    void setHitLayer(int layer)
    {
      m_HitLayer = layer;
    }
 
    void setExtLayerPattern(unsigned int pattern)
    {
      m_ExtLayerPattern = pattern;
    }
 
    void setHitLayerPattern(unsigned int pattern)
    {
      m_HitLayerPattern = pattern;
    }
 
    void setExtBKLMEfficiencyValue(int layer, float efficiency)
    {
      m_ExtBKLMEfficiencyValue[layer] = efficiency;
    }
 
    void setExtEKLMEfficiencyValue(int layer, float efficiency)
    {
      m_ExtEKLMEfficiencyValue[layer] = efficiency;
    }
 
    bool isExtrapolatedBarrelLayerCrossed(int layer) const;
 
    bool isExtrapolatedEndcapLayerCrossed(int layer) const;
 
  private:
 
    int m_PDGCode;
 
    float m_PDFValue[Const::ChargedStable::c_SetSize];
 
    bool m_JunkPDFValue;
 
    float m_LogL[Const::ChargedStable::c_SetSize];
 
    float m_ChiSquared;
 
    int m_DegreesOfFreedom;
 
    unsigned int m_Outcome;
 
    bool m_IsForward;
 
    int m_BarrelExtLayer;
 
    int m_EndcapExtLayer;
 
    int m_ExtLayer;
 
    int m_BarrelHitLayer;
 
    int m_EndcapHitLayer;
 
    int m_HitLayer;
 
    unsigned int m_ExtLayerPattern;
 
    unsigned int m_HitLayerPattern;
 
    float m_ExtBKLMEfficiencyValue[BKLMElementNumbers::getMaximalLayerNumber()];
 
    float m_ExtEKLMEfficiencyValue[EKLMElementNumbers::getMaximalLayerNumber()];
 
    ClassDef(KLMMuidLikelihood, 4)
 
  };
}