Multi-Physics Code Coupling Without preCICE: Alternatives and Custom Approaches

When you work with multi-physics simulations, you often need to couple two or more specialized solvers so they exchange data during computation. preCICE is a mature open-source coupling library for partitioned multi-physics simulations, especially when connecting independent solvers such as FiPy, OpenFOAM, or CalculiX.

But preCICE is not always an option. You may work in an environment where installing a C++-based library with Python bindings is not practical. You may use a commercial solver that does not support preCICE. Or your multi-physics problem may be simple enough that a full coupling framework feels like overkill.

This article covers practical alternatives, including sequential updating inside FiPy, operator splitting, polynomial extrapolation methods, and general-purpose coupling libraries.

Key Takeaways

• preCICE is powerful, but it is not the only option for multi-physics coupling. The right alternative depends on solver availability, language preferences, HPC readiness, and problem complexity.
• Sequential coupling within FiPy works well when both equations live in the same Python process. It is simple, debuggable, and requires no external coupling library.
• Operator splitting decouples physics by solving each equation separately. It is useful when different physical processes operate at different time scales.
• General-purpose coupling libraries such as MUI and MOOSE MultiApps offer alternative architectures with different trade-offs in complexity, language support, and scalability.
• Polynomial-based orchestration through tools such as Rhapsopy is an emerging high-order approach that adapts time steps using coupling-variable error estimates.

Partitioned vs Monolithic vs Sequential Coupling

Before comparing alternatives, it helps to clarify the main coupling strategies. Multi-physics coupling usually falls into three categories.

Partitioned Coupling

In partitioned coupling, separate solvers communicate through an external interface or middleware layer. The solvers remain independent black boxes, and each solver does not need to know the internal structure of the other.

preCICE is the canonical example. The advantages include code reuse, flexibility, and the ability to couple commercial or legacy codes. The trade-off is communication overhead and the need for mesh mapping, data transfer, and coupling coordination.

Monolithic Coupling

In monolithic coupling, all physics are solved together in a single solver and often share the same system matrix. This can be more efficient for tightly coupled problems because nonlinearities are handled implicitly.

The trade-off is high development effort. All physics must be implemented inside one framework. MOOSE is a notable framework that supports monolithic-style workflows and also offers partitioned patterns through MultiApps.

Sequential Coupling

Sequential coupling works when all physics can be expressed inside one solver framework. In FiPy, for example, you can solve coupled equations one after another inside the same Python process.

This avoids external middleware entirely. The trade-off is that you lose the ability to couple independent solvers written in different languages or maintained by different organizations.

Sequential Coupling with FiPy Sweeping

The simplest alternative to preCICE is to solve coupled equations sequentially in the same Python process. FiPy supports this pattern through the sweep() and updateOld() methods.

The Pattern

The standard implementation follows a nested loop:

1. Declare variables with hasOld=True so they can store previous values for transient terms.
2. Call updateOld() once per physical time step to lock the current state as the old value.
3. Call eq.sweep() repeatedly in an inner loop until residuals converge.

from fipy import CellVariable, Grid1D
from fipy import TransientTerm, DiffusionTerm, ImplicitSourceTerm

# 1. Setup mesh and variables
mesh = Grid1D(nx=50, Lx=1.0)

v0 = CellVariable(
    name="Variable 0",
    mesh=mesh,
    value=0.5,
    hasOld=True
)

v1 = CellVariable(
    name="Variable 1",
    mesh=mesh,
    value=0.5,
    hasOld=True
)

# 2. Define coupled equations
eq0 = (
    TransientTerm(var=v0)
    == DiffusionTerm(coeff=0.01, var=v0)
    - ImplicitSourceTerm(coeff=1.0, var=v1)
)

eq1 = (
    TransientTerm(var=v1)
    == DiffusionTerm(coeff=0.01, var=v1)
    - ImplicitSourceTerm(coeff=1.0, var=v0)
)

# 3. Simulation parameters
dt = 1e-3
steps = 100
tolerance = 1e-4

# 4. Time-stepping and sweeping loop
for step in range(steps):
    v0.updateOld()
    v1.updateOld()
    
    residual0 = residual1 = 1.0
    
    while (residual0 > tolerance) or (residual1 > tolerance):
        residual0 = eq0.sweep(var=v0, dt=dt)
        residual1 = eq1.sweep(var=v1, dt=dt)

