Admin : /* Links */

2018-03-02T09:11:57Z

Links

← Version précédente		Version du 2 mars 2018 à 09:11
Ligne 21 :		Ligne 21 :

	=== Links ===		=== Links ===
	Orekit attitudes : [https://www.orekit.org/static/architecture/attitudes.html\|Orekit Attitudes architecture description]		Orekit attitudes : [https://www.orekit.org/static/architecture/attitudes.html Orekit Attitudes architecture description]

	=== Useful Documents ===		=== Useful Documents ===

Admin : Page créée avec « == Introduction == === Scope === The purpose of this chapter is to describe the current Patrius attitude legs. An attitude leg is a time-bounded attitude law. Generalit... »

2018-03-02T08:32:07Z

Page créée avec « == Introduction == === Scope === The purpose of this chapter is to describe the current Patrius attitude legs. An attitude leg is a time-bounded attitude law. Generalit... »

Nouvelle page

== Introduction ==
=== Scope ===
The purpose of this chapter is to describe the current Patrius attitude legs.

An attitude leg is a time-bounded attitude law. Generalities on attitude laws can be found [[User Manual 3.4.1 Attitude law|here]].

=== Javadoc ===
{| class="wikitable"
|-
! scope="col"| Library
! scope="col"| Javadoc
|-
|Orekit
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/package-summary.html Package org.orekit.attitudes]
|-
|Orekit addons
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/package-summary.html Package org.orekit.attitudes]
|}

