Utilisation du module

L'utilisation de ce module peut se faire à plusieurs niveaux.

Utilisation directe des classes du module

Le niveau le plus bas correspond à une utilisation directe des classes du module dans un programme Java. Supposons par exemple que nous souhaitons résoudre le problème simple suivant :

pour tout t dans [0;1], y'(t) = y(t)

y(0) = 1

Tout d'abord on instancie un problème, puis un schéma d'Euler (explicite dans notre cas) en précisant le nombre de pas de temps et on attache à ce problème le schéma, la condition initiale et l'équation. Pour l'équation on utilise le mécanisme des classes internes qui rend dans ce cas plus lisible et plus léger le programme. Ensuite il ne reste plus qu'à résoudre le problème par appel de la méthode solve(). Une manière de faire est présentée dans le programme suivant :

import opale.tools.*;  
import opale.mathtools.*;  
import opale.ode.*;  
import opale.ode.scheme.*;  

public class exemple  
{
	  
  public static void main(String[] arg)  
  {  
     Problem pb = new Problem();  
     ExplicitEuler ts = new ExplicitEuler();  
     ts.setNstep(100);
     DVect cd = new DVect(1);  
     cd.set(0,1);  
     pb.setInit(cd);  
     pb.setEqn(new Equation() {   
                   public int dim() {  return  1 ; }
		   public DVect derivs(double t, DVect x) {return x;}    
		   }   
		);  
     pb.setTS(ts);  
     pb.solve(); 
     System.out.println(pb.printSol()); 
   }  
}  

Il existe un autre niveau d'utilisation du module ODE : les fichiers de données ODE qui permettent de lire/écrire sous un certain format des problèmes.

Utilisation des fichiers de données

Grâce aux fichiers de données il est possible de sauvegarder ou lire un problème dans un fichier texte ainsi que de résoudre des problèmes.

Tout d'abord précisons que les jeux de données n'ont de sens uniquement dans le cas où la dimension du problème est comprise entre 1 et 3. La raison est simple : comme nous allons le voir l'équation sera écrite dans un fichier texte sous forme d'une chaine de caractères et l'interpréteur d'équations utilisé dans opale ne sait lire pour l'instant que les variables t, x, y, z.

Un jeu de données est un fichier texte contenant la description des équations, des schémas en temps et des problèmes à résoudre. Leur structure est simple et il est plus clair d'en juger sur un exemple :

Equation eq
{
	f1(t,x,y,z)= '3*t'
	f2(t,x,y,z)= '3'
	f3(t,x,y,z)= '1'
}

ExplicitEuler sc
{
	tmin 0
	tmax 1
	N 100
}

Problem pb
{
	dim 3
	sch sc
	eqn eq
	y0 1 1 2
}

On constate trois blocs décrivant d'abord l'équation puis le schéma en temps et enfin le problème à résoudre. Chaque bloc contient en premier le nom du type d'objet qui va \^etre décrit par la suite (Equation, ExplicitScheme ou Problem) suivi d'un nom utilisateur laissé au choix de l'utilisateur (eq, sc, pb). Après la description du format d'un jeu de données passons à leur utilisation dans nos programmes Java.

Supposons donc que nous ayons écrit le fichier de données précédent dans un fichier file1.ode et que nous désirons écrire un programme sachant relire ce fichier dans le but de résoudre le problème qui y est décrit. Le programme devra ressembler alors à :

import opale.ode.*;
import opale.ode.scheme.*;
import opale.tools.*;


public class file
{

  public static void main(String[] arg)
  {
   
   try
   {
     ODE ode = new ODE();
     StreamReader rf = new StreamReader("file1.ode");
     ode.read(rf);
     ode.solve();
     System.err.println(((Problem) ode.getObject("pb")).printSol());
     
     rf = new StreamReader("file2.ode");
     ode.clear();
     ode.read(rf);
     ode.solve();
     System.err.println(((Problem) ode.getObject("pb_ee")).printSol());
	
   }
   catch(java.io.IOException e)
   {}	
   catch(InvalidFormatException e)
   {System.err.println(e);}	
   }
}

Nous remarquons l'utilisation d'une nouvelle classe, la classe ODE. Elle permet d'encapsuler un ensemble d'objets du module ode. Pour lire un fichier de données, il faut instancier un objet de type ODE et lui appliquer la méthode read(StreamReader). L'objet de type ODE se charge alors d'instancier des objets de type Equation, TimeScheme et Problem en fonction de ce qui est indiqué dans le fichier de données. Il est ensuite possible d'accéder aux objets lus et stockés dans l'instance de ODE par appel de la méthode ObjectODE getObject(String id) où id est l'identifiant de l'objet souhaité (nom donné dans le fichier de données). Pour résoudre le problème il suffit ensuite d'appeler la méthode solve() qui se charge de résoudre tous les problèmes (un seul dans notre cas).

Utilisation d'une interface

Il est enfin possible d'utiliser un programme bati lui même sur le module ode. Par exemple on peut citer l'applet AODE, ou bien le logiciel GEOODE. Voici l'applet AODE :

Evolution du module

Le module ode, de par structure objet est évolutif : l'ajout de nouveaux schémas par exemple est aisé. Les développements prévus dans le futur sont entre autres :

• ajout de nouveaux schémas, en particulier la famile des méthodes Runge & Kutta
• ajout de schémas multi-pas
• noyau de résolution de systèmes différentiels

Un exemple en image pour finir

Pour terminer illustrons cette page par exemple traité entierement par les outils Opale : il consiste en la résolution du problème de Van der Pol par le module ODE et le postraitement de la solution par le module 2d. Le fichier source de cet exemple se trouve ici

Opale Team : January 31 2004 23:14:10.