Moniteurs de Simulation - plaa/Modular GitHub Wiki

Les Moniteurs de Simulation sont une fonction avancée permettant de monitorer et d'interagir avec les simulations de vol lorsqu'elles tournent. Ils fonctionnent en programmant des routines de code personnalisées qui sont appelées à différents endroit durant la simulation. OpenRocket permet un contrôle total du vol durant la simulation. Cela permet par exemple de simuler un "air-starts", des mécanismes de contrôle actif ou de calculer certains paramètres de vol sur le moment.

L'utilisation des moniteurs de simulations demande des connaissances simple en Java et de savoir utiliser la ligne de commande.

Les étapes pour implémenter et utiliser simplement les moniteurs de simulation sont décrites ci-dessous:

1. Coder le moniteur de simulation en Java.
2. Compiler le fichier class Java.
3. Démarrer OpenRocket et inclure le fichier class dans le classpath.
4. Ajouter le moniteur de simulation à une simulation et lancer la simulation.

L'exemple qui suit explique comment simuler un "air-start launch" qui lance à une hauteur de 1000 mètres.

Tout d'abord nous avons besoin de coder le moniteur de simulation en Java. Le code ci-dessous est stocké dans le fichier "AirStart.java":

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

import net.sf.openrocket.simulation.SimulationStatus;
import net.sf.openrocket.simulation.exception.SimulationException;
import net.sf.openrocket.simulation.listeners.AbstractSimulationListener;
import net.sf.openrocket.util.Coordinate;

/**
 * Moniteur de simulation qui fait décoller une fusée à une altitude spécifique.
 */
public class AirStart extends AbstractSimulationListener {

    /** Altitude de décollage en metres */
    private static final double ALTITUDE = 1000.0;

    @Override
    public void startSimulation(SimulationStatus status) throws SimulationException {
        Coordinate position = status.getRocketPosition();
        position = position.add(0, 0, ALTITUDE);
        status.setRocketPosition(position);
    }

}

Les lignes 1-4 contiennent les imports de classes nécessaires pour utiliser les classes d'OpenRocket.

La ligne 9 est la définition de la classe AirStart. La classe est une extension de la classe AbstractSimulationListener, ce qui est la manière que nous recommandons pour définir les moniteurs de simulation. Cela permettra une meilleure compatibilité dans le futur, vous permet de faire un "override" et d'implémenter seulement les méthodes dont vous avez besoin.

La ligne 12 définie une constante pour l'altitude de lancement. OpenRocket ne permet pas pour le moment de configurer les moniteurs de simulations donc leurs paramètres doivent être codés en dure ou lu depuis une source externe.

Les lignes 14-15 font un "override" de la méthode startSimulation. Cette méthode est appelée au début d'une simulation. C'est à cet endroit qu'il faut configurer les conditions initiales de la simulation. La fonction a pour argument un objet SimulationStatus, qui contient tous les détails concernant la position de la fusée, son orientation et mouvement ainsi que tous les détails de la simulation. Cela peut être librement modifié pour répondre aux besoins de customization.

Les lignes 16-18 contiennent l’implémentation de l'"air-start". A la ligne 16 il y a la position en temps réel de la fusée représenté par une coordonnée cartésienne en 3 dimensions (qui représente le point d'origine (0,0,0)). On line 17 we add the launch altitude to the Z-axis, which corresponds to altitude above ground. Finally on line 18 we set the position back into the SimulationStatus object.

After the listener has been implemented, it needs to be compiled into a Java class file. This requires providing the OpenRocket application on the classpath so that the compilation dependencies are met. Assuming that the OpenRocket JAR file and the AirStart.java file are both in the current directory, the file can be compiled for example on the command line with:

 $ javac -cp OpenRocket-1.1.6.jar AirStart.java 

Ceci aura pour résultat le fichier AirStart.class, qui est le fichier de la classe compilée.

Next we need to start OpenRocket with the directory containing the class file included on the classpath. The startup class needs to be explicitly defined, because using the -jar option would override the classpath set on the command line. From the command line:

 $ java -cp OpenRocket-1.1.6.jar:. net.sf.openrocket.startup.Startup

Finally we need to add the simulation listener to a simulation. Open the Three-stage rocket example design. Create a new simulation which uses the [C6-5;] motor configuration. Then open the Simulation options tab, and click Add under Simulation listeners. Type in AirStart, click OK and run the simulation.

Vous devriez avoir une altitude à l'apogée comprise entre 1400-1500 mètres. Lorsque vous tracez la simulation la fusée démarre à une altitude de 1000 mètres , monte à environs 1450 mètres et finalement atterrie à 0 mètres. Une version légèrement améliorée du moniteur de simulation "air-start" est inclut dans la package d'OpenRocket et peut être utilisé directement avec le nom net.sf.openrocket.simulation.listeners.example.AirStart. Le code source est disponible dans SVN.

Les moniteurs de simulations peuvent exécuter n'importe quelle action et modifier l’état de la fusée à n'importe quel moment. (noms des méthodes inclue entre parenthèses):

• avant et après la simulation (startSimulation, endSimulation)
• before and after a single step of the simulation (preStep, postStep)
• avant d'ajouter un événement de vol à la file d'attente d’événements (addFlightEvent)
• before handling a flight event (handleFlightEvent)
• avant tout allumage d'un moteur (motorIgnition) ou du déploiement du dispositif de récupération (recoveryDeviceDeployment)
• avant ou après n'importe quel calcul(pre<em>Xyz</em>, post<em>Xyz</em>)

Pour implémenter les moniteurs de simulation nous vous recommandons d’étendre la class AbstractSimulationListener. This implements all of the hook methods with abstract implementations that do nothing. During future development the interfaces may be augmented or change slightly, but the abstract class will contain backward-compatible callbacks.

The hook methods come in three varieties depending on the return value.

• The startSimulation, endSimulation and postStep are hooks that are called at a specific point of the simulation. Ce sont des fonctions void qui ne retournent pas de valeur.
• The preStep and event-related hooks return a boolean value indicating whether the action should be taken or not. A return value of true indicates that the action should be taken as normally would be (default), false will inhibit the action.
• The pre- and post-computation methods may return the computed value, either as an object or a double value. The pre-computation methods allow pre-empting the entire computation, while the post-computation methods allow augmenting the computed values. These methods may return null or Double.NaN to use the original values (default), or return an overriding value.

Each listener method may also throw a SimulationException. This is considered an error during simulation, and an error dialog is displayed to the user with the exception message. The simulation data thus far is not stored in the simulation. Throwing a RuntimeException is considered a bug in the software and will result in a bug report dialog.

If a simulation listener wants to stop a simulation prematurely without an error condition, it needs to add a flight event of type SIMULATION_END to the simulation event queue:

 status.getEventQueue().add(new FlightEvent(FlightEvent.Type.SIMULATION_END, status.getSimulationTime(), null));

Cela aura pour effet de terminer normalement la simulation.