def main():
y0 = [1.0, 0.0, 0.0, 0.0, 5]
yd0 = [0.0, 0.0, 0.0, -9.82, 0.0]
# tout = [1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 5.0]
tout = np.linspace(0.0, 10.0, 500)
implicit_model = Implicit_Problem(res, y0, yd0, name="Example problem")
# implicit_model.jac = jac
implicit_model.algvar = [1.0, 1.0, 1.0, 1.0, 0.0]
implicit_solver = IDA(implicit_model)
implicit_solver.atol = 1E-6
implicit_solver.rtol = 1E-6
implicit_solver.suppress_alg = True
implicit_solver.make_consistent("IDA_YA_YDP_INIT")
t, y, yd = implicit_solver.simulate(10.0, ncp=500)
plt.plot(t, y, linestyle="dashed", marker="o")
plt.xlabel("Time")
plt.ylabel("State")
plt.title(implicit_model.name)
plt.show()
def dae_solver(residual,
y0,
yd0,
t0,
p0=None,
jac=None,
name='DAE',
solver='IDA',
algvar=None,
atol=1e-6,
backward=False,
display_progress=True,
pbar=None,
report_continuously=False,
rtol=1e-6,
sensmethod='STAGGERED',
suppress_alg=False,
suppress_sens=False,
usejac=False,
usesens=False,
verbosity=30,
tfinal=10.,
ncp=500):
'''
DAE solver.
Parameters
----------
residual: function
Implicit DAE model.
y0: List[float]
Initial model state.
yd0: List[float]
Initial model state derivatives.
t0: float
Initial simulation time.
p0: List[float]
Parameters for which sensitivites are to be calculated.
jac: function
Model jacobian.
name: string
Model name.
solver: string
DAE solver.
algvar: List[bool]
A list for defining which variables are differential and which are algebraic.
The value True(1.0) indicates a differential variable and the value False(0.0) indicates an algebraic variable.
atol: float
Absolute tolerance.
backward: bool
Specifies if the simulation is done in reverse time.
display_progress: bool
Actives output during the integration in terms of that the current integration is periodically printed to the stdout.
Report_continuously needs to be activated.
pbar: List[float]
An array of positive floats equal to the number of parameters. Default absolute values of the parameters.
Specifies the order of magnitude for the parameters. Useful if IDAS is to estimate tolerances for the sensitivity solution vectors.
report_continuously: bool
Specifies if the solver should report the solution continuously after steps.
rtol: float
Relative tolerance.
sensmethod: string
Specifies the sensitivity solution method.
Can be either ‘SIMULTANEOUS’ or ‘STAGGERED’. Default is 'STAGGERED'.
suppress_alg: bool
Indicates that the error-tests are suppressed on algebraic variables.
suppress_sens: bool
Indicates that the error-tests are suppressed on the sensitivity variables.
usejac: bool
Sets the option to use the user defined jacobian.
usesens: bool
Aactivates or deactivates the sensitivity calculations.
verbosity: int
Determines the level of the output.
QUIET = 50 WHISPER = 40 NORMAL = 30 LOUD = 20 SCREAM = 10
tfinal: float
Simulation final time.
ncp: int
Number of communication points (number of return points).
Returns
-------
sol: solution [time, model states], List[float]
'''
if usesens is True: # parameter sensitivity
model = Implicit_Problem(residual, y0, yd0, t0, p0=p0)
else:
model = Implicit_Problem(residual, y0, yd0, t0)
model.name = name
if usejac is True: # jacobian
model.jac = jac
if algvar is not None: # differential or algebraic variables
model.algvar = algvar
if solver == 'IDA': # solver
from assimulo.solvers import IDA
sim = IDA(model)
sim.atol = atol
sim.rtol = rtol
sim.backward = backward # backward in time
sim.report_continuously = report_continuously
sim.display_progress = display_progress
sim.suppress_alg = suppress_alg
sim.verbosity = verbosity
if usesens is True: # sensitivity
sim.sensmethod = sensmethod
sim.pbar = np.abs(p0)
sim.suppress_sens = suppress_sens
# Simulation
# t, y, yd = sim.simulate(tfinal, ncp=(ncp - 1))
ncp_list = np.linspace(t0, tfinal, num=ncp, endpoint=True)
t, y, yd = sim.simulate(tfinal, ncp=0, ncp_list=ncp_list)
# Plot
# sim.plot()
# plt.figure()
# plt.subplot(221)
# plt.plot(t, y[:, 0], 'b.-')
# plt.legend([r'$\lambda$'])
# plt.subplot(222)
# plt.plot(t, y[:, 1], 'r.-')
# plt.legend([r'$\dot{\lambda}$'])
# plt.subplot(223)
# plt.plot(t, y[:, 2], 'k.-')
# plt.legend([r'$\eta$'])
# plt.subplot(224)
# plt.plot(t, y[:, 3], 'm.-')
# plt.legend([r'$\dot{\eta}$'])
# plt.figure()
# plt.subplot(221)
# plt.plot(t, yd[:, 0], 'b.-')
# plt.legend([r'$\dot{\lambda}$'])
# plt.subplot(222)
# plt.plot(t, yd[:, 1], 'r.-')
# plt.legend([r'$\ddot{\lambda}$'])
# plt.subplot(223)
# plt.plot(t, yd[:, 2], 'k.-')
# plt.legend([r'$\dot{\eta}$'])
# plt.subplot(224)
# plt.plot(t, yd[:, 3], 'm.-')
# plt.legend([r'$\ddot{\eta}$'])
# plt.figure()
# plt.subplot(121)
# plt.plot(y[:, 0], y[:, 1])
# plt.xlabel(r'$\lambda$')
# plt.ylabel(r'$\dot{\lambda}$')
# plt.subplot(122)
# plt.plot(y[:, 2], y[:, 3])
# plt.xlabel(r'$\eta$')
# plt.ylabel(r'$\dot{\eta}$')
# plt.figure()
# plt.subplot(121)
# plt.plot(yd[:, 0], yd[:, 1])
# plt.xlabel(r'$\dot{\lambda}$')
# plt.ylabel(r'$\ddot{\lambda}$')
# plt.subplot(122)
# plt.plot(yd[:, 2], yd[:, 3])
# plt.xlabel(r'$\dot{\eta}$')
# plt.ylabel(r'$\ddot{\eta}$')
# plt.figure()
# plt.subplot(121)
# plt.plot(y[:, 0], y[:, 2])
# plt.xlabel(r'$\lambda$')
# plt.ylabel(r'$\eta$')
# plt.subplot(122)
# plt.plot(y[:, 1], y[:, 3])
# plt.xlabel(r'$\dot{\lambda}$')
# plt.ylabel(r'$\dot{\eta}$')
# plt.figure()
# plt.subplot(121)
# plt.plot(yd[:, 0], yd[:, 2])
# plt.xlabel(r'$\dot{\lambda}$')
# plt.ylabel(r'$\dot{\eta}$')
# plt.subplot(122)
# plt.plot(yd[:, 1], yd[:, 3])
# plt.xlabel(r'$\ddot{\lambda}$')
# plt.ylabel(r'$\ddot{\eta}$')
# plt.show()
sol = [t, y, yd]
return sol
def run_example(with_plots=True):
r"""
Example for demonstrating the use of a user supplied Jacobian
ODE:
.. math::
\dot y_1-y_3 &= 0 \\
\dot y_2-y_4 &= 0 \\
\dot y_3+y_5 y_1 &= 0 \\
\dot y_4+y_5 y_2+9.82&= 0 \\
y_3^2+y_4^2-y_5(y_1^2+y_2^2)-9.82 y_2&= 0
on return:
- :dfn:`imp_mod` problem instance
- :dfn:`imp_sim` solver instance
"""
#Defines the residual
def f(t, y, yd):
res_0 = yd[0] - y[2]
res_1 = yd[1] - y[3]
res_2 = yd[2] + y[4] * y[0]
res_3 = yd[3] + y[4] * y[1] + 9.82
res_4 = y[2]**2 + y[3]**2 - y[4] * (y[0]**2 + y[1]**2) - y[1] * 9.82
return N.array([res_0, res_1, res_2, res_3, res_4])
#Defines the Jacobian
def jac(c, t, y, yd):
jacobian = N.zeros([len(y), len(y)])
#Derivative
jacobian[0, 0] = 1 * c
jacobian[1, 1] = 1 * c
jacobian[2, 2] = 1 * c
jacobian[3, 3] = 1 * c
#Differentiated
jacobian[0, 2] = -1
jacobian[1, 3] = -1
jacobian[2, 0] = y[4]
jacobian[3, 1] = y[4]
jacobian[4, 0] = y[0] * 2 * y[4] * -1
jacobian[4, 1] = y[1] * 2 * y[4] * -1 - 9.82
jacobian[4, 2] = y[2] * 2
jacobian[4, 3] = y[3] * 2
#Algebraic
jacobian[2, 4] = y[0]
jacobian[3, 4] = y[1]
jacobian[4, 4] = -(y[0]**2 + y[1]**2)
return jacobian
#The initial conditons
y0 = [1.0, 0.0, 0.0, 0.0, 5] #Initial conditions
yd0 = [0.0, 0.0, 0.0, -9.82, 0.0] #Initial conditions
#Create an Assimulo implicit problem
imp_mod = Implicit_Problem(f,
y0,
yd0,
name='Example using an analytic Jacobian')
#Sets the options to the problem
imp_mod.jac = jac #Sets the jacobian
imp_mod.algvar = [1.0, 1.0, 1.0, 1.0, 0.0] #Set the algebraic components
#Create an Assimulo implicit solver (IDA)
imp_sim = IDA(imp_mod) #Create a IDA solver
#Sets the paramters
imp_sim.atol = 1e-6 #Default 1e-6
imp_sim.rtol = 1e-6 #Default 1e-6
imp_sim.suppress_alg = True #Suppres the algebraic variables on the error test
#Let Sundials find consistent initial conditions by use of 'IDA_YA_YDP_INIT'
imp_sim.make_consistent('IDA_YA_YDP_INIT')
#Simulate
t, y, yd = imp_sim.simulate(
5, 1000) #Simulate 5 seconds with 1000 communication points
#Basic tests
nose.tools.assert_almost_equal(y[-1][0], 0.9401995, places=4)
nose.tools.assert_almost_equal(y[-1][1], -0.34095124, places=4)
nose.tools.assert_almost_equal(yd[-1][0], -0.88198927, places=4)
nose.tools.assert_almost_equal(yd[-1][1], -2.43227069, places=4)
#Plot
if with_plots:
import pylab as P
P.plot(t, y, linestyle="dashed", marker="o") #Plot the solution
P.xlabel('Time')
P.ylabel('State')
P.title(imp_mod.name)
P.show()
return imp_mod, imp_sim
def run_example(with_plots=True):
#Defines the residual
def f(t,y,yd):
res_0 = yd[0]-y[2]
res_1 = yd[1]-y[3]
res_2 = yd[2]+y[4]*y[0]
res_3 = yd[3]+y[4]*y[1]+9.82
#res_4 = y[0]**2+y[1]**2-1
res_4 = y[2]**2+y[3]**2-y[4]*(y[0]**2+y[1]**2)-y[1]*9.82
return N.array([res_0,res_1,res_2,res_3,res_4])
#Defines the jacobian
def jac(c,t,y,yd):
jacobian = N.zeros([len(y),len(y)])
#Derivative
jacobian[0,0] = 1*c
jacobian[1,1] = 1*c
jacobian[2,2] = 1*c
jacobian[3,3] = 1*c
#Differentiated
jacobian[0,2] = -1
jacobian[1,3] = -1
jacobian[2,0] = y[4]
jacobian[3,1] = y[4]
jacobian[4,0] = y[0]*2*y[4]*-1
jacobian[4,1] = y[1]*2*y[4]*-1-9.82
jacobian[4,2] = y[2]*2
jacobian[4,3] = y[3]*2
#Algebraic
jacobian[2,4] = y[0]
jacobian[3,4] = y[1]
jacobian[4,4] = -(y[0]**2+y[1]**2)
return jacobian
#The initial conditons
y0 = [1.0,0.0,0.0,0.0,5] #Initial conditions
yd0 = [0.0,0.0,0.0,-9.82,0.0] #Initial conditions
#Create an Assimulo implicit problem
imp_mod = Implicit_Problem(f,y0,yd0)
#Sets the options to the problem
imp_mod.jac = jac #Sets the jacobian
imp_mod.algvar = [1.0,1.0,1.0,1.0,0.0] #Set the algebraic components
imp_mod.name = 'Test Jacobian'
#Create an Assimulo implicit solver (IDA)
imp_sim = IDA(imp_mod) #Create a IDA solver
#Sets the paramters
imp_sim.atol = 1e-6 #Default 1e-6
imp_sim.rtol = 1e-6 #Default 1e-6
imp_sim.suppress_alg = True #Suppres the algebraic variables on the error test
#Let Sundials find consistent initial conditions by use of 'IDA_YA_YDP_INIT'
imp_sim.make_consistent('IDA_YA_YDP_INIT')
#Simulate
t, y, yd = imp_sim.simulate(5,1000) #Simulate 5 seconds with 1000 communication points
#Basic tests
nose.tools.assert_almost_equal(y[-1][0],0.9401995, places=4)
nose.tools.assert_almost_equal(y[-1][1],-0.34095124, places=4)
nose.tools.assert_almost_equal(yd[-1][0], -0.88198927, places=4)
nose.tools.assert_almost_equal(yd[-1][1], -2.43227069, places=4)
#Plot
if with_plots:
P.plot(t,y)
P.show()
def run_example(with_plots=True):
r"""
Example for demonstrating the use of a user supplied Jacobian
ODE:
.. math::
\dot y_1-y_3 &= 0 \\
\dot y_2-y_4 &= 0 \\
\dot y_3+y_5 y_1 &= 0 \\
\dot y_4+y_5 y_2+9.82&= 0 \\
y_3^2+y_4^2-y_5(y_1^2+y_2^2)-9.82 y_2&= 0
on return:
- :dfn:`imp_mod` problem instance
- :dfn:`imp_sim` solver instance
"""
global order
order = []
#Defines the residual
def f(t, y, yd):
res_0 = yd[0] - y[2]
res_1 = yd[1] - y[3]
res_2 = yd[2] + y[4] * y[0]
res_3 = yd[3] + y[4] * y[1] + 9.82
res_4 = y[2]**2 + y[3]**2 - y[4] * (y[0]**2 + y[1]**2) - y[1] * 9.82
return N.array([res_0, res_1, res_2, res_3, res_4])
def handle_result(solver, t, y, yd):
global order
order.append(solver.get_last_order())
solver.t_sol.extend([t])
solver.y_sol.extend([y])
solver.yd_sol.extend([yd])
#The initial conditons
y0 = [1.0, 0.0, 0.0, 0.0, 5] #Initial conditions
yd0 = [0.0, 0.0, 0.0, -9.82, 0.0] #Initial conditions
#Create an Assimulo implicit problem
imp_mod = Implicit_Problem(f,
y0,
yd0,
name='Example for plotting used order')
imp_mod.handle_result = handle_result
#Sets the options to the problem
imp_mod.algvar = [1.0, 1.0, 1.0, 1.0, 0.0] #Set the algebraic components
#Create an Assimulo implicit solver (IDA)
imp_sim = IDA(imp_mod) #Create a IDA solver
#Sets the paramters
imp_sim.atol = 1e-6 #Default 1e-6
imp_sim.rtol = 1e-6 #Default 1e-6
imp_sim.suppress_alg = True #Suppres the algebraic variables on the error test
imp_sim.report_continuously = True
#Let Sundials find consistent initial conditions by use of 'IDA_YA_YDP_INIT'
imp_sim.make_consistent('IDA_YA_YDP_INIT')
#Simulate
t, y, yd = imp_sim.simulate(5) #Simulate 5 seconds
#Basic tests
nose.tools.assert_almost_equal(y[-1][0], 0.9401995, places=4)
nose.tools.assert_almost_equal(y[-1][1], -0.34095124, places=4)
nose.tools.assert_almost_equal(yd[-1][0], -0.88198927, places=4)
nose.tools.assert_almost_equal(yd[-1][1], -2.43227069, places=4)
nose.tools.assert_almost_equal(order[-1], 5, places=4)
#Plot
if with_plots:
P.figure(1)
P.plot(t, y, linestyle="dashed", marker="o") #Plot the solution
P.xlabel('Time')
P.ylabel('State')
P.title(imp_mod.name)
P.figure(2)
P.plot([0] + N.add.accumulate(N.diff(t)).tolist(), order)
P.title("Used order during the integration")
P.xlabel("Time")
P.ylabel("Order")
P.show()
return imp_mod, imp_sim
def run_example(with_plots=True):
#Defines the residual
def f(t, y, yd):
res_0 = yd[0] - y[2]
res_1 = yd[1] - y[3]
res_2 = yd[2] + y[4] * y[0]
res_3 = yd[3] + y[4] * y[1] + 9.82
#res_4 = y[0]**2+y[1]**2-1
res_4 = y[2]**2 + y[3]**2 - y[4] * (y[0]**2 + y[1]**2) - y[1] * 9.82
return N.array([res_0, res_1, res_2, res_3, res_4])
#Defines the jacobian
def jac(c, t, y, yd):
jacobian = N.zeros([len(y), len(y)])
#Derivative
jacobian[0, 0] = 1 * c
jacobian[1, 1] = 1 * c
jacobian[2, 2] = 1 * c
jacobian[3, 3] = 1 * c
#Differentiated
jacobian[0, 2] = -1
jacobian[1, 3] = -1
jacobian[2, 0] = y[4]
jacobian[3, 1] = y[4]
jacobian[4, 0] = y[0] * 2 * y[4] * -1
jacobian[4, 1] = y[1] * 2 * y[4] * -1 - 9.82
jacobian[4, 2] = y[2] * 2
jacobian[4, 3] = y[3] * 2
#Algebraic
jacobian[2, 4] = y[0]
jacobian[3, 4] = y[1]
jacobian[4, 4] = -(y[0]**2 + y[1]**2)
return jacobian
#The initial conditons
y0 = [1.0, 0.0, 0.0, 0.0, 5] #Initial conditions
yd0 = [0.0, 0.0, 0.0, -9.82, 0.0] #Initial conditions
#Create an Assimulo implicit problem
imp_mod = Implicit_Problem(f, y0, yd0)
#Sets the options to the problem
imp_mod.jac = jac #Sets the jacobian
imp_mod.algvar = [1.0, 1.0, 1.0, 1.0, 0.0] #Set the algebraic components
imp_mod.name = 'Test Jacobian'
#Create an Assimulo implicit solver (IDA)
imp_sim = IDA(imp_mod) #Create a IDA solver
#Sets the paramters
imp_sim.atol = 1e-6 #Default 1e-6
imp_sim.rtol = 1e-6 #Default 1e-6
imp_sim.suppress_alg = True #Suppres the algebraic variables on the error test
#Let Sundials find consistent initial conditions by use of 'IDA_YA_YDP_INIT'
imp_sim.make_consistent('IDA_YA_YDP_INIT')
#Simulate
t, y, yd = imp_sim.simulate(
5, 1000) #Simulate 5 seconds with 1000 communication points
#Basic tests
nose.tools.assert_almost_equal(y[-1][0], 0.9401995, places=4)
nose.tools.assert_almost_equal(y[-1][1], -0.34095124, places=4)
nose.tools.assert_almost_equal(yd[-1][0], -0.88198927, places=4)
nose.tools.assert_almost_equal(yd[-1][1], -2.43227069, places=4)
#Plot
if with_plots:
P.plot(t, y)
P.show()
from sei_1d_outputs_detailed import *
elif mode == 'homogeneous':
from sei_1d_functions import residual_homogeneous as residual
from sei_1d_outputs_homogeneous import *
elif mode == 'reduced':
from sei_1d_functions import residual_reduced as residual
from sei_1d_outputs_reduced import *
else:
raise Exception('Please select a valid simulation mode." + \
" Available options are "detailed", "homogeneous", and "reduced"')
print('\n Running simulation\n')
# Set up problem instance
SEI_1D = Implicit_Problem(residual, SV_0, SV_dot_0)
SEI_1D.algvar = algvar
# Define simulation parameters
simulation = IDA(SEI_1D) # Create simulation instance
simulation.atol = 1e-8 # Solver absolute tolerance
simulation.rtol = 1e-4 # Solver relative tolerance
#simulation.maxh = 55 # Solver max step size
simulation.make_consistent('IDA_YA_YDP_INIT')
# Set simulation end time, slope flag (for anode voltage cycle), and run simulation
t_f = times[-1]
#ncp_list = np.arange(0, t_f, 0.15)
#ncp = 10000