=== Links ===
Orekit attitudes : [https://www.orekit.org/static/architecture/attitudes.html|Orekit Attitudes architecture description]

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

=== Package Overview ===
The attitude leg <code>AttitudeLeg</code> interface inherits the <code>AttitudeProvider</code> interface.
Its place in the global Attitude design can be found [[User Manual 3.4.1 Attitude law#Package Overview|here]].

== Features Description ==

=== Generalities ===
Attitude legs inherit the interface <code>AttitudeLeg</code>. They are time-bounded attitude providers.
In addition to <code>AttitudeProvider</code> services, they provide the method <code>getTimeInterval()</code> returning the leg timespan.

=== Available attitude leg ===
==== Attitude legs sequence ====
An attitude legs sequence is a container for several attitude legs, contiguous for their time intervals, in such a way that the attitude legs sequence can be processed like a single attitude leg by the propagator.

The attitude legs sequence is the equivalent of the [[User Manual 3.4.1 Attitude law#Attitudes sequence|Attitudes sequence]], using attitude legs (<code>AttitudeLeg</code> instances) rather than attitude laws (<code>AttitudeLaw</code> instances).
The switching from one attitude leg to another is based on the time interval of validity of the two legs.

An attitude legs sequence is associated to a <code>PVCoordinatesProvider</code> instance, which will '''override any PVCoordinatesProvider''' passed as parameter to the methods like getAttitude(). The reason for such a behaviour, which violates the contract of the <code>AttitudeProvider</code> interface, is that :

* an attitude legs sequence needs to '''enforce coherence''' between its inner attitude legs and its homing maneuvers.

* homing maneuvers are created and computed once by using a specific <code>PVCoordinatesProvider</code>, in order to preserve good performances.

Therefore, the attitude legs sequence can only compute attitudes with the <code>PVCoordinatesProvider</code> instance it was built with, and the inner attitude legs should be coherent with this provider (the attitude sequence does not check if it's the case!)

==== TabulatedAttitude ====
<code>TabulatedAttitude</code> is an implementation of <code>AttitudeLeg</code>. It represents a tabulated attitude leg.

In order to interpolate the attitude at a date, the user must specify a list of '''ordered''' attitudes, and can specify a number of points used by Hermite interpolation.
If not specified, the number of points used by Hermite interpolation is set to a default number (currently 2).

<syntaxhighlight lang="java">
final List<Attitude> attList = new ArrayList<Attitude>();
attList.add(attitude0);
attList.add(attitude1);
final int nbrInterpPoints = 2;
final TabulatedAttitude attLeg = new TabulatedAttitude(attList, nbrInterpPoints);
</syntaxhighlight>

It is possible to get the non-interpolated ordered attitudes :
<syntaxhighlight lang="java">
final List<Attitude> attitudes = attLeg.getAttitudes();
</syntaxhighlight>

Once the tabulated is defined, the computation can be performed on any orbital state using <code>getAttitude()</code> method:
<syntaxhighlight lang="java">
Attitude attitude = attLeg.getAttitude(orbit, date, FramesFactory.getEME2000());
</syntaxhighlight>

==== RelativeTabulatedAttitudeLeg ====
<code>RelativeTabulatedAttitudeLeg</code> is an implementation of <code>AttitudeLeg</code>. An instance of <code>RelativeTabulatedAttitudeLeg</code> can be created with a <code>List<Pair<Double, Rotation>></code> or with a <code>List<Pair<Double, AngularCoordinates>></code>. Each <code>Rotation</code> (or <code>AngularCoordinates</code>) is associated with a <code>double</code> representing its time ellapsed in seconds since the reference date. Here is an example of a creation of an instance of <code>RelativeTabulatedAttitudeLeg</code> :

<syntaxhighlight lang="java">
// date and frame
AbsoluteDate refDate = new AbsoluteDate(2008, 1, 1, TimeScalesFactory.getTAI());
Frame frame = FramesFactory.getGCRF();
double timeEllapsedSinceRefDate = 1.0;

// List of AR
List<Pair<Double, AngularCoordinates>> listAr = new ArrayList<Pair<Double, AngularCoordinates>>();
final AngularCoordinates ar = new AngularCoordinates(
new Rotation(false, 0.48, 0.64, 0.36, 0.48), Vector3D.PLUS_I, Vector3D.PLUS_J);
listAr.add(new Pair<Double, AngularCoordinates>(timeEllapsedSinceRefDate, ar));

// create RelativeTabulatedAttitudeLeg
final RelativeTabulatedAttitudeLeg relativeTabulatedAttitudeLeg =
new RelativeTabulatedAttitudeLeg(refDate, frame, listAr);
</syntaxhighlight>

== Getting Started ==
=== Building an attitude legs sequence ===

The attitude legs sequence was designed as a simple container, it performs only a few coherence checks on its inner attitude laws. Here's how an attitude sequence is built.

* An attitude legs sequence is created empty, associated to a single <code>PVCoordinatesProvider</code> instance.

* The sequence is mutable, attitude laws can be added to it one by one.

* Each attitude law is identified by a code.

* The sequence has a validity time interval, which is the grouping of the validity time intervals of all contained laws.

* The time interval of a newly added law must be contiguous to the grouped time interval of the already added laws. Otherwise an OrekitException is thrown.

* As soon as the sequence contains at least one law, methods of the <code>AttitudeLeg</code> interface can be called on the attitude sequence. The attitude sequence forwards the request to the appropriate attitude leg (according to the asking date), but replaces the <code>PVCoordinatesProvider</code> attribute of the call with the inner <code>PVCoordinatesProvider</code> instance.

=== AttitudeLawLeg and AttitudeLegsSequence : Code sample ===

<syntaxhighlight lang="java">
final BodyCenterPointing earthCenterAttitudeLaw = new BodyCenterPointing(itrf);
final AttitudeLeg law1 = new AttitudeLawLeg(earthCenterAttitudeLaw, date1, date2);
final AttitudeLeg law2 = ... ;
final AttitudeLeg law3 = ... ;

PVCoordinatesProvider pvProvider = new CartesianOrbit(pvCoordinates, gcrf, date1, mu);
final AttitudeLegsSequence sequence = new AttitudeLegsSequence(pvProvider);
// After each add the sequence has to be contiguous, so the order may be important
sequence.add("L1", law1);
sequence.add("L2", law2);
sequence.add("L3", law3);

// Call to getAttitude on the sequence ignores otherPvProvider and uses pvProvider internally instead
final Attitude sAttitude = sequence.getAttitude(otherPvProvider, date, itrf);
</syntaxhighlight>

== Contents ==
=== Interfaces ===
{| class="wikitable"
|-
! scope="col"| Interface
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''AttitudeLeg'''
|This interface extends the AttitudeProvider interface and adds the time interval of validity notion to the attitude laws.
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/AttitudeLeg.html ...]
|}

=== Classes ===
{| class="wikitable"
|-
! scope="col"| Class
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''AttitudeLawLeg'''
|Object representing an attitude law for spacecraft attitude field purposes.
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/AttitudeLawLeg.html ...]
|-
|'''TabulatedAttitude'''
|Object representing a tabulated attitude leg : the attitude at a date is interpolated from a list of known ones.
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/TabulatedAttitude.html ...]
|-
|'''AttitudeLegsSequence'''
|Object representing a sequence of contiguous attitude legs.
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/AttitudeLegsSequence.html ...]
|-
|'''RelativeTabulatedAttitudeLeg'''
|This class implements a tabulated attitude leg with relative dates.
|[{{JavaDoc3.4.1}}/org/orekit/attitudes/RelativeTabulatedAttitudeLeg.html ...]
|}

[[Category:User_Manual_3.4.1_Attitude]]

User Manual 3.4.1 Attitude leg - Historique des versions

Admin : /* Links */

Admin : Page créée avec « == Introduction == === Scope === The purpose of this chapter is to describe the current Patrius attitude legs. An attitude leg is a time-bounded attitude law. Generalit... »

Admin : /* Links */

Admin : Page créée avec « == Introduction == === Scope === The purpose of this chapter is to describe the current Patrius attitude legs. An attitude leg is a time-bounded attitude law. Generalit... »