DAE solver with zero crossing
[r, nn [, hd]] = daskr(x0, t0, t [, atol [, rtol]], res [, jac], ng, surf [, info [, psol] [, pjac]] [, hd])
is either y0 (ydot0 is
estimated by daskr with zero as first estimate)
or the matrix [y0 ydot0].
g(t, y0, ydot0) must be equal to zero.
If you only know an estimate of ydot0, set
info(7)=1.
a real column vector of initial conditions.
a real column vector of the time derivative of
y at t0 (may be an estimate).
a real number, it is the initial instant.
a real scalar or vector. Gives instants for which you want the
solution. Note that you can get solution at each daskr's step point
by setting info(2)=1.
real scalars or column vectors of same size as
y or both of size 1. atol and rtol give respectively
absolute and relative error tolerances of solution. If vectors, the
tolerances are specified for each component of
y.
external (function, list or string). Computes the value of
g(t, y, ydot). It may be :
A Scilab function.
Its syntax must be
[r, ires] = res(t, y, ydot) and must return the residual
r = g(t, y, ydot) and error flag
ires. ires = 0 if
res succeeds to compute r,
ires = -1 if residual is locally not defined for
(t, y, ydot), ires = -2 if
parameters are out of admissible range.
A list.
This form allows to pass parameters other than t, y, ydot to the function. It must be as follows:
list(res, x1, x2, ...)
where the syntax of the function
res is now
r = res(t, y, ydot, x1, x2, ...)
res still returns
r = g(t, y, ydot) as a function of
(t, y, ydot, x1, x2, ...).
Warning: this form must not be used if there is no extra argument to pass to the function.
A string.
It must refer to the name of a C function or a Fortran subroutine linked with Scilab.
In C, the syntax must be:
In Fortran, it must be:
subroutine res(t, y, yd, r, ires, rpar, ipar) double precision t, y(*), yd(*),r(*),rpar(*) integer ires, ipar(*)
The rpar and ipar
arrays must be present but cannot be used.
external (function, list or string).
Computes the value of dg/dy + cj*dg/dydot for a given value of parameter
cj.
A Scilab function.
Its syntax must be
r = jac(t, y, ydot, cj) and must return
r = dg(t, y, ydot)/dy + cj*dg(t, y, ydot)/dydot where
cj is a real scalar.
A list.
It must be as follows
list(jac, x1, x2, ...)
where the syntax of the function
jac is now
r=jac(t, y, ydot, cj, x1, x2,...)
jac still returns
dg/dy + cj*dg/dydot as a function of
(t, y, ydot, cj, x1, x2, ...).
A character string.
It must refer to the name of a C function or a Fortran subroutine linked with Scilab
In C, the syntax must be:
In Fortran, it must be:
subroutine jac(t, y, yd, pd, cj, rpar, ipar) double precision t, y(*), yd(*), pd(*), cj, rpar(*) integer ipar(*)
external (function, list or string).
Computes the value of the column vector surf(t, y) with
ng components. Each component defines a surface.
It may be defined by:
A Scilab function.
Its syntax must be
surf(t, y)
A list.
It must be as follows
where the syntax of the function
surf is now
r = surf(t, y, x1, x2, ...)
A character string.
It must refer to the name of a C function or a Fortran subroutine linked with Scilab.
In C, the syntax must be:
In Fortran, it must be:
list which contains 14 elements. Default value is
list([], 0, [], [], [], 0, [], 0, [], 0, 0, [], [], 1).
real scalar which gives the maximum time for which
g is allowed to be evaluated or an empty matrix
[] if no limits imposed for time.
flag which indicates if daskr returns
its intermediate computed values (= 1)
or only the user specified time point values
(= 0).
2 components vector which give the
definition [ml,mu] of band matrix computed
by jac; r(i - j + ml + mu + 1,j) = "dg(i)/dy(j)+cj*dg(i)/dydot(j)".
If jac returns a full matrix set
info(3)=[].
Treat as dummy if
info(8)=1.
real scalar which gives the maximum step size. Set
info(4)=[] if no limitation.
real scalar which gives the initial step size. Set
info(5)=[] if not specified.
set info(6)=1 if the solution is
known to be non negative, else set
info(6)=0.
if ydot0 is set so that
g(t0, y0, ydot0) = 0 then set
info(7)=[]. Otherwise, set
info(7)=[+-1, ..., +-1], with
info(7)(i) = 1 if y(i) is a differential variable and
info(7)(i) = -1 if y(i) is an algebraic variable
(if its derivatives do not appear explicitly in the function g(t, y, ydot)).
direct / Krylov method. Set info(8)=1 and provide a routine in psol
if you want the solver to use Krylov iterations, else (daskr's direct method) set
info(8)=0.
Krylov parameters. Treat as dummy argument if you have set
info(8)=0. Otherwise, set
info(9)=[] or
info(9)=[maxl kmp nrmax epli], where:
- maxl = maximum number of iterations in the GMRes algorithm (default
min(5, neq)),
- kmp = number of vectors on which orthogonalization is done in the GMRes algorithm (default maxl),
- nrmax = maximum number of restarts of the GMRes algorithm per nonlinear iteration
(default 5),
- epli = convergence test constant in GMRes algorithm (default 0.05).
initial conditions. Treat as dummy argument if
info(7)=[]. Set
info(10)=1 if the solver should stop right after
computation of the initial conditions, else set
info(10)=0.
preconditioner computation and LU-factorization routine for psol.
Treat as dummy argument if info(8)=0. Set
info(11)=1 and provide a pjac routine if the
external psol should use a specific routine, else set
info(11)=0.
if you wish to control errors locally on all the variables then set
info(12)=[]. Otherwise, set
info(12)=[+-1, ..., +-1], with
info(12)(i) = 1 if y(i) is a differential variable and
info(12)(i) = -1 if y(i) is an algebraic variable
(if its derivatives do not appear explicitly in the function g(t, y, ydot)).
heuristic parameters. Treat as dummy argument if
info(7)=[]. Otherwise, set
info(13)=[] or
info(13)=[mxnit mxnj mxnh lsoff stptol epinit], where:
- mxnit = maximum number of Newton iterations per Jacobian or preconditioner evaluation (default
5 if info(8)=0, 15 otherwise),
- mxnj = maximum number of Jacobian or preconditioner evaluations (default
6 if info(8)=0, 2 otherwise),
- mxnh = maximum number of values of the artificial stepsize
parameter h to be tried if info(7) ≠ []
(default 5),
- lsoff = flag to turn off the linesearch algorithm (lsoff = 0 means linesearch is on, lsoff = 1 means it is turned off)
(default 0),
- stptol = minimum scaled step in linesearch algorithm (default (unit roundoff)^(2/3)),
- epinit = swing factor in the Newton iteration convergence test (default 0.01).
verbosity. Set info(14)=1 for minimal extra printing,
info(14)=2 for full printing, else set
info(14)=0.
external (function, list or string). Solves a linear system
P*x = b, with P being the factored preconditioner that routine pjac
computed beforehand and stored in wp and iwp.
A Scilab function.
Its syntax must be
[r, ier] = psol(wp, iwp, b) and must return the solution of the system in
r and an error flag ier.
A list.
It must be as follows:
list(psol, x1, x2, ...)
where the syntax of psol is now
psol(wp, iwp, b, x1, x2, ...)
psol still returns the solution in r.
A character string.
It must refer to the name of a C function or a Fortran subroutine linked with Scilab
In C, the syntax must be:
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 and iwp contain matrix elements of LU-factored preconditioner
P, wp being the values and
iwp the pivots used in the factorization.
In Fortran, it must be:
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 (function, list or string). Computes the value of
dg/dy + cj*dg/dydot for a given value of parameter
cj and LU-factorizes it in two arrays, real and integer.
A Scilab function.
Its syntax must be
[wp, iwp, ires] = pjac(neq, t, y, ydot, h, cj, rewt, savr) and in return,
the arrays wp and iwp must contain all factored preconditioner information.
A list.
It must be as follows
list(pjac, x1, x2, ...)
where the syntax of pjac is
pjac(neq, t, y, ydot, h, cj, rewt, savr, x1, x2,...)
pjac still returns factorized
dg/dy + cj*dg/dydot as a function of
(neq, t, y, ydot, h, cj, rewt, savr, x1, x2, ...).
A character string.
It must refer to the name of a C function or a Fortran subroutine linked with Scilab
In C, the syntax must be:
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)
In Fortran, it must be:
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(*)
real vector which allows to store the daskr
context and to resume integration.
real matrix. Each column is the vector [t; x(t); xdot(t)] where
t is the time index for which the solution has been computed,
x(t) is the value of the computed solution,
xdot(t) is the derivative of the computed solution.
a vector with two entries [times num],
times is the value of the time at which the surface is crossed,
num is the number of the crossed surface.
Solution of the implicit differential equation:
g(t, y, ydot) = 0 y(t0) = y0 and ydot(t0) = ydot0
Returns the surface crossing instants and the number of the surface
reached in nn.
Detailed examples can be found in 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 // Should return nn = [2.4698972 2] |  |  |
| Versão | Descrição |
| 5.5.0 | daskr solver added |