org.orekit.utils

Class FieldPVCoordinates<T extends RealFieldElement<T>>

java.lang.Object

org.orekit.utils.FieldPVCoordinates<T>

Type Parameters:

T - the type of the field elements

All Implemented Interfaces:

Serializable, TimeShiftable<FieldPVCoordinates<T>>

Direct Known Subclasses:

TimeStampedFieldPVCoordinates

public class FieldPVCoordinates<T extends RealFieldElement<T>>
extends Object
implements TimeShiftable<FieldPVCoordinates<T>>, Serializable

Simple container for Position/Velocity pairs, using RealFieldElement.

The state can be slightly shifted to close dates. This shift is based on a simple linear model. It is not intended as a replacement for proper orbit propagation (it is not even Keplerian!) but should be sufficient for either small time shifts or coarse accuracy.

This class is the angular counterpart to FieldAngularCoordinates.

Instances of this class are guaranteed to be immutable.

Since:

6.0

Author:

Luc Maisonobe

See Also:

PVCoordinates, Serialized Form

Constructor Summary

Constructors

Constructor and Description
FieldPVCoordinates(double a, FieldPVCoordinates<T> pv) Multiplicative constructor
FieldPVCoordinates(double a1, FieldPVCoordinates<T> pv1, double a2, FieldPVCoordinates<T> pv2) Linear constructor
FieldPVCoordinates(double a1, FieldPVCoordinates<T> pv1, double a2, FieldPVCoordinates<T> pv2, double a3, FieldPVCoordinates<T> pv3) Linear constructor
FieldPVCoordinates(double a1, FieldPVCoordinates<T> pv1, double a2, FieldPVCoordinates<T> pv2, double a3, FieldPVCoordinates<T> pv3, double a4, FieldPVCoordinates<T> pv4) Linear constructor
FieldPVCoordinates(FieldPVCoordinates<T> start, FieldPVCoordinates<T> end) Subtractive constructor
FieldPVCoordinates(FieldVector3D<T> position, FieldVector3D<T> velocity) Builds a PVCoordinates triplet with zero acceleration.
FieldPVCoordinates(FieldVector3D<T> position, FieldVector3D<T> velocity, FieldVector3D<T> acceleration) Builds a PVCoordinates triplet.
FieldPVCoordinates(T a, FieldPVCoordinates<T> pv) Multiplicative constructor
FieldPVCoordinates(T a1, FieldPVCoordinates<T> pv1, T a2, FieldPVCoordinates<T> pv2) Linear constructor
FieldPVCoordinates(T a1, FieldPVCoordinates<T> pv1, T a2, FieldPVCoordinates<T> pv2, T a3, FieldPVCoordinates<T> pv3) Linear constructor
FieldPVCoordinates(T a1, FieldPVCoordinates<T> pv1, T a2, FieldPVCoordinates<T> pv2, T a3, FieldPVCoordinates<T> pv3, T a4, FieldPVCoordinates<T> pv4) Linear constructor
FieldPVCoordinates(T a, PVCoordinates pv) Multiplicative constructor
FieldPVCoordinates(T a1, PVCoordinates pv1, T a2, PVCoordinates pv2) Linear constructor
FieldPVCoordinates(T a1, PVCoordinates pv1, T a2, PVCoordinates pv2, T a3, PVCoordinates pv3) Linear constructor
FieldPVCoordinates(T a1, PVCoordinates pv1, T a2, PVCoordinates pv2, T a3, PVCoordinates pv3, T a4, PVCoordinates pv4) Linear constructor

Method Summary

Methods

Modifier and Type	Method and Description
static <T extends RealFieldElement<T>> FieldVector3D<T>	estimateVelocity(FieldVector3D<T> start, FieldVector3D<T> end, double dt) Estimate velocity between two positions.
FieldVector3D<T>	getAcceleration() Gets the acceleration.
FieldVector3D<T>	getAngularVelocity() Get the angular velocity (spin) of this point as seen from the origin.
FieldVector3D<T>	getMomentum() Gets the momentum.
FieldVector3D<T>	getPosition() Gets the position.
FieldVector3D<T>	getVelocity() Gets the velocity.
static <T extends RealFieldElement<T>> FieldPVCoordinates<T>	interpolate(AbsoluteDate date, boolean useVelocities, Collection<Pair<AbsoluteDate,FieldPVCoordinates<T>>> sample) Deprecated. as of 7.0, replaced with TimeStampedFieldPVCoordinates.interpolate(AbsoluteDate, CartesianDerivativesFilter, Collection)
FieldPVCoordinates<T>	negate() Get the opposite of the instance.
FieldPVCoordinates<T>	normalize() Normalize the position part of the instance.
FieldPVCoordinates<T>	shiftedBy(double dt) Get a time-shifted state.
PVCoordinates	toPVCoordinates() Convert to a constant position-velocity without derivatives.
String	toString() Return a string representation of this position/velocity pair.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

