find numerical solution of differential-algebraic initial value problems - Maple Help

Online Help

All Products    Maple    MapleSim

Home : Support : Online Help : Mathematics : Factorization and Solving Equations : Numerical Solutions : dsolve/numeric/DAE

dsolve/numeric/DAE - find numerical solution of differential-algebraic initial value problems

Calling Sequence

dsolve(daesys, numeric, vars, options)




set or list; ordinary differential equation(s), algebraic equation(s) and initial conditions



name; instruct dsolve to find a numerical solution



(optional) dependent variable or a set or list of dependent variables for daesys



(optional) equations of the form keyword = value



The dsolve command with the numeric or type=numeric option and a real-valued differential-algebraic initial value problem (DAE IVP) finds a numerical solution for the DAE IVP. If the optional equation method=numericmethod is provided (where numericmethod is one of rkf45_dae, ck45_dae, rosenbrock_dae, or mebdfi), dsolve uses that method to obtain the numerical solution.


In most cases dsolve is able to detect if the problem is a DAE system, as opposed to an ODE system, namely the cases in which pure algebraic equations in the dependent variables are present. If the input is a DAE system containing no purely algebraic equations, the method must be included to specify that the system is a DAE system.


Constrained mechanical systems often give rise to DAE problems. (See the pendulum example below.)


The return value of dsolve and the following high level or common options are discussed in dsolve[numeric] and dsolve[Error_Control].



keyword or array






numeric or list









name or list of names





The exception is that for the DAE solvers the absolute error tolerance can be specified as a per-component list. For expected behavior, the variables of the problem must also be specified as a list, and the entries of 'abserr' must correspond 1-1 to the variables in the list, or to the variables in the system converted to first order using the order of the variables in the list. For more information, see the ?dsolve[numeric,IVP] help page.


The default DAE IVP method is a modified Runge-Kutta Fehlberg method, which uses a base order 4-5 method, but has been modified to find solutions for DAE problems. The default stiff method is a Rosenbrock method, which uses a base order 3-4 method. For a description of the modifications done to these methods in extending them to DAE solution, see the ?dae_extension help page. The other method available for DAE IVP is the dsolve[mebdfi] method, which is short for Modified Extended Backward-Differentiation Formula Implicit method.


In general, the DAE IVP solvers are very similar to the standard differential IVP solvers, so this page is primarily concerned with outlining the differences between them.


The DAE solvers are currently restricted to finding solutions for real-valued problems.


For use of any of the methods, the specified initial conditions must satisfy all hidden constraints of the system (that is, they must be a consistent set of initial conditions with respect to the DAE). In the event that they do not, an error results, and information is provided on the unsatisfied condition.


In some cases, it may be necessary to use fsolve to compute consistent initial conditions for the problem.


If the ?dae_extension methods are in use, the differential option is set to true, and the system is sufficiently linear in the algebraic variables (i.e., variables which have no derivatives appearing in the input system), it is possible to skip initial conditions for those variables. If the initial conditions are skipped when they are required, an error will be produced.


The following options are also available for some or all of the DAE methods:

































list of names


'minstep', 'maxstep', and 'initstep'


These options are discussed in dsolve[Error_Control], and are only available for the dsolve[mebdfi] method.




'startinit'= boolean


This option controls the behavior of the numerical integration with respect to consecutive calculations. This option is described in dsolve[numeric,IVP].


For the methods, rkf45_dae, ck45_dae, and rosenbrock_dae, when a 'range' has been specified, the solution is recomputed only when the new value of the independent variable is not between the initial point and any other previously requested solution point. This has the effect of never reversing the direction of integration, and making evaluation of the solution for an already computed interval quite inexpensive (the solution values are obtained by interpolation). The storage of the solution can also be enabled by using the storage argument. The startinit parameter also forces these methods to recompute the solution whenever a solution value is desired.




'events'= list


'event_pre'= keyword


'event_maxiter'= integer


These options are available only for the rkf45_dae, ck45_dae, and rosenbrock_dae methods, and are used to specify and control the behavior of events. These are the same as for standard IVP problems. For a description, see the ?dsolve[numeric,IVP] and ?dsolve[Events] help pages.




'projection', 'differential', and 'implicit'


The 'projection', 'differential' and 'implicit' options are specific to the extension methods, so they are discussed there.




