|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectmn.Integrateur
public class Integrateur
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()".
Mathieu HAVEL, Pierre INIZAN, Guillaume BOUBIN, Gaetan LE CHAT version du 10/01/2007)
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 |
---|
double h
int taille
double[] parametres
int nbrParam
double[] xNew
double tNew
double tFinal
double erreur
InterfaceEqMvmt mvmt
Constructor Detail |
---|
public Integrateur(int nbrVariable, double[] tabParametres, String fEqMvmt)
nbrVariable
- Nombre d'équation du mouvement (ou de manière nombre de variables)tabParametres
- Tableau contenant les différents paramètresfEqMvmt
- Nom du Fichier contenant la méthode qui implémente la méthode eqMvmt de l'interface InterfaceEqMvmtMethod Detail |
---|
public double[] rk4(double[] x, double hh)
Formule générale : x(t+h)=x(t)+h/6*(k1+2*k2+2*k3+k4);
x
- Tableau de la forme [X1,X2,...]hh
- Pas d'intégration
public double[] rk4sympf(double[] x, double hh, double eps, double relax)
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)
x
- Tableau contenant la position initiale x(t)hh
- Pas d'intégrationeps
- Précision souhaitéeparametre
- Paramètre de relaxation pour l'algorithme de Newton
DetermineZero
,
FctNewtSymp
,
JacNewtSymp
public double[] rk4pv(double[] x, double intTps, double precision, boolean vieuxCalcul)
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 recommencevieuxCalcul
- =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
public double[] rk4pv(double[] x, double intTps)
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
public double[] rk4pv(double[] x, double deltaT, boolean vieuxCalcul)
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
public double[] rk4pv(double deltaT)
deltaT
- Interval de temps durant lequel on fait l'intégration, c'est après ce temps qu'on veut une réponse.
public double[] rk4pv(double deltaT, double precision)
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
public double[] rk4pv(double[] x, double deltaT, double precision)
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
public double[] interpolation(double[] y1, double[] y2, double tInterpol, double tTotal)
y1
- Valeur de la fonction évalué en t1y2
- Valeur de la fonction évalué en t2tInterpol
- Sachant que t est le temps auquel on veut l'interpolation, tInterpol=t-t1tTotal
- t2-t1
public double maximum(double[] tab)
tab
- Tableau de double
public double[] rk4(double[] x, double hh, ChoixDeFonction aIntegrer)
Formule générale : x(t+h)=x(t)+h/6*(k1+2*k2+2*k3+k4);
x
- Tableau de la forme [X1,X2,...]hh
- Pas d'intégrationaIntegrer
- Fonction à intégrer
public double[] rk4pv(double[] x, double intTps, double precision, ChoixDeFonction aIntegrer, boolean vieuxCalcul)
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 recommenceaIntegrer
- Fonction à intégrervieuxCalcul
- =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
public double[] rk4pv(double deltaT, double precision, ChoixDeFonction aIntegrer)
public double[] rk4pv(double[] x, double deltaT, double precision, ChoixDeFonction aIntegrer)
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |