VXDMomentumEstimationMeasurementCreator.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/creators/BaseMeasurementCreatorFromCoordinateMeasurement.h>
#include <tracking/vxdMomentumEstimation/VXDMomentumEstimation.h>
#include <tracking/trackFitting/measurementCreator/measurements/PlanarVXDMomentumMeasurement.h>
#include <genfit/PlanarMeasurement.h>
 
namespace Belle2 {
  template <class HitType, Const::EDetector detector>
  class VXDMomentumEstimationMeasurementCreator : public BaseMeasurementCreatorFromCoordinateMeasurement<HitType, detector> {
  public:
    explicit VXDMomentumEstimationMeasurementCreator(const genfit::MeasurementFactory<genfit::AbsMeasurement>& measurementFactory) :
      BaseMeasurementCreatorFromCoordinateMeasurement<HitType, detector>(measurementFactory) {}
 
    virtual ~VXDMomentumEstimationMeasurementCreator() { }
 
    void setParameter(const std::string& parameterName, const std::string& parameterValue) override
    {
      if (parameterName == "minimumMomentum") {
        m_minimumMomentum = std::stod(parameterValue);
      } else if (parameterName == "aE") {
        m_fitParameters.aE = std::stod(parameterValue);
      } else if (parameterName == "bE") {
        m_fitParameters.bE = std::stod(parameterValue);
      } else if (parameterName == "cE") {
        m_fitParameters.cE = std::stod(parameterValue);
      } else if (parameterName == "dE") {
        m_fitParameters.dE = std::stod(parameterValue);
      } else if (parameterName == "aM") {
        m_correctionFitParameters.aM = std::stod(parameterValue);
      } else if (parameterName == "bM") {
        m_correctionFitParameters.bM = std::stod(parameterValue);
      } else if (parameterName == "cM") {
        m_correctionFitParameters.cM = std::stod(parameterValue);
      } else if (parameterName == "dM") {
        m_correctionFitParameters.dM = std::stod(parameterValue);
      } else if (parameterName == "useMCInformation") {
        m_useMCInformation = std::stoi(parameterValue);
      } else if (parameterName == "useThickness") {
        m_useThickness = std::stoi(parameterValue);
      } else if (parameterName == "sigma") {
        m_sigma = std::stod(parameterValue);
      } else if (parameterName == "useTrackingSeeds") {
        m_useTrackingSeeds = std::stoi(parameterValue);
      } else {
        B2FATAL("A parameter with the name " << parameterName << " and the value " << parameterValue << " could not be set.");
      }
    }
 
  protected:
    virtual std::vector<genfit::AbsMeasurement*> createMeasurementFromCoordinateMeasurement(HitType* hit,
        const RecoTrack& recoTrack, const RecoHitInformation&,
        genfit::AbsMeasurement* coordinateMeasurement) const override
    {
      genfit::PlanarMeasurement* planarMeasurement = dynamic_cast<genfit::PlanarMeasurement*>(coordinateMeasurement);
      if (planarMeasurement == nullptr) {
        B2FATAL("Can only add VXD hits which are based on PlanarMeasurements with momentum estimation!");
        // Make CPP check happy
        return {};
      }
 
      const ROOT::Math::XYZVector& momentum = recoTrack.getMomentumSeed();
 
      if (momentum.R() > m_minimumMomentum) {
        return {};
      }
 
      // cppcheck-suppress nullPointerRedundantCheck
      PlanarVXDMomentumMeasurement<HitType>* momentumMeasurement = new PlanarVXDMomentumMeasurement<HitType>(*planarMeasurement, hit,
          &recoTrack);
      momentumMeasurement->setCorrectionFitParameters(m_correctionFitParameters);
      momentumMeasurement->setFitParameters(m_fitParameters);
      momentumMeasurement->setSigma(m_sigma);
      momentumMeasurement->setUseMCInformation(m_useMCInformation);
      momentumMeasurement->setUseThickness(m_useThickness);
      momentumMeasurement->setUseTrackingSeeds(m_useTrackingSeeds);
      return {momentumMeasurement};
    }
 
  private:
    typename VXDMomentumEstimation<HitType>::FitParameters m_fitParameters;
    typename VXDMomentumEstimation<HitType>::CorrectionFitParameters m_correctionFitParameters;
    bool m_useMCInformation = false;
    bool m_useThickness = false;
    double m_minimumMomentum = 0.1;
    double m_sigma = 0.03;
    bool m_useTrackingSeeds = false;
  };
 
  using SVDMomentumMeasurementCreator = VXDMomentumEstimationMeasurementCreator<RecoHitInformation::UsedSVDHit, Const::SVD>;
  using PXDMomentumMeasurementCreator = VXDMomentumEstimationMeasurementCreator<RecoHitInformation::UsedPXDHit, Const::PXD>;
}