V0Fitter.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/datastore/StoreArray.h>
#include <framework/gearbox/Const.h>
#include <mdst/dataobjects/TrackFitResult.h>
#include <mdst/dataobjects/V0.h>
#include <tracking/dataobjects/V0ValidationVertex.h>
#include <tracking/dataobjects/RecoTrack.h>
#include <genfit/Track.h>
 
#include <TVector3.h>
 
#include <utility>
 
namespace genfit {
  class MeasuredStateOnPlane;
  class GFRaveVertex;
  class Track;
}
 
namespace Belle2 {
  class V0Fitter {
    friend class V0FitterTest_GetTrackHypotheses_Test;
    friend class V0FitterTest_EnableValidation_Test;
    friend class V0FitterTest_InitializeCuts_Test;
 
  public:
    V0Fitter(const std::string& trackFitResultsName = "", const std::string& v0sName = "",
             const std::string& v0ValidationVerticesName = "",
             const std::string& recoTracksName = "",
             const std::string& copiedRecoTracksName = "CopiedRecoTracks",
             bool enableValidation = false);
 
    void initializeCuts(double beamPipeRadius,
                        double vertexChi2CutOutside,
                        std::tuple<double, double> invMassRangeKshort,
                        std::tuple<double, double> invMassRangeLambda,
                        std::tuple<double, double> invMassRangePhoton);
 
    void setFitterMode(int fitterMode);
 
    bool fitAndStore(const Track* trackPlus, const Track* trackMinus, const Const::ParticleType& v0Hypothesis, bool& isForceStored,
                     bool&  isHitRemoved);
 
    std::pair<Const::ParticleType, Const::ParticleType> getTrackHypotheses(const Const::ParticleType& v0Hypothesis) const;
 
  private:
 
    bool vertexFitWithRecoTracks(const Track* trackPlus, const Track* trackMinus,
                                 RecoTrack* recoTrackPlus, RecoTrack* recoTrackMinus,
                                 const Const::ParticleType& v0Hypothesis,
                                 unsigned int& hasInnerHitStatus, TVector3& vertexPos,
                                 const bool forceStore);
 
    RecoTrack* copyRecoTrack(RecoTrack* origRecoTrack);
 
    RecoTrack* copyRecoTrackAndFit(RecoTrack* origRecoTrack, const int trackPDG);
 
    bool removeInnerHits(RecoTrack* prevRecoTrack, RecoTrack* recoTrack,
                         const int trackPDG, const TVector3& vertexPosition);
 
    int checkSharedInnermostCluster(const RecoTrack* recoTrackPlus, const RecoTrack* recoTrackMinus);
 
    bool fitGFRaveVertex(genfit::Track& trackPlus, genfit::Track& trackMinus, genfit::GFRaveVertex& vertex);
 
    bool extrapolateToVertex(genfit::MeasuredStateOnPlane& stPlus, genfit::MeasuredStateOnPlane& stMinus,
                             const TVector3& vertexPosition);
 
    bool extrapolateToVertex(genfit::MeasuredStateOnPlane& stPlus, genfit::MeasuredStateOnPlane& stMinus,
                             const TVector3& vertexPosition, unsigned int& hasInnerHitStatus);
 
    double getBzAtVertex(const TVector3& vertexPosition);
 
    TrackFitResult* buildTrackFitResult(const genfit::Track& track, const RecoTrack* recoTrack,
                                        const genfit::MeasuredStateOnPlane& msop, const double Bz,
                                        const Const::ParticleType& trackHypothesis,
                                        const int sharedInnermostCluster);
 
 
  private:
    bool m_validation;  
    std::string m_recoTracksName;   
    StoreArray<RecoTrack> m_recoTracks; 
    StoreArray<TrackFitResult> m_trackFitResults;  
    StoreArray<V0> m_v0s;  
    StoreArray<V0ValidationVertex> m_validationV0s;  
    StoreArray<RecoTrack> m_copiedRecoTracks; 
 
    double m_beamPipeRadius;  
    double m_vertexChi2CutOutside;  
    std::tuple<double, double> m_invMassRangeKshort; 
    std::tuple<double, double> m_invMassRangeLambda; 
    std::tuple<double, double> m_invMassRangePhoton; 
    int    m_v0FitterMode;  
    bool   m_forcestore;
    bool   m_useOnlyOneSVDHitPair;
  };
 
}