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

Propagator Actor plugin for the GX2F. More...

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

Public Types
using	result_type = Gx2FitterResult<traj_t>
	Broadcast the result_type.
using	TrackStateProxy_t = typename traj_t::TrackStateProxy

Public Member Functions
const Logger &	logger () const
	Logger helper.
template<typename propagator_state_t, typename stepper_t, typename navigator_t>
Result< void >	act (propagator_state_t &state, const stepper_t &stepper, const navigator_t &navigator, result_type &result, const Logger &) const
	Gx2f actor operation.
template<typename propagator_state_t, typename stepper_t, typename navigator_t>
Result< void >	makeTrackState (propagator_state_t &state, const stepper_t &stepper, const navigator_t &navigator, result_type &result) const
template<typename propagator_state_t, typename stepper_t, typename navigator_t>
Result< void >	fillMaterialMap (propagator_state_t &state, const stepper_t &stepper, const navigator_t &navigator, result_type &result) const
template<typename propagator_state_t, typename stepper_t, typename navigator_t, typename result_t>
bool	checkAbort (propagator_state_t &, const stepper_t &, const navigator_t &, const result_t &result, const Logger &) const

Public Attributes
const std::unordered_map< const Surface *, SourceLink > *	inputMeasurements {}
	Allows retrieving measurements for a surface.
bool	doMultipleScattering = false
	Whether to consider multiple scattering.
bool	doEnergyLoss = false
	Whether to consider energy loss.
double	scatteringCutOff = 0.
double	elossCutOff = 0.
	Cutoff value on the energy loss to fine tune the number of energy loss parameters in the fit.
FreeToBoundCorrection	freeToBoundCorrection
	Whether to include non-linear correction during global to local transformation.
const Logger *	actorLogger {nullptr}
	The logger instance.
Gx2FitterExtensions< traj_t >	extensions
const CalibrationContext *	calibrationContext {nullptr}
	Calibration context for the fit.
const BoundTrackParameters *	startParameters = nullptr
	Start parameters of the track fit.

Detailed Description

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

Propagator Actor plugin for the GX2F.

Template Parameters

parameters_t	The type of parameters used for "local" parameters.
calibrator_t	The type of calibrator
outlier_finder_t	Type of the outlier finder class

The GX2F Actor does not rely on the measurements to be sorted along the track.

Definition at line 754 of file Chi2Fitter.h.

Member Typedef Documentation

result_type

template<typename propagator_t, typename traj_t>

using MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::result_type = Gx2FitterResult<traj_t>

Broadcast the result_type.

Definition at line 757 of file Chi2Fitter.h.

TrackStateProxy_t

template<typename propagator_t, typename traj_t>

using MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::TrackStateProxy_t = typename traj_t::TrackStateProxy

Definition at line 759 of file Chi2Fitter.h.

Member Function Documentation

act()

template<typename propagator_t, typename traj_t>

template<typename propagator_state_t, typename stepper_t, typename navigator_t>

Result< void > MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::act ( propagator_state_t & state, const stepper_t & stepper, const navigator_t & navigator, result_type & result, const Logger &  ) const

inline

Gx2f actor operation.

Template Parameters

propagator_state_t	is the type of Propagator state
stepper_t	Type of the stepper
navigator_t	Type of the navigator

Parameters

state	is the mutable propagator state object
stepper	The stepper in use
navigator	The navigator in use
result	is the mutable result state object

