def solve(self):
# Setup IDA
assert self._initial_time is not None
problem = Implicit_Problem(self._residual_vector_eval,
self.solution.vector(),
self.solution_dot.vector(),
self._initial_time)
problem.jac = self._jacobian_matrix_eval
problem.handle_result = self._monitor
# Define an Assimulo IDA solver
solver = IDA(problem)
# Setup options
assert self._time_step_size is not None
solver.inith = self._time_step_size
if self._absolute_tolerance is not None:
solver.atol = self._absolute_tolerance
if self._max_time_steps is not None:
solver.maxsteps = self._max_time_steps
if self._relative_tolerance is not None:
solver.rtol = self._relative_tolerance
if self._report:
solver.verbosity = 10
solver.display_progress = True
solver.report_continuously = True
else:
solver.display_progress = False
solver.verbosity = 50
# Assert consistency of final time and time step size
assert self._final_time is not None
final_time_consistency = (
self._final_time - self._initial_time) / self._time_step_size
assert isclose(
round(final_time_consistency), final_time_consistency
), ("Final time should be occuring after an integer number of time steps"
)
# Prepare monitor computation if not provided by parameters
if self._monitor_initial_time is None:
self._monitor_initial_time = self._initial_time
assert isclose(
round(self._monitor_initial_time / self._time_step_size),
self._monitor_initial_time / self._time_step_size
), ("Monitor initial time should be a multiple of the time step size"
)
if self._monitor_time_step_size is None:
self._monitor_time_step_size = self._time_step_size
assert isclose(
round(self._monitor_time_step_size / self._time_step_size),
self._monitor_time_step_size / self._time_step_size
), ("Monitor time step size should be a multiple of the time step size"
)
monitor_t = arange(
self._monitor_initial_time,
self._final_time + self._monitor_time_step_size / 2.,
self._monitor_time_step_size)
# Solve
solver.simulate(self._final_time, ncp_list=monitor_t)
def initialize_ode_solver(self, y_0, yd_0, t_0):
model = Implicit_Problem(self.residual, y_0, yd_0, t_0)
model.handle_result = self.handle_result
solver = IDA(model)
solver.rtol = self.solver_rtol
solver.atol = self.solver_atol # * np.array([100, 10, 1e-4, 1e-4])
solver.inith = 0.1 # self.wind.R_g / const.C
solver.maxh = self.dt * self.wind.R_g / const.C
solver.report_continuously = True
solver.display_progress = False
solver.verbosity = 50 # 50 = quiet
solver.num_threads = 3
# solver.display_progress = True
return solver
def buildsim(self, ):
"""
Setup the assimulo IDA simulator.
"""
# Create an Assimulo implicit solver (IDA)
imp_sim = IDA(self.imp_mod) # Create a IDA solver
# Sets the paramters
# 1e-4 #Default 1e-6
imp_sim.atol = self.p.RunInput['TIMESTEPPING']['SOLVER_TOL']
# 1e-4 #Default 1e-6
imp_sim.rtol = self.p.RunInput['TIMESTEPPING']['SOLVER_TOL']
# Suppres the algebraic variables on the error test
imp_sim.suppress_alg = True
imp_sim.display_progress = False
imp_sim.verbosity = 50
imp_sim.report_continuously = True
imp_sim.time_limit = 10.
self.imp_sim = imp_sim
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
### Simulate
#imp_mod.set_iapp( I_app/10. )
#imp_sim.make_consistent('IDA_YA_YDP_INIT')
#ta, ya, yda = imp_sim.simulate(0.1,5)
##
#imp_mod.set_iapp( I_app/2. )
#imp_sim.make_consistent('IDA_YA_YDP_INIT')
#tb, yb, ydb = imp_sim.simulate(0.2,5)
#imp_mod.set_iapp( I_app )
#imp_sim.make_consistent('IDA_YA_YDP_INIT')
## Sim step 1
#t1, y1, yd1 = imp_sim.simulate(1./Crate*3600.*0.2,100)
imp_sim.display_progress = False
imp_sim.verbosity = 50
imp_sim.report_continuously = True
imp_sim.time_limit = 10.
### Simulate
t01, t02 = 0.1, 0.2
imp_mod.set_iapp(I_app / 10.)
imp_sim.make_consistent('IDA_YA_YDP_INIT')
ta, ya, yda = imp_sim.simulate(t01, 2)
imp_mod.set_iapp(I_app / 2.)
imp_sim.make_consistent('IDA_YA_YDP_INIT')
tb, yb, ydb = imp_sim.simulate(t02, 2)