FieldPVCoordinates

public FieldPVCoordinates(FieldVector3D<T> position,
                  FieldVector3D<T> velocity)

Builds a PVCoordinates triplet with zero acceleration.

Parameters:

position - the position vector (m)

velocity - the velocity vector (m/s)

FieldPVCoordinates

public FieldPVCoordinates(FieldVector3D<T> position,
                  FieldVector3D<T> velocity,
                  FieldVector3D<T> acceleration)

Builds a PVCoordinates triplet.

Parameters:

position - the position vector (m)

velocity - the velocity vector (m/s)

acceleration - the acceleration vector (m/s²)

FieldPVCoordinates

public FieldPVCoordinates(double a,
                  FieldPVCoordinates<T> pv)

Multiplicative constructor

Build a PVCoordinates from another one and a scale factor.

The PVCoordinates built will be a * pv

Parameters:

a - scale factor

pv - base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a,
                  FieldPVCoordinates<T> pv)

Multiplicative constructor

Build a PVCoordinates from another one and a scale factor.

The PVCoordinates built will be a * pv

Parameters:

a - scale factor

pv - base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a,
                  PVCoordinates pv)

Multiplicative constructor

Build a PVCoordinates from another one and a scale factor.

The PVCoordinates built will be a * pv

Parameters:

a - scale factor

pv - base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(FieldPVCoordinates<T> start,
                  FieldPVCoordinates<T> end)

Subtractive constructor

Build a relative PVCoordinates from a start and an end position.

The PVCoordinates built will be end - start.

Parameters:

start - Starting PVCoordinates

end - ending PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(double a1,
                  FieldPVCoordinates<T> pv1,
                  double a2,
                  FieldPVCoordinates<T> pv2)

Linear constructor

Build a PVCoordinates from two other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a1,
                  FieldPVCoordinates<T> pv1,
                  T a2,
                  FieldPVCoordinates<T> pv2)

Linear constructor

Build a PVCoordinates from two other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a1,
                  PVCoordinates pv1,
                  T a2,
                  PVCoordinates pv2)

Linear constructor

Build a PVCoordinates from two other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(double a1,
                  FieldPVCoordinates<T> pv1,
                  double a2,
                  FieldPVCoordinates<T> pv2,
                  double a3,
                  FieldPVCoordinates<T> pv3)

Linear constructor

Build a PVCoordinates from three other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

a3 - third scale factor

pv3 - third base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a1,
                  FieldPVCoordinates<T> pv1,
                  T a2,
                  FieldPVCoordinates<T> pv2,
                  T a3,
                  FieldPVCoordinates<T> pv3)

Linear constructor

Build a PVCoordinates from three other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

a3 - third scale factor

pv3 - third base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a1,
                  PVCoordinates pv1,
                  T a2,
                  PVCoordinates pv2,
                  T a3,
                  PVCoordinates pv3)

Linear constructor

Build a PVCoordinates from three other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

a3 - third scale factor

pv3 - third base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(double a1,
                  FieldPVCoordinates<T> pv1,
                  double a2,
                  FieldPVCoordinates<T> pv2,
                  double a3,
                  FieldPVCoordinates<T> pv3,
                  double a4,
                  FieldPVCoordinates<T> pv4)

Linear constructor

Build a PVCoordinates from four other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

a3 - third scale factor

pv3 - third base (unscaled) PVCoordinates

a4 - fourth scale factor

pv4 - fourth base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a1,
                  FieldPVCoordinates<T> pv1,
                  T a2,
                  FieldPVCoordinates<T> pv2,
                  T a3,
                  FieldPVCoordinates<T> pv3,
                  T a4,
                  FieldPVCoordinates<T> pv4)

Linear constructor

Build a PVCoordinates from four other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

a3 - third scale factor

pv3 - third base (unscaled) PVCoordinates

a4 - fourth scale factor

pv4 - fourth base (unscaled) PVCoordinates

FieldPVCoordinates

public FieldPVCoordinates(T a1,
                  PVCoordinates pv1,
                  T a2,
                  PVCoordinates pv2,
                  T a3,
                  PVCoordinates pv3,
                  T a4,
                  PVCoordinates pv4)

Linear constructor

Build a PVCoordinates from four other ones and corresponding scale factors.

