pyoomph 0.2.1__tar.gz → 0.2.2__tar.gz

{pyoomph-0.2.1 → pyoomph-0.2.2}/CHANGELOG.md

@@ -1,5 +1,91 @@
 # Changelog
 
+## [0.2.2] - 2026-10-04
+
+79 commits since 0.2.1. Three themes: symbolic code generation that no longer treats an expression
+DAG as a tree, an analytic Hessian that reaches through multi-return callbacks, and MUMPS reachable
+without PETSc. Plus a long tail of remesh, continuation and `--distribute` fixes.
+
+### Added
+
+- **MUMPS without PETSc**, via the separate `pyoomph_mumps` package: the linear solver `--mumps`
+  (serial or natively distributed) and the eigensolver `--mumps_eigen` (Spectra with MUMPS
+  factorising the shifted matrix, real and complex), so azimuthal and Floquet stability no longer
+  need a full PETSc+SLEPc stack.
+- **Analytic Hessians through `CustomMultiReturnExpression`**, which brings the UNIFAC and AIOMFAC
+  activity coefficients, the log-conformation decompositions, `InvertMatrix` and the Cahn-Hilliard
+  potentials within reach of the eigenvalue, bifurcation, Floquet and orbit workflows.
+- **The exact UNIFAC Jacobian is emitted into the generated C** instead of being finite-differenced
+  (`analytic_c_jacobian=False` restores the old body).
+- **Liquid-mixture diffusivity estimation from the activity coefficients**,
+  `MixtureLiquidProperties.set_estimate_diffusivities()`.
+- **Symbolic comparisons and branching**: `var("time") < 2*second` yields a held relational
+  expression, `conditional(cond, iftrue, iffalse)` compiles it to a C ternary, and comparisons
+  combine with `~`, `&`, `|` and `^`.
+- **`is_zero(..., tensors=True)`** recognises a zero vector or matrix, which the plain test never did.
+- **NSCH: a C1 clamp for density and viscosity**, plus an optional temporal error estimator; the old
+  branch-wise clamp made Newton two-cycle once the phase field overshot `|phi|>1`.
+- **`--where` now also picks the state a `--runmode c` resumes from**, taking a `.dump` file, `i=N`,
+  `t=X` or a bool expression over `step` and `time`.
+- **Tracer collections living on an interface are written to state files** (state format 0.1.6);
+  they were previously lost on `--runmode c`.
+
+### Changed / Improved
+
+- **Code generation treats the residual as the DAG it is**, memoising or converting to DAG walks the
+  residual mappers, `MakeResidualSteady`, the subexpression-to-struct mapper, the parameter
+  substitution of the `dResidual/dParameter` loop, the two collectors and the last preorder scans of
+  the emission path -- a UNIFAC mass-transfer residual under `azimuthal_stability=True` previously
+  never finished at all.
+- **The unit split skips `collect_common_factors` above a term count**, which is where an
+  evaporating droplet's never-returning split spent all of its samples.
+- **`write_code` reports where it spends its time**, per residual set, with mapper and memo counters.
+- **GiNaC patches** for `real_part`/`imag_part` of an integer power, `pow(0,0)`, a real and
+  commutative `subexpression()` marker, number lookups in `ex`-keyed caches, and a unit under a
+  symbolic exponent; the patch step re-runs when the patch set changes.
+- **A spline macro element is parametrised by arclength** rather than the raw spline parameter, so
+  refinement puts new nodes at the geometric midpoint of an edge after a remesh.
+- **Units written into a data file no longer contain a space**, which made them unreadable to
+  anything but pyoomph's own reader.
+- **"There is no domain X defined in this mesh" after a remesh now says what it means**: the mesher
+  was handed a geometry it could not fill.
+- The documentation builds against the current Sphinx generation.
+
+### Fixed
+
+- **The arclength continuation tangent is carried correctly across a remesh or an adapt** -- five
+  defects that each left the arclength invariant satisfied while the tangent pointed elsewhere, so
+  nothing reported them.
+- **Two defects in the viscoelastic equations on a moving mesh**, both invisible on the static,
+  dimensionless meshes the tests used.
+- **Axisymmetric pinch-off and coalescence beside a wall survive their own surgery**, and the
+  degenerate branch of the zeta invertibility check is now pinned by tests.
+- **Remeshing on an inverted element asks for a different mesh on each retry**, scaling
+  `default_resolution` so that the gmsh size fields move too.
+- **Under `--distribute`**: a 1-D submesh survives a rank that gets none of it, an unowned interface
+  dof is skipped during interface generation, the nearest-node fallback searches the old mesh
+  globally, and fragment counting agrees across ranks.
+- **State files**: tracer collections are restored when the file brings its own mesh, and a template
+  rebuilt from a stored `.msh` keeps its boundary corner sizes.
+- **A resumed run leaves the output files an uninterrupted one would write**, rather than a time
+  column that runs forwards and then jumps back.
+- **Two reference leaks**: a delayed expansion pinned both itself and its callable, and a mixture
+  stayed uncollectible once it had a multi-return activity model.
+- `get_real_part()`/`get_imag_part()` split an argument that no longer contains a field.
+- `numouts` produces at least one output.
+- Docstring markup that rendered as artifacts on Read the Docs, NSCH's forward references under
+  Sphinx, the clone URL on the two source-install pages, and the macOS stubs.
+
+### Packaging & CI
+
+- **The source distribution ships the sources, not the whole checkout**: 0.2.1 was 9.6 MB, most of it
+  a `docs/` tree that `.gitignore` had already punched holes in.
+- arm64 Macs are pointed at `pyoomph_mumps`, and the deprecated `x86_64` arch is dropped for the
+  current Command Line Tools.
+- `Programming Language :: Python :: 3.14` is declared, which the cp312 Stable-ABI wheel already
+  covers and is smoke-tested on.
+- Test helper scripts in `tests/` are importable, so `pytest *.py` does not collect them as tests.
+
 ## [0.2.1]
 
 Released as urgent patch of 0.2.0. 

