solveur de DAE avec traversées de zéros
[r, nn [, hd]] = daskr(x0, t0, t [, atol [, rtol]], res [, jac], ng, surf [, info [, psol] [, pjac]] [, hd])
représente soit y0
(ydot0
sera
estimé par daskr
avec zéro comme première estimation),
soir la matrice [y0 ydot0]
.
g(t, y0, ydot0)
doit être égal à zéro. Si vous ne connaissez
qu'une estimation de ydot0
, assignez
info(7)=1
.
vecteur colonne réel des conditions initiales.
vecteur colonne réel de la dérivée en temps de
y
à t0
(peut être une estimation.
réel, temps initial.
réel, scalaire ou vecteur. Temps auxquels la solution est désirée.
Notez que vous pouvez obtenir la solution à chaque étape de daskr en fixant
info(2)=1
.
réels scalaires ou vecteurs colonnes de même taille que
y
ou tous deux de taille 1
. atol
et rtol
représentent
les tolérances d'erreur absolue et relative de la solution.
Si ce sont des vecteurs, alors les tolérances sont spécifiées pour chaque composante de
y
.
external (fonction, liste ou chaîne de caractères).
Calcule la valeur de
g(t, y, ydot)
. Elle peut être :
Une fonction Scilab.
Sa séquence d'appel doit être
[r, ires] = res(t, y, ydot)
et doit retourner le résidu
r = g(t, y, ydot)
et un drapeau d'erreur
ires
. ires = 0
si
res
a correctement calculé r
,
ires = -1
si le résidu est localement non défini pour
(t, y, ydot)
, ires = -2
si
des paramètres sont hors du champ admissible.
Une liste.
Cette forme permet de passer des paramètres autres que t, y, ydot à la fonction. Elle doit se présenter comme suit :
list(res, x1, x2, ...)
où la séquence d'appel de la fonction
res
est maintenant
r = res(t, y, ydot, x1, x2, ...)
res
retourne toujours
r = g(t, y, ydot)
comme fonction de
(t, y, ydot, x1, x2, ...)
.
Attention : cette forme ne doit pas être utilisée s'il n'y pas d'argument additionnel à passer à la fonction.
Une chaîne de caractères.
Elle doit se référer au nom d'une fonction C ou une routine Fortran reliée à Scilab.
En C, la séquence d'appel doit être :
En Fortran, elle doit être :
subroutine res(t, y, yd, r, ires, rpar, ipar) double precision t, y(*), yd(*),r(*),rpar(*) integer ires, ipar(*)
Les tableaux rpar
et ipar
doivent être présents mais ne peuvent pas être utilisés.
external (fonction, liste ou chaîne de caractères).
Calcule la valeur de dg/dy + cj*dg/dydot
pour une valeur donnée du paramètre
cj
.
Une fonction Scilab.
Sa séquence d'appel doit être
r = jac(t, y, ydot, cj)
et doit retourner
r = dg(t, y, ydot)/dy + cj*dg(t, y, ydot)/dydot
où
cj
est un scalaire réel.
Une liste.
Elle doit se présenter comme suit :
list(jac, x1, x2, ...)
où la séquence d'appel de la fonction
jac
est désormais
r=jac(t, y, ydot, cj, x1, x2,...)
jac
retourne toujours
dg/dy + cj*dg/dydot
comme fonction de
(t, y, ydot, cj, x1, x2,...)
.
Une chaîne de caractères.
Elle doit se référer au nom d'une fonction C ou une routine Fortran reliée à Scilab.
En C, la séquence d'appel doit être :
En Fortran, elle doit être :
subroutine jac(t, y, yd, pd, cj, rpar, ipar) double precision t, y(*), yd(*), pd(*), cj, rpar(*) integer ipar(*)
external (fonction, liste ou chaîne de caractères).
Calcule la valeur du vecteur colonne surf(t, y)
à
ng
composantes. Chaque composante représente une surface.
Elle doit être définie comme suit :
Une fonction Scilab.
Sa séquence d'appel doit être
surf(t, y)
Une liste.
Elle doit se présenter comme suit :
où la séquence d'appel de la fonction
surf
est maintenant
r = surf(t, y, x1, x2, ...)
Une chaîne de caractères.
Elle doit se référer au nom d'une fonction C ou une routine Fortran reliée à Scilab.
En C, la séquence d'appel doit être :
En Fortran, elle doit être :
liste contenant 14
éléments. La valeur par défaut est
list([], 0, [], [], [], 0, [], 0, [], 0, 0, [], [], 1)
.
réel scalaire donnant le temps maximal pour lequel
g
peut être évalué ou une matrice vide
[]
si aucune limite de temps n'est imposée.
drapeau indiquant si daskr
retourne
ses valeurs intermédiaires calculées (= 1
)
ou seulement les temps indiqués par l'utilisateur
(= 0
).
vecteur de deux éléments donnant la définition
[ml,mu]
de la matrice bande calculeé par
jac
; r(i - j + ml + mu + 1,j) = "dg(i)/dy(j)+cj*dg(i)/dydot(j)"
.
Si jac
retourne une matrice pleine, fixer
info(3)=[]
.
Inutile si
info(8)=1
.
réel scalaire donnant la taille maximale du pas. Fixer
info(4)=[]
si illimité.
réel scalaire donnant le pas initial. Fixer
info(5)=[]
si non spécifié.
fixer info(6)=1
si la solution est
non-négative, sinon fixer
info(6)=0
.
si ydot0 est fixé tel que
g(t0, y0, ydot0) = 0
, alors fixer
info(7)=[]
. Sinon, fixer
info(7)=[+-1, ..., +-1]
, avec
info(7)(i) = 1
si y(i) est une variable différentielle et
info(7)(i) = -1
si y(i) est une variable algébrique
(si ses dérivées n'apparaissent pas explicitement dans la fonction g(t, y, ydot)).
méthode directe / Krylov. Fixer info(8)=1
et founrnir une routine psol
si vous souhaitez que le solveur utilise des itérations de Krylov, sinon (méthode directe) fixer
info(8)=0
.
paramètres de Krylov. Inutile si vous avez fixé
info(8)=0
. Sinon, fixer
info(9)=[]
ou
info(9)=[maxl kmp nrmax epli]
, où :
- maxl = nombre maximal d'itérations de l'algorithme GMRes (par défaut
min(5, neq)
),
- kmp = nombre de vecteurs sur lesquels l'orthogonalisation est faite dans GMRes (par défaut maxl),
- nrmax = nombre maximal de redémarrages de GMRes par intération non-linéaire
(par défaut 5
),
- epli = constante du test de convergence de GMRes (par défaut 0.05
).
conditions initiales. A ignorer si
info(7)=[]
. Fixer
info(10)=1
si le solveur doit s'arrêter après
le calcul des valeurs initiales, sinon fixer
info(10)=0
.
routine pour le calcul et la factorisation LU du préconditionneur pour psol
.
Inutile si info(8)=0
. Fixer
info(11)=1
et fournir une routine pjac
si l'external
psol
doit utiliser une routine spécifique, sinon fixer
info(11)=0
.
si vous souhaitez contrôler l'erreur localement sur toutes les variables, fixez
info(12)=[]
. Sinon, fixez
info(12)=[+-1, ..., +-1]
, avec
info(12)(i) = 1
si y(i) est une variable différentielle et
info(12)(i) = -1
si y(i) est une variable algébrique
(si ses dérivées n'apparaissent pas explicitement dans la fonction g(t, y, ydot)).
paramètres heuristiques. Ignorer si
info(7)=[]
. Sinon, fixer
info(13)=[]
ou
info(13)=[mxnit mxnj mxnh lsoff stptol epinit]
, où :
- mxnit = nombre maximal d'itérations de Newton par évaluation du préconditionneur (par défaut
5
si info(8)=0
, 15
sinon),
- mxnj = nombre maximal d'évaluations du préconditionneur (par défaut
6
si info(8)=0
, 2
sinon),
- mxnh = nombre maximal de valeurs artificielles du pas h
à tenter si info(7) ≠ [] (par défaut
5
),
- lsoff = drapeau pour désactiver l'algorithme de recherche linéaire (lsoff = 0 pour activer, lsoff = 1 pour désactiver)
(par défaut 0
),
- stptol = pas minimal (dimmensionné) dans l'algorithme de recherche linéaire (par défaut (unit roundoff)^(2/3)
),
- epinit = facteur déterminant dans le test de convergence de l'itération Newton (par défaut 0.01
).
verbosité. Fixer info(14)=1
pour une information minimale,
info(14)=2
pour une information maximale, sinon fixer
info(14)=0
.
external (fonction, liste ou chaîne de caractères).
Résout un système linéraire P*x = b
,
où P est le préconditionneur LU-factorisé que pjac
a calculé auparavant et stocké dans wp
et iwp
.
Une fonction Scilab.
Sa séquence d'appel doit être
[r, ier] = psol(wp, iwp, b)
et doit retourner la solution du système dans
r
et un drapeau d'erreur ier
.
Une liste.
Elle doit se présenter comme suit :
list(psol, x1, x2, ...)
où la séquence d'appel de psol
est
psol(wp, iwp, b, x1, x2, ...)
psol
retourne toujours la solution dans r
.
Une chaîne de caractères.
Elle doit se référer au nom d'une fonction C ou une routine Fortran reliée à Scilab
En C, la séquence d'appel doit être :
void psol (int*neq, double*t, double*y, double*ydot, double*savr, double*wk, double*cj, double*wght, double*wp, int*iwp, double*b, double*eplin, int*ier, double*rpar, int*ipar)
wp
et iwp
contiennent le préconditionneur LU-factorisé
P
, wp
représentant les valeurs et
iwp
les pivots utilisés dans la factorisation.
En Fortran, elle doit être :
subroutine psol (neq, t, y, ydot, savr, wk, cj, wght, wp, iwp, b, eplin, ier, rpar, ipar) double precision t,y(*), ydot(*), savr(*), wk(*), cj, wght(*), wp(*), b(*), eplin, rpar(*) integer neq, iwp(*), ier, ipar(*)
external (fonction, liste ou chaîne de caractères). Calcule la valeur de
dg/dy + cj*dg/dydot
pour une valeur donnée du paramètre
cj
et la LU-factorise en deux vecteurs, réel et entier.
Une fonction Scilab.
Sa séquence d'appel doit être
[wp, iwp, ires] = pjac(neq, t, y, ydot, h, cj, rewt, savr)
et en retour,
les vecteurs wp
et iwp
doivent contenir toutes les informations du préconditionneur factorisé.
Une liste.
Elle doit se présenter comme suit :
list(pjac, x1, x2, ...)
où la séquence d'appel de pjac
est
pjac(neq, t, y, ydot, h, cj, rewt, savr, x1, x2,...)
pjac
retourne toujours
dg/dy + cj*dg/dydot
comme fonction de
(neq, t, y, ydot, h, cj, rewt, savr, x1, x2, ...)
.
Une chaîne de caractères.
Elle doit se référer au nom d'une fonction C ou une routine Fortran reliée à Scilab
En C, la séquence d'appel doit être :
void pjac (double*res, int*ires, int*neq, double*t, double*y, double*ydot, double*rewt, double*savr, double*wk, double*h, double*cj, double*wp, int*iwp, int*ier, double*rpar, int*ipar)
En Fortran, elle doit être :
subroutine pjac (res, ires, neq, t, y, ydot, rewt, savr, wk, h, cj, wp, iwp, ier, rpar, ipar) double precision res(*), t, y(*), ydot(*), rewt(*), savr(*), wk(*), h, cj, wp(*), rpar(*) integer ires, neq, iwp(*), ier, ipar(*)
vecteur réel servant à stocker le contexte de
daskr
et reprendre l'intégration.
matrice réelle. Chaque colonne est le vecteur [t; x(t); xdot(t)]
où
t
est l'indice en temps aulequel la solution a été calculée,
x(t)
est la valeur de la solution calculée,
xdot(t)
est la dérivée de la solution calculée.
vecteur à deux entrées [times num]
,
times
est la valeur du temps auquel la surface est traversée,
num
est le nombre de surfaces traversées.
Solution de l'équation différentielle implicite :
g(t, y, ydot) = 0 y(t0) = y0 et ydot(t0) = ydot0
Retourne les temps de traversée de surface et le nombre de surfaces traversées
dans nn
.
Des exemples détaillés se trouvent dans SCI/modules/differential_equations/tests/unit_tests/daskr.tst
// dy/dt = ((2*log(y)+8)/t-5)*y, y(1) = 1, 1 <= t <= 6 // g1 = ((2*log(y)+8)/t-5)*y // g2 = log(y) - 2.2491 y0 = 1; t = 2:6; t0 = 1; y0d = 3; atol = 1.d-6; rtol = 0; ng = 2; deff('[delta, ires] = res1(t, y, ydot)', 'ires = 0; delta = ydot-((2*log(y)+8)/t-5)*y') deff('[rts] = gr1(t, y)', 'rts = [((2*log(y)+8)/t-5)*y; log(y)-2.2491]') [yy, nn] = daskr([y0, y0d], t0, t, atol, rtol, res1, ng, gr1); nn // Retourne nn = [2.4698972 2] | ![]() | ![]() |
Version | Description |
5.5.0 | daskr ajouté |