mn
Class Integrateur

java.lang.Object
  extended by mn.Integrateur

public class Integrateur
extends Object

Classe contenant un ensemble de méthodes pour intégrer un problème donné par l'équation de mouvement "eqMvmt()" (qui est implémentée dans une classe qui implémente UsineEqMvmt.java). On utilise une méthode runge-kutta d'ordre 4 "rk4()", runge-kutta à pas variable "rk4pv()", et une méthode symplectique d'ordre 4 "rk4sympf()".

Since:
Projet Trois Corps 2006
Version:
10/01/2007
Author:
Nicolas DELSATE (version du 17/01/2006)

Mathieu HAVEL, Pierre INIZAN, Guillaume BOUBIN, Gaetan LE CHAT version du 10/01/2007)

See Also:
InterfaceEqMvmt

Field Summary
(package private)  double erreur
           
(package private)  double h
           h Pas d'intégration courant initialise à 0 dans le constructeur taille Taille du tableau que l'on passe en paramètre du constructeur, équivalent au nombre d'équations du mouvement parametres Tableau de paramètres passe à la méthode "eqMvmt()" nbrParam Taille du tableau paramètres xNew Tableau servant à l'adaptation du pas, utilise dans rk4pv tNew Temps au dernier pointt trouve par l'algo, de manière générale = tNew+h ; au debut il est = 0 tFinal Temps auquel on demande une réponse, il sera de manière générale = tFinal+intTps ; au debut il est = 0 erreur Valeur de la dernière erreur commise : sert pour l'adaptation du pas mvmt Contient le "nom" de l'équation du mouvement; on fera accès à l'équation en faisant mvmt.eqMvmt
(package private)  InterfaceEqMvmt mvmt
           
(package private)  int nbrParam
           
(package private)  double[] parametres
           
(package private)  int taille
           
(package private)  double tFinal
           
(package private)  double tNew
           
(package private)  double[] xNew
           
 
Constructor Summary
Integrateur(int nbrVariable, double[] tabParametres, String fEqMvmt)
           
 
Method Summary
 double[] interpolation(double[] y1, double[] y2, double tInterpol, double tTotal)
          Interpolation par une droite
 double maximum(double[] tab)
          Calcul de la valeur de l'élément le plus grand en valeur absolue d'un tableau
 double[] rk4(double[] x, double hh)
          Méthode qui utilise une méthode Runge-Kutta à pas fixe d'ordre 4 pour calculer à partir d'un vecteur x et d'un pas une solution xPlush Formule générale : x(t+h)=x(t)+h/6*(k1+2*k2+2*k3+k4);
 double[] rk4(double[] x, double hh, ChoixDeFonction aIntegrer)
          Méthode qui utilise une méthode Runge-Kutta à pas fixe d'ordre 4 pour calculer à partir d'un vecteur x et d'un pas une solution xPlush Formule générale : x(t+h)=x(t)+h/6*(k1+2*k2+2*k3+k4);
 double[] rk4pv(double deltaT)
          Appelle la fonction rk4pv(double deltaT, double precision) avec une précision fixée à 1.0e-6
 double[] rk4pv(double[] x, double intTps)
          Runge-Kutta d'ordre 4 à pas variable avec une précision prédéfinie=1.0e-3
 double[] rk4pv(double[] x, double deltaT, boolean vieuxCalcul)
          Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) avec une précision fixée à 1.0e-6
 double[] rk4pv(double[] x, double deltaT, double precision)
          Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) avec "false" pour le paramètre boolean
 double[] rk4pv(double[] x, double intTps, double precision, boolean vieuxCalcul)
          Runge-Kutta d'ordre 4 à pas variable avec une preécision à préciser Cette méthode adapte le pas lors de son intégration mais aussi adapte le pas pour que la dernière étape donne exactement le résultat au temps "intTps" voulu sans faire d'interpolation !
 double[] rk4pv(double[] x, double deltaT, double precision, ChoixDeFonction aIntegrer)
          Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) avec "false" pour le parametre boolean Voir rk4pv(double[] x,double deltaT, double precision, boolean vieuxCalcul)
 double[] rk4pv(double[] x, double intTps, double precision, ChoixDeFonction aIntegrer, boolean vieuxCalcul)
          Runge-Kutta d'ordre 4 à pas variable avec une précision à définir Cette méthode adapte le pas lors de son intégration mais aussi adapte le pas pour que la dernière étape donne exactement le résultat au temps "intTps" voulu sans faire d'interpolation !
 double[] rk4pv(double deltaT, double precision)
          Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) sachant qu'on est dans la suite d'un vieux calcul.
 double[] rk4pv(double deltaT, double precision, ChoixDeFonction aIntegrer)
          Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) sachant que on est dans la suite d'un vieux calcul.
 double[] rk4sympf(double[] x, double hh, double eps, double relax)
          Runge-Kutta symplectique d'ordre 4 à pas fixe pour passer de x(t) à x(t+h) : x(t+h) = x(t) + h*b1*f(t+b1/2*h,e1) + h*b2*f(t+(b1+b2/2)*h,e2) + h*b3*f(t+(b1+b2+b3/2)*h,e3) avec : e1 = x(t) + h*b1/2*f(t+b1/2*h,e1) e2 = x(t) + h*b1*f(t+(b1+b2/2)*h,e1) + h*b2/2*f(t+(b1+b2/2)*h,e2) e3 = x(t) + h*b1*f(t+(b1+b2+b3/2)*h,e1) + h*b2*f(t+(b1+b2+b3/2)*h,e2) + h*b3/2*f(t+(b1+b2+b3/2)*h,e3) e1, e2, e3 sont déterminés successivement, par un algorithme de Newton (multidimensionnel)
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

h

double h


taille

int taille

parametres

double[] parametres

nbrParam

int nbrParam

xNew

double[] xNew

tNew

double tNew

tFinal

double tFinal

erreur

double erreur

mvmt

InterfaceEqMvmt mvmt
Constructor Detail

Integrateur

public Integrateur(int nbrVariable,
                   double[] tabParametres,
                   String fEqMvmt)
Parameters:
nbrVariable - Nombre d'équation du mouvement (ou de manière nombre de variables)
tabParametres - Tableau contenant les différents paramètres
fEqMvmt - Nom du Fichier contenant la méthode qui implémente la méthode eqMvmt de l'interface InterfaceEqMvmt
Method Detail

rk4

public double[] rk4(double[] x,
                    double hh)
Méthode qui utilise une méthode Runge-Kutta à pas fixe d'ordre 4 pour calculer à partir d'un vecteur x et d'un pas une solution xPlush

Formule générale : x(t+h)=x(t)+h/6*(k1+2*k2+2*k3+k4);

Parameters:
x - Tableau de la forme [X1,X2,...]
hh - Pas d'intégration
Returns:
Un tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4sympf

public double[] rk4sympf(double[] x,
                         double hh,
                         double eps,
                         double relax)
Runge-Kutta symplectique d'ordre 4 à pas fixe pour passer de x(t) à x(t+h) :

x(t+h) = x(t) + h*b1*f(t+b1/2*h,e1) + h*b2*f(t+(b1+b2/2)*h,e2) + h*b3*f(t+(b1+b2+b3/2)*h,e3) avec :

e1 = x(t) + h*b1/2*f(t+b1/2*h,e1)

e2 = x(t) + h*b1*f(t+(b1+b2/2)*h,e1) + h*b2/2*f(t+(b1+b2/2)*h,e2)

e3 = x(t) + h*b1*f(t+(b1+b2+b3/2)*h,e1) + h*b2*f(t+(b1+b2+b3/2)*h,e2) + h*b3/2*f(t+(b1+b2+b3/2)*h,e3)

e1, e2, e3 sont déterminés successivement, par un algorithme de Newton (multidimensionnel)

Parameters:
x - Tableau contenant la position initiale x(t)
hh - Pas d'intégration
eps - Précision souhaitée
parametre - Paramètre de relaxation pour l'algorithme de Newton
Returns:
Nouvelle position après intégration x(t+h)
Since:
Projet Trois Corps 2007
See Also:
DetermineZero, FctNewtSymp, JacNewtSymp

rk4pv

public double[] rk4pv(double[] x,
                      double intTps,
                      double precision,
                      boolean vieuxCalcul)
Runge-Kutta d'ordre 4 à pas variable avec une preécision à préciser Cette méthode adapte le pas lors de son intégration mais aussi adapte le pas pour que la dernière étape donne exactement le résultat au temps "intTps" voulu sans faire d'interpolation !

Parameters:
x - Tableau de la forme [X1,X2,...]
intTps - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
precision - Précision sur la différence relative entre deux resultats. Si l'on atteint cette précision, on renvoit la solution. Sinon, on diminue le pas et on recommence
vieuxCalcul - =FALSE si on veut faire un nouveau calcul et =TRUE si on continue un ancien calcul; dans ce cas, on ne tient pas compte du "x" passe en argument
Returns:
Tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double[] x,
                      double intTps)
