TrackFitResult.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/gearbox/Const.h>
#include <framework/datastore/RelationsObject.h>
#include <framework/dataobjects/Helix.h>
#include <framework/dataobjects/UncertainHelix.h>
#include <framework/geometry/BFieldManager.h>
 
#include <TVector3.h>
#include <TMatrixDSym.h>
#include <Math/Vector4D.h>
 
#include <stdint.h>
#include <vector>
#include <cmath>
 
namespace Belle2 {
  class HitPatternCDC;
  class HitPatternVXD;
 
  class TrackFitResult : public RelationsObject {
  public:
    TrackFitResult();
 
    TrackFitResult(const TVector3& position, const TVector3& momentum,
                   const TMatrixDSym& covariance, const short int charge,
                   const Const::ParticleType& particleType, const float pValue,
                   const float bField,
                   const uint64_t hitPatternCDCInitializer,
                   const uint32_t hitPatternVXDInitializer,
                   const uint16_t NDF);
 
    TrackFitResult(const std::vector<float>& tau, const std::vector<float>& cov5,
                   const Const::ParticleType& particleType, const float pValue,
                   const uint64_t hitPatternCDCInitializer,
                   const uint32_t hitPatternVXDInitializer,
                   const uint16_t NDF
                  );
 
    TVector3 getPosition() const { return getHelix().getPerigee(); }
 
    TVector3 getMomentum() const
    {
      const double bField = BFieldManager::getField(getPosition()).Z() / Unit::T;
      return getHelix().getMomentum(bField);
    }
 
    ROOT::Math::PxPyPzEVector get4Momentum() const
    {
      const B2Vector3D momentum = getMomentum();
      return ROOT::Math::PxPyPzEVector(momentum.x(), momentum.y(), momentum.z(), getEnergy());
    }
 
    double getEnergy() const
    {
      return std::sqrt(getMomentum().Mag2() + getParticleType().getMass() * getParticleType().getMass());
    }
 
    double getTransverseMomentum() const
    {
      const double bField = BFieldManager::getField(getPosition()).Z() / Unit::T;
      return getHelix().getTransverseMomentum(bField);
    }
 
    TMatrixDSym getCovariance6() const
    {
      const double bField = BFieldManager::getField(getPosition()).Z() / Unit::T;
      return getUncertainHelix().getCartesianCovariance(bField);
    }
 
    Const::ParticleType getParticleType() const { return Const::ParticleType(m_pdg); }
 
    short getChargeSign() const { return (getOmega() > 0) - (getOmega() < 0); }
 
    double getPValue() const { return m_pValue; }
 
    int getNDF() const;
 
    double getChi2() const;
 
    //------------------------------------------------------------------------
    // --- Getters for perigee helix parameters
    //------------------------------------------------------------------------
    double getD0() const { return m_tau[iD0]; }
 
    double getPhi0() const { return m_tau[iPhi0]; }
 
    double getPhi() const { return getPhi0(); }
 
    double getOmega() const { return m_tau[iOmega]; }
 
    double getZ0() const { return m_tau[iZ0]; }
 
    double getTanLambda() const { return m_tau[iTanLambda]; }
 
    double getCotTheta() const { return getTanLambda(); }
 
    std::vector<float> getTau() const { return std::vector<float>(m_tau, m_tau + c_NPars); }
 
    std::vector<float> getCov() const { return std::vector<float>(m_cov5, m_cov5 + c_NCovEntries); }
 
    TMatrixDSym getCovariance5() const;
 
    Helix getHelix() const
    { return Helix(getD0(), getPhi0(), getOmega(), getZ0(), getTanLambda()); }
 
    Helix getHelix(float momentumScale) const
    { return Helix(getD0(), getPhi0(), getOmega() / momentumScale, getZ0(), getTanLambda()); }
 
    UncertainHelix getUncertainHelix() const
    {
      return UncertainHelix(getD0(), getPhi0(), getOmega(), getZ0(),
                            getTanLambda(), getCovariance5(), getPValue());
    }
 
    HitPatternCDC getHitPatternCDC() const;
 
    HitPatternVXD getHitPatternVXD() const;
 
    virtual std::string getInfoHTML() const override;
 
  private:
 
    //---------------------------------------------------------------------------------------------------------------------------
    const unsigned int m_pdg;
 
    const Double32_t m_pValue;
 
    static const unsigned int c_NPars = 5; 
    static const unsigned int c_NCovEntries = 5 * 6 / 2; 
    static const unsigned int iD0 = 0;        
    static const unsigned int iPhi0 = 1;      
    static const unsigned int iOmega = 2;     
    static const unsigned int iZ0 = 3;        
    static const unsigned int iTanLambda = 4; 
    Double32_t m_tau[c_NPars];
 
    Double32_t m_cov5[c_NCovEntries];
 
    uint64_t m_hitPatternCDCInitializer;
    const uint32_t m_hitPatternVXDInitializer;
 
    static const uint16_t c_NDFFlag = 0xFFFF;
 
    uint16_t m_NDF;
 
    ClassDefOverride(TrackFitResult, 8); 
    /* Version history:
       ver 8: add NDF
       ver 7: fixed sign errors in the translation of position and momentum covariances.
       ver 6: use fixed size arrays instead of vectors (add schema evolution rule), use Double32_t.
       ver 5: CDC Hit Pattern now a single variable (add schema evolution rule).
       ver 4: added hit pattern
       ver 3: back to vectors for the elements
       ver 4: fixed-size arrays for the elements  <------- incompatible with later version 4
       ver 3: add data fields for hit patterns
       ver 2: re-arranging of members
       ver 1:
       ver 2:                                     <------- incompatible with later version 2
       ver 1:
    */
  };
}