TrackFitter.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 <tracking/trackFitting/measurementCreator/adder/MeasurementAdder.h>
#include <framework/gearbox/Const.h>
#include <framework/core/Environment.h>
#include <tracking/dbobjects/DAFParameters.h>
#include <tracking/dbobjects/DAFConfiguration.h>
 
#include <TError.h>
 
#include <string>
#include <memory>
 
namespace genfit {
  class AbsFitter;
  class AbsTrackRep;
}
 
namespace Belle2 {
 
  class RecoTrack;

  class TrackFitter {
  public:
    static constexpr double s_defaultDeltaPValue = 1.0;
    static constexpr double s_defaultProbCut = 0.001;
    static constexpr unsigned int s_defaultMaxFailedHits = 5;

    explicit TrackFitter(const DAFConfiguration::ETrackFitType trackFitType = DAFConfiguration::c_Default,
                         const std::string& storeArrayNameOfPXDHits = "",
                         const std::string& storeArrayNameOfSVDHits = "",
                         const std::string& storeArrayNameOfCDCHits = "",
                         const std::string& storeArrayNameOfBKLMHits = "",
                         const std::string& storeArrayNameOfEKLMHits = "",
                         const bool initializeCDCTranslators = true,
                         bool fromTrackCreator = false):
      m_measurementAdder(storeArrayNameOfPXDHits, storeArrayNameOfSVDHits, storeArrayNameOfCDCHits,
                         storeArrayNameOfBKLMHits, storeArrayNameOfEKLMHits, initializeCDCTranslators, fromTrackCreator)
    {
      if (Environment::Instance().isCosmicRun()) {
        // Resetting with parameters for cosmics data
        resetFitterToCosmicsSettings();
      } else {
        // Resetting with parameters for beam data
        resetFitterToDBSettings(trackFitType);
      }
    }

    static int createCorrectPDGCodeForChargedStable(const Const::ChargedStable& particleType, const RecoTrack& recoTrack);

    void resetFitter(const std::shared_ptr<genfit::AbsFitter>& fitter);

    void resetFitterToDBSettings(const DAFConfiguration::ETrackFitType trackFitType = DAFConfiguration::c_Default);

    void resetFitterToUserSettings(const DAFParameters* DAFParams);

    void resetFitterToCosmicsSettings();

    bool fit(RecoTrack& recoTrack, genfit::AbsTrackRep* trackRepresentation, bool resortHits = false) const;

    bool fit(RecoTrack& recoTrack, const Const::ChargedStable& particleType, bool resortHits = false) const;

    bool fit(RecoTrack& recoTrack, const int pdgCode, bool resortHits = false) const;

    bool fit(RecoTrack& recoTrack, bool resortHits = false) const;

    void resetMeasurementCreatorsToDefaultSettings()
    {
      m_measurementAdder.resetMeasurementCreatorsToDefaultSettings();
    }

    void resetMeasurementCreators(
      const std::vector<std::shared_ptr<PXDBaseMeasurementCreator>>& pxdMeasurementCreators,
      const std::vector<std::shared_ptr<SVDBaseMeasurementCreator>>& svdMeasurementCreators,
      const std::vector<std::shared_ptr<CDCBaseMeasurementCreator>>& cdcMeasurementCreators,
      const std::vector<std::shared_ptr<BKLMBaseMeasurementCreator>>& bklmMeasurementCreators,
      const std::vector<std::shared_ptr<EKLMBaseMeasurementCreator>>& eklmMeasurementCreators,
      const std::vector<std::shared_ptr<BaseMeasurementCreator>>& additionalMeasurementCreators)
    {
      m_measurementAdder.resetMeasurementCreators(pxdMeasurementCreators,
                                                  svdMeasurementCreators,
                                                  cdcMeasurementCreators,
                                                  bklmMeasurementCreators,
                                                  eklmMeasurementCreators,
                                                  additionalMeasurementCreators);
    }

    void resetMeasurementCreatorsUsingFactories(
      const std::map<std::string, std::map<std::string, std::string>>& pxdMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& svdMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& cdcMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& bklmMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& eklmMeasurementCreators,
      const std::map<std::string, std::map<std::string, std::string>>& additionalMeasurementCreators)
    {
      m_measurementAdder.resetMeasurementCreatorsUsingFactories(pxdMeasurementCreators,
                                                                svdMeasurementCreators,
                                                                cdcMeasurementCreators,
                                                                bklmMeasurementCreators,
                                                                eklmMeasurementCreators,
                                                                additionalMeasurementCreators);
    }

    void setgErrorIgnoreLevel(Int_t errorIgnoreLevel) { m_gErrorIgnoreLevel = errorIgnoreLevel; }

    Int_t getgErrorIgnoreLevel() { return m_gErrorIgnoreLevel; }
 
  private:
    std::shared_ptr<genfit::AbsFitter> m_fitter;

    bool m_skipDirtyCheck = false;

    MeasurementAdder m_measurementAdder;

    Int_t m_gErrorIgnoreLevel = kFatal;

    DBObjPtr<DAFConfiguration> m_DAFConfiguration;

    bool fitWithoutCheck(RecoTrack& recoTrack, const genfit::AbsTrackRep& trackRepresentation, bool resortHits = false) const;
  };

}