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.state_events = self.state_events
#model.handle_events = self.handle_event
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.maxsteps = self.max_steps
solver.num_threads = 3
#solver.display_progress = True
return solver
y30,yp30=squeezer_ind3.init_squeezer3() # Initial values
t0 = 0 # Initial time
squeezemodel2 = Implicit_Problem(squeezer_ind2.squeezer2, y20, yp20, t0)
squeezemodel3 = Implicit_Problem(squeezer_ind3.squeezer3, y30, yp30, t0)
algvar = 7*[1.]+13*[0.]
solver2 = IDA(squeezemodel2) # Create solver instance
solver3 = IDA(squeezemodel3) # Create solver instance
solver2.algvar = algvar
solver3.algvar = algvar
solver2.suppress_alg=True
solver3.suppress_alg=True
solver2.atol = 1e-7
solver3.atol = 1e-7
solver3.maxsteps = 322
print(solver3.maxsteps)
tf = .03 # End time for simulation
t2, y2, yd2 = solver2.simulate(tf)
t3, y3, yd3 = solver3.simulate(tf)
figure(1)
plot(t2,y2[:,14:16])
title('Index 2')
figure(2)
plot(t3,y3[:,14:16])
title('Index 3')
show()
