|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.orekit.utils.AngularCoordinates
org.orekit.utils.TimeStampedAngularCoordinates
public class TimeStampedAngularCoordinates
time-stamped
version of AngularCoordinates
.
Instances of this class are guaranteed to be immutable.
Field Summary |
---|
Fields inherited from class org.orekit.utils.AngularCoordinates |
---|
IDENTITY |
Constructor Summary | |
---|---|
TimeStampedAngularCoordinates(AbsoluteDate date,
PVCoordinates u1,
PVCoordinates u2,
PVCoordinates v1,
PVCoordinates v2,
double tolerance)
Build the rotation that transforms a pair of pv coordinates into another pair. |
|
TimeStampedAngularCoordinates(AbsoluteDate date,
PVCoordinates u1,
PVCoordinates u2,
PVCoordinates v1,
PVCoordinates v2,
double tolerance,
boolean spinDerivativesComputation)
Build the rotation that transforms a pair of pv coordinates into another pair. |
|
TimeStampedAngularCoordinates(AbsoluteDate date,
Rotation rotation,
Vector3D rotationRate,
Vector3D rotationAcceleration)
Builds a rotation/rotation rate pair. |
Method Summary | |
---|---|
TimeStampedAngularCoordinates |
addOffset(AngularCoordinates offset)
Add an offset from the instance. |
TimeStampedAngularCoordinates |
addOffset(AngularCoordinates offset,
boolean computeSpinDerivatives)
Add an offset from the instance. |
AbsoluteDate |
getDate()
Get the date. |
static TimeStampedAngularCoordinates |
interpolate(AbsoluteDate date,
AngularDerivativesFilter filter,
Collection<TimeStampedAngularCoordinates> sample)
Interpolate angular coordinates. |
static TimeStampedAngularCoordinates |
interpolate(AbsoluteDate date,
AngularDerivativesFilter filter,
Collection<TimeStampedAngularCoordinates> sample,
boolean computeSpinDerivatives)
Interpolate angular coordinates. |
TimeStampedAngularCoordinates |
revert()
Revert a rotation/rotation rate/rotation acceleration triplet. |
TimeStampedAngularCoordinates |
revert(boolean computeSpinDerivative)
Revert a rotation/rotation rate/rotation acceleration triplet. |
TimeStampedAngularCoordinates |
shiftedBy(double dt)
Get a time-shifted state. |
TimeStampedAngularCoordinates |
shiftedBy(double dt,
boolean computeSpinDerivative)
Get a time-shifted state. |
TimeStampedAngularCoordinates |
subtractOffset(AngularCoordinates offset)
Subtract an offset from the instance. |
TimeStampedAngularCoordinates |
subtractOffset(AngularCoordinates offset,
boolean computeSpinDerivatives)
Subtract an offset from the instance. |
Methods inherited from class org.orekit.utils.AngularCoordinates |
---|
applyTo, applyTo, createFromModifiedRodrigues, createFromModifiedRodrigues, estimateRate, getModifiedRodrigues, getModifiedRodrigues, getRotation, getRotationAcceleration, getRotationRate, interpolate, interpolate |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public TimeStampedAngularCoordinates(AbsoluteDate date, Rotation rotation, Vector3D rotationRate, Vector3D rotationAcceleration)
date
- coordinates daterotation
- rotationrotationRate
- rotation rate Ω (rad/s)rotationAcceleration
- rotation acceleration dΩ/dt (rad²/s²)public TimeStampedAngularCoordinates(AbsoluteDate date, PVCoordinates u1, PVCoordinates u2, PVCoordinates v1, PVCoordinates v2, double tolerance) throws OrekitException
WARNING! This method requires much more stringent assumptions on
its parameters than the similar constructor
from the Rotation
class.
As far as the Rotation constructor is concerned, the v₂
vector from
the second pair can be slightly misaligned. The Rotation constructor will
compensate for this misalignment and create a rotation that ensure v₁ = r(u₁)
and v₂ ∈ plane (r(u₁), r(u₂))
. 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₁ = r(u₁)
, v₂ = r(u₂)
, dv₁/dt = dr(u₁)/dt
, dv₂/dt
= dr(u₂)/dt
, d²v₁/dt² = d²r(u₁)/dt²
, d²v₂/dt² = d²r(u₂)/dt²
.
Warning: spin derivative is not computed.
date
- coordinates dateu1
- 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 singularities
OrekitException
- if the vectors components cannot be converted to
DerivativeStructure
with proper orderpublic TimeStampedAngularCoordinates(AbsoluteDate date, PVCoordinates u1, PVCoordinates u2, PVCoordinates v1, PVCoordinates v2, double tolerance, boolean spinDerivativesComputation) throws OrekitException
WARNING! This method requires much more stringent assumptions on
its parameters than the similar constructor
from the Rotation
class.
As far as the Rotation constructor is concerned, the v₂
vector from
the second pair can be slightly misaligned. The Rotation constructor will
compensate for this misalignment and create a rotation that ensure v₁ = r(u₁)
and v₂ ∈ plane (r(u₁), r(u₂))
. 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₁ = r(u₁)
, v₂ = r(u₂)
, dv₁/dt = dr(u₁)/dt
, dv₂/dt
= dr(u₂)/dt
, d²v₁/dt² = d²r(u₁)/dt²
, d²v₂/dt² = d²r(u₂)/dt²
.
date
- coordinates dateu1
- 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 singularitiesspinDerivativesComputation
- true if the spin derivative should be computed If not, spin derivative is set to null
OrekitException
- if the vectors components cannot be converted to
DerivativeStructure
with proper orderMethod Detail |
---|
public AbsoluteDate getDate()
getDate
in interface TimeStamped
public TimeStampedAngularCoordinates revert(boolean computeSpinDerivative)
revert
in class AngularCoordinates
computeSpinDerivative
- true if spin derivative should be computed. If not, spin derivative is set to null
public TimeStampedAngularCoordinates revert()
Warning: spin derivative is not computed.
revert
in class AngularCoordinates
public TimeStampedAngularCoordinates shiftedBy(double dt, boolean computeSpinDerivative)
The state can be slightly shifted to close dates. This shift is based on an approximate solution of the fixed acceleration motion. It is not intended as a replacement for proper attitude propagation but should be sufficient for either small time shifts or coarse accuracy.
shiftedBy
in class AngularCoordinates
dt
- time shift in secondscomputeSpinDerivative
- true if spin derivative should be computed. If not, spin derivative is set to null
public TimeStampedAngularCoordinates shiftedBy(double dt)
The state can be slightly shifted to close dates. This shift is based on an approximate solution of the fixed acceleration motion. It is not intended as a replacement for proper attitude propagation but should be sufficient for either small time shifts or coarse accuracy.
Warning: spin derivative is not computed.
shiftedBy
in interface TimeShiftable<AngularCoordinates>
shiftedBy
in class AngularCoordinates
dt
- time shift in seconds
public TimeStampedAngularCoordinates addOffset(AngularCoordinates 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.
Warning: spin derivative is not computed.
addOffset
in class AngularCoordinates
offset
- offset to subtract
subtractOffset(AngularCoordinates)
public TimeStampedAngularCoordinates addOffset(AngularCoordinates offset, boolean computeSpinDerivatives)
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.
addOffset
in class AngularCoordinates
offset
- offset to subtractcomputeSpinDerivatives
- true if spin derivatives should be computed. If not, spin derivative is set to null
subtractOffset(AngularCoordinates)
public TimeStampedAngularCoordinates subtractOffset(AngularCoordinates 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.
Warning: spin derivative is not computed.
subtractOffset
in class AngularCoordinates
offset
- offset to subtract
addOffset(AngularCoordinates)
public TimeStampedAngularCoordinates subtractOffset(AngularCoordinates offset, boolean computeSpinDerivatives)
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.
subtractOffset
in class AngularCoordinates
offset
- offset to subtractcomputeSpinDerivatives
- true if spin derivatives should be computed. If not, spin derivative is set to null
addOffset(AngularCoordinates)
public static TimeStampedAngularCoordinates interpolate(AbsoluteDate date, AngularDerivativesFilter filter, Collection<TimeStampedAngularCoordinates> sample) throws OrekitException
The interpolated instance is created by polynomial Hermite interpolation on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.
This method is based on Sergei Tanygin's paper Attitude Interpolation, changing the norm of the vector to match the modified Rodrigues vector as described in Malcolm D. Shuster's paper A Survey of Attitude Representations. This change avoids the singularity at π. There is still a singularity at 2π, which is handled by slightly offsetting all rotations when this singularity is detected.
Note that even if first and second time derivatives (rotation rates and acceleration) 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 rotations.
Warning: spin derivative is not computed.
date
- interpolation datefilter
- filter for derivatives from the sample to use in interpolationsample
- sample points on which interpolation should be done
OrekitException
- if the number of point is too small for interpolatingpublic static TimeStampedAngularCoordinates interpolate(AbsoluteDate date, AngularDerivativesFilter filter, Collection<TimeStampedAngularCoordinates> sample, boolean computeSpinDerivatives) throws OrekitException
The interpolated instance is created by polynomial Hermite interpolation on Rodrigues vector ensuring rotation rate remains the exact derivative of rotation.
This method is based on Sergei Tanygin's paper Attitude Interpolation, changing the norm of the vector to match the modified Rodrigues vector as described in Malcolm D. Shuster's paper A Survey of Attitude Representations. This change avoids the singularity at π. There is still a singularity at 2π, which is handled by slightly offsetting all rotations when this singularity is detected.
Note that even if first and second time derivatives (rotation rates and acceleration) 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 rotations.
date
- interpolation datefilter
- filter for derivatives from the sample to use in interpolationsample
- sample points on which interpolation should be donecomputeSpinDerivatives
- true if spin derivative should be computed. If not, spin derivative is set to null
OrekitException
- if the number of point is too small for interpolating
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |