Trk::MultiComponentStateCombiner Namespace Reference

Functions
std::unique_ptr< Trk::TrackParameters >	combineToSingle (const MultiComponentState &, const bool useMode=false)
	@bried Calculate combined state of many components More...
void	combineWithWeight (Trk::ComponentParameters &mergeTo, const Trk::ComponentParameters &addThis)
	Combined/merge a component to another one. More...
void	combineParametersWithWeight (AmgVector(5) &firstParameters, double &firstWeight, const AmgVector(5) &secondParameters, const double secondWeight)
	Update parameters. More...
void	combineCovWithWeight (const AmgVector(5) &firstParameters, AmgSymMatrix(5) &firstMeasuredCov, const double firstWeight, const AmgVector(5) &secondParameters, const AmgSymMatrix(5) &secondMeasuredCov, const double secondWeight)
	Update cov matrix. More...
Trk::MultiComponentState	combineWithSmoother (const Trk::MultiComponentState &forwardsMultiState, const Trk::MultiComponentState &smootherMultiState, unsigned int maximumNumberOfComponents)
	Helper to combine forward with smoother MultiComponentStates. More...

Function Documentation

combineCovWithWeight()

ATH_FLATTEN void Trk::MultiComponentStateCombiner::combineCovWithWeight	(	const AmgVector(5) &	firstParameters,
		AmgSymMatrix(5) &	firstMeasuredCov,
		const double	firstWeight,
		const AmgVector(5) &	secondParameters,
		const AmgSymMatrix(5) &	secondMeasuredCov,
		const double	secondWeight
	)

Update cov matrix.

Definition at line 385 of file MultiComponentStateCombiner.cxx.

{
  double invTotalWeight = 1.0/(firstWeight + secondWeight);
  AmgVector(5) parameterDifference = firstParameters - secondParameters;
  parameterDifference[2] = CxxUtils::wrapToPi(parameterDifference[2]);
  parameterDifference *= invTotalWeight;
  firstMeasuredCov =
      (firstWeight * firstMeasuredCov + secondWeight * secondMeasuredCov) *
      invTotalWeight;
  firstMeasuredCov += firstWeight * secondWeight * parameterDifference *
                      parameterDifference.transpose();
}

combineParametersWithWeight()

ATH_FLATTEN void Trk::MultiComponentStateCombiner::combineParametersWithWeight	(	AmgVector(5) &	firstParameters,
		double &	firstWeight,
		const AmgVector(5) &	secondParameters,
		const double	secondWeight
	)

Update parameters.

Moment-preserving merge of two 5D components for example see Runnalls, Andrew R.

(2007) Kullback-Leibler approach to Gaussian mixture reduction equations (2),(3),(4)

Definition at line 358 of file MultiComponentStateCombiner.cxx.

{
  double totalWeight = firstWeight + secondWeight;
  double invTotalWeight = 1.0/totalWeight;
  double deltaPhi = firstParameters[2] - secondParameters[2];
  if (deltaPhi > M_PI) {
    firstParameters[2] -= 2 * M_PI;
  } else if (deltaPhi < -M_PI) {
    firstParameters[2] += 2 * M_PI;
  }
  firstParameters =
      (firstWeight * firstParameters + secondWeight * secondParameters) *
      invTotalWeight;
  // Ensure that phi is between -pi and pi
  firstParameters[2] = CxxUtils::wrapToPi(firstParameters[2]);
  firstWeight = totalWeight;
}

combineToSingle()

std::unique_ptr< Trk::TrackParameters > Trk::MultiComponentStateCombiner::combineToSingle	(	const MultiComponentState &	uncombinedState,
		const bool	useMode = false
	)

@bried Calculate combined state of many components

Definition at line 305 of file MultiComponentStateCombiner.cxx.

                                                                   {
  Trk::ComponentParameters combinedComponent =
      combineToSingleImpl(uncombinedState, useMode);
  return std::move(combinedComponent.params);
}

combineWithSmoother()

ATH_FLATTEN Trk::MultiComponentState Trk::MultiComponentStateCombiner::combineWithSmoother	(	const Trk::MultiComponentState &	forwardsMultiState,
		const Trk::MultiComponentState &	smootherMultiState,
		unsigned int	maximumNumberOfComponents
	)

Helper to combine forward with smoother MultiComponentStates.

Definition at line 409 of file MultiComponentStateCombiner.cxx.

