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