{pyoomph-0.2.1 → pyoomph-0.2.2}/CMakeLists.txt

@@ -451,6 +451,7 @@ if(PYOOMPH_GENERATE_STUBS)
     COMMAND "${Python_EXECUTABLE}" "${CMAKE_SOURCE_DIR}/cmake/generate_stubs.py"
             --module-dir "$<TARGET_FILE_DIR:_pyoomph_core>"
             --module-name "_pyoomph_core"
+            --expect-file "$<TARGET_FILE:_pyoomph_core>"
             --stage-dir "${PYOOMPH_STUB_STAGE_DIR}"
             --patch-script "${CMAKE_SOURCE_DIR}/src/nanobind/patch_stubs.py"
             --python "${Python_EXECUTABLE}"

{pyoomph-0.2.1 → pyoomph-0.2.2}/INSTALL.md

@@ -28,14 +28,23 @@ If you encounter segmentation faults during solving, please try to downgrade you
 
 ## On Mac
 
-The fast `MKL Pardiso` solver from `mkl` is not available on `arm64` Macs. Since the default solver on `arm64` Macs (`Accelerate`) is unable to tackle larger problems at reasonable times, you definitely either want to use `MKL Pardiso` with a workaround or use `MUMPS` via `PETSc`.
-To use `MKL Pardiso`, install pyoomph in a `Rosetta 2 terminal`, see [here](https://www.courier.com/blog/tips-and-tricks-to-setup-your-apple-m1-for-development/) how to set it up (**note**: recent systems must be handled differently, see [here](https://developer.apple.com/forums/thread/718666)).
+The fast `MKL Pardiso` solver from `mkl` is not available on `arm64` Macs - Intel does not ship `mkl` for `arm64` at all. Since the default solver on `arm64` Macs (`Accelerate`) is unable to tackle larger problems at reasonable times, you definitely either want to use `MUMPS` or `MKL Pardiso` with a workaround.
+
+The recommended way is `MUMPS`, which runs natively on `arm64`. There are two routes:
+
+* the standalone [pyoomph_mumps](https://github.com/pyoomph/pyoomph_mumps) package, which binds `MUMPS` directly and needs no `PETSc`. It gives you the `mumps` linear solver (`--mumps`) and, via pyoomph's built-in `Spectra` eigensolver, the `mumps` eigensolver (`--mumps_eigen`), in real and complex arithmetic. Install it (a Fortran compiler is required, e.g. by `brew install gcc`) via
+
+  > git clone https://github.com/pyoomph/pyoomph_mumps.git ; cd pyoomph_mumps ; python3 -m pip install .
+
+  See [here](https://pyoomph.readthedocs.io/en/latest/tutorial/installation/mumps.html) for details and build options.
+
+* `PETSc/MUMPS`, i.e. `MUMPS` through `PETSc`, which additionally gives you `PETSc` as linear solver and `SLEPc` as (also distributed) eigensolver, but is considerably more to install. See [here](https://pyoomph.readthedocs.io/en/latest/tutorial/installation/petscslepc.html) for details.
+
+To use `MKL Pardiso` instead, install pyoomph in a `Rosetta 2 terminal`, see [here](https://www.courier.com/blog/tips-and-tricks-to-setup-your-apple-m1-for-development/) how to set it up (**note**: recent systems must be handled differently, see [here](https://developer.apple.com/forums/thread/718666)). Note that Apple's x86_64 support degrades with every system update, so this route gets harder over time (the newer Command Line Tools cannot compile x86_64 any more, see the [documentation](https://pyoomph.readthedocs.io/en/latest/tutorial/installation/source/mac.html)).
 Also, please downgrade `mkl` by
 
 > python3 -m pip install mkl==2021.4.0
 
-The alternative, solving with `PETSc/MUMPS`, runs natively on `arm64`, but requires the installation of `PETSc/MUMPS`. See [here](https://pyoomph.readthedocs.io/en/latest/tutorial/installation/petscslepc.html) for details.
-
 Make sure to have the `Xcode` developer tools, e.g. by installing them via
 
 > xcode-select --install

{pyoomph-0.2.1 → pyoomph-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyoomph
-Version: 0.2.1
+Version: 0.2.2
 Summary: pyoomph - a multi-physics finite element framework based on oomph-lib and GiNaC
 Author-Email: Christian Diddens <c.diddens@utwente.nl>, Duarte Rocha <d.rocha@utwente.nl>, Maxim de Wildt <m.dewildt@utwente.nl>
 License: GNU GENERAL PUBLIC LICENSE Version 3
@@ -861,6 +861,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Scientific/Engineering :: Physics

{pyoomph-0.2.1 → pyoomph-0.2.2}/citools/generate_aiomfac_parameters.py

@@ -189,7 +189,7 @@ def emit_short_range(p: AIOMFACParameters, keep_names: dict[int, str]) -> str:
 
 ##########################################################################################
 # These parameters stem from the AIOMFAC activity model
-#\t\thttp://www.aiomfac.caltech.edu/
+#\t\thttps://aiomfac.lab.mcgill.ca/
 #
 # For the source code and parameter tables (GPL v3), see
 #\t\thttps://github.com/andizuend/AIOMFAC
@@ -207,7 +207,7 @@ from ..activity import UNIFACLikeActivityModel,ActivityModel
 @ActivityModel.register_activity_model()
 class AIOMFAC(UNIFACLikeActivityModel):
     """
-    AIOMFAC activity model (http://www.aiomfac.caltech.edu/), parameters taken from the AIOMFAC
+    AIOMFAC activity model (https://aiomfac.lab.mcgill.ca/), parameters taken from the AIOMFAC
     source code (https://github.com/andizuend/AIOMFAC).
 
     Cite the publications when using this activity model (https://aiomfac.lab.mcgill.ca/citation.html).

pyoomph-0.2.2/citools/patches/apply_ginac_patch.sh

@@ -0,0 +1,128 @@
+#!/usr/bin/env bash
+# Applies pyoomph's GiNaC patches to a GiNaC source tree (run with cwd = the
+# extracted GiNaC source root, i.e. the directory containing ginac/).
+#
+# Idempotent by design: cmake/ThirdPartyGiNaC.cmake makes the ExternalProject
+# patch step depend on this script and on every *.patch beside it, so touching
+# any of them re-runs the step against a tree that is already (partly) patched.
+# A plain `patch -p1 -i ...` fails loudly the second time ("Reversed (or
+# previously applied) patch detected!"), so each patch has to be recognised as
+# already applied and skipped - while a genuine mismatch (e.g. GiNaC source
+# changed unexpectedly) still aborts the build loudly.
+#
+# That recognition used to be "reverse-dry-run the whole patch; if it applies,
+# it is already applied". That is wrong for patches that touch the same region
+# of the same file, and it broke the 2026-09-22 nightly: patch 5 inserts
+# exact_whole_number_exponent() and the real_part()/imag_part() preamble
+# exactly into patch 4's trailing context, so against a tree carrying both,
+# patch 4 no longer reverses (its hunk 1 wants power::real_part() to follow
+# binomial_expansion_pow(), and now it does not) while its hunk 1 still
+# *forward*-matched with fuzz somewhere else. Neither branch held and the
+# script aborted on a correctly patched tree.
+#
+# So record what was applied instead of re-deriving it: a stamp per patch under
+# $stamp_dir, holding that patch's checksum. The stamp lives inside the source
+# tree, so a re-extracted tarball correctly starts over, and editing a patch
+# invalidates only its own stamp. The two fallbacks below adopt a tree that was
+# patched before stamps existed - including the tree the 2026-09-22 failure
+# left behind - and write its stamps, so this heals in place with no need to
+# blow away build/.
+set -euo pipefail
+
+script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+stamp_dir=".pyoomph-ginac-patches"
+
+# The first two fix the same class of bug (GiNaC hashing the ASLR-dependent
+# address of an RTTI type-name string instead of something deterministic) in
+# two different spots; the third stops power::to_polynomial() recursing
+# forever on a negative integer power of a power with a symbolic exponent; the
+# fourth stops power::real_part()/imag_part() raising pow(0,0) on the end terms
+# of their binomial expansion; the fifth lets those two use that binomial branch
+# for an inexact whole-number exponent (2.0) as well, instead of falling through
+# to a polar form that buries the basis in an atan2.
+# See each patch's own header comment for the full rationale. Applied in
+# order; add further patches to this list as found.
+patches=(
+    "ginac-deterministic-hash-seed.patch"
+    "ginac-deterministic-constant-hash.patch"
+    "ginac-to-polynomial-symbolic-exponent.patch"
+    "ginac-binomial-real-imag-pow00.patch"
+    "ginac-inexact-whole-number-exponent.patch"
+)
+
+# Every non-blank line a patch adds, already present in the file it adds it to?
+# The last-resort "already applied" test, and the only one that survives a
+# later patch rewriting an earlier one's context: it asks about the state of
+# the tree rather than about whether patch(1) can still line the hunks up.
+# Exact whole-line matching, so it does not confuse an added line with a
+# similar one elsewhere; context and removed lines are deliberately ignored.
+added_lines_all_present() {
+    awk '
+        /^\+\+\+ / { target = $2; sub(/^b\//, "", target); next }
+        /^--- /    { next }
+        /^\+/ {
+            if (target == "")
+                next
+            line = substr($0, 2)
+            if (line ~ /^[[:space:]]*$/)
+                next
+            if (!(target in loaded)) {
+                loaded[target] = 1
+                while ((getline l < target) > 0)
+                    present[target SUBSEP l] = 1
+                close(target)
+            }
+            if (!((target SUBSEP line) in present))
+                ok = 1
+        }
+        END { exit ok }
+    ' "$1"
+}
+
+# sha256sum is GNU coreutils and is NOT on a stock macOS: the arm64 prebuild runner died here with
+# "sha256sum: command not found" (exit 127) while the Intel one happened to have coreutils pulled in
+# by some other brew formula, so this broke on exactly one of the four prebuild platforms. BSD/macOS
+# ships `shasum -a 256` instead, and openssl is the last resort for an image with neither. Only the
+# hex digest is wanted, hence the cut in every branch - the three tools pad and order their output
+# differently ("<hash>  <file>" for the first two, "SHA256(<file>)= <hash>" for openssl).
+if command -v sha256sum >/dev/null 2>&1; then
+    checksum_of() { sha256sum "$1" | cut -d' ' -f1; }
+elif command -v shasum >/dev/null 2>&1; then
+    checksum_of() { shasum -a 256 "$1" | cut -d' ' -f1; }
+elif command -v openssl >/dev/null 2>&1; then
+    checksum_of() { openssl dgst -sha256 "$1" | awk '{print $NF}'; }
+else
+    echo "none of sha256sum, shasum or openssl is available; cannot checksum the patches" >&2
+    exit 1
+fi
+
+mkdir -p "$stamp_dir"
+
+for patch_name in "${patches[@]}"; do
+    patch_file="$script_dir/$patch_name"
+    stamp_file="$stamp_dir/$patch_name.applied"
+    checksum="$(checksum_of "$patch_file")"
+
+    if [ -f "$stamp_file" ] && [ "$(cat "$stamp_file")" = "$checksum" ]; then
+        echo "$patch_name already applied (stamp), skipping."
+        continue
+    fi
+
+    # --fuzz=0: a hunk must match exactly. With patch(1)'s default fuzz of 2 an
+    # already-applied patch can half-match somewhere else entirely - which is
+    # how patch 4 reported "Hunk #1 succeeded at 698 with fuzz 1 (offset 36
+    # lines)" against a tree that already had it - and applying that would
+    # duplicate the addition rather than fail.
+    if patch -p1 -N --fuzz=0 --dry-run -s -i "$patch_file" >/dev/null 2>&1; then
+        patch -p1 -N --fuzz=0 -i "$patch_file"
+    elif patch -p1 -R --fuzz=0 --dry-run -s -i "$patch_file" >/dev/null 2>&1; then
+        echo "$patch_name already applied (reverses cleanly), recording stamp."
+    elif added_lines_all_present "$patch_file"; then
+        echo "$patch_name already applied (every added line present), recording stamp."
+    else
+        echo "ERROR: $patch_name does not apply to $(pwd) and is not already applied - GiNaC source may have changed unexpectedly." >&2
+        exit 1
+    fi
+
+    printf '%s\n' "$checksum" > "$stamp_file"
+done

pyoomph-0.2.2/citools/patches/ginac-binomial-real-imag-pow00.patch

@@ -0,0 +1,55 @@
+Stop GiNaC::power::real_part()/imag_part() from raising "pow(0,0) is undefined" on an integer power
+whose basis has a zero real or a zero imaginary part.
+
+Both build Re/Im of (a+I*b)^N from the binomial expansion and write each term as
+binomial(NN,n) * pow(a, NN-n) * pow(b, n). A binomial expansion needs the 0^0 == 1 convention for
+its end terms, and GiNaC's pow() refuses: pow(0,0) throws. So (I*x)^2, whose expansion contains the
+factor a^0 with a == Re(I*x) == 0, aborts code generation with a ValueError that says nothing about
+where it came from. Every terminating case is unchanged: pow(x,0) is 1 for every x for which the
+old code did not throw.
+
+pyoomph reaches it from the azimuthal real/imaginary split. subexpression() now reports the real and
+imaginary parts of a marker whose content is provably real (that is what keeps the split from
+multiplying products out, see dev_docs/subexpression_unit_analysis_stall.md), so mul::find_real_imag
+can now conclude that the real part of a factor is exactly zero, where before it produced a held
+real_part() node that was never zero. The GiNaC bug is independent of pyoomph - "ex e = pow(I*x, 2);
+e.real_part();" reproduces it - and is what to send upstream.
+
+--- a/ginac/power.cpp
++++ b/ginac/power.cpp
+@@ -662,6 +662,17 @@
+ 	return conjugate_function(*this).hold();
+ }
+ 
++// x^n for one factor of a binomial expansion, with the 0^0 == 1 convention that such an expansion
++// requires. GiNaC's pow() throws "power::eval(): pow(0,0) is undefined" instead, which makes
++// real_part()/imag_part() of an integer power abort whenever the basis has a zero real OR a zero
++// imaginary part - e.g. (I*x)^2, whose expansion contains a term with the factor a^0 = 0^0.
++static ex binomial_expansion_pow(const ex & x, long n)
++{
++	if (n == 0)
++		return _ex1;
++	return pow(x, n);
++}
++
+ ex power::real_part() const
+ {
+ 	// basis == a+I*b, exponent == c+I*d
+@@ -683,7 +694,7 @@
+ 		ex numer = N > 0 ? _ex1 : pow(pow(a,2) + pow(b,2), NN);
+ 		ex result = 0;
+ 		for (long n = 0; n <= NN; n += 2) {
+-			ex term = binomial(NN, n) * pow(a, NN-n) * pow(b, n) / numer;
++			ex term = binomial(NN, n) * binomial_expansion_pow(a, NN-n) * binomial_expansion_pow(b, n) / numer;
+ 			if (n % 4 == 0) {
+ 				result += term;  // sign: I^n w/ n == 4*m
+ 			} else {
+@@ -720,7 +731,7 @@
+ 		ex numer = N > 0 ? _ex1 : pow(pow(a,2) + pow(b,2), NN);
+ 		ex result = 0;
+ 		for (long n = 1; n <= NN; n += 2) {
+-			ex term = binomial(NN, n) * pow(a, NN-n) * pow(b, n) / numer;
++			ex term = binomial(NN, n) * binomial_expansion_pow(a, NN-n) * binomial_expansion_pow(b, n) / numer;
+ 			if (n % 4 == p) {
+ 				result += term;  // sign: I^n w/ n == 4*m+p
+ 			} else {

pyoomph-0.2.2/citools/patches/ginac-inexact-whole-number-exponent.patch

@@ -0,0 +1,78 @@
+Make GiNaC::power::real_part()/imag_part() use their integer-binomial branch for an INEXACT
+whole-number exponent too, instead of falling through to the polar form.
+
+Both decide whether the (exact, rational) binomial expansion of Re/Im of (a+I*b)^N applies by asking
+exponent.info(integer). An inexact 2.0 does not satisfy that even though the expansion is just as
+valid for it, so they take the general branch
+
+    |X|^c * exp(-d*atan2(b,a)) * cos(c*atan2(b,a) + d*log|X|)
+
+which is mathematically right and useless to a caller that must not have the basis appear inside a
+transcendental function. In pyoomph it is the dimensional analysis of a residual that then fails:
+the basis is a mass density, atan2 hides its units from collect_base_units(), and code generation
+aborts with "The added residual contribution is not dimensionless. It still carries the base units:
+kilogram, meter". The exponent reached that state through a cache that compared the exact -2 to a
+stored -2.0 - GiNaC hashes and compares numbers by value, and ex::compare() then unifies the two by
+pointer, rewriting the power in place.
+
+That cache is fixed in pyoomph, and keeping numbers exact is where the problem belongs. This is the
+backstop for the whole class: an exponent that is an integer VALUE is treated as the integer it is,
+by redoing the call with the exact number. Nothing else changes - every case that already took the
+binomial branch had an exact exponent and is untouched.
+
+This patch applies on top of ginac-binomial-real-imag-pow00.patch (it shares its context) and is
+worth sending upstream together with it.
+
+--- a/ginac/power.cpp
++++ b/ginac/power.cpp
+@@ -673,8 +673,38 @@
+ 	return pow(x, n);
+ }
+ 
++// An exponent that is an inexact numeric happening to be a whole number - 2.0 rather than 2 - as
++// the exact integer it is, or the expression unchanged if it is not one. real_part() and
++// imag_part() below decide whether they may use the (exact, real) integer-binomial expansion by
++// asking exponent.info(integer), which an inexact 2.0 does not satisfy even though the expansion is
++// just as valid for it. They then fall through to the general polar form
++// |X|^c*exp(-d*atan2(b,a))*cos(c*atan2(b,a)+d*log|X|), which is correct but useless to any caller
++// that has to keep the result free of transcendental functions of the basis - in pyoomph, the
++// dimensional analysis of a residual, which cannot separate the units of a basis that has landed
++// inside an atan2. Numbers should of course be kept exact in the first place; this is the backstop.
++static ex exact_whole_number_exponent(const ex & e)
++{
++	if (!is_exactly_a<numeric>(e))
++		return e;
++	const numeric & n = ex_to<numeric>(e);
++	if (n.is_crational() || !n.is_real())
++		return e;
++	const double d = n.to_double();
++	if (d > 1e15 || d < -1e15)
++		return e;
++	const long l = (long)d;
++	if ((double)l != d)
++		return e;
++	return numeric(l);
++}
++
+ ex power::real_part() const
+ {
++	{
++		const ex xexponent = exact_whole_number_exponent(exponent);
++		if (!are_ex_trivially_equal(xexponent, exponent))
++			return pow(basis, xexponent).real_part();
++	}
+ 	// basis == a+I*b, exponent == c+I*d
+ 	const ex a = basis.real_part();
+ 	const ex c = exponent.real_part();
+@@ -711,6 +741,11 @@
+ 
+ ex power::imag_part() const
+ {
++	{
++		const ex xexponent = exact_whole_number_exponent(exponent);
++		if (!are_ex_trivially_equal(xexponent, exponent))
++			return pow(basis, xexponent).imag_part();
++	}
+ 	// basis == a+I*b, exponent == c+I*d
+ 	const ex a = basis.real_part();
+ 	const ex c = exponent.real_part();

pyoomph-0.2.2/citools/patches/ginac-to-polynomial-symbolic-exponent.patch

@@ -0,0 +1,44 @@
+Stop GiNaC::power::to_polynomial() from recursing forever on (x^a)^(-n), i.e. a negative integer
+power of a power whose own exponent is symbolic.
+
+The negint branch rebuilds pow(basis_pref, exponent) and recurses into it, justified by the comment
+"(A*B)^n will be automagically transformed to A^n*B^n". That holds for a `mul` basis, and for a
+`power` basis whose inner exponent is numeric ((x^3)^(-2) evaluates to x^(-6)). It does NOT hold for
+a `power` basis with a SYMBOLIC inner exponent: power::eval only contracts (x^a)^b into x^(a*b) when
+that is provably valid, since for symbolic a the two sides differ across the branch cut. So
+pow((x^a), -2) evaluates back to the very expression to_polynomial was called on, and the recursion
+is a self-call with an unchanged argument -- roughly 47000 frames deep here before the stack runs
+out, with no diagnostic of any kind.
+
+Recursing only when the rebuilt expression actually differs leaves every terminating case
+bit-identical (there t differs from *this by construction) and turns the non-terminating one into
+the same opaque-symbol replacement that to_polynomial already applies to any other non-polynomial
+subexpression -- including, without this patch, the closely related (x^a)^(1/2).
+
+pyoomph reaches it through unit extraction: collect_base_units() calls collect_common_factors(),
+which calls to_polynomial(). A Vignes-interpolated Maxwell-Stefan diffusivity written as
+D0_ij^e_ij * D0_ji^e_ji has composition FIELDS in its exponents, and when the mixture viscosity
+inside D0 is a sum the unit symbols do not cancel automatically, leaving factors of the form
+kilogram^(<field expression>) for collect_common_factors to choke on. See
+dev_docs/examples/ginac_to_polynomial_symbolic_exponent.cpp, which reproduces it in five lines with
+no pyoomph involved and is what to send upstream.
+
+--- a/ginac/normal.cpp
++++ b/ginac/normal.cpp
+@@ -2720,10 +2720,13 @@
+ 		if (is_exactly_a<mul>(basis_pref) || is_exactly_a<power>(basis_pref)) {
+ 			// (A*B)^n will be automagically transformed to A^n*B^n
+ 			ex t = pow(basis_pref, exponent);
+-			return t.to_polynomial(repl);
++			// ... but a power with a SYMBOLIC exponent is not, and rebuilding it unchanged
++			// would make this an infinite self-recursion. Fall through to the replacement
++			// below instead, which is what any other non-polynomial basis gets.
++			if (!t.is_equal(*this))
++				return t.to_polynomial(repl);
+ 		}
+-		else
+-			return pow(replace_with_symbol(pow(basis, _ex_1), repl), -exponent);
++		return pow(replace_with_symbol(pow(basis, _ex_1), repl), -exponent);
+ 	} 
+ 	else
+ 		return replace_with_symbol(*this, repl);

{pyoomph-0.2.1 → pyoomph-0.2.2}/citools/test_all_tutorial_scripts.py

@@ -40,6 +40,12 @@ parser.add_argument("--report-json", metavar="PATH", default=None, help="Also wr
 parser.add_argument("--mpirun", type=int, default=0, metavar="N", help="Run each script under 'mpirun -n N' instead of directly. Default 0, i.e. no mpirun")
 parser.add_argument("--omp", type=int, default=0, metavar="N", help="Pass '--omp N' to each script, i.e. assemble the elements on N threads. Default 0, i.e. leave each script on the serial element loop. Composes with --mpirun, which is threads per rank then")
 parser.add_argument("--distribute", help="Pass --distribute to each script, i.e. distribute the mesh over the ranks. Only meaningful together with --mpirun", action="store_true")
+# Deliberately general rather than one option per solver. Note what forcing a solver DOES, though:
+# it changes what is being computed, not just how fast. petsc_mumps collapses hopf_switch's arclength
+# continuation and plain --petsc (an iterative KSP) fails outright on the augmented systems, so a
+# failure under this flag is not by itself a failure of the backend - re-run the same script without
+# it before concluding anything.
+parser.add_argument("--extra-arg", action="append", default=[], metavar="ARG", help="Pass this argument on to every script. Repeatable, e.g. --extra-arg --mumps. See the note in the source about what forcing a solver changes")
 # For chasing one flaky script across the platforms: a full pass is hours per OS, and a script that
 # only fails once in a while has to be run as the CI runs it - same wheel, same runner - not once in
 # a scratch directory. Substring rather than glob, on "Folder/script.py", so that a bare script name
@@ -158,6 +164,14 @@ _MISSING_MODULE=re.compile(rb"ModuleNotFoundError: No module named '([A-Za-z0-9_
 _UNAVAILABLE_SOLVER=re.compile(rb"^RuntimeError: .* is not available \(ModuleNotFoundError: No module named '([A-Za-z0-9_.]+)'\)")
 _BROKEN_IMPORT=re.compile(rb"^ImportError: (.*)$")
 _TRACEBACK_FRAME=re.compile(rb'^  File "([^"]+)"')
+# Under mpirun every stderr line is tagged "[rank N] " - on every rank and in every --mpi-output mode,
+# see pyoomph/generic/logging.py _ConsoleWrapper._decorate. The three anchored patterns above would
+# therefore never match in the MPI pass (only _MISSING_MODULE, which searches, survived), so the tag
+# comes off before a line is examined.
+_RANK_TAG=re.compile(rb"^\[rank \d+\] ?")
+
+def untag_rank(line):
+  return _RANK_TAG.sub(b"",line)
 
 def missing_optional_module(output):
   """(package, why) when an optional package, and nothing else, ended this script - else None.
@@ -183,7 +197,7 @@ def missing_optional_module(output):
   lines=output.strip().splitlines()
   if not lines:
     return None
-  last=lines[-1]
+  last=untag_rank(lines[-1])
   m=_UNAVAILABLE_SOLVER.match(last)
   if m is not None:
     name=m.group(1).decode().split(".")[0]
@@ -195,7 +209,7 @@ def missing_optional_module(output):
   m=_BROKEN_IMPORT.match(last)
   if m is None:
     return None
-  frames=[f.group(1).decode() for f in (_TRACEBACK_FRAME.match(l) for l in lines) if f]
+  frames=[f.group(1).decode() for f in (_TRACEBACK_FRAME.match(untag_rank(l)) for l in lines) if f]
   for name in _OPTIONAL_MODULES:
     if any(("/"+name+"/") in p or p.endswith("/"+name+".py") for p in frames):
       return (name,"is installed but cannot be loaded here ("+m.group(1).decode()+")")
@@ -207,16 +221,40 @@ def missing_optional_module(output):
 # for why - so without dropping that epilogue every optional-package skip would be counted as a real
 # failure in the MPI pass, which is exactly the noise the skip mechanism exists to avoid.
 _DASH_RULE=re.compile(rb"^-{20,}$")
+# Not everything mpirun appends is fenced, and since 2026-08-18 pyoomph appends a line of its own.
+# Both sit AFTER the traceback and so become "the last line" that missing_optional_module() reads:
+#
+#   pyoomph: uncaught ... -- aborting the whole job.
+#       generic/mpi.py's excepthook (commit a8973de2), which turns a rank dying alone - and the other
+#       three then spinning in a collective until the step's timeout - into an MPI_Abort. It prints
+#       this note after the traceback it has just let through.
+#   [duarte:37160] N more processes have sent help message ...
+#       Open MPI's help-message aggregator, written by mpirun itself once the job is down. Plain
+#       "[host:pid] " lines, with no dash rules around them.
+#
+# Together they are why the mpirun pass reported rayleigh_plateau_pinchoff.py as FAILED on the
+# 2026-09-02 and 2026-09-03 nightlies while the serial pass skipped it for the same missing shapely.
+_UNFENCED_EPILOGUE=(re.compile(rb"^\[[^\]\s]+:\d+\]\s"),
+                    re.compile(rb"^pyoomph: uncaught \w+ on MPI rank \d+ of \d+ -- aborting the whole job\."))
 
 def strip_mpirun_epilogue(output):
   lines=output.rstrip().splitlines()
-  while len(lines)>=2 and _DASH_RULE.match(lines[-1].strip()):
-    for i in range(len(lines)-2,-1,-1):
-      if _DASH_RULE.match(lines[i].strip()):
-        del lines[i:]
-        break
-    else:
-      break # an unpaired rule: not one of mpirun's blocks, leave the output alone
+  peeled=True
+  while peeled: # the two kinds interleave, so keep going until a pass changes nothing
+    peeled=False
+    while len(lines)>=2 and _DASH_RULE.match(lines[-1].strip()):
+      for i in range(len(lines)-2,-1,-1):
+        if _DASH_RULE.match(lines[i].strip()):
+          del lines[i:]
+          peeled=True
+          break
+      else:
+        break # an unpaired rule: not one of mpirun's blocks, leave the output alone
+      while lines and not lines[-1].strip():
+        lines.pop()
+    while lines and any(p.match(untag_rank(lines[-1].strip())) for p in _UNFENCED_EPILOGUE):
+      lines.pop()
+      peeled=True
     while lines and not lines[-1].strip():
       lines.pop()
   return b"\n".join(lines)
@@ -437,6 +475,7 @@ for d in glob.glob("./*/"):
       cmd.append("--distribute")
     if args.omp>0:
       cmd+=["--omp",str(args.omp)]
+    cmd+=args.extra_arg
     started_at=time.time()
     proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env)
     #proc = subprocess.Popen([sys.executable, '-u', f], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
@@ -550,6 +589,7 @@ if report_json is not None:
                "python":sys.version.split()[0],
                "options":{"quick_test":args.quick_test,"tcc":args.tcc,"no_petsc":args.no_petsc,
                           "mpirun":args.mpirun,"omp":args.omp,"distribute":args.distribute,
+                          "extra_arg":args.extra_arg,
                           "timeout":args.timeout,
                           "skips":skips,"only":args.only},
                "scripts":records},jf,indent=1)