solve-nivp 0.1.3.dev0__tar.gz → 0.2.0.dev1__tar.gz

{solve_nivp-0.1.3.dev0/solve_nivp.egg-info → solve_nivp-0.2.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solve_nivp
-Version: 0.1.3.dev0
+Version: 0.2.0.dev1
 Summary: A Python toolkit for integrating nonsmooth dynamical systems
 Author: David Riley, Ioannis Stefanou
 License: MIT

{solve_nivp-0.1.3.dev0 → solve_nivp-0.2.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "solve_nivp"
-version = "0.1.3.dev0"
+version = "0.2.0.dev1"
 description = "A Python toolkit for integrating nonsmooth dynamical systems"
 readme = "README.md"
 license = {text = "MIT"}

{solve_nivp-0.1.3.dev0 → solve_nivp-0.2.0.dev1}/setup.py

@@ -50,7 +50,7 @@ class BuildSphinx(Command):
 
 setup(
     name="solve_nivp",
-    version="0.1.3.dev0",
+    version="0.2.0.dev1",
     packages=find_packages(),  # automatically discovers packages
     description="A solver package for implicit ODEs and projection-based solvers",
     cmdclass={'build_sphinx': BuildSphinx},

{solve_nivp-0.1.3.dev0 → solve_nivp-0.2.0.dev1}/solve_nivp/ODESolver.py

@@ -40,10 +40,11 @@ class ODESolver:
         store_fk: bool = True,
         gc_interval: int = 0,
         abort_on_fixed_failure: bool = True,
+        t_eval: Optional[np.ndarray] = None,
     ):
         """
         Initialize the ODESolver.
-        
+
         Parameters:
             system: The ODE system to be integrated.
             t_span: A tuple (t0, tf) specifying the start and end times.
@@ -59,15 +60,57 @@ class ODESolver:
                 nonlinear failure instead of marching forward with the failed
                 state. The failed attempt is still recorded in
                 ``error_estimates``.
+            t_eval: Strictly increasing array of times in ``[t0, tf]`` that
+                must be evaluated.  When provided, the time loop clips the
+                step so it lands exactly on each ``t_eval`` entry, and the
+                returned histories contain only those entries (matches the
+                scipy ``solve_ivp`` convention).  Pass ``None`` to keep the
+                adaptive/fixed grid as the output.
         """
         self.system = system
         self.t0, self.tf = t_span
         self.h_initial = h
-        self.t_values: List[float] = [self.t0]
-        self.y_values: List[np.ndarray] = [self.system.current_y.copy()]
-        self.h_values: List[float] = [h]
+
+        # ---- t_eval validation and bookkeeping ----
+        self._use_t_eval: bool = False
+        self._t_eval: Optional[np.ndarray] = None
+        self._t_eval_idx: int = 0
+        if t_eval is not None:
+            t_eval_arr = np.asarray(t_eval, dtype=float).reshape(-1)
+            if t_eval_arr.size > 0:
+                if np.any(np.diff(t_eval_arr) <= 0.0):
+                    raise ValueError("t_eval must be strictly increasing")
+                tf_eps = 1.0e-12 * max(abs(self.t0), abs(self.tf), 1.0)
+                if (t_eval_arr[0] < self.t0 - tf_eps
+                        or t_eval_arr[-1] > self.tf + tf_eps):
+                    raise ValueError(
+                        f"t_eval out of range [{self.t0}, {self.tf}]: "
+                        f"got [{t_eval_arr[0]}, {t_eval_arr[-1]}]"
+                    )
+                self._t_eval = np.clip(t_eval_arr, self.t0, self.tf)
+                self._use_t_eval = True
+
+        if self._use_t_eval:
+            self.t_values: List[float] = []
+            self.y_values: List[np.ndarray] = []
+            self.h_values: List[float] = []
+            self.fk: List[Any] = []
+            # If t_eval[0] coincides with t0, record the initial state.
+            te0 = float(self._t_eval[0])
+            t0_eps = 1.0e-12 * max(abs(self.t0), 1.0)
+            if abs(te0 - self.t0) <= t0_eps:
+                self.t_values.append(te0)
+                self.y_values.append(self.system.current_y.copy())
+                self.h_values.append(h)
+                self.fk.append(None)
+                self._t_eval_idx = 1
+        else:
+            self.t_values = [self.t0]
+            self.y_values = [self.system.current_y.copy()]
+            self.h_values = [h]
+            self.fk = []
+
         self.error_estimates: List[Tuple[Any, bool, int]] = []
-        self.fk: List[Any] = []
         # Memory-saving options
         self.thin_output = max(1, int(thin_output))
         self.store_fk = bool(store_fk)
@@ -123,9 +166,38 @@ class ODESolver:
         # fail, falsely reporting "reached minimum step size".
         _tf_eps = 4.0 * np.finfo(float).eps * max(abs(self.t0), abs(self.tf), 1.0)
 
+        # Helper to record a stored sample (handles store_fk + fk fallback).
+        def _record(t_store, y, fk_val, h_taken, errinfo):
+            self.t_values.append(t_store)
+            self.y_values.append(y.copy())
+            if self.store_fk:
+                self.fk.append(fk_val.copy() if fk_val is not None else None)
+            else:
+                self.fk.append(None)
+            self.h_values.append(h_taken)
+            self.error_estimates.append(errinfo)
+
+        # Helper to drain any t_eval points that the latest accepted step
+        # advanced over (catches both exact landings and tiny float drift).
+        def _drain_t_eval(t_now, y_now, fk_val, h_taken, errinfo):
+            if not self._use_t_eval:
+                return
+            te_eps = 1.0e-9 * max(abs(t_now), 1.0)
+            while (self._t_eval_idx < len(self._t_eval)
+                   and self._t_eval[self._t_eval_idx] <= t_now + te_eps):
+                te = float(self._t_eval[self._t_eval_idx])
+                _record(te, y_now, fk_val, h_taken, errinfo)
+                self._t_eval_idx += 1
+
         while self.tf - t > _tf_eps:
             # Ensure we do not overshoot the final time.
             h_step = min(h, self.tf - t)
+            # When t_eval is given, also clip the step so it lands exactly
+            # on the next required output time.
+            if self._use_t_eval and self._t_eval_idx < len(self._t_eval):
+                next_te = float(self._t_eval[self._t_eval_idx])
+                if next_te > t:
+                    h_step = min(h_step, next_te - t)
             if self.system.adaptive:
                 # Adaptive stepping returns:
                 # (y_new, fk_new, h_new, E, success, solver_error, iterations)
@@ -133,17 +205,15 @@ class ODESolver:
                 if success:
                     t += h_step
                     _step_count += 1
-                    # Thin output: only store every Nth step (always store last)
-                    _is_last = (t >= self.tf - 1e-14 * abs(self.tf))
-                    if _step_count % _thin == 0 or _is_last:
-                        self.t_values.append(t)
-                        self.y_values.append(y_new.copy())
-                        if self.store_fk:
-                            self.fk.append(fk_new.copy() if fk_new is not None else None)
-                        else:
-                            self.fk.append(None)
-                        self.h_values.append(h_step)
-                        self.error_estimates.append((solver_error, success, iterations))
+                    if self._use_t_eval:
+                        _drain_t_eval(t, y_new, fk_new, h_step,
+                                      (solver_error, success, iterations))
+                    else:
+                        # Thin output: only store every Nth step (always store last)
+                        _is_last = (t >= self.tf - 1e-14 * abs(self.tf))
+                        if _step_count % _thin == 0 or _is_last:
+                            _record(t, y_new, fk_new, h_step,
+                                    (solver_error, success, iterations))
                     self.system.current_y = y_new
                     h = h_new  # Update step size for next iteration.
                     # Periodic garbage collection for large problems
@@ -162,16 +232,14 @@ class ODESolver:
                 if success:
                     t += h_step
                     _step_count += 1
-                    _is_last = (t >= self.tf - 1e-14 * abs(self.tf))
-                    if _step_count % _thin == 0 or _is_last:
-                        self.t_values.append(t)
-                        self.y_values.append(y_new.copy())
-                        if self.store_fk:
-                            self.fk.append(fk_new.copy() if fk_new is not None else None)
-                        else:
-                            self.fk.append(None)
-                        self.h_values.append(h_step)
-                        self.error_estimates.append((solver_error, success, iterations))
+                    if self._use_t_eval:
+                        _drain_t_eval(t, y_new, fk_new, h_step,
+                                      (solver_error, success, iterations))
+                    else:
+                        _is_last = (t >= self.tf - 1e-14 * abs(self.tf))
+                        if _step_count % _thin == 0 or _is_last:
+                            _record(t, y_new, fk_new, h_step,
+                                    (solver_error, success, iterations))
                     self.system.current_y = y_new
                     if _gc_iv > 0 and _step_count % _gc_iv == 0:
                         gc.collect()
@@ -187,16 +255,14 @@ class ODESolver:
                         break
                     t += h_step
                     _step_count += 1
-                    _is_last = (t >= self.tf - 1e-14 * abs(self.tf))
-                    if _step_count % _thin == 0 or _is_last:
-                        self.t_values.append(t)
-                        self.y_values.append(y_new.copy())
-                        if self.store_fk:
-                            self.fk.append(fk_new.copy() if fk_new is not None else None)
-                        else:
-                            self.fk.append(None)
-                        self.h_values.append(h_step)
-                        self.error_estimates.append((solver_error, success, iterations))
+                    if self._use_t_eval:
+                        _drain_t_eval(t, y_new, fk_new, h_step,
+                                      (solver_error, success, iterations))
+                    else:
+                        _is_last = (t >= self.tf - 1e-14 * abs(self.tf))
+                        if _step_count % _thin == 0 or _is_last:
+                            _record(t, y_new, fk_new, h_step,
+                                    (solver_error, success, iterations))
                     self.system.current_y = y_new
                     if _gc_iv > 0 and _step_count % _gc_iv == 0:
                         gc.collect()

{solve_nivp-0.1.3.dev0 → solve_nivp-0.2.0.dev1}/solve_nivp/__init__.py

@@ -62,7 +62,8 @@ from .projections import (
   CompositeContactProjection,
 )
 from .nonlinear_solvers import ImplicitEquationSolver, UMFPACK_AVAILABLE, PETSC_AVAILABLE
-from .integrations import BackwardEuler, Trapezoidal, ThetaMethod, CompositeMethod, EmbeddedBETR, SDIRK2  # , BDFMethod
+from .integrations import BackwardEuler, BackwardEulerSchur, RadauIIASchur, Trapezoidal, ThetaMethod, CompositeMethod, EmbeddedBETR, SDIRK2, RadauIIA  # , BDFMethod
+from .block_system import SchurComplementSolver, BlockStructuredSystem
 from .ODESystem import ODESystem
 from .ODESolver import ODESolver
 from .contact import build_impulse_contact, ContactSystem
@@ -73,6 +74,24 @@ from .alart_curnier_contact import (
 from .ncp_contact import (
   build_ncp_contact,
   build_dynamic_ncp_contact,
+  build_ncp_contact_blocked,
+)
+from .desaxce_contact import (
+  build_dynamic_desaxce_contact,
+  build_dynamic_desaxce_projected_contact,
+  build_dynamic_desaxce_residual_contact,
+)
+from .rattle_contact import (
+  build_dynamic_rattle_contact,
+  solve_dynamic_rattle_contact,
+  build_rattle_system,
+  RattleMechanicalSystem,
+  RattleContactSpec,
+  RattleBilateralSpec,
+  RattleAlgebraicSpec,
+  RattleContactSystem,
+  RattleSolveResult,
+  RattleSolver,
 )
 
 # Curated public API
@@ -83,7 +102,7 @@ __all__ = [
   # Nonlinear solver
   'ImplicitEquationSolver',
   # Integrators
-  'BackwardEuler', 'Trapezoidal', 'ThetaMethod', 'CompositeMethod', 'EmbeddedBETR', 'SDIRK2',
+  'BackwardEuler', 'BackwardEulerSchur', 'RadauIIASchur', 'Trapezoidal', 'ThetaMethod', 'CompositeMethod', 'EmbeddedBETR', 'SDIRK2', 'RadauIIA',
   # Projections
   'Projection',
   'CoulombProjection', 'SignProjection', 'IdentityProjection',
@@ -93,7 +112,22 @@ __all__ = [
   # Contact helpers
   'build_impulse_contact', 'build_alart_curnier_contact',
   'build_dynamic_alart_curnier_contact', 'build_ncp_contact',
-  'build_dynamic_ncp_contact', 'ContactSystem',
+  'build_dynamic_ncp_contact', 'build_ncp_contact_blocked',
+  'SchurComplementSolver', 'BlockStructuredSystem',
+  'build_dynamic_desaxce_contact',
+  'build_dynamic_desaxce_projected_contact',
+  'build_dynamic_desaxce_residual_contact',
+  'build_dynamic_rattle_contact',
+  'solve_dynamic_rattle_contact',
+  'build_rattle_system',
+  'ContactSystem',
+  'RattleMechanicalSystem',
+  'RattleContactSpec',
+  'RattleBilateralSpec',
+  'RattleAlgebraicSpec',
+  'RattleContactSystem',
+  'RattleSolveResult',
+  'RattleSolver',
 ]
 
 
@@ -126,6 +160,7 @@ def solve_nivp(
   abort_on_fixed_failure=True,
   jacobian_scaling=None,
   active_set_filter=False,
+  t_eval=None,
 ):
   """Integrate an ODE / simple index–1 DAE with optional nonsmooth projection.
 
@@ -140,7 +175,9 @@ def solve_nivp(
     Initial state.
   method : str, default 'composite'
     Time stepping scheme: ``'backward_euler'``, ``'trapezoidal'``, ``'theta'``,
-    ``'composite'`` (TR-BE like second order), ``'embedded_betr'``, ``'sdirk2'``.
+    ``'composite'`` (TR-BE like second order), ``'embedded_betr'``, ``'sdirk2'``,
+    ``'radau_iia'`` (L-stable, stiffly accurate, order 3 or 5; stages controlled
+    via ``integrator_opts={'stages': 2}`` or ``{'stages': 3}``).
   projection : str or Projection or None, default 'identity'
     Name of projection to build: ``'coulomb'``, ``'sign'``, ``'identity'`` or
     ``None``. At the high-level API, ``None`` is promoted to the identity
@@ -348,6 +385,8 @@ def solve_nivp(
     integrator = EmbeddedBETR(solver=solver_instance, A=A)
   elif m == 'sdirk2':
     integrator = SDIRK2(solver=solver_instance, A=A, **_integrator_opts)
+  elif m in ('radau_iia', 'radau'):
+    integrator = RadauIIA(solver=solver_instance, A=A, **_integrator_opts)
   # elif m == 'bdf':
   #     integrator = BDFMethod(solver=solver_instance, atol=atol, rtol=rtol)
   else:
@@ -466,6 +505,7 @@ def solve_nivp(
     store_fk=store_fk,
     gc_interval=gc_interval,
     abort_on_fixed_failure=abort_on_fixed_failure,
+    t_eval=t_eval,
   )
   return solver_obj.solve(return_attempts=return_attempts)
 

{solve_nivp-0.1.3.dev0 → solve_nivp-0.2.0.dev1}/solve_nivp/adaptive_integrator.py

@@ -416,6 +416,10 @@ class AdaptiveStepping:
     # ------------------------------------------------------------------
 
     def _infer_method_order(self, integrator) -> int:
+        p_emb = getattr(integrator, 'embedded_order', None)
+        if isinstance(p_emb, (int, float)) and p_emb > 0:
+            return int(p_emb)
+
         p = getattr(integrator, 'order', None)
         if isinstance(p, (int, float)) and p > 0:
             return int(p)