T
- the type of the field elementsTimeStampedFieldAngularCoordinates
public class FieldAngularCoordinates<T extends org.hipparchus.RealFieldElement<T>> extends Object
RealFieldElement
.
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 attitude propagation but should be sufficient for either small time shifts or coarse accuracy.
This class is the angular counterpart to FieldPVCoordinates
.
Instances of this class are guaranteed to be immutable.
AngularCoordinates
Constructor | Description |
---|---|
FieldAngularCoordinates(org.hipparchus.Field<T> field,
AngularCoordinates ang) |
Builds a FieldAngularCoordinates from a field and a regular AngularCoordinates.
|
FieldAngularCoordinates(org.hipparchus.geometry.euclidean.threed.FieldRotation<org.hipparchus.analysis.differentiation.FieldDerivativeStructure<T>> r) |
Builds a FieldAngularCoordinates from a
FieldRotation <FieldDerivativeStructure >. |
FieldAngularCoordinates(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> rotation,
org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationRate) |
Builds a rotation/rotation rate pair.
|
FieldAngularCoordinates(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> rotation,
org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationRate,
org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationAcceleration) |
Builds a rotation / rotation rate / rotation acceleration triplet.
|
FieldAngularCoordinates(FieldPVCoordinates<T> u1,
FieldPVCoordinates<T> u2,
FieldPVCoordinates<T> v1,
FieldPVCoordinates<T> v2,
double tolerance) |
Build the rotation that transforms a pair of pv coordinates into another one.
|
Modifier and Type | Method | Description |
---|---|---|
FieldAngularCoordinates<T> |
addOffset(FieldAngularCoordinates<T> offset) |
Add an offset from the instance.
|
FieldPVCoordinates<T> |
applyTo(FieldPVCoordinates<T> pv) |
Apply the rotation to a pv coordinates.
|
FieldPVCoordinates<T> |
applyTo(PVCoordinates pv) |
Apply the rotation to a pv coordinates.
|
TimeStampedFieldPVCoordinates<T> |
applyTo(TimeStampedFieldPVCoordinates<T> pv) |
Apply the rotation to a pv coordinates.
|
TimeStampedFieldPVCoordinates<T> |
applyTo(TimeStampedPVCoordinates pv) |
Apply the rotation to a pv coordinates.
|
static <T extends org.hipparchus.RealFieldElement<T>> |
createFromModifiedRodrigues(T[][] r) |
Convert a modified Rodrigues vector and derivatives to angular coordinates.
|
static <T extends org.hipparchus.RealFieldElement<T>> |
estimateRate(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> start,
org.hipparchus.geometry.euclidean.threed.FieldRotation<T> end,
double dt) |
Estimate rotation rate between two orientations.
|
static <T extends org.hipparchus.RealFieldElement<T>> |
estimateRate(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> start,
org.hipparchus.geometry.euclidean.threed.FieldRotation<T> end,
T dt) |
Estimate rotation rate between two orientations.
|
static <T extends org.hipparchus.RealFieldElement<T>> |
getIdentity(org.hipparchus.Field<T> field) |
Fixed orientation parallel with reference frame
(identity rotation, zero rotation rate and acceleration).
|
T[][] |
getModifiedRodrigues(double sign) |
Convert rotation, rate and acceleration to modified Rodrigues vector and derivatives.
|
org.hipparchus.geometry.euclidean.threed.FieldRotation<T> |
getRotation() |
Get the rotation.
|
org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> |
getRotationAcceleration() |
Get the rotation acceleration.
|
org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> |
getRotationRate() |
Get the rotation rate.
|
FieldAngularCoordinates<T> |
revert() |
Revert a rotation / rotation rate / rotation acceleration triplet.
|
FieldAngularCoordinates<T> |
shiftedBy(double dt) |
Get a time-shifted state.
|
FieldAngularCoordinates<T> |
shiftedBy(T dt) |
Get a time-shifted state.
|
FieldAngularCoordinates<T> |
subtractOffset(FieldAngularCoordinates<T> offset) |
Subtract an offset from the instance.
|
AngularCoordinates |
toAngularCoordinates() |
Convert to a regular angular coordinates.
|
org.hipparchus.geometry.euclidean.threed.FieldRotation<org.hipparchus.analysis.differentiation.FieldDerivativeStructure<T>> |
toDerivativeStructureRotation(int order) |
Transform the instance to a
FieldRotation <FieldDerivativeStructure >. |
public FieldAngularCoordinates(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> rotation, org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationRate)
rotation
- rotationrotationRate
- rotation rate Ω (rad/s)public FieldAngularCoordinates(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> rotation, org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationRate, org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> rotationAcceleration)
rotation
- i.e. the orientation of the vehiclerotationRate
- rotation rate rate Ω, i.e. the spin vector (rad/s)rotationAcceleration
- angular acceleration vector dΩ/dt (rad²/s²)public FieldAngularCoordinates(FieldPVCoordinates<T> u1, FieldPVCoordinates<T> u2, FieldPVCoordinates<T> v1, FieldPVCoordinates<T> v2, double tolerance)
WARNING! This method requires much more stringent assumptions on
its parameters than the similar constructor
from the FieldRotation
class.
As far as the FieldRotation constructor is concerned, the v\u2082
vector from
the second pair can be slightly misaligned. The FieldRotation constructor will
compensate for this misalignment and create a rotation that ensure
v\u2081 = r(u\u2081)
and v\u2082 \u2208 plane (r(u\u2081), r(u\u2082))
. THIS IS NOT
TRUE ANYMORE IN THIS CLASS! As derivatives are involved and must be
preserved, this constructor works only if the two pairs are fully
consistent, i.e. if a rotation exists that fulfill all the requirements:
v\u2081 = r(u\u2081)
, v\u2082 = r(u\u2082)
, dv\u2081/dt = dr(u\u2081)/dt
, dv\u2082/dt
= dr(u\u2082)/dt
, d²v\u2081/dt² = d²r(u\u2081)/dt²
, d²v\u2082/dt² = d²r(u\u2082)/dt²
.
u1
- first vector of the origin pairu2
- second vector of the origin pairv1
- desired image of u1 by the rotationv2
- desired image of u2 by the rotationtolerance
- relative tolerance factor used to check singularitiespublic FieldAngularCoordinates(org.hipparchus.Field<T> field, AngularCoordinates ang)
field
- field for the componentsang
- AngularCoordinates to convertpublic FieldAngularCoordinates(org.hipparchus.geometry.euclidean.threed.FieldRotation<org.hipparchus.analysis.differentiation.FieldDerivativeStructure<T>> r)
FieldRotation
<FieldDerivativeStructure
>.
The rotation components must have time as their only derivation parameter and have consistent derivation orders.
r
- rotation with time-derivatives embedded within the coordinatespublic static <T extends org.hipparchus.RealFieldElement<T>> FieldAngularCoordinates<T> getIdentity(org.hipparchus.Field<T> field)
T
- the type of the field elementsfield
- field for the componentspublic org.hipparchus.geometry.euclidean.threed.FieldRotation<org.hipparchus.analysis.differentiation.FieldDerivativeStructure<T>> toDerivativeStructureRotation(int order)
FieldRotation
<FieldDerivativeStructure
>.
The DerivativeStructure
coordinates correspond to time-derivatives up
to the user-specified order.
order
- derivation order for the vector componentspublic static <T extends org.hipparchus.RealFieldElement<T>> org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> estimateRate(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> start, org.hipparchus.geometry.euclidean.threed.FieldRotation<T> end, double dt)
Estimation is based on a simple fixed rate rotation during the time interval between the two orientations.
T
- the type of the field elementsstart
- start orientationend
- end orientationdt
- time elapsed between the dates of the two orientationspublic static <T extends org.hipparchus.RealFieldElement<T>> org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> estimateRate(org.hipparchus.geometry.euclidean.threed.FieldRotation<T> start, org.hipparchus.geometry.euclidean.threed.FieldRotation<T> end, T dt)
Estimation is based on a simple fixed rate rotation during the time interval between the two orientations.
T
- the type of the field elementsstart
- start orientationend
- end orientationdt
- time elapsed between the dates of the two orientationspublic FieldAngularCoordinates<T> revert()
Build a triplet which reverse the effect of another triplet.
public FieldAngularCoordinates<T> shiftedBy(double dt)
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 attitude propagation but should be sufficient for either small time shifts or coarse accuracy.
dt
- time shift in secondspublic FieldAngularCoordinates<T> shiftedBy(T dt)
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 attitude propagation but should be sufficient for either small time shifts or coarse accuracy.
dt
- time shift in secondspublic org.hipparchus.geometry.euclidean.threed.FieldRotation<T> getRotation()
public org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> getRotationRate()
public org.hipparchus.geometry.euclidean.threed.FieldVector3D<T> getRotationAcceleration()
public FieldAngularCoordinates<T> addOffset(FieldAngularCoordinates<T> offset)
We consider here that the offset rotation is applied first and the
instance is applied afterward. Note that angular coordinates do not
commute under this operation, i.e. a.addOffset(b)
and
b.addOffset(a)
lead to different results in most cases.
The two methods addOffset
and
subtractOffset
are designed
so that round trip applications are possible. This means that both
ac1.subtractOffset(ac2).addOffset(ac2)
and
ac1.addOffset(ac2).subtractOffset(ac2)
return angular coordinates equal to ac1.
offset
- offset to subtractsubtractOffset(FieldAngularCoordinates)
public FieldAngularCoordinates<T> subtractOffset(FieldAngularCoordinates<T> offset)
We consider here that the offset Rotation is applied first and the
instance is applied afterward. Note that angular coordinates do not
commute under this operation, i.e. a.subtractOffset(b)
and
b.subtractOffset(a)
lead to different results in most cases.
The two methods addOffset
and
subtractOffset
are designed
so that round trip applications are possible. This means that both
ac1.subtractOffset(ac2).addOffset(ac2)
and
ac1.addOffset(ac2).subtractOffset(ac2)
return angular coordinates equal to ac1.
offset
- offset to subtractaddOffset(FieldAngularCoordinates)
public AngularCoordinates toAngularCoordinates()
public FieldPVCoordinates<T> applyTo(PVCoordinates pv)
pv
- vector to apply the rotation topublic TimeStampedFieldPVCoordinates<T> applyTo(TimeStampedPVCoordinates pv)
pv
- vector to apply the rotation topublic FieldPVCoordinates<T> applyTo(FieldPVCoordinates<T> pv)
pv
- vector to apply the rotation topublic TimeStampedFieldPVCoordinates<T> applyTo(TimeStampedFieldPVCoordinates<T> pv)
pv
- vector to apply the rotation topublic T[][] getModifiedRodrigues(double sign)
The modified Rodrigues vector is tan(θ/4) u where θ and u are the rotation angle and axis respectively.
sign
- multiplicative sign for quaternion componentscreateFromModifiedRodrigues(RealFieldElement[][])
public static <T extends org.hipparchus.RealFieldElement<T>> FieldAngularCoordinates<T> createFromModifiedRodrigues(T[][] r)
T
- the type of the field elementsr
- modified Rodrigues vector (with first and second times derivatives)getModifiedRodrigues(double)
Copyright © 2002-2019 CS Systèmes d'information. All rights reserved.