T
 the type of the field elementspublic class FieldTransform<T extends RealFieldElement<T>> extends Object implements TimeStamped, TimeShiftable<FieldTransform<T>>
This class represents the transformation engine between frames
.
It is used both to define the relationship between each frame and its
parent frame and to gather all individual transforms into one
operation when converting between frames far away from each other.
The convention used in OREKIT is vectorial transformation. It means that a transformation is defined as a transform to apply to the coordinates of a vector expressed in the old frame to obtain the same vector expressed in the new frame.
Instances of this class are guaranteed to be immutable.
We want to transform the FieldPVCoordinates
PV_{A} to
PV_{B} with :
PV_{A} = ({1, 0, 0}, {2, 0, 0}, {3, 0, 0});
PV_{B} = ({0, 0, 0}, {0, 0, 0}, {0, 0, 0});
The transform to apply then is defined as follows :
Vector3D translation = new Vector3D(1, 0, 0); Vector3D velocity = new Vector3D(2, 0, 0); Vector3D acceleration = new Vector3D(3, 0, 0); Transform R1toR2 = new Transform(date, translation, velocity, acceleration); PVB = R1toR2.transformPVCoordinate(PVA);
We want to transform the FieldPVCoordinates
PV_{A} to
PV_{B} with
PV_{A} = ({1, 0, 0}, { 1, 0, 0});
PV_{B} = ({0, 1, 0}, {2, 1, 0});
The transform to apply then is defined as follows :
Rotation rotation = new Rotation(Vector3D.PLUS_K, FastMath.PI / 2); Vector3D rotationRate = new Vector3D(0, 0, 2); Transform R1toR2 = new Transform(rotation, rotationRate); PVB = R1toR2.transformPVCoordinates(PVA);
Constructor and Description 

FieldTransform(Field<T> field,
Transform transform)
Build a transform from a regular transform.

FieldTransform(FieldAbsoluteDate<T> date,
FieldAngularCoordinates<T> angular)
Build a rotation transform.

FieldTransform(FieldAbsoluteDate<T> date,
FieldPVCoordinates<T> cartesian)
Build a translation transform, with its first time derivative.

FieldTransform(FieldAbsoluteDate<T> date,
FieldRotation<T> rotation)
Build a rotation transform.

FieldTransform(FieldAbsoluteDate<T> date,
FieldRotation<T> rotation,
FieldVector3D<T> rotationRate)
Build a rotation transform.

FieldTransform(FieldAbsoluteDate<T> date,
FieldRotation<T> rotation,
FieldVector3D<T> rotationRate,
FieldVector3D<T> rotationAcceleration)
Build a rotation transform.

FieldTransform(FieldAbsoluteDate<T> date,
FieldTransform<T> first,
FieldTransform<T> second)
Build a transform by combining two existing ones.

FieldTransform(FieldAbsoluteDate<T> date,
FieldVector3D<T> translation)
Build a translation transform.

FieldTransform(FieldAbsoluteDate<T> date,
FieldVector3D<T> translation,
FieldVector3D<T> velocity)
Build a translation transform, with its first time derivative.

FieldTransform(FieldAbsoluteDate<T> date,
FieldVector3D<T> translation,
FieldVector3D<T> velocity,
FieldVector3D<T> acceleration)
Build a translation transform, with its first and second time derivatives.

Modifier and Type  Method and Description 

FieldTransform<T> 
freeze()
Get a frozen transform.

FieldVector3D<T> 
getAcceleration()
Get the second time derivative of the translation.

FieldAngularCoordinates<T> 
getAngular()
Get the underlying elementary angular part.

FieldPVCoordinates<T> 
getCartesian()
Get the underlying elementary Cartesian part.

AbsoluteDate 
getDate()
Get the date.

FieldAbsoluteDate<T> 
getFieldDate()
Get the date.

static <T extends RealFieldElement<T>> 
getIdentity(Field<T> field)
Get the identity transform.

FieldTransform<T> 
getInverse()
Get the inverse transform of the instance.

void 
getJacobian(CartesianDerivativesFilter selector,
T[][] jacobian)
Compute the Jacobian of the
transformPVCoordinates(FieldPVCoordinates)
method of the transform. 
FieldRotation<T> 
getRotation()
Get the underlying elementary rotation.

FieldVector3D<T> 
getRotationAcceleration()
Get the second time derivative of the rotation.

FieldVector3D<T> 
getRotationRate()
Get the first time derivative of the rotation.

FieldVector3D<T> 
getTranslation()
Get the underlying elementary translation.

FieldVector3D<T> 
getVelocity()
Get the first time derivative of the translation.