Definition at line 806 of file Chi2Fitter.h.

                                            {
      assert(result.fittedStates && "No MultiTrajectory set");
 
      // Check if we can stop to propagate
      if (result.measurementStates == inputMeasurements->size()) {
        ACTS_DEBUG("Actor: finish: All measurements have been found.");
        result.finished = true;
      } else if (state.navigation.navigationBreak) {
        ACTS_DEBUG("Actor: finish: navigationBreak.");
        result.finished = true;
      }
 
      // End the propagation and return to the fitter
      if (result.finished) {
        // Remove the missing surfaces that occur after the last measurement
        if (result.measurementStates > 0) {
          result.missedActiveSurfaces.resize(result.measurementHoles);
        }
 
        return Result<void>::success();
      }
 
      // We are only interested in surfaces. If we are not on a surface, we
      // continue the navigation
      const Surface* surface = navigator.currentSurface(state.navigation);
      if (surface == nullptr) {
        return Result<void>::success();
      }
 
      ++result.surfaceCount;
      const GeometryIdentifier geoId = surface->geometryId();
      ACTS_DEBUG("Surface "
                 << geoId << ", " << surface->bounds() << " detected. "
                 << "Sensitive: " << (surface->isSensitive() ? "yes" : "no")
                 << ", has material: "
                 << (surface->hasMaterial() ? "yes" : "no"));
 
      auto matFillResult = fillMaterialMap(state, stepper, navigator, result);
      if (!matFillResult.ok()) {
        return matFillResult.error();
      }
 
      auto trackStateResult = makeTrackState(state, stepper, navigator, result);
      if (!trackStateResult.ok()) {
        return trackStateResult.error();
      }
      // Here we handle all measurements
      if (auto sourceLinkIt = inputMeasurements->find(surface);
          sourceLinkIt != inputMeasurements->end()) {
        // We count the processed measurement
        ++result.processedMeasurements;
 
        result.lastMeasurementIndex = result.lastTrackIndex;
 
        // TODO check for outlier first
        // We count the state with measurement
        ++result.measurementStates;
 
        // We count the processed state
        ++result.processedStates;
 
        // Update the number of holes count only when encountering a
        // measurement
        result.measurementHoles = result.missedActiveSurfaces.size();
 
        return Result<void>::success();
      }
 
      ACTS_DEBUG("    The surface contains no measurement/material/hole.");
      return Result<void>::success();
    }

checkAbort()

template<typename propagator_t, typename traj_t>

template<typename propagator_state_t, typename stepper_t, typename navigator_t, typename result_t>

bool MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::checkAbort ( propagator_state_t & , const stepper_t & , const navigator_t & , const result_t & result, const Logger &  ) const

inline

Definition at line 1132 of file Chi2Fitter.h.

                                           {
      return result.finished;
    }

fillMaterialMap()

template<typename propagator_t, typename traj_t>

template<typename propagator_state_t, typename stepper_t, typename navigator_t>

Result< void > MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::fillMaterialMap ( propagator_state_t & state, const stepper_t & stepper, const navigator_t & navigator, result_type & result ) const

inline

Template Parameters

propagator_state_t	is the type of Propagator state
stepper_t	Type of the stepper
navigator_t	Type of the navigator

Parameters

state	is the mutable propagator state object
stepper	The stepper in use
navigator	The navigator in use
result	is the mutable result state object

Entry is already present. Nothing to be done

There is measurement of the energy loss but the surface material is good. Calculate the expected energy loss from Bethe-Bloch.

Energy loss uncertainty

Accumulate the material across surfaces

