Voir la source de User Manual 4.14 Maneuvers



== Introduction ==
=== Scope ===
The scope of this section is to present the maneuver models available through the Patrius libraries.

=== Javadoc ===
All the classes related to maneuvers are in the following packages:

{| class="wikitable"
|-
! scope="col"| Library
! scope="col"| Javadoc
|-
|Patrius 
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/package-summary.html Package fr.cnes.sirius.patrius.forces.maneuvers]
|}

=== Links ===
None as of now.

=== Useful Documents ===
None as of now.

=== Package Overview ===
The maneuver package <code>fr.cnes.sirius.patrius.forces.maneuvers</code> contains:
* Continuous maneuvers: both constant and variable)
* Impulsive maneuvers
* Maneuvers sequences
* An analytical model for small maneuvers
* Impulsive maneuvers based on orbital increments (da, de, di).

== Features Description ==
=== Continuous Thrust Maneuver ===
Continuous thrust maneuvers are defined using the class <code>ContinuousThrustManeuver</code>.
With it, you can  either define:
* A constant maneuver
* A variable maneuver

A maneuver contains the following parameters:

* A start date / end date: this can be defined either:
** With a start date and a duration (former method)
**With event detectors, first detector for starting the maneuver, second detector for stopping the maneuver. '''Action.STOP''' is required to trigger (start/stop) the thrust. Any other action will be discarded.

When using event detectors, pay attention to events that may occur several times. If you want the maneuver to perform only once, the event detectors have to be included in a nth occurrence detector or its <code>shouldBeRemoved()</code> method have to return <code>true</code>. Otherwise the maneuver may be performed more than once: if a maneuver starts at the perigee (using a perigee detector) and stops at the apogee (using an apogee detector), then a maneuver will start at every perigee and stop at every apogee.

* A frame in which the thrust direction is provided. This can either be:
** A generic <code>frame</code>
** A local orbital frame <code>LOFType</code>
** The spacecraft frame (in this case, attitude is mandatory to compute transform from spacecraft frame from propagation frame)

* A <code>PropulsiveProperty</code> which contains:
** Thrust: it can be either constant (using <code>double</code>) or variable (using <code>IDependentVariable<SpacecraftState></code>). If defined as constant, thrust is then defined as a <code>Parameter</code> and derivative with respect to thrust can be computed
** ISP: it can be either constant (using <code>double</code>) or variable (using <code>IDependentVariable<SpacecraftState></code>)

* A <code>MassProvider</code> used to compute total mass of spacecraft

* A <code>TankProperty</code> indicating the tank to use for the maneuver

If your propagation starts within a maneuver, two methods are available to manually start/stop a maneuver :
* <code>isFiring()</code>
* <code>setFiring(final boolean isFiring)</code>
A user wanting to start a propagation during a maneuver will call <code>setFiring(true)</code> before launching the propagation.
This is useful since maneuver start and stop criteria are defined through event detectors.
This mecanism is available for any non-impulsive maneuver i.e. <code>ContinuousThrustManeuver</code> and <code>ConstantThrustError</code>.

The construction possibilities are listed in the following array:

{| class="wikitable"
|-
! scope="col"| Parameter type
! scope="col"| Number of possibilities
! scope="col"| Detail
|-
|**Thrust start/end criteria
|2
|Date + thrust duration or event detectors for start/end.
|-
|**ISP, Thrust
|1
|Propulsive property (can be constant or variable).
|-
|**Thrust direction
|2
|Constant (Vector3D) or variable (IDependentVectorVariable<SpacecraftState>).
|-
|**Thrust direction frame
|3
|Satellite frame, local orbital frame or Frame object.
|-
|**Fuel tank
|1
|TankProperty.
|}

All these possibilities lead to 12 constructors.

This class also provides a method to retrieve current DV used: <code>getDeltaVSat</code>. The total used Delta-V is updated after each integration step.

Below are examples with constant and variable thrust maneuvers.

==== Constant Thrust Maneuver ====
In this case, the thrust, the ISP and the acceleration direction are constant values.

Here is an example of a constant maneuver of direction [1, 0, 0] in TNW frame.
<syntaxhighlight lang="java">
final double thrust = 420;
final double isp = 318;
final Vector3D direction = Vector3D.PLUS_I;
final PropulsiveProperty propulsiveProperty = new PropulsiveProperty(thrust, isp);
final TankProperty tankProperty = new TankProperty(1000.);
final ContinuousThrustManeuver maneuver = new ContinuousThrustManeuver(date, duration, propulsiveProperty, direction, massProvider, tankProperty, LOFType.TNW);
</syntaxhighlight>

Partial derivatives with respect to thrust can be computed. To do so, you either:
* Define your own thrust as a parameter:
<syntaxhighlight lang="java">
final double thrustParam = new Parameter("Thrust", 420);
final double ispParam = new Parameter("ISP", 318);
final PropulsiveProperty propulsiveProperty = new PropulsiveProperty(thrustParam, ispParam);
</syntaxhighlight>
And then call <code>maneuver.addDAccDParam(..., thrustParam, ...)</code>

* Or retrieve the thrust parameter:
<syntaxhighlight lang="java">
final double thrust = 420;
final double isp = 318;
final PropulsiveProperty propulsiveProperty = new PropulsiveProperty(thrust, isp);
finl Parameter thrustParam = propulsiveProperty.getThrustParam();
</syntaxhighlight>
And then call <code>maneuver.addDAccDParam(..., thrustParam, ...)</code>

==== Variable Thrust Maneuver ====
In this case, the thrust, the ISP and the acceleration direction can be variable values.

Here is an example of a variable maneuver of variable direction in TNW frame and variable thrust and ISP.
<syntaxhighlight lang="java">
final IDependentVariable<SpacecraftState> thrust = ...;
final IDependentVariable<SpacecraftState> isp = ...;
final IDependentVectorVariable<SpacecraftState> direction = ...;
final PropulsiveProperty propulsiveProperty  = new PropulsiveProperty(thrust, isp);
final TankProperty tankProperty = new TankProperty(1000.);
final ContinuousThrustManeuver maneuver = new ContinuousThrustManeuver(date, duration, propulsiveProperty, direction, massProvider, tankProperty, LOFType.TNW);
</syntaxhighlight>

No implementation of <code>IDependentVariable<SpacecraftState></code> and <code>IDependentVectorVariable<SpacecraftState></code> are provided in Patrius. You can however easily create your own.

Remember that partial derivatives with respect to thrust cannot be computed using variable maneuvers.

=== Impulse Maneuver ===
This <code>ImpulseManeuver</code> class implements the <code>EventDetector</code> interface.<br>
This maneuver is provided with an underlying event detector; when an underlying event is triggered, and only if its action is set to STOP, the maneuver is triggered and the current <code>SpacecraftState</code> is reset. An increment or a decrement is applied to its velocity and a ratio is applied to the mass. These changes depend on the direction of variation of the integration variable (time) during integration : propagation or retro-propagation case.

This class also provides a method to retrieve current DV used: <code>getDeltaVSat</code>. In the impulse maneuver case, the DV is either 0 or the DV provided by the user once the maneuver has been performed.

=== List of maneuvers ===
The class <code>ManeuversSequence</code> handles the creation and the operations on a list of maneuvers; the maneuvers that can be added to the list are the following ones :
* Impulse maneuvers;

* Continue constant maneuvers;

* Continue maneuvers with variable thrust and ISP;

The user can do the following operations on the list:
* add a new maneuver; to add it, the following conditions must be met:
** there must be no superposition between the new maneuver and any maneuver in the list. <br> If the new maneuver is an impulse one and its triggering event detector is not a date detector, it always adds the maneuver (there is no way to know in advance its date). Otherwise if the new maneuver is an impulse one and its triggering event detector is a date detector, it gets the date of the maneuver from the triggering detector and uses this information to check the superposition;
** the time between the end of the previous maneuver and the start of the new maneuver, as well as the time between the end of the new maneuver and the start of the next maneuver, must be bigger than a threshold value. The threshold value depends on the type of maneuver (impulse or continue) and can be chosen by the user.

* remove a maneuver already in the list;

* get the number of maneuvers in the list;

* add all the maneuvers of the list to the propagator; 

The following lines show the usage of the class:

<syntaxhighlight lang="java">
final ManeuversSequence sequence = new ManeuversSequence(0.0, 0.0);
// add the maneuvers to the sequence:
sequence.add(constantManeuver);
sequence.add(impulseManeuver);
// apply the maneuvers to the propagator:
sequence.applyTo(numericalPropagator);
</syntaxhighlight>

=== Impulse maneuvers based on orbital increments ===

Three class are currently available:
* <code>ImpulseDaManeuver</code>: semi-major axis change
* <code>ImpulseDeManeuver</code>: semi-major axis as well as eccentricity change
* <code>ImpulseDiManeuver</code>: semi-major axis as well as inclination change
These classes simply modify the orbital parameters according to user provided data (da, de or di). The DV and used mass are computed accordingly.
These maneuvers inherit <code>ImpulseManeuver</code>, hence should be used in the same way with propagators.

== Getting Started ==
{{specialInclusion prefix=$theme_sub section="GettingStarted"/}}

== Contents ==
=== Interfaces ===

=== Classes ===

{| class="wikitable"
|-
! scope="col"| Class
! scope="col"| Summary
! scope="col"| Javadoc
|-
|'''ContinuousThrustManeuver'''
|This class implements a continuous thrust maneuver.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/ContinuousThrustManeuver.html ...]
|-
|'''ImpulseManeuver'''
|This class implements an impulse maneuver model.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/ImpulseManeuver.html ...]
|-
|'''SmallManeuverAnalyticalModel'''
|This class implements an analytical model for small maneuvers.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/SmallManeuverAnalyticalModel.html ...]
|-
|'''ManeuversSequence'''
|This class implements a sequence of maneuvers.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/ManeuversSequence.html ...]
|-
|'''ImpulseDaManeuver'''
|This class implements an impulse maneuver modifying the orbit semi-major axis.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/orbman/ImpulseDaManeuver.html ...]
|-
|'''ImpulseDeManeuver'''
|This class implements an impulse maneuver modifying the orbit semi-major axis and eccentricity.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/orbman/ImpulseDeManeuver.html ...]
|-
|'''ImpulseDiManeuver'''
|This class implements an impulse maneuver modifying the orbit semi-major axis and inclination.
|[{{JavaDoc4.14}}/fr/cnes/sirius/patrius/forces/maneuvers/orbman/ImpulseDiManeuver.html ...]
|}

[[Category:User_Manual_4.14_Mission]]