static <T extends RealFieldElement<T>> 
interpolate(FieldAbsoluteDate<T> date,
CartesianDerivativesFilter cFilter,
AngularDerivativesFilter aFilter,
Collection<FieldTransform<T>> sample)
Interpolate a transform from a sample set of existing transforms.

static <T extends RealFieldElement<T>> 
interpolate(FieldAbsoluteDate<T> date,
CartesianDerivativesFilter cFilter,
AngularDerivativesFilter aFilter,
Stream<FieldTransform<T>> sample)
Interpolate a transform from a sample set of existing transforms.

static <T extends RealFieldElement<T>> 
interpolate(FieldAbsoluteDate<T> interpolationDate,
Collection<FieldTransform<T>> sample)
Interpolate a transform from a sample set of existing transforms.

FieldTransform<T> 
shiftedBy(double dt)
Get a timeshifted instance.

FieldTransform<T> 
shiftedBy(T dt)
Get a timeshifted instance.

FieldLine<T> 
transformLine(FieldLine<T> line)
Transform a line.

FieldLine<T> 
transformLine(Line line)
Transform a line.

FieldVector3D<T> 
transformPosition(FieldVector3D<T> position)
Transform a position vector (including translation effects).

FieldVector3D<T> 
transformPosition(Vector3D position)
Transform a position vector (including translation effects).

FieldPVCoordinates<T> 
transformPVCoordinates(FieldPVCoordinates<T> pv)
Transform
TimeStampedFieldPVCoordinates including kinematic effects. 
FieldPVCoordinates<T> 
transformPVCoordinates(PVCoordinates pv)
Transform
TimeStampedPVCoordinates including kinematic effects. 
TimeStampedFieldPVCoordinates<T> 
transformPVCoordinates(TimeStampedFieldPVCoordinates<T> pv)
Transform
TimeStampedFieldPVCoordinates including kinematic effects. 
TimeStampedFieldPVCoordinates<T> 
transformPVCoordinates(TimeStampedPVCoordinates pv)
Transform
TimeStampedPVCoordinates including kinematic effects. 
FieldVector3D<T> 
transformVector(FieldVector3D<T> vector)
Transform a vector (ignoring translation effects).

FieldVector3D<T> 
transformVector(Vector3D vector)
Transform a vector (ignoring translation effects).

public FieldTransform(Field<T> field, Transform transform)
field
 field of the elementstransform
 regular transform to convertpublic FieldTransform(FieldAbsoluteDate<T> date, FieldVector3D<T> translation)
date
 date of the transformtranslation
 translation to apply (i.e. coordinates of
the transformed origin, or coordinates of the origin of the
old frame in the new frame)public FieldTransform(FieldAbsoluteDate<T> date, FieldRotation<T> rotation)
date
 date of the transformrotation
 rotation to apply ( i.e. rotation to apply to the
coordinates of a vector expressed in the old frame to obtain the
same vector expressed in the new frame )public FieldTransform(FieldAbsoluteDate<T> date, FieldVector3D<T> translation, FieldVector3D<T> velocity)
date
 date of the transformtranslation
 translation to apply (i.e. coordinates of
the transformed origin, or coordinates of the origin of the
old frame in the new frame)velocity
 the velocity of the translation (i.e. origin
of the old frame velocity in the new frame)public FieldTransform(FieldAbsoluteDate<T> date, FieldVector3D<T> translation, FieldVector3D<T> velocity, FieldVector3D<T> acceleration)
date
 date of the transformtranslation
 translation to apply (i.e. coordinates of
the transformed origin, or coordinates of the origin of the
old frame in the new frame)velocity
 the velocity of the translation (i.e. origin
of the old frame velocity in the new frame)acceleration
 the acceleration of the translation (i.e. origin
of the old frame acceleration in the new frame)public FieldTransform(FieldAbsoluteDate<T> date, FieldPVCoordinates<T> cartesian)
date
 date of the transformcartesian
 Cartesian part of the transformation to apply (i.e. coordinates of
the transformed origin, or coordinates of the origin of the
old frame in the new frame, with their derivatives)public FieldTransform(FieldAbsoluteDate<T> date, FieldRotation<T> rotation, FieldVector3D<T> rotationRate)
date
 date of the transformrotation
 rotation to apply ( i.e. rotation to apply to the
coordinates of a vector expressed in the old frame to obtain the
same vector expressed in the new frame )rotationRate
 the axis of the instant rotation
expressed in the new frame. (norm representing angular rate)public FieldTransform(FieldAbsoluteDate<T> date, FieldRotation<T> rotation, FieldVector3D<T> rotationRate, FieldVector3D<T> rotationAcceleration)
date
 date of the transformrotation
 rotation to apply ( i.e. rotation to apply to the
coordinates of a vector expressed in the old frame to obtain the
same vector expressed in the new frame )rotationRate
 the axis of the instant rotationrotationAcceleration
 the axis of the instant rotation
