pyoomph 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,5 +1,101 @@
 # 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. 
+
+### Fixed
+
+- **A two-sided interface could exhaust the machine's memory during the first assembly.** The pruned sparsity pattern (`prune_structural_zeros_by_field_coupling`, on by
+  default since 0.2.0) let the two sides of a coupled interface ask each other for an answer each was
+  still computing, which recursed without bound. 
+
 ## [0.2.0] - 2026-08-30
 
 About six weeks and 940+ commits since 0.1.9. Four themes: h-adaptivity generalised from quads and

{pyoomph-0.2.0 → 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.0 → pyoomph-0.2.2}/INSTALL.md

@@ -16,58 +16,31 @@ Verify whether everything runs fine by
 
 > python -m pyoomph check all
 
-If you encounter segmentation faults during solving, please try to downgrade your MKL package, e.g. via *python -m pip install mkl==2024.1.0*.
-
-### PETSc/SLEPc via WSL
-
-PETSc/SLEPc (used for a much more stable eigensolver, see the [tutorial](https://pyoomph.readthedocs.io/)) cannot be built natively on Windows. If you need it, install pyoomph inside the [Windows Subsystem for Linux (WSL)](https://learn.microsoft.com/windows/wsl/) instead, where it can be built exactly as on native Linux.
-
-From an elevated PowerShell:
-
-```powershell
-wsl --install -d Ubuntu
-```
+If you encounter segmentation faults during solving, please try to upgrade or downgrade your MKL package, e.g. via *python -m pip install mkl==2024.1.0*.
 
-Reboot if prompted, open the "Ubuntu" app, then inside it install pyoomph as on Linux (see below), keeping the source trees on the Linux filesystem (e.g. `~/...`, not `/mnt/c/...`):
-
-```bash
-sudo apt update
-sudo apt install gcc libopenmpi-dev flex bison
-python3 -m pip install --upgrade pyoomph
-```
+## On Linux
 
-Then build PETSc/SLEPc as on Linux:
+If you have installed via pip (see above), just make sure that you have the `gcc` compiler installed and check via
 
-```bash
-cd A_FOLDER_OF_YOUR_CHOICE
-git clone -b release https://gitlab.com/petsc/petsc.git petsc
-cd petsc
-export PETSC_DIR=$(pwd)
-export PETSC_ARCH=pyoomph_petsc_arch
-./configure --with-mpi --with-petsc4py --download-mumps=yes --download-hypre=yes --download-parmetis=yes --download-ptscotch=yes --download-slepc=yes --download-superlu=yes --download-superlu_dist=yes --download-suitesparse=yes --download-metis=yes --download-scalapack --with-scalar-type=complex
-```
+> python -m pyoomph check all
 
-`configure` prints the exact `make` command to run next. Afterwards, add to `~/.bashrc`:
+If you encounter segmentation faults during solving, please try to downgrade your MKL package, e.g. via *python -m pip install mkl==2024.1.0*.
 
-```bash
-export PETSC_DIR=A_FOLDER_OF_YOUR_CHOICE/petsc
-export PETSC_ARCH=pyoomph_petsc_arch
-export PYTHONPATH=$PYTHONPATH:$PETSC_DIR/$PETSC_ARCH/lib
-```
+## On Mac
 
-If `make` is killed for running out of memory, raise the memory available to WSL2 via `C:\Users\<you>\.wslconfig` (`[wsl2]` section, `memory=8GB`), then `wsl --shutdown` and reopen. If you use VS Code, install the "WSL" remote extension and open the project from within WSL so the editor picks up the environment variables above. Full details, including how to select the SLEPc/MUMPS eigensolver, are in the [tutorial](https://pyoomph.readthedocs.io/en/latest/tutorial/installation/wsl.html).
+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.
 
-## On Linux
+The recommended way is `MUMPS`, which runs natively on `arm64`. There are two routes:
 
-If you have installed via pip (see above), just make sure that you have the `gcc` compiler installed and check via
+* 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
 
-> python -m pyoomph check all
+  > git clone https://github.com/pyoomph/pyoomph_mumps.git ; cd pyoomph_mumps ; python3 -m pip install .
 
-If you encounter segmentation faults during solving, please try to downgrade your MKL package, e.g. via *python -m pip install mkl==2024.1.0*.
+  See [here](https://pyoomph.readthedocs.io/en/latest/tutorial/installation/mumps.html) for details and build options.
 
-## On Mac
+* `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.
 
-The fast `MKL Pardiso` solver from `mkl` is not available on `arm64` Macs. If you want to use it, 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)).
+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
@@ -80,8 +53,6 @@ and test pyoomph via
 
 > python -m pyoomph check all
 
-Alternatively, if you do not want to use the `Rosetta 2 terminal` detour, you can also install it directly on arm64 systems. This will use the `Accelerate Framework` as default solver.
-
 
 ## Compilation from source (including MPI)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyoomph
-Version: 0.2.0
+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.0 → 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.0 → 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)