def _init_backward(self, checkpoint_n, interpolation):
check(lib.CVodeAdjInit(self._ode, checkpoint_n, interpolation))
# Initialized by CVodeCreateB
backward_ode = ffi.new('int*')
check(
lib.CVodeCreateB(self._ode, self._adjoint_solver_type,
backward_ode))
self._odeB = backward_ode[0]
self._state_bufferB = sunode.empty_vector(self._problem.n_states)
check(
lib.CVodeInitB(self._ode, self._odeB, self._adj_rhs.cffi, 0.,
self._state_bufferB.c_ptr))
# TODO
check(lib.CVodeSStolerancesB(self._ode, self._odeB, 1e-10, 1e-10))
linsolver = check(
lib.SUNLinSol_Dense(self._state_bufferB.c_ptr, self._jacB))
check(
lib.CVodeSetLinearSolverB(self._ode, self._odeB, linsolver,
self._jacB))
self._jac_funcB = self._problem.make_sundials_adjoint_jac_dense()
check(lib.CVodeSetJacFnB(self._ode, self._odeB, self._jac_funcB.cffi))
user_data_p = ffi.cast(
'void *', ffi.addressof(ffi.from_buffer(self._user_data.data)))
check(lib.CVodeSetUserDataB(self._ode, self._odeB, user_data_p))
self._quad_buffer = sunode.empty_vector(self._problem.n_params)
self._quad_buffer_out = sunode.empty_vector(self._problem.n_params)
check(
lib.CVodeQuadInitB(self._ode, self._odeB, self._quad_rhs.cffi,
self._quad_buffer.c_ptr))
check(lib.CVodeQuadSStolerancesB(self._ode, self._odeB, 1e-10, 1e-10))
check(lib.CVodeSetQuadErrConB(self._ode, self._odeB, 1))
def __init__(self,
problem: Problem,
*,
compute_sens: bool = False,
abstol: float = 1e-10,
reltol: float = 1e-10,
sens_mode: Optional[str] = None,
scaling_factors: Optional[np.ndarray] = None,
constraints: Optional[np.ndarray] = None,
solver='BDF'):
self._problem = problem
self._user_data = problem.make_user_data()
n_states = self._problem.n_states
n_params = self._problem.n_params
self._state_buffer = sunode.empty_vector(n_states)
self._state_buffer.data[:] = 0
self._jac = check(lib.SUNDenseMatrix(n_states, n_states))
self._constraints = constraints
if solver == 'BDF':
solver_kind = lib.CV_BDF
elif solver == 'ADAMS':
solver_kind = lib.CV_ADAMS
else:
assert False
self._ode = check(lib.CVodeCreate(solver_kind))
rhs = problem.make_sundials_rhs()
check(lib.CVodeInit(self._ode, rhs.cffi, 0., self._state_buffer.c_ptr))
self._set_tolerances(abstol, reltol)
if self._constraints is not None:
assert constraints.shape == (n_states, )
self._constraints_vec = sunode.from_numpy(constraints)
check(
lib.CVodeSetConstraints(self._ode,
self._constraints_vec.c_ptr))
self._make_linsol()
user_data_p = ffi.cast(
'void *', ffi.addressof(ffi.from_buffer(self._user_data.data)))
check(lib.CVodeSetUserData(self._ode, user_data_p))
self._compute_sens = compute_sens
if compute_sens:
sens_rhs = self._problem.make_sundials_sensitivity_rhs()
self._init_sens(sens_rhs, sens_mode)
def __init__(self,
problem: Problem,
*,
solver: str = 'BDF',
jac_kind: str = "dense"):
super().__init__()
self.mark_changed()
self.problem = problem
self.user_data = problem.make_user_data()
self._state_buffer = sunode.empty_vector(self.n_states)
self._state_buffer.data[:] = 0.
self.borrow(self._state_buffer)
if jac_kind == 'dense':
self._jac = matrix.empty_matrix((self.n_states, self.n_states))
elif jac_kind == 'sparse':
self._jac = problem.make_rhs_sparse_jac_template()
else:
raise ValueError(f'Unknown jac_kind {jac_kind}.')
self.borrow(self._jac)
if solver == 'BDF':
self.c_ptr = check_ptr(lib.CVodeCreate(lib.CV_BDF))
elif solver == 'ADAMS':
self.c_ptr = check_ptr(lib.CVodeCreate(lib.CV_ADAMS))
else:
raise ValueError(f'Unknown solver {solver}.')
self._rhs = self.problem.make_sundials_rhs()
def finalize(c_ptr: CPointer,
release_borrowed: Callable[[], None]) -> None:
if c_ptr == ffi.NULL:
logger.warn("Trying to free Solver, but it is NULL.")
else:
logger.debug("Freeing Solver")
lib.CVodeFree(c_ptr)
release_borrowed()
weakref.finalize(self, finalize, self.c_ptr,
self.release_borrowed_func())
def __init__(self,
problem,
*,
abstol=1e-10,
reltol=1e-10,
checkpoint_n=500_000,
interpolation='polynomial',
constraints=None,
solver='BDF',
adjoint_solver='BDF'):
self._problem = problem
n_states, n_params = problem.n_states, problem.n_params
self._user_data = problem.make_user_data()
self._state_buffer = sunode.empty_vector(n_states)
self._state_buffer.data[:] = 0
self._jac = check(lib.SUNDenseMatrix(n_states, n_states))
self._jacB = check(lib.SUNDenseMatrix(n_states, n_states))
rhs = problem.make_sundials_rhs()
self._adj_rhs = problem.make_sundials_adjoint_rhs()
self._quad_rhs = problem.make_sundials_adjoint_quad_rhs()
self._rhs = problem.make_rhs()
self._constraints = constraints
if solver == 'BDF':
self._solver_type = lib.CV_BDF
elif solver == 'ADAMS':
self._solver_type = lib.CV_ADAMS