Runge-Kutta d'ordre 4 à pas variable avec une précision prédéfinie=1.0e-3

Parameters:
x - Tableau de la forme [Q1,Q2,P1,P2]
intTps - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse
Returns:
Tableau de la forme [Q1,Q2,P1,P2]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double[] x,
                      double deltaT,
                      boolean vieuxCalcul)
Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) avec une précision fixée à 1.0e-6

Parameters:
x - Tableau de la forme [X1,X2,...]
deltaT - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
vieuxCalcul - =FALSE si on veut faire un nouveau calcul et =TRUE si on continue un ancien calcul; dans ce cas, on ne tient pas compte du "x" passe en argument
Returns:
Tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double deltaT)
Appelle la fonction rk4pv(double deltaT, double precision) avec une précision fixée à 1.0e-6

Parameters:
deltaT - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
Returns:
Tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double deltaT,
                      double precision)
Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) sachant qu'on est dans la suite d'un vieux calcul. Donc, on passe un x bidon comme premier paramètre et "true" pour le paramètre boolean

Parameters:
deltaT - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
precision - Précision sur la différence relative entre deux resultats. Si l'on atteint cette précision, on renvoit la solution. Sinon, on diminue le pas et on recommence
Returns:
Tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double[] x,
                      double deltaT,
                      double precision)
Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) avec "false" pour le paramètre boolean

Parameters:
x - Tableau de la forme [X1,X2,...]
deltaT - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
precision - Précision sur la différence relative entre deux resultats. Si l'on atteint cette précision, on renvoit la solution. Sinon, on diminue le pas et on recommence
Returns:
Tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

interpolation

public double[] interpolation(double[] y1,
                              double[] y2,
                              double tInterpol,
                              double tTotal)
Interpolation par une droite

Parameters:
y1 - Valeur de la fonction évalué en t1
y2 - Valeur de la fonction évalué en t2
tInterpol - Sachant que t est le temps auquel on veut l'interpolation, tInterpol=t-t1
tTotal - t2-t1
Returns:
L'interpolation au temps t
Since:
Projet Trois Corps 2006

maximum

public double maximum(double[] tab)
Calcul de la valeur de l'élément le plus grand en valeur absolue d'un tableau

Parameters:
tab - Tableau de double
Returns:
Valeur de l'élément le plus grand en valeur absolue d'un tableau
Since:
Projet Trois Corps 2006

rk4

public double[] rk4(double[] x,
                    double hh,
                    ChoixDeFonction aIntegrer)
Méthode qui utilise une méthode Runge-Kutta à pas fixe d'ordre 4 pour calculer à partir d'un vecteur x et d'un pas une solution xPlush

Formule générale : x(t+h)=x(t)+h/6*(k1+2*k2+2*k3+k4);

Parameters:
x - Tableau de la forme [X1,X2,...]
hh - Pas d'intégration
aIntegrer - Fonction à intégrer
Returns:
Un tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double[] x,
                      double intTps,
                      double precision,
                      ChoixDeFonction aIntegrer,
                      boolean vieuxCalcul)
Runge-Kutta d'ordre 4 à pas variable avec une précision à définir Cette méthode adapte le pas lors de son intégration mais aussi adapte le pas pour que la dernière étape donne exactement le résultat au temps "intTps" voulu sans faire d'interpolation !

Parameters:
x - Tableau de la forme [X1,X2,...]
intTps - Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
precision - Précision sur la différence relative entre deux résultats. Si l'on atteint cette précision, on renvoit la solution. Sinon, on diminue le pas et on recommence
aIntegrer - Fonction à intégrer
vieuxCalcul - =FALSE si on veut faire un nouveau calcul et =TRUE si on continue un ancien calcul; dans ce cas, on ne tient pas compte du "x" passe en argument
Returns:
Tableau de la forme [X1,X2,...]
Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double deltaT,
                      double precision,
                      ChoixDeFonction aIntegrer)
Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) sachant que on est dans la suite d'un vieux calcul. Donc, on passe un x bidon comme premier parametre et "true" pour le parametre boolean Voir rk4pv(double[] x,double deltaT, double precision, boolean vieuxCalcul)

Since:
Projet Trois Corps 2006

rk4pv

public double[] rk4pv(double[] x,
                      double deltaT,
                      double precision,
                      ChoixDeFonction aIntegrer)
Appelle la fonction rk4pv(double[] x, double deltaT, double precision, boolean vieuxCalcul) avec "false" pour le parametre boolean Voir rk4pv(double[] x,double deltaT, double precision, boolean vieuxCalcul)

Since:
Projet Trois Corps 2006