Expert layer by module

Every public object re-exported by conatus.expert, grouped by the module that defines it and documented from its docstring.

conatus.verify

Verification tools: MMS, convergence studies, reports — never a CORRECT flag.

Check(name, value, threshold, what)
VerificationReport(checks)
verify(pevp, mode[, critical, rel_h])	Residuals, rank, reconstruction, spectral tail, sensitivity Taylor test, critical point.

conatus.ir

Mathematical IR: coordinates, bases, domains, fields, expressions, problems.

CartesianCoordinates(*names)	Cartesian coordinates in 1, 2 or 3 dimensions (identity metric).
PolarCoordinates(azimuth, radius)	(phi, r) on the disk or annulus.
CylindricalCoordinates(azimuth, radius, axial)	(phi, r, z) for pipes and periodic cylinders.
S2Coordinates(azimuth, colatitude)	(phi, theta) on the sphere of radius R.
SphericalCoordinates(azimuth, colatitude, radius)	(phi, theta, r) for the ball and the spherical shell.
RealFourier(coord, size, bounds[, dealias, grid])	Real Fourier series (cos/sin pairs) for real-valued data.
ComplexFourier(coord, size, bounds[, ...])	Complex Fourier series exp(i k x).
Jacobi(coord, size, bounds, a, b[, dealias, ...])	Jacobi polynomials P_n^(a,b) on a bounded interval (mapped from [-1, 1]).
Chebyshev(coord, size, bounds[, dealias, grid])	Chebyshev T_n = Jacobi(-1/2, -1/2) up to normalisation.
ChebyshevT
ChebyshevU(coord, size, bounds[, dealias])	Chebyshev polynomials of the second kind U_n = C_n^(1) (Dedalus ChebyshevU).
ChebyshevV(coord, size, bounds[, dealias])	Gegenbauer C_n^(2), under Dedalus's name ChebyshevV (= Ultraspherical(alpha=2)).
Legendre(coord, size, bounds[, dealias])	Legendre P_n = Jacobi(0, 0).
Ultraspherical(coord, size, bounds, lam[, ...])	Ultraspherical (Gegenbauer) C_n^(lambda) = Jacobi(lambda-1/2, lambda-1/2) up to norm.
DiskBasis(coord, size[, radius, dealias])	Radial basis of the full disk r in [0, R], regular at the axis (Vasil et al., JCP 2016).
AnnulusBasis(coord, size, radii[, dealias])	Radial basis of the annulus r in [ri, ro] (0 < ri): Chebyshev T_n(t), r = c + h t.
SphereBasis(coord, size[, radius, dealias])	Colatitude part of the spin-weighted spherical harmonics (Vasil et al. 2019), attached to theta of S2Coordinates or SphericalCoordinates, next to a Fourier basis in phi.
ShellBasis(coord, size, radii[, dealias])	Spherical shell ri <= r <= ro (0 < ri): Chebyshev T_n(t), r = c + h t, for every spin component; equations in a declared r-multiplied form (each row times the smallest power of r that makes its coefficients polynomial, as Dedalus's r^-k Jacobi(k-1/2, k-1/2) derivative bases).
BallBasis(coord, size[, radius, dealias])	Full ball 0 <= r <= R, regular at the centre (Vasil et al. 2019, Lecoanet et al. 2019): the regularity component sigma of degree l is rho^k Q_n^(a, k + 1/2)(2 rho^2 - 1), k = l + sigma, n < size - floor(l/2) (Dedalus's BallBasis truncation), a = derivative level (0 for fields).
Hermite(coord, size[, center, scale, dealias])	Hermite functions on the whole line: f(x) = sum_n c_n psi_n((x - center)/scale), with psi_n(y) = H_n(y) exp(-y^2/2) / sqrt(2^n n! sqrt(pi)) (orthonormal).
Laguerre(coord, size[, start, scale, dealias])	Laguerre functions on the half line x >= start: f(x) = sum_n c_n L_n(y) exp(-y/2), y = (x - start)/scale (orthonormal).
CompoundChebyshev(coord, sizes, breakpoints)	Chebyshev T series on consecutive subintervals [x_0, x_1], [x_1, x_2], ..., each with its own size (sizes); coefficients stored piece after piece.
Domain(coordsys, bases)	Tensor-product domain: one coordinate system, bases for a subset of its coords.
Field(name, domain[, tensorsig, dtype, symmetry])	A named unknown / coefficient field on a domain.
VectorField(name, domain[, dtype, symmetry])	Vector field: a Field with one index in the domain's coordinate system.
TensorField(name, domain, rank[, dtype, ...])	Tensor field of the given rank on the domain's coordinate system.
Parameter(name[, value, dtype])	Named scalar parameter (Re, Ra, eigenvalue...).
dot(a, b)	Contraction of the last index of a with the first index of b (rank >= 1).
cross(a, b)	a x b for two vectors of the same 3D coordinate system.
outer(a, b)	Outer (tensor) product; a plain product when one factor is a scalar.
conj(x)	Complex conjugate (the identity on real expressions).
comp(x, index)	Component index of a tensor along its first index.
diff(x, coord)	Partial derivative of x along coord (zero if x does not depend on it).
grad(x[, coordsys])	Gradient of x (adds a first index) in coordsys, by default that of x's domain.
div(x)	Divergence: contracts the derivative with the first index of x (rank >= 1).
lap(x[, coordsys])	Laplacian of x in coordsys, by default that of x's domain.
curl(x[, coordsys])	Curl: of a vector in 3D (a vector), of a vector in 2D (a scalar), of a scalar in 2D (a vector).
dt(x)	Time derivative (IVP left-hand side, or sigma in a linearized EVP).
integ(x[, coords])	Integral of x over coords (all coordinates of its domain by default).
interp(x, coord, position[, side])	Value of x at coord = position (a number, 'left' or 'right'): traces and BCs.
lift(x, basis, n[, lam, piece])	Tau term: x times the polynomial of index N+n of basis (lam=0) or of the ultraspherical C^(lam) basis of the same size and interval (lam >= 1, Chebyshev only): lifting an order-q equation in C^(q) puts its taus in the last q rows of the ultraspherical equation, the classic Olver–Townsend tau (no spurious eigenvalues for dt lap^2-type operators, which T-lifts produce).
unit_vector(coord)	Constant unit vector e_coord of a Cartesian (or the z of a cylindrical) system.
exp(x)	Pointwise exponential (non-polynomial: evaluated on the grid, aliasing reported).
log(x)	Pointwise natural logarithm (non-polynomial: evaluated on the grid, aliasing reported).
sin(x)	Pointwise sine (non-polynomial: evaluated on the grid, aliasing reported).
cos(x)	Pointwise cosine (non-polynomial: evaluated on the grid, aliasing reported).
tanh(x)	Pointwise hyperbolic tangent (non-polynomial: evaluated on the grid, aliasing reported).
sqrt(x)	Pointwise square root (non-polynomial: evaluated on the grid, aliasing reported).
absolute(x)	Pointwise absolute value (non-polynomial: evaluated on the grid, aliasing reported).
sign(x)	Pointwise sign (non-polynomial: evaluated on the grid, aliasing reported).
Problem(variables, *[, name, symmetry, ...])	Common machinery: variables, equations, LHS/RHS checks, counting, explain().
IVP(variables, *[, name, symmetry, namespace])	Initial value problem: M dt(X) + L X = F(X, t).
LBVP(variables, *[, name, symmetry, namespace])	Linear boundary value problem: L X = F, F independent of X.
EVP(variables, eigenvalue, *[, name, ...])	Generalized eigenvalue problem L X = -sigma M X written with sigma in the LHS; RHS = 0.
NLBVP(variables, *[, name, symmetry, namespace])	Nonlinear boundary value problem F(X) = 0, F = LHS - RHS; any term may be nonlinear.
NonlinearLHSError([message, where, why, ...])	The LHS contains a term that is not linear in the problem variables.
ProblemError
RankReport(variable_components, ...[, ...])	IR-level count of a problem: unknown and equation components, gauges and one DirectionReport per non-periodic coordinate; status and explain().
EVEN	+1 (even / symmetric) or -1 (odd / antisymmetric).
ODD	+1 (even / symmetric) or -1 (odd / antisymmetric).
Reflection(coord[, about])	Reflection x_c -> 2*about - x_c.
SymmetrySubspace(*generators, **parities)	Invariant subspace of a group generated by reflections, with field parities.
SymmetryError([message, where, why, fix, doc])	Inconsistent symmetry declaration.
SymmetryBreakingError([message, where, why, ...])	A term does not have the parity required by the declared subspace.
ShiftReflect(coord, shift)	Shift-and-reflect of a periodic pipe or cylinder: phi -> -phi composed with the half-period shift z -> z + Lz/2 of the axis,
AzimuthalMFold(coord[, m0])	Rotation phi -> phi + 2 pi / m0 about the axis (disk, annulus, cylinder, sphere, shell, ball).
EquatorialParity(coordsys)	Equatorial reflection z -> -z (theta -> pi - theta) of S2 or spherical coordinates: the parity (-1)^(l+m) of Y_l^m (spin components: u_+ <-> -u_-).
MappedChebyshev(coord, size, map[, dealias, ...])	Chebyshev T_n(xi) with a declared map y = m(xi) onto an (semi-)infinite interval.
RationalMap(L[, origin, contour])	Half line y in [origin, inf): y = origin + L (1 + xi)/(1 - xi) (rational Chebyshev TL).
TanhMap(L[, origin, contour])	Infinite line y in (-inf, inf): y = origin + L artanh(xi).
TanMap(L[, origin, contour])	Infinite line y in (-inf, inf): y = origin + L tan(pi xi / 2).

parse_equation(text[, namespace])	Parse "lhs = rhs" into an Equation (no eval).
parse_expr(text[, namespace])	Parse one expression (no '=') into an IR expression (a number stays a Constant).

conatus.flows

Usual base flows and their domains, stated explicitly (no hidden defaults).

ChannelBaseFlow(y, basis, domain, U, ncc, ...)	Wall-normal coordinate y, its Chebyshev basis and domain, base flow U and NCC data.
channel(N, base, *[, interval, dealias])	Plane channel in y with base flow base ('poiseuille', 'couette', or None).

conatus.units

Units and nondimensionalizations.

UnitSystem(name, family[, scales, reynolds])	A nondimensionalization: named reference scales within a family, and its Reynolds group.
convert(value, kind, frm, to)	Express value (a kind quantity written in system frm) in system to.
Energy(value, convention)	An energy value tagged with its convention; conversion only by an explicit call.
ChannelUnits(Re, based_on)	A channel Reynolds number with its convention stated (based_on is mandatory).

conatus.discretize

Spectral discretization: Olver–Townsend operators, generalized tau, per-group plans.

DiscretizationError([message, where, why, ...])	The expression cannot be discretized as requested (explicit reason given).
LBVPSolution(coeffs, residuals, plan, reduced)	Solution of an LBVP (plan.solve()): coefficients by variable and the relative residual of every group solve (always reported).
Plan(problem[, ncc, params, ncc_cutoff, ...])	Discretized problem: layout, groups, matrices on demand, rank checks, LBVP solve.
RankError([message, where, why, fix, doc])	The discrete system is under-/over-determined or singular (refused before factorization).
discretize(problem[, ncc, params, ...])	Build the discretization plan of a problem (matrices are assembled lazily per group).

conatus.reference

NumPy reference backend: the oracle of every fast path (C++/CUDA banded solves, NumPy/CuPy transforms and fused kernels).

FieldData(field, data[, layout])	Numerical values of a Field, with an explicit layout (never an implicit state).
grid(b[, dealias])	1D grid points of b (dealiased grid by default).

conatus.solvers

Solvers on discretization plans: generalized EVP, Newton for NLBVP; LBVP lives on Plan.solve.

EVPResult(values, vectors, residuals, method)	Eigenvalues sigma of (L + sigma M) x = 0 for one group, with residuals and a filter log.
solve_dense(L, M, *[, left, label])	All eigenvalues by the QZ algorithm (scipy.linalg.eig), infinite ones counted and removed.
solve_sparse(L, M, target[, n_modes, label, tol])	n_modes eigenvalues nearest target by shift-invert Arnoldi on (L + target M)^{-1} M (k= is the deprecated former name of n_modes: k is a wavenumber everywhere else).
eigenvalues(plan[, group, reduced, method, ...])	Eigenvalues sigma of (L + sigma M) x = 0 in one group of plan.
ParametricEVP(problem, params, *[, ncc, ...])	Pencil L(p) + sigma M(p) of one group, assembled once for all values of params.
CriticalPoint(parameter, value, over, mode, ...)	Neutral value of parameter (growth = 0), minimized over over if given.
critical(pevp, parameter, *, bracket[, ...])	Neutral parameter (growth(sigma) = 0 for the least stable selected mode).
NewtonSolver(problem, *[, tol, damping, ...])	Newton for an NLBVP.
NLBVPSolution(coeffs, iterations, converged, ...)
NewtonNotConverged([message, where, why, ...])	Newton did not reach the declared tolerance within the declared number of iterations.
PeriodicNewtonSolver(problem, *[, tol, ...])	Newton with a dense coupled Jacobian for an NLBVP on an all-Fourier domain.

conatus.linearize

Linearization of a problem around a base state, and inner products.

linearize(problem, around, eigenvalue, *[, ...])	Perturbation EVP of problem around the base state around (variable -> field).
InnerProduct(plan[, weights])	Weighted L² inner product on the field unknowns of a plan group.

conatus.timestep

Time integration of IVPs: pseudospectral F, stacked groups, IMEX schemes.

CFL(solver, velocity, safety)	dt_cfl = safety / max_x sum_i |u_i(x)| / dx_i(x) on the collocation grid.
EmbeddedError(solver[, adapt, tol, safety, ...])	Temporal error of one step, from a lower-order companion on the same data.
TauWatch(solver, growth_limit)	Max |coefficient| of each tau variable, recorded at every call.
IVPSolver(plan, scheme, dt, *[, reduced, ...])	Constant-step IMEX solver of a discretized IVP (see module docstring).
SCHEMES	Built-in immutable sequence.
SpectralError([message, where, why, fix, doc])	The expression cannot be evaluated by the pseudospectral RHS evaluator.

conatus.adjoint

Discrete tangent and adjoint of the IMEX time steppers (see).

FlowMap(solver, steps, *[, checkpoints, ...])	Φ(X_0) = X_N for an IVPSolver (CPU or GPU), with exact discrete jvp and vjp (see the module docstring for the explicit choices f_transpose, solves, checkpoints).
VJPSuspended(message, *, journal, position)	The reverse sweep reached its time budget and was written to its journal (not an error of the computation: re-run the same call to resume).
revolve_cost(steps, checkpoints)	Forward steps recomputed by the reverse sweep of FlowMap.vjp (excluding the stage recomputation inside each step's adjoint), its ratio to steps, the peak number of stored checkpoints and the number of checkpoint stores.

conatus.ecs

Exact coherent structures: Newton–Krylov–hookstep, equilibria, travelling waves, relative / pre-periodic orbits and their stability. Notes:

FourierOps(solver)	Translation, generator and reflection on the state of a 1D RealFourier IVP.
NewtonKrylovHookstep(*[, tol, ...])	Newton–Krylov with hookstep.
Equilibrium(kind, X, params, residual, ...)	v(u) = 0.
equilibrium_eigenvalues(solver, sol, n_modes, *)	n_modes leading eigenvalues (largest real part) of the Jacobian of v (+ c ∂x for a TW), full space without the mean: dense QZ if the active size ≤ dense_max (declared default DENSE_MAX), ARPACK otherwise at the accuracy arnoldi_tol (required: the budget is declared, the tolerance required; k= is the former name of n_modes, k being a wavenumber everywhere else).
find_equilibrium(solver, x0, newton, *[, ...])	v(u) = 0.
find_travelling_wave(solver, x0, c0, newton, *)	u(x, t) = U(x − c t): v(U) + c ∂x U = 0, unknowns (U, c), phase ⟨∂x U*, δU⟩ = 0.
find_relative_periodic_orbit(solver, x0, T0, ...)	S τ_ℓ Φ_T(u) = u with unknowns (u, T, ℓ) and phase conditions ⟨v(u*), δu⟩ = 0 (time), ⟨∂x u*, δu⟩ = 0 (translation).
floquet_multipliers(solver, sol, n_modes, *)	n_modes leading Floquet multipliers of S τ_ℓ J_T (monodromy of the discrete map, full space without the mean): dense if the active size ≤ dense_max (declared default), ARPACK otherwise with its required accuracy arnoldi_tol (k=: former name of n_modes).
symmetry_breaking_check(solver, sol, *[, ...])	Stability of a reflection-symmetric equilibrium (R u = u) in each isotypic component of the reflection R: the Jacobian commutes with R, so its spectrum splits into the symmetric block (R v = v, what a subspace computation sees) and the antisymmetric block (R v = −v, invisible there).
EdgeTracker(advance, classify, measure, ...)	advance(X, T) -> X integrates T time units (T a multiple of the time step, declared by the caller); classify; measure(X) -> dict (recorded along the edge); norm(X) the distance used for the separation test; ref: laminar state.
ThresholdBisection(fate, *, rtol[, scale, ...])	Bisection on one amplitude (e.g. the seed energy E0 of a minimal seed) between a value that relaminarizes and one that transitions: the transition threshold as a bracket ]lo, hi], never as a single guessed number.

conatus.continuation

Pseudo-arclength continuation: generic core and NLBVP adapter.

ContinuationSettings(*, ds, ds_min, ds_max, ...)	Steps, tolerance and budgets of a pseudo-arclength run; explain() prints them.
NLBVPContinuation(solver[, parameter, ...])	Pseudo-arclength continuation of solver.problem in the parameter parameter (param: its deprecated former name, v0.1).
KSDomainContinuation(*, N, dealias, dp_fd, ...)	Equilibria of KS continued in L within R u = u; every numerical choice is an argument.

conatus.floquet

Floquet–Hill toolkit (decision D9).

HillBlocks(*, diag, couplings, Nh, size, label)	Block-banded Hill matrix M(μ) with half-width M = max |m| of the couplings.
hill_from_plan(build, base, *, Nh, omega, label)	Hill operator of an IR eigenvalue problem whose base flow is T-periodic.
secant_root(hill, start, *, tol[, ...])	Secant on det M(μ)/|det M(start)| (log-scaled, no overflow) from an explicit start.
exponents_dense(hill, *, finite_cap)	All Floquet exponents of a μ-linear Hill operator (M(μ) = A + μ B), small sizes only.
HillGPU(hill, *[, patch, affine_check_tol])	Device mirror of a μ-affine HillBlocks (optionally with μ-dependent patched rows).
CertifiedRoot(mu, residual, iterations, params)	A Floquet exponent with the evidence that it is one.
SecantRoot(mu, converged, residual, ...[, ...])	Result of conatus.floquet.hill_general.secant_root().
shell_floquet(solver, period, steps, *, m[, ...])	Floquet exponents of azimuthal wavenumber m of a linear period-period shell IVP (module doc): the n_modes multipliers of largest modulus of the discrete one-period map (steps steps of solver from t0; dt = period / steps required).

conatus.growth

floquet_exponents(build, base_harmonics, kx, ...)	Floquet exponents of the wave (kx, kz) with the same build and base_harmonics as optimal_gain().
optimal_gain(build, base_harmonics, kx, kz, ...)	Optimal energy gain G(t0, T) of one wave (kx, kz) about a time-periodic base flow.
periodic_operator(build, base_harmonics, kx, ...)	PeriodicOperator of build({"kx": kx, "kz": kz}), a linear IR problem of one wave (IVP with dt(), or EVP in the convention (L + σM) x = 0), or a (problem, ncc) pair whose ncc holds the other (time-independent) coefficient data.
energy_factor(op[, theta_weight])	F with ‖F x‖² = ½ Σ_comp w_comp ∫|comp|² dy (Fejér quadrature on the Chebyshev grid).
gain(Phi, F, Z)	G = max ‖F Φ x‖² / ‖F x‖² over x in range(Z) (SVD), and the optimal structures.
propagator(op, t0, T, steps, scheme[, backend])	Φ mapping state coefficients at t0 to state coefficients at t0 + T (returned on host).

conatus.nonmodal

Non-modal stability: transient growth and the continuous adjoint.

Y	Symbol class is used to create symbolic variables.
compare_adjoints(system, adjoint_bcs, N, ...)	Discrete and continuous adjoint of the eigenmode of system nearest target.
max_growth(ss, t_bounds, *, xtol[, n_scan])	(G_max, t_max) over t in t_bounds: scan of n_scan points (declared default MAX_GROWTH_N_SCAN = 64), then bounded Brent to xtol (required) around the best scan point.
numerical_abscissa(ss)	ω(Ã) = max eig((Ã + Ãᴴ)/2) = d/dt ‖e^{tÃ}‖ at t = 0⁺, of this matrix.
parallel_shear_flow(U, *, kx, kz, Re, walls)	Linearized Navier–Stokes around U(y) e_x, mode e^{i(kx x + kz z)}, primitive variables.
state_space(desc, *, infinite_tol)	Reduce M x' + L x = 0 to q̃' = Ã q̃ in energy-orthonormal coordinates (see module doc).

conatus.presets

Study presets built on the generic unit systems of :mod:conatus.units.

CHANNEL_SYSTEMS
laminar_poiseuille(*, Re_c)	Exact Reynolds numbers of laminar Poiseuille flow at centreline Reynolds Re_c.

conatus.methods

plan.methods(): a “Methods” paragraph generated from the plan.

methods(plan[, solver, eigen_solver, commit])

Build the Methods paragraph.

conatus.errors

Public exception hierarchy of Conatus (v0.1).

ConatusError([message, where, why, fix, doc])	Base class.
EquationError([message, where, why, fix, doc])	An equation (or the whole problem) is inconsistent with the problem type or variables.
UndeclaredVariableError([message, where, ...])	A field is used as an unknown (or needs data) but is neither a variable nor given data.
ParameterError([message, where, why, fix, doc])	A parameter has no value, or a parameter name is unknown.
BoundaryConditionError([message, where, ...])	Boundary conditions are missing, in excess, or placed where none is possible.
EquationSyntaxError([message, text, position])	A string equation does not follow the declared grammar (conatus.ir.parse.GRAMMAR) or names something that is not in its declared namespace.
ResolutionError([message, where, why, fix, doc])	The resolution is too small for what is asked (boundary conditions, derivatives...).
CoordinateError([message, where, why, fix, doc])	Inconsistent coordinates, bases or domain.
OptionError([message, where, why, fix, doc])	An option has an invalid value (scheme, backend, method...); close names are suggested.
InputTypeError([message, where, why, fix, doc])	An argument has the wrong type (a Parameter, a Field, a number was expected...).
DtypeError([message, where, why, fix, doc])	Real/complex (dtype) mismatch; conversions are never implicit.
TensorError([message, where, why, fix, doc])	Tensor signatures do not match (scalar vs vector, different coordinate systems).
ConvergenceError([message, where, why, fix, doc])	An iteration did not reach its declared tolerance within its declared budget.
NumericalError([message, where, why, fix, doc])	A computed state is not finite (NaN or inf): a time integration blew up.
UnderResolvedWarning	A running simulation is under-resolved: the relative spectral tail of an unknown along a direction exceeds the declared RUN_TAIL_TOL (measured at the finite-state check; warned once per run and recorded by explain()).
IllPosedWarning	An implicit term makes the initial-value problem ill-posed: its leading-order growth rate increases without bound with the wavenumber (backward diffusion, a negative viscosity), detected when the model is compiled and named with the term.
InitialDataWarning	Callable initial data are not fully resolved: their relative spectral tail beyond the resolution (sampled on twice the grid) lies between INITIAL_TAIL_TOL and the refusal level INITIAL_TAIL_REFUSE (a coarse N of a resolution study); warned once per initial(...) call and recorded by explain().
BackendError([message, where, why, fix, doc])	The requested backend (GPU, compiled core) is not available here.
MissingDependencyError([message, where, ...])	An optional package or the compiled core is missing.
MissingFileError([message, where, why, fix, doc])	A file to read (an output, a checkpoint) does not exist, or is a directory.
UnsupportedError([message, where, why, fix, doc])	Declared in the IR but not implemented (yet) for this case.
AmbiguousNameError([message, where, why, ...])	A name means two different things (two modules export it); use one of the explicit names.
ResolutionWarning	A returned result is under-resolved by a declared measure: the mode an eigenvalue result selects has its energy in the last coefficients, a Floquet-Hill mode in its outermost harmonics.
CorrectnessWarning	The returned answer may not be the one the call meant: it is about another base state, another group of modes, or a choice the call did not declare.
BaseStateWarning	A linearization about a base state that is not a steady solution: its steady residual exceeds BASE_RESIDUAL_TOL and base_residual='accept' was not given, so the modes are not the normal modes of a flow that exists (accepted in v0.1, refused in v0.2).
GroupWarning	An eigenvalue call without a group (no k= on a periodic model, no m=/kz=/ ell= on a curvilinear one) solved one group only (k = 0, or the first group): the modes of every other wavenumber are absent from the result (required in v0.2).
DefaultChoiceWarning	A choice that decides the answer was left out and the v0.1 default or guess was used: the growth rule of an eigenvalue guessed from its name (m.eigenvalue("c") ranks by Im c), the top condition of this case (no-slip).
ExperimentalWarning	A feature of the experimental list was used (once per feature and process): it is shipped and tested, but not promised: its API and defaults may change in a minor release without a deprecation cycle, and some of its claims rest on fewer measurements.

conatus.gpu

Is there a usable GPU here? gpu_available() and gpu_report().

gpu_available()	True when backend='cuda' can run here: CuPy sees a device and the compiled core has CUDA with a device.
gpu_report()	One line per requirement of backend='cuda', each marked ok/missing with its reason.

conatus.bifurcation

Native bifurcation core on the Conatus IR.

ir_system(problem, parameters, *[, values, ...])	DynamicalSystem of an IR IVP with free parameters parameters.
ode_problem(variables, parameters, rhs[, name])	IR IVP of an ODE system dx_i/dt = f_i(x; p) (a "0-D" problem).
continue_equilibria(system, x0, parameter, ...)	Pseudo-arclength branch of equilibria in parameter from a converged x0.
normal_form(system, x0, *, kind[, par, ...])	Normal form at the equilibrium x0 (a located event: fold, branch point or Hopf).
CollocationMesh(ntst, ncol, tmesh)	Mesh in τ = t/T ∈ [0, 1]: ntst intervals, ncol Gauss collocation points each.
PeriodicOrbitProblem(system, parameter, mesh, *)	Collocation equations of periodic orbits of system in the free parameter parameter.
continue_orbits(problem, z0, settings, *[, ...])	Pseudo-arclength branch of periodic orbits from z0 = (nodes, T, p).
branch_switch(curve, event, settings, *[, ...])	Continue the branch emanating from event of curve.
continue_codim2(system, x0, kind, ...[, ...])	Continue a fold (kind="fold") or Hopf (kind="hopf") point in two parameters.
amplitude_equation(system, x0, parameter, *, ...)	Landau equation for the observable amplitude A = observable(x − x0) (linear functional).
ginzburg_landau(system_at, k_c, parameter, ...)	Ginzburg–Landau coefficients of the instability at wavenumber k_c.
cos_mode_observable(system, name)	Linear functional: coefficient of cos(2π x / L_x) of field name along the first (Fourier) axis, from its grid values (mean over the other axes' first grid index).

conatus.slices

Symmetry reduction by slices: first Fourier mode slice of a translation symmetry, with phase reconstruction and slice-border detection. Notes: §3.

FirstFourierModeSlice(ops, *, border_tol[, ...])	Slice of the translation group through a first-Fourier-mode template (see module doc).
find_rpo_in_slice(slc, integrator, section, ...)	Periodic orbit of the reduced flow through the Poincaré section (hyperplane or any g): unknowns (x̂, T), equations reduce(Φ_T(x̂)) − x̂ = 0, slice condition ⟨x̂, t'⟩ = 0 and g(x̂) = 0, solved by Gauss–Newton (least squares: the reduced residual has one component that duplicates the slice condition) with a forward-difference Jacobian of declared step fd_step; converged when the relative residual is ≤ tol.
slice_equilibrium_check(slc, solver, sol)	Equilibrium or travelling wave in the slice: border distance, in-slice speed and phase velocity ℓ̇ (−c expected for a TW, 0 for an equilibrium).

conatus.manifolds

Phase-space geometry: trajectories with declared dense output, Poincaré sections and first-return maps, unstable manifolds of equilibria (parametrization method), connections between equilibria (shooting with projection boundary conditions), unstable manifolds of periodic orbits (linear Floquet seeding) and localized-state snaking. Notes:

PoincareSection(g, *, direction, name[, coords])	g(x) = 0 crossed in direction (+1, −1 or 0), with an optional in-section chart coords(x) (default: the raw state).
first_return_map(crossings, section)	Pairs (P_k, P_{k+1}) of successive in-section coordinates and return times τ_k.
globalize(integrator, points, until)	Integrate every initial point (e.g. fundamental_domain) for until: the manifold as a family of trajectories (not arclength-adaptive; the sampling is the caller's, declared).
unstable_manifold(system, x0, *, order, ...)	Parametrization of the unstable manifold of the equilibrium x0 of system (DynamicalSystem), to the declared order.
find_connection(setup, T, *[, bracket, q0, ...])	Solve the projection conditions for the unknowns q (see module doc).
scan_connection(setup, grid, T, *[, values])	Brackets [q_i, q_{i+1}] of a scalar unknown where the (single) projection condition changes sign on the declared grid, both ends having reached the end sphere (if one is declared: a sign change between an orbit that reached it and one that did not is not a root).
ecs_system(solver, *, odd, degree, dense_max)	DynamicalSystem of the solver's vector field in active coordinates (see module doc).

conatus.sensitivity

Sensitivity of global modes: structural sensitivity, base flow, steady forcing, parameters.

base_flow_sensitivity(factory, base, *, N, ...)	Gradient of the eigenvalue nearest target of factory(base) w.r.t.
ginzburg_landau_exact(*, nu, gamma, mu_c, mu2, n)	Closed-form eigenpair n of ∂t q = −ν q' + γ q'' + (μ_c + μ₂ x²/2) q on the whole line.
linear_ginzburg_landau(*, nu, gamma, mu, bounds)	∂t q = −ν ∂x q + γ ∂x² q + μ(x) q on bounds with q = 0 at both ends (declared).
structural_sensitivity(pair)	Structural sensitivity and wavemaker of the mode in pair.

conatus.datadriven

Data-driven decompositions: POD, DMD, SPOD, EDMD/Koopman.

DMD(eigenvalues, omega, modes, amplitudes, ...)
DataInnerProduct(kind, n[, w, F, note])	⟨a, b⟩ = aᴴ W b on flattened snapshots of length n (see module doc).
SPOD(frequencies, eigenvalues, modes, ...)
dmd(X, *, dt, rank, inner_product[, ...])	DMD of the sequence X = [x_0 … x_m] (pairs x_j → x_{j+1}), or of pairs (X, Y).
edmd(X, Y, *, dictionary, rcond, dt)	EDMD of the pairs (X[j], Y[j]) (arrays m × d) on the declared dictionary.
monomials(d, degree)	All monomials x^α, |α| ≤ degree, in d variables (constant first, then by degree).
pod(X, *, inner_product, rank, method, mean)	POD of the snapshot matrix X (n × m); every choice is declared (see module doc).
rbf(centers, epsilon)	[1, x_1 … x_d, exp(−ε² ‖x − c_k‖²) for each center] (declared centers and shape ε).
spod(Q, *, dt, nfft, noverlap, window, mean, ...)	SPOD of the time series Q (n × nt); every estimation choice is declared.

conatus.chaos

Chaos: Lyapunov spectrum on the exact tangent of the step, covariant Lyapunov vectors, Kaplan–Yorke dimension, finite-time exponents, Poincaré sections and first-return maps. Notes:

kaplan_yorke(exponents)	D_KY = j + (λ_1 + … + λ_j) / |λ_{j+1}|, j the largest index with a non-negative partial sum (exponents sorted in decreasing order).
lyapunov_spectrum(solver, x0, *, n_vectors, ...)	Lyapunov exponents (and optionally CLVs) of solver's discrete map.
poincare_section(solver, x0, g, *, ...[, ...])	Section points of the trajectories from x0 (n,) or (B, n) over steps steps.

conatus.ensembles

Ensembles on one batch: batches of initial conditions and/or parameter values advanced together, basins of attraction, transition probabilities. Notes:

Ensemble(solver, size, *, rhs)	B members of one discretized problem advanced together (see module docstring).
ensemble_fate(ens, classify, *, check_every, ...)	Run ens until every member is decided or max_steps; see the module docstring.
proportion_ci(k, m[, z])	(p, low, high): proportion k/m with its Wilson score interval (default 95 %).

conatus.contour

Contour methods in the complex plane.

CountResult(count, winding, poles, region, ...)	Number of eigenvalues of T(z) in a region, by the argument principle (count()).
BeynResult(values, vectors, residuals, ...)	Certified eigenvalues of T(z) v = 0 in a region (beyn()).
RegionEVPResult(values, vectors, residuals, ...)	An EVPResult restricted to a region of the eigenvalue plane: values are every eigenvalue of the discrete pencil in region (one entry per distinct eigenvalue, multiplicity gives the algebraic multiplicity) and count their number, multiplicities included, certified by the argument principle (count_method).