{
 
  std::unique_ptr<Trk::MultiComponentState> combinedMultiState =
    std::make_unique<Trk::MultiComponentState>();
 
  // Loop over all components in forwards multi-state
  for (const auto& forwardsComponent : forwardsMultiState) {
    // Need to check that all components have associated weight matricies
    const AmgSymMatrix(5)* forwardMeasuredCov =
      forwardsComponent.params->covariance();
    // Loop over all components in the smoother multi-state
    for (const auto& smootherComponent : smootherMultiState) {
      // Need to check that all components have associated weight matricies
      const AmgSymMatrix(5)* smootherMeasuredCov =
        smootherComponent.params->covariance();
      if (!smootherMeasuredCov && !forwardMeasuredCov) {
        return {};
      }
 
      if (!forwardMeasuredCov) {
        Trk::ComponentParameters smootherComponentOnly = {
          smootherComponent.params->uniqueClone(), smootherComponent.weight};
        combinedMultiState->push_back(std::move(smootherComponentOnly));
        continue;
      }
 
      if (!smootherMeasuredCov) {
        Trk::ComponentParameters forwardComponentOnly = {
          forwardsComponent.params->uniqueClone(), forwardsComponent.weight};
        combinedMultiState->push_back(std::move(forwardComponentOnly));
        continue;
      }
 
      const AmgSymMatrix(5) summedCovariance =
        *forwardMeasuredCov + *smootherMeasuredCov;
      const AmgSymMatrix(5) K =
        *forwardMeasuredCov * summedCovariance.inverse();
      const AmgVector(5) newParameters =
        forwardsComponent.params->parameters() +
        K * (smootherComponent.params->parameters() -
             forwardsComponent.params->parameters());
      const AmgVector(5) parametersDiff =
        forwardsComponent.params->parameters() -
        smootherComponent.params->parameters();
 
      AmgSymMatrix(5) covarianceOfNewParameters =
        AmgSymMatrix(5)(K * *smootherMeasuredCov);
 
      std::unique_ptr<Trk::TrackParameters> combinedTrackParameters =
        (forwardsComponent.params)
          ->associatedSurface()
          .createUniqueTrackParameters(newParameters[Trk::loc1],
                                       newParameters[Trk::loc2],
                                       newParameters[Trk::phi],
                                       newParameters[Trk::theta],
                                       newParameters[Trk::qOverP],
                                       std::move(covarianceOfNewParameters));
      const AmgSymMatrix(5) invertedSummedCovariance =
        summedCovariance.inverse();
      // Determine the scaling factor for the new weighting. Determined from the
      // PDF of the many-dimensional gaussian
      double exponent =
        parametersDiff.transpose() * invertedSummedCovariance * parametersDiff;
      double weightScalingFactor = exp(-0.5 * exponent);
      double combinedWeight = smootherComponent.weight *
                              forwardsComponent.weight * weightScalingFactor;
      Trk::ComponentParameters combinedComponent = {
        std::move(combinedTrackParameters), combinedWeight};
      combinedMultiState->push_back(std::move(combinedComponent));
    }
  }
  // Component reduction on the combined state
  Trk::MultiComponentState mergedState =
      merge(std::move(*combinedMultiState), maximumNumberOfComponents);
  // Before return the weights of the states need to be renormalised to one.
  Trk::MultiComponentStateHelpers::renormaliseState(mergedState);
 
  return mergedState;
}

combineWithWeight()

void Trk::MultiComponentStateCombiner::combineWithWeight	(	Trk::ComponentParameters &	mergeTo,
		const Trk::ComponentParameters &	addThis
	)

Combined/merge a component to another one.

Definition at line 313 of file MultiComponentStateCombiner.cxx.

{
  const Trk::TrackParameters* firstTrackParameters = mergeTo.params.get();
  const AmgVector(5)& firstParameters = firstTrackParameters->parameters();
  double firstWeight = mergeTo.weight;
 
  const Trk::TrackParameters* secondTrackParameters = addThis.params.get();
  const AmgVector(5)& secondParameters = secondTrackParameters->parameters();
  double secondWeight = addThis.weight;
 
  // copy over the first
  AmgVector(5) finalParameters(firstParameters);
  double finalWeight = firstWeight;
  combineParametersWithWeight(
    finalParameters, finalWeight, secondParameters, secondWeight);
 
  const AmgSymMatrix(5)* firstMeasuredCov = firstTrackParameters->covariance();
  const AmgSymMatrix(5)* secondMeasuredCov = secondTrackParameters->covariance();
  // Check to see if first track parameters are measured or not
  if (firstMeasuredCov && secondMeasuredCov) {
    AmgSymMatrix(5) finalMeasuredCov(*firstMeasuredCov);
    combineCovWithWeight(firstParameters, finalMeasuredCov, firstWeight,
                         secondParameters, *secondMeasuredCov, secondWeight);
    mergeTo.params->updateParameters(finalParameters, finalMeasuredCov);
    mergeTo.weight = finalWeight;
  } else {
    mergeTo.params->updateParameters(finalParameters);
    mergeTo.weight = finalWeight;
  }
}