When This Works Best

• Both physics can be expressed as PDEs inside FiPy.
• You need rapid prototyping or debugging without external dependencies.
• The coupled system has moderate nonlinearity that converges with iterative sweeping.
• You are solving phase-field models, diffusion-reaction systems, or coupled transport problems.

When It Fails

• You need to couple solvers written in C++, Fortran, or other languages.
• The physics are so tightly coupled that sequential sweeps require too many iterations.
• Your solvers are separate executables from different organizations.
• You need distributed-memory parallel scaling across multiple compute nodes.

Operator-Splitting Approaches

Operator splitting, also called fractional stepping, decomposes a coupled system into sequential sub-steps. Each sub-step solves one physics model. This is useful when physical processes operate at different time scales.

Additive vs Multiplicative Splitting

Additive splitting decomposes an equation into separate operators and solves each contribution independently. Multiplicative splitting applies operators sequentially with a defined order, which matters when operators do not commute.

For multi-physics workflows, additive splitting is often easier to apply. Each physics model can use its own optimized solver, and the coupling logic remains modular.

Python Operator-Splitting Libraries

Several Python-oriented tools and examples support operator splitting workflows:

• pythOS is a Python library for systematic operator splitting of differential equations. It supports patterns such as Strang splitting, implicit-explicit methods, and adaptive time stepping.
• venice is a multi-scale operator-splitting algorithm that uses Strang splitting with adaptive time steps. It is relevant when coupled physics operate across different time scales.
• Operator-Splitting-Methods provides standalone Python scripts for educational use. These scripts are useful for learning but are not production-ready.

FiPy with Operator Splitting

You can also combine FiPy with operator splitting manually. A diffusion-reaction system can be split into a diffusion step and a reaction step:

# Separate the reaction step from diffusion
dt_diffusion = 0.001
dt_reaction = 0.1

# Solve diffusion with a small time step
eq_diff = TransientTerm(var=T) == DiffusionTerm(coeff=k, var=T)
eq_diff.sweep(dt=dt_diffusion)

# Solve reaction with a larger time step
eq_react = TransientTerm(var=T) == ReactionTerm(source, var=T)
eq_react.sweep(dt=dt_reaction)

The basic scheme is first-order accurate. For second-order accuracy, use Strang splitting: half-step diffusion, full-step reaction, then half-step diffusion.

General-Purpose Coupling Libraries

If you need partitioned coupling but cannot use preCICE, several alternatives exist.

MUI: Multiscale Universal Interface

MUI is a header-only C++ library for coupling heterogeneous solvers. It treats exchanged data as clouds of points and handles spatial and temporal interpolation automatically.

Key features include:

• Point-based representation. MUI can transfer data without requiring one solver to know the mesh connectivity of another solver.
• Space and time interpolation. Built-in interpolation tools help solvers operating on different scales communicate.
• Smart Send. This algorithm restricts communication to overlapping domains and reduces unnecessary all-to-all communication.
• Language support. MUI is written in C++ and offers wrappers for Python, Fortran, and C.

MUI is useful when you need to couple solvers with fundamentally different discretizations, such as FEM, FVM, DEM, or SPH.

Choose MUI over preCICE when you need a lightweight embedded interface or when mesh connectivity differences make standard coupling infrastructure too heavy.

Stick with preCICE when you need mature parallel scaling, quasi-Newton acceleration for strongly coupled problems, and a larger adapter ecosystem.

MOOSE MultiApps and Transfer Systems

MOOSE can solve fully coupled systems, but its MultiApps and Transfer systems also support partitioned approaches. MOOSE creates sub-applications that pass field data back and forth.

MOOSE supports several coupling styles:

• Fully coupled workflows where all physics are solved in one nonlinear iteration.
• Tightly coupled Picard or Newton-style workflows where physics sub-applications iterate within each time step.
• Staggered workflows where each physics advances independently and exchanges data at defined boundaries.

MOOSE is primarily C++-focused. Python tools exist, but the ecosystem is less Python-native than workflows built around FiPy or preCICE.

Polynomial-Based Coupling with Rhapsopy

Rhapsopy uses polynomial approximations of coupling variables over time. Instead of exchanging only a single value at each coupling step, each subsystem integrates using a polynomial approximation of its input from the other subsystem.