expressed in the new frame. (norm representing angular rate)public FieldTransform(FieldAbsoluteDate<T> date, FieldAngularCoordinates<T> angular)
date
 date of the transformangular
 angular part of the transformation to apply (i.e. rotation to
apply to the coordinates of a vector expressed in the old frame to obtain the
same vector expressed in the new frame, with its rotation rate)public FieldTransform(FieldAbsoluteDate<T> date, FieldTransform<T> first, FieldTransform<T> second)
Note that the dates of the two existing transformed are ignored, and the combined transform date is set to the date supplied in this constructor without any attempt to shift the raw transforms. This is a design choice allowing user full control of the combination.
date
 date of the transformfirst
 first transform appliedsecond
 second transform appliedpublic static <T extends RealFieldElement<T>> FieldTransform<T> getIdentity(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic AbsoluteDate getDate()
getDate
in interface TimeStamped
public FieldAbsoluteDate<T> getFieldDate()
public FieldTransform<T> shiftedBy(double dt)
shiftedBy
in interface TimeShiftable<FieldTransform<T extends RealFieldElement<T>>>
dt
 time shift in secondspublic FieldTransform<T> shiftedBy(T dt)
dt
 time shift in secondspublic static <T extends RealFieldElement<T>> FieldTransform<T> interpolate(FieldAbsoluteDate<T> interpolationDate, Collection<FieldTransform<T>> sample)
Calling this method is equivalent to call interpolate(FieldAbsoluteDate,
CartesianDerivativesFilter, AngularDerivativesFilter, Collection)
with cFilter
set to CartesianDerivativesFilter.USE_PVA
and aFilter
set to
AngularDerivativesFilter.USE_RRA
set to true.
T
 the type of the field elementsinterpolationDate
 interpolation datesample
 sample points on which interpolation should be donepublic static <T extends RealFieldElement<T>> FieldTransform<T> interpolate(FieldAbsoluteDate<T> date, CartesianDerivativesFilter cFilter, AngularDerivativesFilter aFilter, Collection<FieldTransform<T>> sample)
Note that even if first time derivatives (velocities and rotation rates) 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 and rotations.
As this implementation of interpolation is polynomial, it should be used only with small samples (about 1020 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
T
 the type of the field elementsdate
 interpolation datecFilter
 filter for derivatives from the sample to use in interpolationaFilter
 filter for derivatives from the sample to use in interpolationsample
 sample points on which interpolation should be donepublic static <T extends RealFieldElement<T>> FieldTransform<T> interpolate(FieldAbsoluteDate<T> date, CartesianDerivativesFilter cFilter, AngularDerivativesFilter aFilter, Stream<FieldTransform<T>> sample)
Note that even if first time derivatives (velocities and rotation rates) 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 and rotations.
As this implementation of interpolation is polynomial, it should be used only with small samples (about 1020 points) in order to avoid Runge's phenomenon and numerical problems (including NaN appearing).
T
 the type of the field elementsdate
 interpolation datecFilter
 filter for derivatives from the sample to use in interpolationaFilter
 filter for derivatives from the sample to use in interpolationsample
 sample points on which interpolation should be donepublic FieldTransform<T> getInverse()
public FieldTransform<T> freeze()
This method creates a copy of the instance but frozen in time, i.e. with velocity, acceleration and rotation rate forced to zero.
public FieldVector3D<T> transformPosition(Vector3D position)
position
 vector to transformpublic FieldVector3D<T> transformPosition(FieldVector3D<T> position)
position
 vector to transformpublic FieldVector3D<T> transformVector(Vector3D vector)
vector
 vector to transformpublic FieldVector3D<T> transformVector(FieldVector3D<T> vector)
vector
 vector to transformpublic FieldLine<T> transformLine(Line line)
line
 to transformpublic FieldLine<T> transformLine(FieldLine<T> line)
line
 to transformpublic FieldPVCoordinates<T> transformPVCoordinates(PVCoordinates pv)
TimeStampedPVCoordinates
including kinematic effects.
In order to allow the user more flexibility, this method does not check for
consistency between the transform date
and the timestamped
positionvelocity date
. The returned
value will always have the same date
as
the input argument, regardless of the instance date
.
pv
 timestamped positionvelocity to transform.public TimeStampedFieldPVCoordinates<T> transformPVCoordinates(TimeStampedPVCoordinates pv)
TimeStampedPVCoordinates
including kinematic effects.
In order to allow the user more flexibility, this method does not check for
consistency between the transform date
and the timestamped
positionvelocity date
. The returned
value will always have the same date
as
the input argument, regardless of the instance date
.
pv
 timestamped positionvelocity to transform.public FieldPVCoordinates<T> transformPVCoordinates(FieldPVCoordinates<T> pv)
TimeStampedFieldPVCoordinates
including kinematic effects.
BEWARE! This method does explicit computation of velocity and acceleration by combining
the transform velocity, acceleration, rotation rate and rotation acceleration with the
velocity and acceleration from the argument. This implies that this method should
not be used when derivatives are contained in the field
elements
(typically when using DerivativeStructure
elements where time is one of the differentiation parameter), otherwise
the time derivatives would be computed twice, once explicitly in this method and once implicitly
in the field operations. If time derivatives are contained in the field elements themselves,
then rather than this method the transformPosition
method should be used, so the derivatives are computed once, as part of the field. This
method is rather expected to be used when the field elements are DerivativeStructure
instances
where the differentiation parameters are not time (they can typically be initial state
for computing state transition matrices or force models parameters, or ground stations
positions, ...).
In order to allow the user more flexibility, this method does not check for
consistency between the transform date
and the timestamped
positionvelocity date
. The returned
value will always have the same date
as
the input argument, regardless of the instance date
.
pv
 timestamped positionvelocity to transform.public TimeStampedFieldPVCoordinates<T> transformPVCoordinates(TimeStampedFieldPVCoordinates<T> pv)
TimeStampedFieldPVCoordinates
including kinematic effects.
BEWARE! This method does explicit computation of velocity and acceleration by combining
the transform velocity, acceleration, rotation rate and rotation acceleration with the
velocity and acceleration from the argument. This implies that this method should
not be used when derivatives are contained in the field
elements
(typically when using DerivativeStructure
elements where time is one of the differentiation parameter), otherwise
the time derivatives would be computed twice, once explicitly in this method and once implicitly
in the field operations. If time derivatives are contained in the field elements themselves,
then rather than this method the transformPosition
method should be used, so the derivatives are computed once, as part of the field. This
method is rather expected to be used when the field elements are DerivativeStructure
instances
where the differentiation parameters are not time (they can typically be initial state
for computing state transition matrices or force models parameters, or ground stations
positions, ...).
In order to allow the user more flexibility, this method does not check for
consistency between the transform date
and the timestamped
positionvelocity date
. The returned
value will always have the same date
as
the input argument, regardless of the instance date
.
pv
 timestamped positionvelocity to transform.public void getJacobian(CartesianDerivativesFilter selector, T[][] jacobian)
transformPVCoordinates(FieldPVCoordinates)
method of the transform.
Element jacobian[i][j]
is the derivative of Cartesian coordinate i
of the transformed FieldPVCoordinates
with respect to Cartesian coordinate j
of the input FieldPVCoordinates
in method transformPVCoordinates(FieldPVCoordinates)
.
This definition implies that if we define positionvelocity coordinates
PV₁ = transform.transformPVCoordinates(PV₀)then their differentials dPV₁ and dPV₀ will obey the following relation where J is the matrix computed by this method:
dPV₁ = J × dPV₀
selector
 selector specifying the size of the upper left corner that must be filled
(either 3x3 for positions only, 6x6 for positions and velocities, 9x9 for positions,
velocities and accelerations)jacobian
 placeholder matrix whose upperleft corner is to be filled with
the Jacobian, the rest of the matrix remaining untouchedpublic FieldPVCoordinates<T> getCartesian()
A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary translation with its derivative.
getTranslation()
,
getVelocity()
public FieldVector3D<T> getTranslation()
A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary translation.
getCartesian()
,
getVelocity()
,
getAcceleration()
public FieldVector3D<T> getVelocity()
getCartesian()
,
getTranslation()
,
getAcceleration()
public FieldVector3D<T> getAcceleration()
getCartesian()
,
getTranslation()
,
getVelocity()
public FieldAngularCoordinates<T> getAngular()
A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary rotation with its derivative.
getRotation()
,
getRotationRate()
,
getRotationAcceleration()
public FieldRotation<T> getRotation()
A transform can be uniquely represented as an elementary translation followed by an elementary rotation. This method returns this unique elementary rotation.
getAngular()
,
getRotationRate()
,
getRotationAcceleration()
public FieldVector3D<T> getRotationRate()
The norm represents the angular rate.
getAngular()
,
getRotation()
,
getRotationAcceleration()
public FieldVector3D<T> getRotationAcceleration()
getAngular()
,
getRotation()
,
getRotationRate()
Copyright © 20022019 CS Systèmes d'information. All rights reserved.