The PVCoordinates built will be a1 * u1 + a2 * u2 + a3 * u3 + a4 * u4

Parameters:

a1 - first scale factor

pv1 - first base (unscaled) PVCoordinates

a2 - second scale factor

pv2 - second base (unscaled) PVCoordinates

a3 - third scale factor

pv3 - third base (unscaled) PVCoordinates

a4 - fourth scale factor

pv4 - fourth base (unscaled) PVCoordinates

Method Detail

estimateVelocity

public static <T extends RealFieldElement<T>> FieldVector3D<T> estimateVelocity(FieldVector3D<T> start,
                                                                FieldVector3D<T> end,
                                                                double dt)

Estimate velocity between two positions.

Estimation is based on a simple fixed velocity translation during the time interval between the two positions.

Type Parameters:

T - the type of the field elements

Parameters:

start - start position

end - end position

dt - time elapsed between the dates of the two positions

Returns:

velocity allowing to go from start to end positions

shiftedBy

public FieldPVCoordinates<T> shiftedBy(double dt)

Get a time-shifted state.

The state can be slightly shifted to close dates. This shift is based on a simple quadratic model. It is not intended as a replacement for proper orbit propagation (it is not even Keplerian!) but should be sufficient for either small time shifts or coarse accuracy.

Specified by:

shiftedBy in interface TimeShiftable<FieldPVCoordinates<T extends RealFieldElement<T>>>

Parameters:

dt - time shift in seconds

Returns:

a new state, shifted with respect to the instance (which is immutable)

interpolate

@Deprecated
public static <T extends RealFieldElement<T>> FieldPVCoordinates<T> interpolate(AbsoluteDate date,
                                                                           boolean useVelocities,
                                                                           Collection<Pair<AbsoluteDate,FieldPVCoordinates<T>>> sample)

Deprecated. as of 7.0, replaced with TimeStampedFieldPVCoordinates.interpolate(AbsoluteDate, CartesianDerivativesFilter, Collection)

Interpolate position-velocity.

The interpolated instance is created by polynomial Hermite interpolation ensuring velocity remains the exact derivative of position.

Note that even if first time derivatives (velocities) from sample can be ignored, the interpolated instance always includes interpolated derivatives. This feature can be used explicitly to compute these derivatives when it would be too complex to compute them from an analytical formula: just compute a few sample points from the explicit formula and set the derivatives to zero in these sample points, then use interpolation to add derivatives consistent with the positions.

Type Parameters:

T - the type of the field elements

Parameters:

date - interpolation date

useVelocities - if true, use sample points velocities, otherwise ignore them and use only positions

sample - sample points on which interpolation should be done

Returns:

a new position-velocity, interpolated at specified date

getPosition

public FieldVector3D<T> getPosition()

Gets the position.

Returns:

the position vector (m).

getVelocity

public FieldVector3D<T> getVelocity()

Gets the velocity.

Returns:

the velocity vector (m/s).

getAcceleration

public FieldVector3D<T> getAcceleration()

Gets the acceleration.

Returns:

the acceleration vector (m/s²).

getMomentum

public FieldVector3D<T> getMomentum()

Gets the momentum.

This vector is the p ⊗ v where p is position, v is velocity and ⊗ is cross product. To get the real physical angular momentum you need to multiply this vector by the mass.

The returned vector is recomputed each time this method is called, it is not cached.

Returns:

a new instance of the momentum vector (m²/s).

getAngularVelocity

public FieldVector3D<T> getAngularVelocity()

Get the angular velocity (spin) of this point as seen from the origin.

The angular velocity vector is parallel to the angular momentum and is computed by ω = p × v / ||p||²

Returns:

the angular velocity vector

See Also:

Angular Velocity on Wikipedia

negate

public FieldPVCoordinates<T> negate()

Get the opposite of the instance.

Returns:

a new position-velocity which is opposite to the instance

normalize

public FieldPVCoordinates<T> normalize()

Normalize the position part of the instance.

The computed coordinates first component (position) will be a normalized vector, the second component (velocity) will be the derivative of the first component (hence it will generally not be normalized), and the third component (acceleration) will be the derivative of the second component (hence it will generally not be normalized).

Returns:

a new instance, with first component normalized and remaining component computed to have consistent derivatives

toPVCoordinates

public PVCoordinates toPVCoordinates()

Convert to a constant position-velocity without derivatives.

Returns:

a constant position-velocity

toString

public String toString()

Return a string representation of this position/velocity pair.

Overrides:

toString in class Object

Returns:

string representation of this position/velocity pair