Definition at line 989 of file Chi2Fitter.h.

                                                            {
      if (!doMultipleScattering && !doEnergyLoss) {
        ACTS_DEBUG(
            __func__
            << " | "
            << "Multiple scattering and energy loss are disabled. Returning");
        return Result<void>::success();
      }
      const Surface* surface = navigator.currentSurface(state.navigation);
      if (!surface->hasMaterial()) {
        return Result<void>::success();
      }
 
      // Found material - add a scatteringAngles entry if not done yet and
      // energy loss if enabled. Handling will happen later
      ACTS_DEBUG("    The surface contains material ...");
 
      const GeometryIdentifier geoId = surface->geometryId();
      auto materialMapId = result.materialMap.find(geoId);
 
      if (materialMapId != result.materialMap.end()) {
        ACTS_VERBOSE("   ....  entry is already in the material map.");
        if (materialMapId->second.nDim() == 0ul) {
          ACTS_VERBOSE(" Material surface "
                       << geoId
                       << " has zero dimension - do not keep the index.");
          return Result<void>::success();
        }
        result.materialParamIndices.push_back(
            result.materialParamIndices.back() + materialMapId->second.nDim());
        return Result<void>::success();
      }
 
      ACTS_DEBUG("    ... create entry in material map.");
 
      const Result<MaterialSlab> slabResult =
          Acts::detail::evaluateMaterialSlab(
              state, stepper, *surface,
              Acts::detail::determineMaterialUpdateMode(
                  state, navigator, MaterialUpdateMode::FullUpdate));
      if (!slabResult.ok()) {
        ACTS_DEBUG(__func__ << " | "
                            << "Failed to evaluate material slab: "
                            << slabResult.error());
        return Result<void>::failure(slabResult.error());
      }
      const MaterialSlab& slab = *slabResult;
      const bool goodSlab = !slab.isVacuum();
 
      using ScatteringAtSurface = Gx2fMaterialProperties::ScatteringAtSurface;
      using ELossAtSurface = Gx2fMaterialProperties::ELossAtSurface;
 
      ELossAtSurface eLoss{};
      ScatteringAtSurface scatterer{};
 
      if (goodSlab) {
        const auto& particle = startParameters->particleHypothesis();
 
        const double sigma =
            static_cast<double>(Acts::computeMultipleScatteringTheta0(
                slab, particle.absolutePdg(), particle.mass(),
                static_cast<float>(startParameters->parameters()[eBoundQOverP]),
                particle.absoluteCharge()));
        ACTS_VERBOSE("        The Highland formula gives sigma = " << sigma);
 
        scatterer = ScatteringAtSurface{sigma};
 
      } else {
        ACTS_VERBOSE("        Material slab is not valid.");
      }
 
      if (doEnergyLoss) {
        eLoss = extensions.elossAccumulator(
            state.geoContext, *calibrationContext,
            stepper.position(state.stepping), stepper.direction(state.stepping),
            *surface);
        if (!eLoss.isValid() && goodSlab) {
          const auto& particle = startParameters->particleHypothesis();
 
          const double qOverP = stepper.qOverP(state.stepping);
          ACTS_VERBOSE("The particle has momentum "
                       << (1. / qOverP) * particle.absoluteCharge()
                       << " and charge " << particle.absoluteCharge());
 
          eLoss = ELossAtSurface{
              computeEnergyLossMean(slab, particle.absolutePdg(),
                                    particle.mass(), qOverP,
                                    particle.absoluteCharge()),
              static_cast<double>(Acts::computeEnergyLossLandauSigma(
                  slab, particle.mass(), static_cast<float>(qOverP),
                  particle.absoluteCharge()))};
 
          ACTS_VERBOSE("        The Bethe-Bloch formula gives energy loss "
                       << eLoss.lostEnergy() << " with uncertainty "
                       << eLoss.lostSigma());
        }
      }

      scatterer += result.accScatterer;
      eLoss += result.accEloss;
      if (scatterer.sigma() < scatteringCutOff) {
        result.accScatterer = std::move(scatterer);
        scatterer = ScatteringAtSurface{};
      } else {
        result.accScatterer = ScatteringAtSurface{};
      }
 
      if (eLoss.lostEnergy() < elossCutOff) {
        result.accEloss = std::move(eLoss);
        eLoss = ELossAtSurface{};
      } else {
        result.accEloss = ELossAtSurface{};
      }
      ACTS_DEBUG("    ... add entry in material map with scattering "
                 << scatterer.sigma() << " and energy loss "
                 << eLoss.lostEnergy());
      materialMapId =
          result.materialMap
              .emplace(geoId, Gx2fMaterialProperties{std::move(scatterer),
                                                     std::move(eLoss)})
              .first;
      if (materialMapId->second.nDim() == 0ul) {
        ACTS_VERBOSE(" Material surface "
                     << geoId
                     << " has zero dimension - do not keep the index.");
        return Result<void>::success();
      }
      result.materialParamIndices.push_back(result.materialParamIndices.back() +
                                            materialMapId->second.nDim());
 
      return Result<void>::success();
    }

logger()

template<typename propagator_t, typename traj_t>

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

inline

Logger helper.

Definition at line 783 of file Chi2Fitter.h.

{ return *actorLogger; }

makeTrackState()

template<typename propagator_t, typename traj_t>

template<typename propagator_state_t, typename stepper_t, typename navigator_t>

Result< void > MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::makeTrackState ( propagator_state_t & state, const stepper_t & stepper, const navigator_t & navigator, result_type & result ) const

inline

The surface is neither sensitive or it carries material

There is no material update

