OpenFOAM Industrial Multiphysics Pipeline: From Meshing to Data Supply
New1. Overview
A CFD solver rarely appears on the first page of a physics-AI proposal, yet it decides whether the whole chain is credible. It generates the corpus, it supplies the reference field against which surrogate error is measured, and every claim that a learned model is faster than CFD takes the solver's wall-clock time as its denominator. When a project must span fluid, heat transfer, combustion and multiple phases, one further layer appears: the way the physics is coupled, the consistency of the coupling boundary, and the way meshes are allocated across regions are all decisions that cannot be dodged by renaming the solver.
This entry occupies a specific position. The separate OpenFOAM tool entry on this site already covers the finite-volume discretisation, the case directory layout, the function-object mechanism, cost accounting and failure modes from the point of view of the solver itself. This entry asks a different question: when one industrial pipeline must handle fluid, solid, heat transfer, combustion and multiphase simultaneously, and must turn those results into reusable training data, which engineering decisions actually determine the outcome, and which widely repeated claims about OpenFOAM do not survive verification.
The second question is not a footnote. An earlier description called OpenFOAM the de-facto standard of open-source CFD and presented a seamless capability list covering heat transfer, combustion, multiphase and electromagnetics, while treating three distinct code lines as different versions of one product. All three need correction. A de-facto standard claim has no citable source and cannot be supported or refuted; it only invites scrutiny. Electromagnetic capability does not sit uniformly across the code lines: the OpenCFD line lists electromagnetics among its coverage areas, while the Foundation mainline ships no native electromagnetic solver, and the community option emFoam lives in the Extend-bazaar as a third-party extension derived from a 2019 master's thesis. And the name OpenFOAM covers three lines with different release cadences, feature sets and governance structures, so conflating them breaks reproduction outright.
The entry is therefore rewritten as a fact-checked account, with the corrections gathered in Section 9. The preceding sections give the full picture of an industrial pipeline: the mathematical form of the coupling, the three-stage logic of mesh generation, the interface conventions of multi-region decomposition, the path from a case directory to a dataset, and the cost and failure point at each step. All version statements were checked on 11 November 2026 against three upstream sites and the official release notes.
The audience is threefold: algorithm engineers who need to stand up a CFD corpus line; CAE leads deciding whether the modelling effort a coupled case demands is worth it; and simulation-platform developers wiring multiphysics results into downstream models. For training methods see the physics-informed neural network landscape, for operator-method selection see the neural operator selection guide, and for cost accounting see the cost boundary of classical solvers.
2. How It Works
An industrial multiphysics pipeline decomposes into four layers: the discretisation kernel, mesh generation, physics-domain coupling and data landing. Knowing which layer a problem belongs to is what tells you where a coupling failure actually originates.
The kernel is the finite volume method. Governing equations are integrated over each control volume, volume integrals become face fluxes through the divergence theorem, and an algebraic system is assembled from face interpolation schemes and boundary conditions. This layer determines conservation: mass, momentum and energy are balanced exactly across face fluxes, which is why finite volume dominates industrial CFD and why it differs so fundamentally from finite-element approaches built around weak-form residuals. The coupling problem is settled before it reaches this layer. If the interface condition between two domains cannot be written as a conservative flux balance, no amount of scheme tuning repairs it.
Mesh generation is the second layer and the most underestimated part of an industrial pipeline. The three-stage logic of snappyHexMesh deserves separate treatment. The first stage, castellatedMesh, splits and grades the background Cartesian mesh according to STL feature edges, surfaces and volume regions, retains the target region through locationInMesh, removes exterior cells and applies local refinement through refinementSurfaces and refinementRegions. The second stage, snapping, displaces vertices of the jagged cut mesh onto the STL surface so that the mesh conforms to the geometry. The third stage, layering, inserts controlled-thickness cells near the wall, which is where near-wall resolution and wall-modelling fidelity originate. Each stage has its own dictionary and its own failure mode: cut cells may be distorted, snapping may introduce non-orthogonality, and layering may silently be skipped when the requested layer thickness does not match the outer cell size.
Physics-domain coupling is the third layer. The most common form in OpenFOAM is conjugate heat transfer, implemented by chtMultiRegionFoam and its steady counterpart. Structurally, a single case directory holds several parallel regions, each with its own constant/<region> property dictionary and 0/<region> field directory; regionProperties declares which regions are fluid and which are solid; regions pair up through boundary-condition types. The fluid region solves the Navier-Stokes and continuity equations with energy solved on both sides, while the solid region solves the Fourier conduction equation. The interface conditions are temperature continuity and heat-flux continuity: equal normal flux and equal interface temperature on the two sides. The time step is the minimum over all regions, numerical schemes are managed per region, and the solver iterates across regions until the coupled system converges. Correctness of the coupling therefore rests on mesh and scheme quality inside each region, not on a single coupling parameter.
Multiphase and reacting flows form a separate track. multiphaseEuler uses an Eulerian multiphase framework treating each phase as a continuum, while XiFluid handles flame propagation and ignition. Foundation version 14 rewrote XiFluid as a two-phase solver using the MULES multiphase approach, treating unburnt and burnt gas as two phases whose enthalpy equations are solved in conservative form, with mean properties obtained by averaging the two phases. The rewrite is not only numerical: the two-phase formulation brings the inherently phase-changing nature of combustion into the conservative discretisation path.
Data landing is the fourth layer and the boundary between a physics-AI pipeline and an ordinary CAE workflow. Function objects sample probes, surfaces and volume fields during the run and write archivable data, while the field files in time directories supply the raw material for training samples. The trap in practice is not writing but alignment: if a case directory lacks fvSchemes, fvSolution and a mesh identifier, the resulting arrays cannot be regenerated by a third party and cannot support any mesh-convergence claim.
3. Scope and Assumptions
The first assumption is that the distribution line must be declared up front. Three lines coexist and all are actively maintained. The OpenFOAM Foundation line, developed by CFD Direct and released through a non-profit foundation, uses sequential integer versions, with version 13 released in July 2025 and version 14 on 14 July 2026. The OpenCFD line, maintained by OpenCFD Ltd under Keysight and holder of the OpenFOAM trademark, uses year-month versions and ships twice a year in June and December, with v2512 on 4 November 2025 and v2606 in June 2026. foam-extend is the community branch maintained by Wikki, currently at 5.0. All three publish under GPL v3, yet their release cadences, feature sets and governance structures differ. A case written for one line should not be assumed to run unchanged on another, and this is the most common technical cause of reproduction failure rather than a configuration slip.
The second assumption is the modelling commitment that coupling itself creates. A multi-region conjugate case requires a trustworthy mesh and property definition for every region: solid conductivity, interfacial contact resistance, and the fluid-side mesh and turbulence model all shape the resulting temperature field. Discretisation error at the interface is amplified by the solvers on both sides, and such errors rarely manifest as divergence; they show up as a systematic bias in the temperature field. Verification of a coupled case therefore cannot rest on residual curves alone and needs independent physical criteria such as energy-balance closure, interfacial heat-flux consistency, or comparison against an analytical solution or experiment.
The third assumption concerns where electromagnetic capability actually sits, and precision matters here because it determines whether a proposal can be delivered at all. OpenCFD lists electromagnetics among its coverage areas, which applies to its line. The Foundation mainline ships no native electromagnetic field solver. The community option emFoam lives in the Extend-bazaar area of the OpenFOAM wiki and is a frequency-domain block-coupled Maxwell solver based on a magnetic vector potential formulation, derived from a 2019 master's thesis and producing magnetic vector potential, magnetic flux density, magnetic field intensity, induced current density, Joule heating and Lorentz force. Such an extension is not guaranteed compatible by the mainline maintainers and may break on version upgrades. If a project genuinely needs electromagnetic coupling, the correct move is to evaluate it as a separate technology selection item, not to list it as an out-of-the-box OpenFOAM capability.
The fourth assumption is the precise boundary of licence obligations. GPL v3 copyleft requires that derivative software containing GPL code be distributed under GPL with corresponding source. That obligation triggers on distribution of software, not on publication of computation results. Publishing a case directory and the fields it produces is a different matter from distributing a modified solver binary, and the former generally does not trigger copyleft while the latter does. Whether a particular delivery to a customer constitutes distribution depends on the delivery form, and that judgement belongs to legal review rather than to a technical entry. Writing this down early avoids discovering a delivery constraint late in a project.
The fifth assumption concerns platform and compute environment. Native Linux is the primary environment; the Foundation packages Ubuntu 22.04, 24.04 and 26.04 for x86-64 and ARM64, and reaches Windows through WSL and macOS through Canonical Multipass using the same Ubuntu packages. Source packs must be compiled on a suitable Linux platform, and version 14 targets ISO/IEC 14882:2014, that is C++14, tested with GCC v5.5+ and Clang v14+. Container images ease reproduction, but the image digest must be written into dataset metadata alongside the version string, or the same case may yield slightly different fields six months later.
4. Getting Started
The path from zero to a first reproducible multiphysics result is short, and every step has a checkable acceptance point.
Start by freezing the environment: record the distribution line, the exact version, the compiler version and either the container image digest or the source-pack checksum. These four items are the anchors for all later reproduction work and matter more than running the first case. After loading the environment, begin from an official tutorial case rather than your own geometry, because a tutorial has known expected results and immediately reveals whether the toolchain is sound.
Meshing is where patience is required. Simple structures need only blockMesh followed by checkMesh. For complex geometry, place the STL in constant/triSurface, extract feature edges with surfaceFeatureExtract, build the background mesh with blockMesh, then run snappyHexMesh. Run it in stages: first with castellatedMesh only and inspect the cut-mesh quality, then with snapping to check non-orthogonality, and only then with addLayers to insert boundary layers. Run checkMesh after each stage, because the three stages fail differently and running them together yields only a generic error. In addLayersControls, relativeSizes, expansionRatio, finalLayerThickness and minThickness jointly determine layer quality; when layer thickness does not match the outer cell size the layers are silently skipped, the solve proceeds normally, and near-wall resolution is already insufficient.
Coupling requires translating the physical problem into a region decomposition. regionProperties declares region types, and interfaces pair through boundary types, typically a compressible coupled temperature condition on the fluid side and a coupled temperature condition on the solid side, with an additional thermal coupling where a wall field is involved. Property dictionaries sit per region: constant/<region>/physicalProperties and momentumTransport describe thermodynamics and turbulence, and constant/<region>/radiationProperties enables radiation where needed. The solid mesh may be considerably coarser, so mesh resources should be tilted towards the interface and towards regions of complex flow.
Solving proceeds region by region. Use chtMultiRegionSimpleFoam for steady cases and chtMultiRegionFoam for transient ones. The time step is constrained by all regions, and deltaT must keep the Courant number of the smallest region reasonable. Parallel multi-region runs carry one extra constraint: decomposePar must generate decomposition directories per region, the process count must match numberOfSubdomains, and the decomposition method should be coordinated across region meshes so that interfacial parallel communication does not become badly unbalanced.
The data-landing stage decides whether the result can reach downstream consumers. Configure function objects centrally under system/functions so that the sampling definition is identical on every run, and set the sampling interval explicitly, since writing at every time step produces far more data than required. Choose the export format to match the consumer: VTK for visual inspection, array-friendly field output for training pipelines, and the VTK-HDF output newly available in the OpenCFD v2606 line for lower parsing overhead and less duplication than the legacy XML format. The decisive step is packaging the case directory, fvSchemes, fvSolution, mesh identifier and version string together with the dataset, because shipping only arrays means handing over numbers nobody can trace.
5. Comparison with Alternatives
There are four comparable routes for a multiphysics pipeline, and they answer different questions.
The differences among the three OpenFOAM lines form one comparison in themselves. The Foundation line emphasises robustness, usability and extensibility, uses sequential numbering and is developed by CFD Direct with training provided. The OpenCFD line targets industrial scenarios, releases every two years, offers capabilities the Foundation mainline lacks such as overset meshing, and comes with full commercial support. foam-extend retains advanced features removed from other lines, focuses on fluid-structure interaction, turbomachinery and finite-area methods, and introduces general grid interpolation and block-coupled matrix support. All three are GPL v3, but they are not three packages of one product.
SU2 targets compressible aerodynamics and adjoint-based shape optimisation, with a complete gradient path that suits design optimisation, but its stock of multiphysics coupling and complex industrial cases is narrower than OpenFOAM's. FEniCS discretises variational forms with finite elements, making weak-form residuals and adjoint derivations natural for coupling problems phrased variationally, while finite volume holds the advantage where conservative flux across cell faces is the primary concern. JAX-CFD and PhiFlow are differentiable solvers whose value is a gradient through the simulation, serving solver-in-the-loop training and inverse problems rather than industrial multiphase and multi-region coupling. PhysicsNeMo sits on the physics-informed training side and can impose residual constraints without a labelled field, while NeuralOperator learns maps from coefficients or forcings to solution fields and needs a corpus produced by a CFD tool. Cantera combustion and battery thermal management each have their own specialised toolchains, and putting single-domain depth modelling into one pipeline comparison table misleads.
Coupling schemes form a second comparison. Multi-region coupling on a shared mesh, as in OpenFOAM conjugate heat transfer, is direct and makes interface conditions explicit, but demands geometry continuous across domains and manual balancing of mesh allocation. Immersed boundary methods embed the structure in the fluid mesh and avoid mesh matching, at the cost of extra immersed-surface handling and finer local refinement. Overset grids are mature for moving components, yet interpolation error and the spreading process need separate verification. Partitioned coupling runs independent solvers per domain, which is flexible but makes interface convergence and stability harder to guarantee. Which scheme to choose follows from geometric continuity, the strictness of the interface condition and whether mature per-domain solvers already exist, rather than from which one looks tidier in a paper.
6. Benchmarks and Evidence
Public evidence about OpenFOAM itself is mainly capability and process description, without a directly transferable performance multiplier. The Foundation release notes give feature lists and commit statistics: about 832 commits and 150 resolved issues for version 13, about 938 commits and 130 resolved issues for version 14. OpenCFD describes a quality-assurance system comprising several hundred daily unit tests, a medium-sized weekly battery and large industry-based testing before releases. These are capability and process statements, not measured speed-ups for any particular case.
GPU acceleration is the area attracting most attention and most misinterpretation. OpenCFD provides GPU offloading support for the first time in v2606, expressing parallel loops through C++17/20 std::execution policies, with memory placement managed by Umpire and changes confined to the operator layer so the user-facing API stays intact; testing covered AMD and NVIDIA unified-memory architectures with contributions from STFC and the University of Exeter. The same account lists explicit limits: there is no patch fusing, so each patch is handled separately and cases with many patches degrade noticeably; explicitly serial linear solvers such as DIC, DILU, GaussSeidel and symGaussSeidel are unsuitable and GAMG with a two-stage GaussSeidel smoother should be used instead; parallelisation introduces non-determinism in operation ordering, so CPU and GPU results differ slightly; CPU threading is not properly supported; GPU support is a compile-time option; and the work sits on a separate development branch intended for integration in v2612. Describing this as comprehensive GPU acceleration of OpenFOAM would be wrong: it is a compile-time option covering part of the code path, with clearly documented exclusion zones.
Quantitative evidence on coupled cases is especially scarce and must be produced locally, because such conclusions depend strongly on mesh, coupling boundary settings and region decomposition. A defensible protocol fixes the quantity of interest such as peak interfacial temperature, mean heat flux or total heat-balance error; runs a mesh-convergence study at no fewer than three resolutions and reports each; checks cross-region energy-balance closure; cross-validates against an independent case or analytical solution; and records mesh size and iteration history per region. Numbers obtained this way can actually be reviewed.
Dataset examples offer useful references. CFDBench and AirfRANS show how public CFD datasets organise geometric diversity, parameterisation and field layout, while PDEBench and The Well provide reference frameworks for protocol design and multi-geometry evaluation. These datasets are not produced by OpenFOAM alone and their numbers should not be quoted as an OpenFOAM baseline, but their metadata organisation is worth borrowing. The aerospace CFD case and the topology optimisation case on this site follow the same convention that any quoted figure must ship with its case directory and log.
7. Role in Physics-AI Workflows
Within a physics-AI pipeline, a multiphysics line earns its place in three places: generating physically consistent training corpora, supplying a reference field against which learned models can be checked, and acting as a fallback solver in hybrid deployment. The three impose different technical demands on the pipeline.
When generating corpora, multiphysics coupling creates a difficulty absent in single-domain work: the input parameter space becomes multidimensional and strongly coupled. Changing the geometry changes the mesh, which changes the interface area and the heat-transfer path; changing the operating point changes the phase distribution, which changes the coupling strength. Parameter sweeps therefore cannot range only over properties and boundary conditions; mesh topology has to be fixed as a controlled variable, or the differences inside the corpus will be mixed with discretisation error. The sound approach is to freeze a mesh-generation parameter set and refinement-region definition per geometry family, and to record the mesh identifier and refinement level in the metadata. Function objects should write the same set of quantities for every case, including any derived quantity used downstream in the loss.
Coupled cases also raise a sampling issue that is easy to overlook: the convergence history of a multi-region iteration oscillates at the interface across time steps, so a judgement of the form residuals-are-decreasing simply does not hold for a coupled case. Data selection should be based on physical quantities rather than solver internals, for instance interfacial heat-flux stationarity and regional energy-balance error, rather than taking the last few time steps by default.
When serving as a verification baseline, the reference solve should be stricter than the training corpus: finer mesh, tighter tolerance, longer iteration, and complete parameter separation from the training set. If the reference solve shares the same mesh and the same scheme dictionaries as the training corpus, the surrogate may be learning interpolation of that particular discretisation rather than physics. The trigger for routing a query back to the solver in hybrid deployment should likewise be a physical quantity: interfacial temperature exceeding a limit, an energy-balance residual above threshold, or a deviation in a cross-domain conservation measure all serve better than solver-internal variables.
The distinctive contribution of a coupled pipeline to physics AI is that it supplies multi-domain consistency samples which single-domain data cannot provide. Such samples matter particularly for models trained to be physically consistent rather than numerically smooth. The neural operator selection guide discusses the out-of-distribution failure modes, the fluid simulation toolkit and the multiphysics coupling collection gather the surrounding tooling, and the four ledgers of the cost boundary guide apply to every batch run of this kind.
8. Limitations and Failure Modes
Failures in a multiphysics pipeline are far quieter than in a single-domain one. When the conservative condition at the coupling interface is written incorrectly, the solve does not diverge and the temperature field looks smooth, but the overall energy balance does not close. When the solid conductivity is off by an order of magnitude, the interfacial temperature shifts substantially while the residual curve stays entirely normal. Only physical criteria catch such errors, which makes folding an energy-balance check into the automated pipeline the highest-return investment available here.
Meshes are the other high-incidence area. When snappyHexMesh fails to add layers the solve proceeds normally, near-wall resolution is in fact inadequate, and turbulence-model behaviour changes with no indication at all. Non-orthogonality introduced during snapping biases the diffusive term, and in high-Mach or strongly curved flows that bias is amplified. Running checkMesh after every mesh-generation stage and writing the diagnostics into dataset metadata is the only reliable practice.
Multiphase and reacting flows have failure modes that depend far more on modelling choices. Inter-phase interaction models, turbulence and phase-change coupling, and wall boiling and condensation models in multiphaseEuler and XiFluid all change results significantly, and these choices are hard to freeze across an entire corpus. Assembling cases with different inter-phase models does not produce a dataset; it produces an average of inconsistent physics. Combustion cases additionally face the coupling between chemical mechanism and numerical scheme: too large a mechanism step lets numerical error mask chemical error, and the mechanism itself may fall outside the target physics.
Version drift costs more in the multi-region setting. Three regions may depend on different conventions and solver behaviour across versions, so a single upgrade may shift the output of one region while the overall solve appears normal. Container digests, version strings and a frozen case template are the only effective mitigation, and the records in Section 9 give the concrete differences between the lines, which are precisely where a failure surfaces first when versions are not frozen.
A further class of failure belongs to the learned model rather than the solver. Models trained on multiphysics corpora tend to violate mass or energy conservation near phase-change interfaces, strong-gradient zones and multiphase regions: a data-driven loss does not enforce discrete conservation, and training samples are usually sparser in exactly those zones. When the deliverable must be certified, defended to a customer or used as a safety envelope, a fresh solver run with documented verification remains the only reference. If what a project needs is a gradient through the simulation rather than a corpus, a differentiable solver such as JAX-CFD is a different contract and should be evaluated separately.
9. Version and Source Notes
This section adjudicates conflicting statements in public material one by one, noting the source and evidence class for each, without forcing them into a single reconciled wording.
Record 1: an earlier version of this entry called OpenFOAM the de-facto standard of open-source CFD and the most widely deployed. The claim has no citable source, cannot be supported or refuted, and is withdrawn. The verifiable replacement statement is that OpenFOAM comprises three actively maintained code lines, all published under GPL v3, of which OpenCFD holds the trademark and the Foundation line is developed by CFD Direct.
Record 2: the earlier entry stated that the finite-volume framework covers heat transfer, combustion, multiphase and electromagnetics. Heat transfer, combustion and multiphase hold in the mainline; electromagnetics must be qualified by branch. OpenCFD lists electromagnetics among its coverage areas, whereas the Foundation mainline has no native electromagnetic solver. The community emFoam sits in the Extend-bazaar extension area and implements a frequency-domain block-coupled Maxwell solver based on a magnetic vector potential formulation originating in a 2019 master's thesis; as a third-party extension its compatibility is not guaranteed by the mainline maintainers.
Record 3: version lines and release cadence. The Foundation line uses sequential integer versions, with version 13 released in July 2025 and version 14 on 14 July 2026; official packaging includes snapshots such as 20260714, 20260724 and 20261008, and two public repositories are provided, OpenFOAM-dev for weekly builds that may break backward compatibility and OpenFOAM-14 for the release line. The OpenCFD line uses year-month versions with twice-yearly releases in June and December: v2512 on 4 November 2025 and v2606 in June 2026, with repositories moved to gitlab.com/openfoam on 4 November 2025. foam-extend is currently at 5.0.
Record 4: the capability list of version 14. Field functions and the functionalFixedValue boundary condition let non-uniform fields be initialised without preprocessing utilities such as setFields; units became a standard feature for input parameters, supported by the foamUnits utility and named dimensions; the coded file input framework was overhauled with new directives including #codeDict, #stream and #print; modular Lagrangian reached 80 percent completion; XiFluid was rewritten as a two-phase solver using the MULES multiphase approach; multiphaseEuler improved wall boiling and condensation and added sectional forces; and ParaView became more resilient when reading incorrect input. The release comprises about 938 commits and 130 resolved issues, targets C++14, and was tested with GCC v5.5+ and Clang v14+.
Record 5: the capabilities of v2606 and their boundaries. GPU offloading support appears for the first time, parallelising loops through C++17/20 std::execution policies, managing memory placement with Umpire and confining changes to the operator layer so the API stays intact, tested on AMD and NVIDIA unified-memory architectures. The same release adds the GEKO generalised two-equation turbulence model, the pybFoam and pyOFTools Python bindings, and VTK-HDF output. The limits must be recorded alongside: no patch fusing, explicitly serial linear solvers are unsuitable, parallelisation introduces non-determinism and thus small CPU/GPU differences, CPU threading support is incomplete, GPU support is a compile-time option, and the work currently sits on a separate development branch intended for integration in v2612.
Record 6: cross-branch compatibility of coupled cases is not a given. A third-party multi-region conjugate heat transfer tutorial, covering a fan with cooling fins and a light bulb with free convection and radiation, explicitly states that its case does not work on Foundation versions 4.0, 5.0, 6.0, 7.0 and similar. Multi-region dictionary conventions therefore differ substantively between branches, and running on another branch cannot be assumed.
Record 7: the licence boundary. The GPL v3 copyleft obligation triggers on distribution of derivative software, which is a different matter from publishing a case directory and computation results; whether a particular delivery constitutes distribution is a matter for legal review and is not concluded here. That all three lines publish under GPL v3 is confirmed by each upstream site.
Record 8: the year field is a cataloguing convenience, not a software version, and must not be quoted as a release date; an entry citing a release year should name the exact version and line.
Record 9: evidence classes. A project's own documentation describes capability and quality-assurance process, community tutorials describe concrete configuration and pitfalls, and independent benchmarks report timings for specific cases. The three are not interchangeable, and any figure quoted in a proposal should state which class it comes from.
Record 10: this entry is complementary to, and does not overlap with, the OpenFOAM tool entry on this site. The tool entry covers the solver itself; this one covers the industrial multiphysics pipeline and data supply. Where the two describe versions and licensing, each is bound by its own verification date, and both must be updated if upstream statements change.
All records were checked on 11 November 2026 against the openfoam.org release page and the version 13 and 14 release notes, the openfoam.com news page and the v2606 infrastructure notes, the Extend-bazaar entry on the OpenFOAM wiki, the official foam-extend page, and the version applicability statement in a third-party conjugate heat transfer tutorial. Material originating in a project's own documentation is labelled as official documentation and is not presented as independent validation.
10. References
- OpenFOAM Foundation, "OpenFOAM 14 Released", openfoam.org (checked 11 November 2026).
- OpenFOAM Foundation, "OpenFOAM release notes and version history", openfoam.org/release (checked 11 November 2026).
- OpenFOAM Foundation, "Download v14: Ubuntu, WSL, Multipass and source pack", openfoam.org/download (checked 11 November 2026).
- OpenCFD / Keysight, "OpenFOAM v2606: New and improved infrastructure", openfoam.com/news (checked 11 November 2026).
- OpenCFD / Keysight, "OpenFOAM release news and the repository move to gitlab.com/openfoam", openfoam.com (checked 11 November 2026).
- Wikki Ltd, "foam-extend project: features and release history", wikki.co.uk/index.php/foam-extend (checked 11 November 2026).
- OpenFOAMWiki, "Extend-bazaar / solvers / electromagnetics / emFoam", openfoamwiki.net (checked 11 November 2026).
- CFD Direct / Foundation, "Tutorial: the three-stage snappyHexMesh workflow and the structure of snappyHexMeshDict", official OpenFOAM tutorial (checked 11 November 2026).
- OpenFOAMWiki, "Getting started with chtMultiRegionFoam and the multi-region directory conventions", openfoamwiki.net (checked 11 November 2026).
- CFD Training, "OpenFOAM tutorial: Fan and Fins, conjugate heat transfer", cfd-training.com (checked 11 November 2026; the page states the case does not work on Foundation versions 4.0 to 7.0).
- CFD Training, "OpenFOAM tutorial: Light Bulb, free convection and radiation", cfd-training.com (checked 11 November 2026).
- DClaw Research, "The Cost Boundary of Classical Solvers: When Physics-AI Surrogates Actually Pay Off in 2026", site guide (11 November 2026).
- DClaw Research, "OpenFOAM tool entry: solver internals, cost accounting and failure modes", site entry (9 November 2026).