FieldPVCoordinates (ORbit Extrapolation KIT 10.1 API)

java.lang.Object
- org.orekit.utils.FieldPVCoordinates<T>

Type Parameters:

T - the type of the field elements

All Implemented Interfaces:

TimeShiftable<FieldPVCoordinates<T>>

Direct Known Subclasses:

TimeStampedFieldPVCoordinates
```
public class FieldPVCoordinates<T extends RealFieldElement<T>>
extends Object
implements TimeShiftable<FieldPVCoordinates<T>>
```
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

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(Field<T> field, PVCoordinates pv)` Builds a FieldPVCoordinates from a field and a regular PVCoordinates.
`FieldPVCoordinates(FieldPVCoordinates<T> start, FieldPVCoordinates<T> end)` Subtractive constructor.
`FieldPVCoordinates(FieldVector3D<FieldDerivativeStructure<T>> p)` Builds a FieldPVCoordinates triplet from a `FieldVector3D`<`FieldDerivativeStructure`>.
`FieldPVCoordinates(FieldVector3D<T> position, FieldVector3D<T> velocity)` Builds a FieldPVCoordinates triplet with zero acceleration.
`FieldPVCoordinates(FieldVector3D<T> position, FieldVector3D<T> velocity, FieldVector3D<T> acceleration)` Builds a FieldPVCoordinates 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

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`FieldPVCoordinates<T>`	`crossProduct(FieldPVCoordinates<T> pv2)` Compute the cross-product of two instances.
`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>`	`getZero(Field<T> field)` Get fixed position/velocity at origin (both p, v and a are zero vectors).
`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.
`FieldPVCoordinates<T>`	`shiftedBy(T dt)` Get a time-shifted state.
`FieldPVCoordinates<FieldDerivativeStructure<T>>`	`toDerivativeStructurePV(int order)` Transform the instance to a `FieldPVCoordinates`<`FieldDerivativeStructure`>.
`FieldVector3D<FieldDerivativeStructure<T>>`	`toDerivativeStructureVector(int order)` Transform the instance to a `FieldVector3D`<`FieldDerivativeStructure`>.
`PVCoordinates`	`toPVCoordinates()` Convert to a constant position-velocity.
`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 FieldPVCoordinates 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 FieldPVCoordinates triplet.
    
    Parameters:
    
    position - the position vector (m)
    
    velocity - the velocity vector (m/s)
    
    acceleration - the acceleration vector (m/s²)
  - FieldPVCoordinates
```
public FieldPVCoordinates(Field<T> field,
                          PVCoordinates pv)
```
    Builds a FieldPVCoordinates from a field and a regular PVCoordinates.
    
    Parameters:
    
    field - field for the components
    
    pv - PVCoordinates triplet to convert
  - 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
  - FieldPVCoordinates
```
public FieldPVCoordinates(FieldVector3D<FieldDerivativeStructure<T>> p)
```
    Builds a FieldPVCoordinates triplet from a FieldVector3D<FieldDerivativeStructure>.
    The vector components must have time as their only derivation parameter and have consistent derivation orders.
    
    Parameters:
    
    p - vector with time-derivatives embedded within the coordinates
    
    Since:
    
    9.2
- Method Detail
  - getZero
```
public static <T extends RealFieldElement<T>> FieldPVCoordinates<T> getZero(Field<T> field)
```
    Get fixed position/velocity at origin (both p, v and a are zero vectors).
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    field - field for the components
    
    Returns:
    
    a new fixed position/velocity at origin
  - toDerivativeStructureVector
```
public FieldVector3D<FieldDerivativeStructure<T>> toDerivativeStructureVector(int order)
```
    Transform the instance to a FieldVector3D<FieldDerivativeStructure>.
    The FieldDerivativeStructure coordinates correspond to time-derivatives up to the user-specified order.
    
    Parameters:
    
    order - derivation order for the vector components (must be either 0, 1 or 2)
    
    Returns:
    
    vector with time-derivatives embedded within the coordinates
    
    Since:
    
    9.2
  - toDerivativeStructurePV
```
public FieldPVCoordinates<FieldDerivativeStructure<T>> toDerivativeStructurePV(int order)
```
    Transform the instance to a FieldPVCoordinates<FieldDerivativeStructure>.
    The FieldDerivativeStructure coordinates correspond to time-derivatives up to the user-specified order. As both the instance components position, velocity and acceleration and the derivatives of the components holds time-derivatives, there are several ways to retrieve these derivatives. If for example the order is set to 2, then both pv.getPosition().getX().getPartialDerivative(2), pv.getVelocity().getX().getPartialDerivative(1) and pv.getAcceleration().getX().getValue() return the exact same value.
    
    If derivation order is 1, the first derivative of acceleration will be computed as a Keplerian-only jerk. If derivation order is 2, the second derivative of velocity (which is also the first derivative of acceleration) will be computed as a Keplerian-only jerk, and the second derivative of acceleration will be computed as a Keplerian-only jounce.
    
    Parameters:
    
    order - derivation order for the vector components (must be either 0, 1 or 2)
    
    Returns:
    
    pv coordinates with time-derivatives embedded within the coordinates
    
    Since:
    
    9.2
  - 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)
  - shiftedBy
```
public FieldPVCoordinates<T> shiftedBy(T 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.
    
    Parameters:
    
    dt - time shift in seconds
    
    Returns:
    
    a new state, shifted with respect to the instance (which is immutable)
  - 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
  - crossProduct
```
public FieldPVCoordinates<T> crossProduct(FieldPVCoordinates<T> pv2)
```
    Compute the cross-product of two instances.
    
    Parameters:
    
    pv2 - second instances
    
    Returns:
    
    the cross product v1 ^ v2 as a new instance
  - toPVCoordinates
```
public PVCoordinates toPVCoordinates()
```
    Convert to a constant position-velocity.
    
    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

Class FieldPVCoordinates<T extends RealFieldElement<T>>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

FieldPVCoordinates

Method Detail

getZero

toDerivativeStructureVector

toDerivativeStructurePV

estimateVelocity

shiftedBy

shiftedBy

getPosition

getVelocity

getAcceleration

getMomentum

getAngularVelocity

negate

normalize

crossProduct

toPVCoordinates

toString