MuonExperimental::Gx2Fitter< propagator_t, traj_t > Class Template Reference

Global Chi Square fitter (GX2F) implementation. More...

#include <Chi2Fitter.h>

Collaboration diagram for MuonExperimental::Gx2Fitter< propagator_t, traj_t >:

Classes
class	GX2FActor
	Propagator Actor plugin for the GX2F. More...

Public Member Functions
	Gx2Fitter (const propagator_t &pPropagator, std::unique_ptr< const Logger > log=getDefaultLogger("Gx2Fitter", Logging::INFO))
	Constructor for the Global Chi-Square Fitter.
template<typename source_link_iterator_t, TrackContainerFrontend track_container_t> requires (!std::is_same_v<Gx2fNavigator, DirectNavigator>)
Result< typename track_container_t::TrackProxy >	fit (source_link_iterator_t it, source_link_iterator_t end, const BoundTrackParameters &sParameters, const Gx2FitterOptions< traj_t > &gx2fOptions, track_container_t &trackContainer) const
	Fit implementation.

Private Types
using	Gx2fNavigator = typename propagator_t::Navigator
	The navigator type.

Private Member Functions
const Logger &	logger () const

Private Attributes
propagator_t	m_propagator
	The propagator for the transport and material update.
std::unique_ptr< const Logger >	m_logger
	The logger instance.
std::unique_ptr< const Logger >	m_actorLogger
std::unique_ptr< const Logger >	m_addToSumLogger

Static Private Attributes
static constexpr auto	kInvalid = kTrackIndexInvalid

Detailed Description

template<typename propagator_t, typename traj_t>
class MuonExperimental::Gx2Fitter< propagator_t, traj_t >

Global Chi Square fitter (GX2F) implementation.

Template Parameters

propagator_t

Type of the propagation class

TODO Write description

Definition at line 713 of file Chi2Fitter.h.

Member Typedef Documentation

Gx2fNavigator

template<typename propagator_t, typename traj_t>

using MuonExperimental::Gx2Fitter< propagator_t, traj_t >::Gx2fNavigator = typename propagator_t::Navigator

private

The navigator type.

Definition at line 715 of file Chi2Fitter.h.

Constructor & Destructor Documentation

Gx2Fitter()

template<typename propagator_t, typename traj_t>

MuonExperimental::Gx2Fitter< propagator_t, traj_t >::Gx2Fitter ( const propagator_t & pPropagator, std::unique_ptr< const Logger > log = getDefaultLogger("Gx2Fitter< propagator_t, traj_t >", Logging::INFO) )

inlineexplicit

Constructor for the Global Chi-Square Fitter.

Initializes the fitter with a propagator and optional logger. The fitter uses iterative fitting with a linear equation system to minimize chi-squared including multiple scattering effects.

Parameters

pPropagator	The propagator instance for track propagation
_logger	Logger instance for debugging output (optional)

Definition at line 728 of file Chi2Fitter.h.

      : m_propagator(pPropagator), m_logger{std::move(log)} {}

Member Function Documentation

fit()

template<typename propagator_t, typename traj_t>

template<typename source_link_iterator_t, TrackContainerFrontend track_container_t>
requires (!std::is_same_v<Gx2fNavigator, DirectNavigator>)

Result< typename track_container_t::TrackProxy > MuonExperimental::Gx2Fitter< propagator_t, traj_t >::fit ( source_link_iterator_t it, source_link_iterator_t end, const BoundTrackParameters & sParameters, const Gx2FitterOptions< traj_t > & gx2fOptions, track_container_t & trackContainer ) const

inline

Fit implementation.

Template Parameters

source_link_iterator_t	Iterator type used to pass source links
track_container_t	Type of the track container backend
holder_t	Type defining track container backend ownership

Parameters

it	Begin iterator for the fittable uncalibrated measurements
end	End iterator for the fittable uncalibrated measurements
sParameters	The initial track parameters
gx2fOptions	Gx2FitterOptions steering the fit
trackContainer	Input track container storage to append into

Note

The input measurements are given in the form of SourceLink s. It's the calibrators job to turn them into calibrated measurements used in the fit.

Returns

the output as an output track

Actual Fitting /////////////////////////////////////////////////////////

Move back the material map

Finish Fitting /////////////////////////////////////////////////////////

Actual MATERIAL Fitting ////////////////////////////////////////////////

Finish MATERIAL Fitting ////////////////////////////////////////////////

Definition at line 1158 of file Chi2Fitter.h.

  {
    // Preprocess Measurements (SourceLinks -> map)
    // To be able to find measurements later, we put them into a map.
    // We need to copy input SourceLinks anyway, so the map can own them.
    ACTS_VERBOSE("Preparing " << std::distance(it, end)
                              << " input measurements");
    std::unordered_map<const Surface*, SourceLink> inputMeasurements{};
 
    for (; it != end; ++it) {
      inputMeasurements.try_emplace(gx2fOptions.extensions.surfaceAccessor(*it),
                                    *it);
    }
 
    using GX2FResult = typename GX2FActor::result_type;
    using Actors = Acts::ActorList<GX2FActor>;
 
    using PropagatorOptions = typename propagator_t::template Options<Actors>;
 
    BoundTrackParameters params = sParameters;
    params.covariance() = BoundMatrix::Identity();
    // params.
    double chi2sum = 0;
    double oldChi2sum = std::numeric_limits<double>::max();
 
    // We need to create a temporary track container. We create several times a
    // new track and delete it after updating the parameters. However, if we
    // would work on the externally provided track container, it would be
    // difficult to remove the correct track, if it contains more than one.
    typename track_container_t::TrackContainerBackend trackContainerTempBackend;
    traj_t trajectoryTempBackend;
    TrackContainer trackContainerTemp{trackContainerTempBackend,
                                      trajectoryTempBackend};
 
    // Create an index of the 'tip' of the track stored in multitrajectory. It
    // is needed outside the update loop. It will be updated with each iteration
    // and used for the final track
    std::size_t tipIndex = kInvalid;
 
    // The materialMap stores for each visited surface their scattering
    // properties
    std::unordered_map<GeometryIdentifier, Gx2fMaterialProperties> materialMap;
 
    // This will be filled during the updates with the final covariance of the
    // track parameters.
    BoundMatrix fullCovariancePredicted = BoundMatrix::Identity();
 
    ACTS_VERBOSE("Initial parameters: " << params.parameters().transpose());

    ACTS_DEBUG("Start to iterate");
 
    // Iterate the fit and improve result. Abort after n steps or after
    // convergence.
    // nUpdate is initialized outside to save its state for the track.
    std::size_t nUpdate = 0;
    for (nUpdate = 0; nUpdate < gx2fOptions.nUpdateMax; ++nUpdate) {
      ACTS_DEBUG("nUpdate = " << nUpdate + 1 << "/" << gx2fOptions.nUpdateMax);
 
      // set up propagator and co
      PropagatorOptions propagatorOptions{gx2fOptions.propagatorPlainOptions};
 
      // Add the measurement surface as external surface to the navigator.
      // We will try to hit those surface by ignoring boundary checks.
      for (const auto& [surface, _] : inputMeasurements) {
        propagatorOptions.navigation.registerMeasurementSurface(*surface);
      }
 
      auto& gx2fActor = propagatorOptions.actorList.template get<GX2FActor>();
      gx2fActor.inputMeasurements = &inputMeasurements;
      if (gx2fOptions.includeMaterialInIter) {
        gx2fActor.doMultipleScattering = gx2fOptions.doMultipleScattering;
        gx2fActor.doEnergyLoss = gx2fOptions.doEnergyLoss;
        gx2fActor.scatteringCutOff = gx2fOptions.scatteringCutOff;
        gx2fActor.elossCutOff = gx2fOptions.elossCutOff;
      }
      gx2fActor.extensions = gx2fOptions.extensions;
      gx2fActor.calibrationContext = &gx2fOptions.calibrationContext.get();
      gx2fActor.actorLogger = m_actorLogger.get();
      gx2fActor.startParameters = &params;
 
      auto propagatorState = m_propagator.makeState(propagatorOptions);
 
      auto propagatorInitResult =
          m_propagator.initialize(propagatorState, params, nullptr);
      if (!propagatorInitResult.ok()) {
        ACTS_DEBUG("Propagation initialization failed: "
                   << propagatorInitResult.error());
        return propagatorInitResult.error();
      }
 
      auto& r = propagatorState.template get<Gx2FitterResult<traj_t>>();
      r.fittedStates = &trajectoryTempBackend;
      r.materialMap = std::move(materialMap);
 
      // Clear the track container. It could be more performant to update the
      // existing states, but this needs some more thinking.
      trackContainerTemp.clear();
 
      // Run the fitter
      auto propagationResult = m_propagator.propagate(propagatorState);
 
      auto result =
          m_propagator.makeResult(std::move(propagatorState), propagationResult,
                                  propagatorOptions, false);
 
      if (!result.ok()) {
        ACTS_DEBUG("Propagation failed: " << result.error());
        return result.error();
      }
 
      // TODO Improve Propagator + Actor [allocate before loop], rewrite
      // makeMeasurements
      auto& propRes = *result;
      GX2FResult gx2fResult = std::move(propRes.template get<GX2FResult>());
      materialMap = std::move(gx2fResult.materialMap);
 
      auto track = trackContainerTemp.makeTrack();
      tipIndex = gx2fResult.lastMeasurementIndex;
 
      // It could happen, that no measurements were found. Then the track would
      // be empty and the following operations would be invalid. Usually, this
      // only happens during the first iteration, due to bad initial parameters.
      if (tipIndex == kInvalid) {
        ACTS_INFO("Did not find any measurements in nUpdate "
                  << nUpdate + 1 << "/" << gx2fOptions.nUpdateMax);
        return Experimental::GlobalChiSquareFitterError::NotEnoughMeasurements;
      }
 
      track.tipIndex() = tipIndex;
      track.linkForward();
 
      // System that we fill with the information gathered by the actor and
      // evaluate later
      Gx2fSystem extendedSystem{gx2fResult.materialParamIndices.back()};
 
      // This vector stores the IDs for each visited material in order. We use
      // it later for updating the scattering angles. We cannot use
      // materialMap directly, since we cannot guarantee, that we will visit
      // all stored material in each propagation.
      std::vector<GeometryIdentifier> geoIdVector;
 
      fillGx2fSystem(track, extendedSystem, materialMap,
                     gx2fResult.materialParamIndices, geoIdVector,
                     *m_addToSumLogger);
 
      chi2sum = extendedSystem.chi2();
 
      // This check takes into account the evaluated dimensions of the
      // measurements. To fit, we need at least NDF+1 measurements. However, we
      // count n-dimensional measurements for n measurements, reducing the
      // effective number of needed measurements. We might encounter the case,
      // where we cannot use some (parts of a) measurements, maybe if we do not
      // support that kind of measurement. This is also taken into account here.
      // We skip the check during the first iteration, since we cannot guarantee
      // to hit all/enough measurement surfaces with the initial parameter
      // guess.
      // We skip the check during the first iteration, since we cannot guarantee
      // to hit all/enough measurement surfaces with the initial parameter
      // guess.
      if ((nUpdate > 0) && !extendedSystem.isWellDefined()) {
        ACTS_INFO("Not enough measurements. Require "
                  << extendedSystem.findRequiredNdf() + 1 << ", but only "
                  << extendedSystem.ndf() << " could be used.");
        return Experimental::GlobalChiSquareFitterError::NotEnoughMeasurements;
      }
 
      Eigen::VectorXd deltaParamsExtended =
          computeGx2fDeltaParams(extendedSystem);
 
      ACTS_VERBOSE("aMatrix:\n"
                   << extendedSystem.aMatrix() << "\n"
                   << "bVector:\n"
                   << extendedSystem.bVector() << "\n"
                   << "deltaParamsExtended:\n"
                   << deltaParamsExtended << "\n"
                   << "oldChi2sum = " << oldChi2sum << "\n"
                   << "chi2sum = " << extendedSystem.chi2());
 
      if ((gx2fOptions.relChi2changeCutOff != 0) && (nUpdate > 0) &&
          (std::abs(extendedSystem.chi2() / oldChi2sum - 1) <
           gx2fOptions.relChi2changeCutOff)) {
        ACTS_DEBUG("Abort with relChi2changeCutOff after "
                   << nUpdate + 1 << "/" << gx2fOptions.nUpdateMax
                   << " iterations.");
        updateGx2fCovarianceParams(fullCovariancePredicted, extendedSystem);
        break;
      }
 
      if (extendedSystem.chi2() > oldChi2sum + 1e-5) {
        ACTS_DEBUG("chi2 not converging monotonically in update " << nUpdate);
      }
 
      // If this is the final iteration, update the covariance and break.
      // Otherwise, we would update the scattering angles too much.
      if (nUpdate == gx2fOptions.nUpdateMax - 1) {
        // Since currently most of our tracks converge in 4-5 updates, we want
        // to set nUpdateMax higher than that to guarantee convergence for most
        // tracks. In cases, where we set a smaller nUpdateMax, it's because we
        // want to investigate the behaviour of the fitter before it converges,
        // like in some unit-tests.
        if (gx2fOptions.nUpdateMax > 5) {
          ACTS_INFO("Did not converge in " << gx2fOptions.nUpdateMax
                                           << " updates.");
          return Experimental::GlobalChiSquareFitterError::DidNotConverge;
        }
 
        updateGx2fCovarianceParams(fullCovariancePredicted, extendedSystem);
        break;
      }
 
      updateGx2fParams(params, deltaParamsExtended, materialMap, geoIdVector);
      ACTS_VERBOSE("Updated parameters: " << params.parameters().transpose());
 
      oldChi2sum = extendedSystem.chi2();
    }
    ACTS_DEBUG("Iterations finished");
    ACTS_VERBOSE("Final parameters: " << params.parameters().transpose());
    ACTS_VERBOSE("Final scattering angles and energy loss:");
    for (const auto& [key, value] : materialMap) {
      if (!value.materialIsValid()) {
        continue;
      }
      ACTS_VERBOSE("    ( " << value.deltaTheta() << " | " << value.deltaPhi()
                            << "|" << value.lostEnergy() << " )");
    }

    if (!gx2fOptions.includeMaterialInIter &&
        (gx2fOptions.doEnergyLoss || gx2fOptions.doMultipleScattering)) {
      ACTS_DEBUG("Start to evaluate material");
 
      // Set up the propagator
      PropagatorOptions propagatorOptions{gx2fOptions.propagatorPlainOptions};
 
      // Add the measurement surface as external surface to the navigator.
      // We will try to hit those surface by ignoring boundary checks.
      for (const auto& [surface, _] : inputMeasurements) {
        propagatorOptions.navigation.registerMeasurementSurface(*surface);
      }
 
      auto& gx2fActor = propagatorOptions.actorList.template get<GX2FActor>();
      gx2fActor.inputMeasurements = &inputMeasurements;
      gx2fActor.doMultipleScattering = gx2fOptions.doMultipleScattering;
      gx2fActor.doEnergyLoss = gx2fOptions.doEnergyLoss;
      gx2fActor.extensions = gx2fOptions.extensions;
      gx2fActor.calibrationContext = &gx2fOptions.calibrationContext.get();
      gx2fActor.actorLogger = m_actorLogger.get();
      gx2fActor.startParameters = &params;
      gx2fActor.scatteringCutOff = gx2fOptions.scatteringCutOff;
      gx2fActor.elossCutOff = gx2fOptions.elossCutOff;
 
      auto propagatorState = m_propagator.makeState(propagatorOptions);
 
      auto propagatorInitResult =
          m_propagator.initialize(propagatorState, params, nullptr);
      if (!propagatorInitResult.ok()) {
        ACTS_DEBUG("Propagation initialization failed: "
                   << propagatorInitResult.error());
        return propagatorInitResult.error();
      }
 
      auto& r = propagatorState.template get<Gx2FitterResult<traj_t>>();
      r.fittedStates = &trajectoryTempBackend;
      r.materialMap = std::move(materialMap);
 
      // Clear the track container. It could be more performant to update the
      // existing states, but this needs some more thinking.
      trackContainerTemp.clear();
 
      // Run the fitter
      auto propagationResult = m_propagator.propagate(propagatorState);
 
      auto result =
          m_propagator.makeResult(std::move(propagatorState), propagationResult,
                                  propagatorOptions, false);
 
      if (!result.ok()) {
        ACTS_DEBUG("Propagation failed: " << result.error());
        return result.error();
      }
 
      // TODO Improve Propagator + Actor [allocate before loop], rewrite
      // makeMeasurements
      auto& propRes = *result;
      GX2FResult gx2fResult = std::move(propRes.template get<GX2FResult>());
      materialMap = std::move(gx2fResult.materialMap);
      auto track = trackContainerTemp.makeTrack();
      tipIndex = gx2fResult.lastMeasurementIndex;
 
      // It could happen, that no measurements were found. Then the track would
      // be empty and the following operations would be invalid. Usually, this
      // only happens during the first iteration, due to bad initial parameters.
      if (tipIndex == kInvalid) {
        ACTS_INFO("Did not find any measurements in material fit.");
        return Experimental::GlobalChiSquareFitterError::NotEnoughMeasurements;
      }
 
      track.tipIndex() = tipIndex;
      track.linkForward();
 
      // System that we fill with the information gathered by the actor and
      // evaluate later
      Gx2fSystem extendedSystem{gx2fResult.materialParamIndices.back()};
 
      // This vector stores the IDs for each visited material in order. We use
      // it later for updating the scattering angles. We cannot use
      // materialMap directly, since we cannot guarantee, that we will visit
      // all stored material in each propagation.
      std::vector<GeometryIdentifier> geoIdVector;
 
      fillGx2fSystem(track, extendedSystem, materialMap,
                     gx2fResult.materialParamIndices, geoIdVector,
                     *m_addToSumLogger);
 
      chi2sum = extendedSystem.chi2();
 
      // This check takes into account the evaluated dimensions of the
      // measurements. To fit, we need at least NDF+1 measurements. However, we
      // count n-dimensional measurements for n measurements, reducing the
      // effective number of needed measurements. We might encounter the case,
      // where we cannot use some (parts of a) measurements, maybe if we do not
      // support that kind of measurement. This is also taken into account here.
      // We skip the check during the first iteration, since we cannot guarantee
      // to hit all/enough measurement surfaces with the initial parameter
      // guess.
      if ((nUpdate > 0) && !extendedSystem.isWellDefined()) {
        ACTS_INFO("Not enough measurements. Require "
                  << extendedSystem.findRequiredNdf() + 1 << ", but only "
                  << extendedSystem.ndf() << " could be used.");
        return Experimental::GlobalChiSquareFitterError::NotEnoughMeasurements;
      }
 
      Eigen::VectorXd deltaParamsExtended =
          computeGx2fDeltaParams(extendedSystem);
 
      ACTS_VERBOSE("aMatrix:\n"
                   << extendedSystem.aMatrix() << "\n"
                   << "bVector:\n"
                   << extendedSystem.bVector() << "\n"
                   << "deltaParamsExtended:\n"
                   << deltaParamsExtended << "\n"
                   << "oldChi2sum = " << oldChi2sum << "\n"
                   << "chi2sum = " << extendedSystem.chi2());
 
      chi2sum = extendedSystem.chi2();
 
      updateGx2fParams(params, deltaParamsExtended, materialMap, geoIdVector);
      ACTS_VERBOSE("Updated parameters: " << params.parameters().transpose());
 
      updateGx2fCovarianceParams(fullCovariancePredicted, extendedSystem);
 
      ACTS_DEBUG("Finished to evaluate material");
      ACTS_VERBOSE("Final parameters after material: "
                   << params.parameters().transpose());
 
      ACTS_VERBOSE("Final scattering angles and energy loss:");
      for (const auto& [key, value] : materialMap) {
        if (!value.materialIsValid()) {
          continue;
        }
        ACTS_VERBOSE("    ( " << value.deltaTheta() << " | " << value.deltaPhi()
                              << "|" << value.lostEnergy() << " )");
      }
    }
    ACTS_VERBOSE("Final covariance:\n" << fullCovariancePredicted);
 
    // Propagate again with the final covariance matrix. This is necessary to
    // obtain the propagated covariance for each state.
    // We also need to recheck the result and find the tipIndex, because at this
    // step, we will not ignore the boundary checks for measurement surfaces. We
    // want to create trackstates only on surfaces, that we actually hit.
    if (false && gx2fOptions.nUpdateMax > 0) {
      ACTS_VERBOSE("Propagate with the final covariance.");
      // update covariance
      params.covariance() = fullCovariancePredicted;
 
      // set up the propagator
      PropagatorOptions propagatorOptions{gx2fOptions.propagatorPlainOptions};
      auto& gx2fActor = propagatorOptions.actorList.template get<GX2FActor>();
      gx2fActor.inputMeasurements = &inputMeasurements;
      gx2fActor.doMultipleScattering = gx2fOptions.doMultipleScattering;
      gx2fActor.doEnergyLoss = gx2fOptions.doEnergyLoss;
      gx2fActor.extensions = gx2fOptions.extensions;
      gx2fActor.calibrationContext = &gx2fOptions.calibrationContext.get();
      gx2fActor.actorLogger = m_actorLogger.get();
      gx2fActor.startParameters = &params;
 
      auto propagatorState = m_propagator.makeState(propagatorOptions);
 
      auto propagatorInitResult =
          m_propagator.initialize(propagatorState, params, nullptr);
      if (!propagatorInitResult.ok()) {
        ACTS_DEBUG("Propagation initialization failed: "
                   << propagatorInitResult.error());
        return propagatorInitResult.error();
      }
 
      auto& r = propagatorState.template get<Gx2FitterResult<traj_t>>();
      r.fittedStates = &trackContainer.trackStateContainer();
      r.materialMap = std::move(materialMap);
 
      // Run the fitter
      auto propagationResult = m_propagator.propagate(propagatorState);
 
      auto result =
          m_propagator.makeResult(std::move(propagatorState), propagationResult,
                                  propagatorOptions, false);
 
      if (!result.ok()) {
        ACTS_DEBUG("Propagation failed: " << result.error());
        return result.error();
      }
 
      auto& propRes = *result;
      GX2FResult gx2fResult = std::move(propRes.template get<GX2FResult>());
      materialMap = std::move(gx2fResult.materialMap);
 
      if (tipIndex != gx2fResult.lastMeasurementIndex) {
        ACTS_INFO("Final fit used unreachable measurements.");
        tipIndex = gx2fResult.lastMeasurementIndex;
 
        // It could happen, that no measurements were found. Then the track
        // would be empty and the following operations would be invalid.
        if (tipIndex == kInvalid) {
          ACTS_INFO("Did not find any measurements in final propagation.");
          return Experimental::GlobalChiSquareFitterError::
              NotEnoughMeasurements;
        }
      }
    }
 
    if (!trackContainer.hasColumn(
            Acts::hashString(Gx2fConstants::gx2fnUpdateColumn))) {
      trackContainer.template addColumn<std::uint32_t>("Gx2fnUpdateColumn");
    }
 
    // Prepare track for return
    auto track = trackContainer.makeTrack();
    track.tipIndex() = tipIndex;
    track.parameters() = params.parameters();
    track.covariance() = fullCovariancePredicted;
    track.setReferenceSurface(params.referenceSurface().getSharedPtr());
 
    if (trackContainer.hasColumn(
            Acts::hashString(Gx2fConstants::gx2fnUpdateColumn))) {
      ACTS_DEBUG("Add nUpdate to track");
      track.template component<std::uint32_t>("Gx2fnUpdateColumn") =
          static_cast<std::uint32_t>(nUpdate);
    }
 
    // TODO write test for calculateTrackQuantities
    calculateTrackQuantities(track);
 
    // Set the chi2sum for the track summary manually, since we don't calculate
    // it for each state
    track.chi2() = chi2sum;
 
    track.linkForward();
 
    // Return the converted Track
    return track;
  }