In addition to the computation of solution values for the given input problem, the procedure returns (that is, output=procedurelist, listprocedure or operator) provide additional interactive features, including the ability to specify parameters. Information on these features is provided on the dsolve[numeric,interactive] page. The exception is that the mebdfi method cannot work with parametrized problems.


As a first example, we consider the problem of modeling the dynamics of a mass on a string of unit length in 2-D Cartesian coordinates (the pendulum problem). We let r be the position of the mass on the string, and v the velocity:



r := VectorCalculus[Vector]([x(t),y(t)]);



v := VectorCalculus[diff](r,t);



Since the mass is on a string of fixed length l, we have the constraint:

con := VectorCalculus[DotProduct](r,r)-l^2;



Now we want to construct the DAE system using the Euler-Lagrange formulation, so we compute the kinetic energy T and the potential energy V as:

T := m/2*VectorCalculus[DotProduct](v,v);



V := m*g*y(t);



where m is the mass, and g is the gravitational constant (we will use 9.8). The Lagrangian and modified Lagrangian are given by:

L := T-V;



ML := L - lambda(t)*con;



We can then construct the Euler-Lagrange formulation via:

Q := remove(has,VariationalCalculus:-EulerLagrange(



EQx := isolate(select(has,Q,diff(x(t),t,t))[1],diff(x(t),t,t));



EQy := isolate(select(has,Q,diff(y(t),t,t))[1],diff(y(t),t,t));



EQc := remove(has,Q,diff)[1];



Now we have the equations of motion for the pendulum. Next, we need to determine consistent initial conditions. To do so, we must identify any hidden constraints of the system. These are easy to find, as we have only one constraint.

Dcon := diff(EQc,t);



DDcon := eval(diff(Dcon,t),{EQx,EQy});



Our initial conditions must satisfy EQc, Dcon, and DDcon at the initial point, leaving only 2 degrees of freedom for the conditions. So for a pendulum starting at the minimum value of y0=l having an initial horizontal velocity of Dx0=vx, we get:

sys := {y(0)=-l,D(x)(0)=vx} union



ini := [solve(sys,{x(0),y(0),D(x)(0),D(y)(0),lambda(0)})][1];



So we consider the above with a pendulum of unit length l=1 having unit mass m=1 and an initial horizontal velocity of vx=110, giving us the DAE system and initial conditions:

dsys := eval({EQx,EQy,EQc},{l=1,m=1,g=9.8,vx=1/10});



dini := eval(ini,{l=1,m=1,g=9.8,vx=1/10});



We can then obtain the solution as:

dsol1 := dsolve(dsys union dini, numeric);

dsol1:=procx_rkf45_dae...end proc








Solution with rosenbrock_dae:

dsol2 := dsolve(dsys union dini, numeric, method=rosenbrock_dae);

dsol2:=procx_rosenbrock_dae...end proc








Solution with mebdfi:

dsol3 := dsolve(dsys union dini, numeric, method=mebdfi);

dsol3:=procx_mebdfi...end proc








Now consider a similar problem as above, but in addition add a second mass supported from the first by another string, this one of length 1/2 (the double pendulum). The system can be obtained and solved as:

dsysd := {
   diff(x1(t),t,t)    +2*lambda1(t)*x1(t)+2*lambda2(t)*(x1(t)-x2(t)),
   diff(x2(t),t,t)                       -2*lambda2(t)*(x1(t)-x2(t)),
   diff(y2(t),t,t)+9.8                   -2*lambda2(t)*(y1(t)-y2(t)),



ics := {x1(0)=0,D(x1)(0)=-3,y1(0)=-1,D(y1)(0)=0,



dsold := dsolve(dsysd union ics,numeric);

dsold:=procx_rkf45_dae...end proc


The trajectory of the second mass can be plotted via:


Note that we did not specify initial conditions for lambda1t and lambda2t as we were using an extension method, and the system was sufficiently linear in the lambda.

See Also

dsolve/dae_extension, dsolve/Error_Control, dsolve[ck45], dsolve[Events], dsolve[maxfun], dsolve[mebdfi], dsolve[numeric,interactive], dsolve[numeric,IVP], dsolve[numeric], dsolve[rkf45], dsolve[rosenbrock], dsolve[Stiffness], plots[odeplot]

Download Help Document

Was this information helpful?

Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam