User Manual 3.3 Kinematics - Historique des versions

Admin le 26 février 2018 à 16:53

2018-02-26T16:53:32Z

← Version précédente		Version du 26 février 2018 à 16:53
Ligne 183 :		Ligne 183 :
	== [[File:lightBulb.png]] Tips & Tricks ==		== [[File:lightBulb.png]] Tips & Tricks ==
	{{specialInclusion prefix=$theme_sub section="Tips"/}}		{{specialInclusion prefix=$theme_sub section="Tips"/}}

			[[Category:User_Manual_3.3_Attitude]]

Admin le 26 février 2018 à 16:53

2018-02-26T16:53:06Z

@@ Ligne 8 : / Ligne 8 : @@
 The kinematics objects are available in the package org.orekit.attitudes.kinematics in the Orekit library.
-|=(% colspan="3" %)Library|=(% colspan="6" %)Javadoc
+{| class="wikitable"
-|(% colspan="3" %)Orekit|(% colspan="6" %)[{{JavaDoc3.3}}/org/orekit/attitudes/kinematics/package-summary.html Package org.orekit.attitudes.kinematics]
+|-
 === Links ===
@@ Ligne 19 : / Ligne 25 : @@
 === Package Overview ===
 The following diagram represents the main classes of the <code>org.orekit.attitudes.kinematics</code> package:
 == Features Description ==
@@ Ligne 47 : / Ligne 52 : @@
 * compute the spin from the Euler or Cardan angles and their derivatives;
 * using a direct analytic computation (when the function representing its variation over time is available).
 === Time-dependent orientation function===
@@ Ligne 146 : / Ligne 136 : @@
 * Analytic computation: if the spin is represented by a function, its instantaneous value must be obtained by direct analytic computation (the <code>IVector3DFunction</code> classes have been created for this purpose)
 == Tutorials ==

Admin : /* Compute the spin */

2018-02-26T16:47:33Z

Compute the spin

← Version précédente		Version du 26 février 2018 à 16:47
Ligne 127 :		Ligne 127 :
	* Estimation: two rotations corresponding to two different dates are used to compute the spin (the velocity is supposed to be constant during the time interval between the two rotations).		* Estimation: two rotations corresponding to two different dates are used to compute the spin (the velocity is supposed to be constant during the time interval between the two rotations).
	This function is implemented by the following method in the kinematics toolkit:		This function is implemented by the following method in the kinematics toolkit:
	~~<code>public static Vector3D estimateSpin(final Rotation start, final Rotation end, final double dt)</code>.~~

	* <math>\Omega_{S/R}^{[S]} = 2Q_{S/R}\~~.Q_~~{S/R}</math>, when knowing the derivative of the quaternion.		<syntaxhighlight lang="java">public static Vector3D estimateSpin(final Rotation start, final Rotation end, final double dt)</syntaxhighlight>.

			* <math>\Omega_{S/R}^{[S]} = 2Q_{S/R}\dot{Q}_{S/R}</math>, when knowing the derivative of the quaternion.
	This equation is implemented by the following kinematics toolkit method:		This equation is implemented by the following kinematics toolkit method:
	<~~code~~>public static Vector3D computeSpin(final Quaternion q, final Quaternion qd)</~~code~~>.
			<syntaxhighlight lang="java">public static Vector3D computeSpin(final Quaternion q, final Quaternion qd)</syntaxhighlight>.

	* Using the derivative of the Euler or Cardan angles:		* Using the derivative of the Euler or Cardan angles:
	** Euler (not to be used when the angles are small):		** Euler (not to be used when the angles are small):
	<math>\Omega_{S/R}^{[S]} = \left[ \begin{array}{c} \dot{\psi}\sin(\theta)\sin(\phi) + \dot{\theta}\cos(\phi) \\ \dot{\psi}\sin(\theta)\cos(\phi)- \dot{\theta}\sin(\phi) \\ \dot{\psi}\cos(\theta) + \dot{\phi} \end{array} \right]</math>		<math>\Omega_{S/R}^{[S]} = \left[ \begin{array}{c} \dot{\psi}\sin(\theta)\sin(\phi) + \dot{\theta}\cos(\phi) \\ \dot{\psi}\sin(\theta)\cos(\phi)- \dot{\theta}\sin(\phi) \\ \dot{\psi}\cos(\theta) + \dot{\phi} \end{array} \right]</math>
	** Cardan (only to be used when the angles are small):		** Cardan (only to be used when the angles are small):
	<math>\Omega_{S/R}^{[S]} = \left[ \begin{array}{c}-\dot{\psi}\sin(\theta)+\dot{\phi} \\ \dot{\psi}\cos(\theta)\sin(\phi) + \dot{\theta}\cos(\phi) \\ \dot{\psi}\cos(\theta)\cos(\phi) - \dot{\theta}\sin(\phi) \end{array} \right]</math>		<math>\Omega_{S/R}^{[S]} = \left[ \begin{array}{c}-\dot{\psi}\sin(\theta)+\dot{\phi} \\ \dot{\psi}\cos(\theta)\sin(\phi) + \dot{\theta}\cos(\phi) \\ \dot{\psi}\cos(\theta)\cos(\phi) - \dot{\theta}\sin(\phi) \end{array} \right]</math>

	These formula are implemented by the following kinematics toolkit method:		These formula are implemented by the following kinematics toolkit method:
	<~~code~~>public static Vector3D computeSpin(final double[] ang, final double[] angd, final RotationOrder order)</~~code~~>.
			<syntaxhighlight lang="java">public static Vector3D computeSpin(final double[] ang, final double[] angd, final RotationOrder order)</syntaxhighlight>.

	* Analytic computation: if the spin is represented by a function, its instantaneous value must be obtained by direct analytic computation (the <code>IVector3DFunction</code> classes have been created for this purpose)		* Analytic computation: if the spin is represented by a function, its instantaneous value must be obtained by direct analytic computation (the <code>IVector3DFunction</code> classes have been created for this purpose)

Admin : /* Differentiate a quaternion */

2018-02-26T16:43:43Z

Differentiate a quaternion

← Version précédente		Version du 26 février 2018 à 16:43
Ligne 95 :		Ligne 95 :
	As a time-dependent quaternion can be represented by the <code>OrientationFunction</code> interface, the derivative of the quaternion can be computed using the <code>derivative()</code> method. As this method is implemented by the user, he can choose to use a numerical differentiation method or to compute the exact derivative, when possible.		As a time-dependent quaternion can be represented by the <code>OrientationFunction</code> interface, the derivative of the quaternion can be computed using the <code>derivative()</code> method. As this method is implemented by the user, he can choose to use a numerical differentiation method or to compute the exact derivative, when possible.

	The derivative of a quaternion can be also computed using the kinematics equation: <math>\~~.Q_~~{S/R} = \frac{1}{2}Q_{S/R}\Omega_{S/R}^{[S]}</math>.		The derivative of a quaternion can be also computed using the kinematics equation: <math>\dot{Q}_{S/R} = \frac{1}{2}Q_{S/R}\Omega_{S/R}^{[S]}</math>.
	This equation is implemented by the following method in the kinematics toolkit:		This equation is implemented by the following method in the kinematics toolkit:
	<~~code~~>public static Quaternion differentiateQuaternion(final Quaternion q, final Vector3D spin)</~~code~~>
			<syntaxhighlight lang="java">public static Quaternion differentiateQuaternion(final Quaternion q, final Vector3D spin)</syntaxhighlight>

	=== Integrate a quaternion ===		=== Integrate a quaternion ===

Admin : /* Time-dependent orientation function */

2018-02-26T16:41:24Z

Time-dependent orientation function

← Version précédente		Version du 26 février 2018 à 16:41
Ligne 72 :		Ligne 72 :
	* return the function representing the derivative of the quaternion components, by the <code>derivative()</code> method. A numerical differentiation method is used to compute the derivatives, nevertheless the classes inheriting the <code>AbstractOrientationFunction</code> can override this method and return the analytical function representing the derivatives, when possible.		* return the function representing the derivative of the quaternion components, by the <code>derivative()</code> method. A numerical differentiation method is used to compute the derivatives, nevertheless the classes inheriting the <code>AbstractOrientationFunction</code> can override this method and return the analytical function representing the derivatives, when possible.

	* compute the function representing the spin using the <math>\Omega_{S/R}^{[S]} = 2Q_{S/R}\~~.Q_~~{S/R}</math> formula, by the <code>computeSpinFunction()</code> method. The derivatives of the quaternion are computed thanks to the <code>derivative()</code> method.		* compute the function representing the spin using the <math>\Omega_{S/R}^{[S]} = 2Q_{S/R}\dot{Q}_{S/R}</math> formula, by the <code>computeSpinFunction()</code> method. The derivatives of the quaternion are computed thanks to the <code>derivative()</code> method.

	* estimate the function representing the spin using two rotations corresponding to two different dates (the velocity is supposed to be constant during the time interval between the two rotations), by the <code>estimateRateFunction(dt)</code> method.		* estimate the function representing the spin using two rotations corresponding to two different dates (the velocity is supposed to be constant during the time interval between the two rotations), by the <code>estimateRateFunction(dt)</code> method.

Admin : /* Features Description */

2018-02-26T16:39:31Z

Features Description

← Version précédente		Version du 26 février 2018 à 16:39
Ligne 27 :		Ligne 27 :
	A quaternion can be differentiated using various methods:		A quaternion can be differentiated using various methods:

	* The quaternion differentiation’s formula <math>\~~.Q_~~{S/R} = \frac{1}{2}Q_{S/R}\Omega_{S/R}^{[S]}</math>.		* The quaternion differentiation’s formula <math>\dot{Q}_{S/R} = \frac{1}{2}Q_{S/R}\Omega_{S/R}^{[S]}</math>.
	This formula connects time derivative of the quaternion q(t) with the vector of angular velocity W(t).		This formula connects time derivative of the quaternion q(t) with the vector of angular velocity W(t).

	* When the quaternion is represented by a set of differentiable functions (Fourier series or polynomials), a direct analytic computation can be performed to get its derivative;		* When the quaternion is represented by a set of differentiable functions (Fourier series or polynomials), a direct analytic computation can be performed to get its derivative;

Admin : Admin a déplacé la page Kinematics vers User Manual 3.3 Kinematics sans laisser de redirection

2018-02-26T16:34:55Z

Admin a déplacé la page Kinematics vers User Manual 3.3 Kinematics sans laisser de redirection

← Version précédente	Version du 26 février 2018 à 16:34
(Aucune différence)

Admin : 1 révision importée

2018-02-26T16:34:21Z

1 révision importée

← Version précédente	Version du 26 février 2018 à 16:34
(Aucune différence)

Admin le 26 février 2018 à 16:34

2018-02-26T16:34:21Z

Nouvelle page

== Introduction ==
=== Scope ===
The purpose is to extend the current Orekit attitude package with classes and methods to compute and process kinematics operations.

=== Javadoc ===
The kinematics objects are available in the package org.orekit.attitudes.kinematics in the Orekit library.

|=(% colspan="3" %)Library|=(% colspan="6" %)Javadoc
|(% colspan="3" %)Orekit|(% colspan="6" %)[{{JavaDoc3.3}}/org/orekit/attitudes/kinematics/package-summary.html Package org.orekit.attitudes.kinematics]

=== Links ===
{{specialInclusion prefix=$theme_sub section="Links"/}}

=== Useful Documents ===
{{specialInclusion prefix=$theme_sub section="UsefulDocs"/}}

=== Package Overview ===
The following diagram represents the main classes of the <code>org.orekit.attitudes.kinematics</code> package:
[[File:kinematics.bmp|center]]

== Features Description ==
=== Quaternions differentiation ===
A quaternion can be differentiated using various methods:

* The quaternion differentiation’s formula <math>\.Q_{S/R} = \frac{1}{2}Q_{S/R}\Omega_{S/R}^{[S]}</math>.
This formula connects time derivative of the quaternion q(t) with the vector of angular velocity W(t).

* When the quaternion is represented by a set of differentiable functions (Fourier series or polynomials), a direct analytic computation can be performed to get its derivative;

* Numerical differentiation (using finite difference, Ridders differentiation method, ...)

=== Quaternion integration ===
A rotation can be integrated, knowing its spin time function, using these methods:
* Wilcox method, with available approximations orders 1 to 4
* Edwards method, that corresponds to an order 3 approximation

=== Spin computation ===
The spin can be represented by a vector (instantaneous spin), or by a time-dependent function.
The computation of the instantanous value of the spin can be made by one of the following methods:

* estimate the spin from two rotations corresponding to two different dates;
* using the kinematics equation when a quaternion and its derivative are known;
* compute the spin from the Euler or Cardan angles and their derivatives;
* using a direct analytic computation (when the function representing its variation over time is available).

== Getting Started ==
TBD

== Contents ==
=== Interfaces ===
|=(% colspan="3" %)Interface|=(% colspan="6" %)Summary|=(% colspan="1" %)Javadoc
|(% colspan="3" %)'''OrientationFunction'''|(% colspan="6" %)This interface represents a generic univariate orientation function.|[{{JavaDoc3.3}}/org/orekit/attitudes/kinematics/OrientationFunction.html ...]
|(% colspan="3" %)'''Vector3DFunction'''|(% colspan="6" %)This interface represents a generic univariate 3-D vector function.|[{{JavaDoc3.3}}/org/orekit/attitudes/kinematics/Vector3DFunction.html ...]

=== Classes ===
|=(% colspan="3" %)Class|=(% colspan="6" %)Summary|=(% colspan="1" %)Javadoc
|(% colspan="3" %)'''AbstractOrientationFunction'''|(% colspan="6" %)This class represents an orientation function.|[{{JavaDoc3.3}}/org/orekit/attitudes/kinematics/AbstractOrientationFunction.html ...]
|(% colspan="3" %)'''AbstractVector3DFunction'''|(% colspan="6" %)This class represents a spin function, or a spin n-th derivative function.|[{{JavaDoc3.3}}/org/orekit/attitudes/kinematics/AbstractVector3DFunction.html ...]

=== Time-dependent orientation function===
The interface <code>OrientationFunction</code> and the abstract class <code>AbstractOrientationFunction</code> have been added to the kinematics package in order to represent a time-dependent orientation function.

These classes provide the following functionalities:

* return the orientation at a date, by the <code>getOrientation(AbsoluteDate)</code> method; it is an abstract method because it is specific to the orientation (or attitude) law the user wants to implement;

* return the function representing the derivative of the quaternion components, by the <code>derivative()</code> method. A numerical differentiation method is used to compute the derivatives, nevertheless the classes inheriting the <code>AbstractOrientationFunction</code> can override this method and return the analytical function representing the derivatives, when possible.

* compute the function representing the spin using the <math>\Omega_{S/R}^{[S]} = 2Q_{S/R}\.Q_{S/R}</math> formula, by the <code>computeSpinFunction()</code> method. The derivatives of the quaternion are computed thanks to the <code>derivative()</code> method.

* estimate the function representing the spin using two rotations corresponding to two different dates (the velocity is supposed to be constant during the time interval between the two rotations), by the <code>estimateRateFunction(dt)</code> method.

* return the spin at a date, by the <code>computeSpin(AbsoluteDate)</code>, or <code>estimateRate(AbsoluteDate, dt)</code> methods (they call the <code>computeSpinFunction()</code> and <code>estimateRateFunction(dt)</code> methods)

=== Time-dependent spin function===
The interface <code>Vector3DFunction</code> and the abstract class <code>AbstractVector3DFunction</code> have been added to the kinematics package in order to represent a time-dependent vector 3D function; a vector 3D function is used to represent the spin, or the n-th derivative of the spin.

These classes provide the following functionalities:

* return the vector at a date, by the <code>getVector3D(AbsoluteDate)</code> method; it is an abstract method because it is specific to the spin (or derivative of the spin) the user wants to implement;

* return the function representing the n-th derivative of the vector, by the <code>nthDerivative(order)</code> method. A numerical differentiation method is used to compute the derivatives, nevertheless the classes inheriting the <code>AbstractVector3DFunction</code> can override this method and return the analytical function representing the derivatives, when possible.
This method uses the Commons Math classes contained in the differentiation package, in particular the <code>DerivativeStructure</code> class, which allows to compute the n-th derivatives of a function at a point;

* return the integral of the function by the <code>integral(x0, xf)</code> method. A numerical integration method is used to compute the integral, nevertheless the classes inheriting the <code>AbstractVector3DFunction</code> can override this method and return the analytical function representing the integral, when possible.

The <code>DynamicsElements</code> object is created from a spin function and it gathers the n-th derivatives of spin at a given date; an attribute of this class is contained in the <code>Attitude</code> class.

=== Differentiate a quaternion ===
As a time-dependent quaternion can be represented by the <code>OrientationFunction</code> interface, the derivative of the quaternion can be computed using the <code>derivative()</code> method. As this method is implemented by the user, he can choose to use a numerical differentiation method or to compute the exact derivative, when possible.

The derivative of a quaternion can be also computed using the kinematics equation: <math>\.Q_{S/R} = \frac{1}{2}Q_{S/R}\Omega_{S/R}^{[S]}</math>.
This equation is implemented by the following method in the kinematics toolkit:
<code>public static Quaternion differentiateQuaternion(final Quaternion q, final Vector3D spin)</code>

=== Integrate a quaternion ===
The rotation integration is to be made by the following methods of the <code>KinematicsToolkit</code> class :

* Wilcox method :

<syntaxhighlight lang="java">
Rotation finalRot = KinematicsToolkit.integrate(IntegrationType.WILCOX_1,
initOrientation, initDate, finalDate, spin, dt);
</syntaxhighlight>

The order integer is the approximation order : the ones available are 1 to 4.

* Edwards method :

<syntaxhighlight lang="java">
Rotation finalRot = KinematicsToolkit.integrate(IntegrationType.EDWARDS,
initOrientation, initDate, finalDate, spin, dt);
</syntaxhighlight>

=== Differentiate and integrate a vector ===
In a similar way to the orientation function, a new class has been added in order to represent a time-dependent 3-D vector function. This class implements the <code>Vector3DFunction</code> interface, and it contains the methods to compute the derivative of the vector or its integral over a time period. The computation can be done using a numerical method or it can be analytical, when possible.

=== Compute the spin ===
The Kinematics package contains some methods aiming to compute the instantaneous spin. These methods are listed hereafter:

* Estimation: two rotations corresponding to two different dates are used to compute the spin (the velocity is supposed to be constant during the time interval between the two rotations).
This function is implemented by the following method in the kinematics toolkit:
<code>public static Vector3D estimateSpin(final Rotation start, final Rotation end, final double dt)</code>.

* <math>\Omega_{S/R}^{[S]} = 2Q_{S/R}\.Q_{S/R}</math>, when knowing the derivative of the quaternion.
This equation is implemented by the following kinematics toolkit method:
<code>public static Vector3D computeSpin(final Quaternion q, final Quaternion qd)</code>.

* Using the derivative of the Euler or Cardan angles:
** Euler (not to be used when the angles are small):
<math>\Omega_{S/R}^{[S]} = \left[ \begin{array}{c} \dot{\psi}\sin(\theta)\sin(\phi) + \dot{\theta}\cos(\phi) \\ \dot{\psi}\sin(\theta)\cos(\phi)- \dot{\theta}\sin(\phi) \\ \dot{\psi}\cos(\theta) + \dot{\phi} \end{array} \right]</math>
** Cardan (only to be used when the angles are small):
<math>\Omega_{S/R}^{[S]} = \left[ \begin{array}{c}-\dot{\psi}\sin(\theta)+\dot{\phi} \\ \dot{\psi}\cos(\theta)\sin(\phi) + \dot{\theta}\cos(\phi) \\ \dot{\psi}\cos(\theta)\cos(\phi) - \dot{\theta}\sin(\phi) \end{array} \right]</math>
These formula are implemented by the following kinematics toolkit method:
<code>public static Vector3D computeSpin(final double[] ang, final double[] angd, final RotationOrder order)</code>.

* Analytic computation: if the spin is represented by a function, its instantaneous value must be obtained by direct analytic computation (the <code>IVector3DFunction</code> classes have been created for this purpose)

== Tutorials ==
=== Tutorial 1 ===
{{specialInclusion prefix=$theme_sub section="Tuto1"/}}

=== Tutorial 2 ===
{{specialInclusion prefix=$theme_sub section="Tuto2"/}}

== [[File:lightBulb.png]] Tips & Tricks ==
{{specialInclusion prefix=$theme_sub section="Tips"/}}

User Manual 3.3 Kinematics - Historique des versions

Admin le 26 février 2018 à 16:53

Admin le 26 février 2018 à 16:53

Admin : /* Compute the spin */

Admin : /* Differentiate a quaternion */

Admin : /* Time-dependent orientation function */

Admin : /* Features Description */

Admin : Admin a déplacé la page Kinematics vers User Manual 3.3 Kinematics sans laisser de redirection

Admin : 1 révision importée

Admin le 26 février 2018 à 16:34

Admin : /* Compute the spin */

Admin : /* Differentiate a quaternion */

Admin : /* Time-dependent orientation function */

Admin : /* Features Description */

Admin : Admin a déplacé la page Kinematics vers User Manual 3.3 Kinematics sans laisser de redirection

Admin : 1 révision importée