logger()

template<typename propagator_t, typename traj_t>

const Logger & MuonExperimental::Gx2Fitter< propagator_t, traj_t >::logger ( ) const

inlineprivate

Definition at line 744 of file Chi2Fitter.h.

{ return *m_logger; }

Member Data Documentation

kInvalid

template<typename propagator_t, typename traj_t>

auto MuonExperimental::Gx2Fitter< propagator_t, traj_t >::kInvalid = kTrackIndexInvalid

staticconstexprprivate

Definition at line 717 of file Chi2Fitter.h.

m_actorLogger

template<typename propagator_t, typename traj_t>

std::unique_ptr<const Logger> MuonExperimental::Gx2Fitter< propagator_t, traj_t >::m_actorLogger

private

Initial value:

{
      m_logger->cloneWithSuffix("Actor")}

Definition at line 739 of file Chi2Fitter.h.

                                           {
      m_logger->cloneWithSuffix("Actor")};

m_addToSumLogger

template<typename propagator_t, typename traj_t>

std::unique_ptr<const Logger> MuonExperimental::Gx2Fitter< propagator_t, traj_t >::m_addToSumLogger

private

Initial value:

{
      m_logger->cloneWithSuffix("AddToSum")}

Definition at line 741 of file Chi2Fitter.h.

                                              {
      m_logger->cloneWithSuffix("AddToSum")};

m_logger

template<typename propagator_t, typename traj_t>

std::unique_ptr<const Logger> MuonExperimental::Gx2Fitter< propagator_t, traj_t >::m_logger

private

The logger instance.

Definition at line 738 of file Chi2Fitter.h.

m_propagator

template<typename propagator_t, typename traj_t>

propagator_t MuonExperimental::Gx2Fitter< propagator_t, traj_t >::m_propagator

private

The propagator for the transport and material update.

Definition at line 735 of file Chi2Fitter.h.

---

The documentation for this class was generated from the following file:

• Chi2Fitter.h