How It Works

During one coupling step, each subsystem is integrated with its own solver while using polynomially approximated input variables. At the end of the step, new coupling variables are computed and the polynomials are updated.

This approach can help with:

1. Accuracy. Higher-order polynomial approximations capture temporal changes better than constant or linear extrapolation.
2. Adaptive time stepping. Error estimates from polynomial approximations can guide coupling time-step size.
3. Explicit and implicit coupling. Implicit versions can improve stability but require solving a fixed-point problem at each step.

Current Status

Rhapsopy is currently best viewed as a demonstration tool for small-scale problems. It is promising for Python users who want high-order adaptive coupling, but it is not yet a mature large-scale HPC solution.

COMSOL Native Coupling

COMSOL Multiphysics uses a different model. Instead of coupling external solvers, COMSOL defines multiphysics couplings natively inside the same software environment.

COMSOL users can:

• Define interface conditions such as heat flux continuity or stress equilibrium.
• Use fully coupled solution strategies for nonlinear problems.
• Switch between segregated and fully coupled strategies depending on problem complexity.

This is straightforward for users already inside COMSOL. The trade-off is vendor lock-in. Coupling external solvers usually requires COMSOL-specific interfaces, LiveLink workflows, or scripting bridges.

Comparison Summary

Practical Decision Guide

Use this decision guide when you cannot or do not want to use preCICE.

1. Are all physics expressible within FiPy? Use sequential sweeping. It is the simplest path and requires no external dependencies.
2. Do your physics operate at very different time scales? Try operator splitting. The decoupling lets each physics use its own time step.
3. Are you coupling solvers with fundamentally different discretizations? Consider MUI. Its point-based representation can handle mesh-to-mesh and mesh-to-particle coupling.
4. Are you working in C++ or the MOOSE ecosystem? MOOSE MultiApps offer monolithic, tightly coupled, and staggered options inside one framework.
5. Do you need adaptive time stepping based on coupling errors? Try Rhapsopy for small-scale experiments or monitor its development for larger workflows.
6. Are you using a commercial solver? Check whether it has native multiphysics features or supports external coupling libraries.

What We Recommend

For FiPy users working in Python, the recommendation depends on problem complexity.

• Simple coupling, such as diffusion-reaction, phase-field, or transport: use sequential sweeping with sweep(). It is straightforward and requires no external dependencies.
• Moderate complexity, such as loosely coupled external solvers or different time scales: use operator splitting with a structured library such as pythOS.
• High complexity, such as tightly coupled solvers across different languages: use preCICE when possible. The alternatives do not yet offer the same maturity, parallel scalability, or convergence acceleration.

If preCICE is not available, the next best option depends on your environment. For academic research without HPC access, MUI’s header-only design can be easier to integrate. For production simulations that require parallel scaling, preCICE remains the strongest option if you can use it.

What to Avoid

• Manual data exchange in loops without iteration or convergence criteria. This can diverge or produce inaccurate results.
• Extrapolating coupling variables without error control. Using the previous time step’s coupling value as the current value is only first-order accurate and can be unstable for strongly coupled problems.
• Neglecting under-relaxation. For nonlinear coupling, include under-relaxation parameters to reduce solver divergence.
• Assuming sequential sweeping scales. Sequential coupling inside one Python process will not scale across distributed-memory compute nodes.

Related Guides

• Code Coupling with preCICE: Multi-Physics Simulations in Python — Installation, adapter implementation, and configuration when preCICE is available.
• Extending FiPy with Custom Modules — Organizing reusable PDE code, source terms, and coupled models within FiPy.
• What Is FiPy and When Should You Use It? — FiPy fundamentals and use cases.
• Understanding Phase-Field Models in Materials Science — Multi-physics phase-field applications.
• Managing Large-Scale PDE Problems: Strategies, Solvers, and HPC Case Studies — Strategies for scaling complex simulation workflows.

Need Help Designing Your Multi-Physics Workflow?

Choosing the right coupling approach depends on your solvers, constraints, and problem complexity. MatForge offers consultation services for research software and simulation design. We can help evaluate trade-offs between preCICE, sequential coupling, operator splitting, and other approaches for your specific multi-physics problem.

Visit MatForge homepage to learn more about consultation services and research workflows.