Definition at line 882 of file Chi2Fitter.h.

                                                           {
      const Surface* surface = navigator.currentSurface(state.navigation);
 
      const GeometryIdentifier geoId = surface->geometryId();
 
      auto sourceLinkIt = inputMeasurements->find(surface);
      auto materialItr = result.materialMap.find(geoId);
      const bool isSensitive =
          surface->isSensitive() || sourceLinkIt != inputMeasurements->end();
      const bool hasMaterial = surface->hasMaterial() &&
                               materialItr != result.materialMap.end() &&
                               materialItr->second.materialIsValid();
      if (!isSensitive && !hasMaterial) {
        return Result<void>::success();
      }
 
      auto& fittedStates = *result.fittedStates;
 
      // Add a <trackStateMask> TrackState entry multi trajectory. This
      // allocates storage for all components, which we will set later.
      TrackStateProxy_t trackStateProxy = fittedStates.makeTrackState(
          Gx2fConstants::trackStateMask, result.lastTrackIndex);
 
      result.lastTrackIndex = trackStateProxy.index();
 
      auto typeFlags = trackStateProxy.typeFlags();
      typeFlags.setHasParameters();
 
      // Transport the covariance to the surface
      auto transportRes = stepper.transportToBound(
          state.stepping, *surface, freeToBoundCorrection);
      if (!transportRes.ok()) {
        return transportRes.error();
      }
 
      // Set the trackStateProxy components with the state from the ongoing
      // propagation
      trackStateProxy.setReferenceSurface(surface->getSharedPtr());
 
      // Not const since, we might need to update with scattering angles
      auto res = stepper.boundParameters(state.stepping, *surface);
      if (!res.ok()) {
        return res.error();
      }
      // Not const since, we might need to update with scattering angles
      auto& boundParams = *res;
 
      trackStateProxy.smoothedCovariance() = stepper.covariance(state.stepping).value();
      trackStateProxy.jacobian() = *transportRes;
      trackStateProxy.pathLength() = stepper.pathLength(state.stepping);

      if (hasMaterial) {
        typeFlags.setHasMaterial();
 
        // track
        ACTS_DEBUG("    Update parameters with material effects.");
        ACTS_VERBOSE("        boundParams before the update: "
                     << boundParams.parameters().transpose());
 
        materialItr->second.updateTrackParameters(boundParams);
        ACTS_VERBOSE("        boundParams after the update: "
                     << boundParams.parameters().transpose());
 
        stepper.update(state.stepping,
                       transformBoundToFreeParameters(
                           trackStateProxy.referenceSurface(), state.geoContext,
                           boundParams.parameters()),
                       boundParams.parameters(),
                       trackStateProxy.smoothedCovariance(), *surface);
      }
 
      // Fill the track state
      trackStateProxy.smoothed() = boundParams.parameters();
      if (!isSensitive) {
        return Result<void>::success();
      }
 
      if (sourceLinkIt == inputMeasurements->end()) {
        typeFlags.setIsHole();
        return Result<void>::success();
      }
      typeFlags.setIsMeasurement();
 
      // We have smoothed parameters, so calibrate the uncalibrated input
      // measurement
      extensions.calibrator(state.geoContext, *calibrationContext,
                            sourceLinkIt->second, trackStateProxy);
 
      return Result<void>::success();
    }

Member Data Documentation

actorLogger

template<typename propagator_t, typename traj_t>

const Logger* MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::actorLogger {nullptr}

The logger instance.

Definition at line 780 of file Chi2Fitter.h.

{nullptr};

calibrationContext

template<typename propagator_t, typename traj_t>

const CalibrationContext* MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::calibrationContext {nullptr}

Calibration context for the fit.

Definition at line 788 of file Chi2Fitter.h.

{nullptr};

doEnergyLoss

template<typename propagator_t, typename traj_t>

bool MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::doEnergyLoss = false

Whether to consider energy loss.

Definition at line 768 of file Chi2Fitter.h.

doMultipleScattering

template<typename propagator_t, typename traj_t>

bool MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::doMultipleScattering = false

Whether to consider multiple scattering.

Definition at line 765 of file Chi2Fitter.h.

elossCutOff

template<typename propagator_t, typename traj_t>

double MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::elossCutOff = 0.

Cutoff value on the energy loss to fine tune the number of energy loss parameters in the fit.

Definition at line 774 of file Chi2Fitter.h.

extensions

template<typename propagator_t, typename traj_t>

Gx2FitterExtensions<traj_t> MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::extensions

Definition at line 785 of file Chi2Fitter.h.

freeToBoundCorrection

template<typename propagator_t, typename traj_t>

FreeToBoundCorrection MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::freeToBoundCorrection

Whether to include non-linear correction during global to local transformation.

Definition at line 778 of file Chi2Fitter.h.

inputMeasurements

template<typename propagator_t, typename traj_t>

const std::unordered_map<const Surface*, SourceLink>* MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::inputMeasurements {}

Allows retrieving measurements for a surface.

Definition at line 762 of file Chi2Fitter.h.

{};

scatteringCutOff

template<typename propagator_t, typename traj_t>

double MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::scatteringCutOff = 0.

Definition at line 770 of file Chi2Fitter.h.

startParameters

template<typename propagator_t, typename traj_t>

const BoundTrackParameters* MuonExperimental::Gx2Fitter< propagator_t, traj_t >::GX2FActor::startParameters = nullptr

Start parameters of the track fit.

The hypothesis is needed to estimate the material effects

Definition at line 792 of file Chi2Fitter.h.

---

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

• Chi2Fitter.h