dualmesh-multiphysics 0.1.0__tar.gz

dualmesh_multiphysics-0.1.0/.clang-format

@@ -0,0 +1,13 @@
+# Based on the MOOSE framework style.
+BasedOnStyle: LLVM
+AlwaysBreakAfterReturnType: TopLevelDefinitions
+AlignAfterOpenBracket: Align
+AllowShortFunctionsOnASingleLine: Inline
+BinPackArguments: false
+BinPackParameters: false
+BreakBeforeBraces: Allman
+ColumnLimit: 100
+IndentWidth: 2
+PointerAlignment: Middle
+SpaceAfterCStyleCast: true
+Standard: c++17

dualmesh_multiphysics-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,116 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  cpp:
+    name: C++ (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DDUALMESH_BUILD_PYTHON=OFF
+      - name: Build
+        run: cmake --build build --config Release -j
+      - name: Test
+        run: ctest --test-dir build --build-config Release --output-on-failure
+
+  mpi:
+    name: MPI (1, 2, 3 and 4 processes)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install MPI and METIS
+        run: sudo apt-get update && sudo apt-get install -y libopenmpi-dev openmpi-bin libmetis-dev libeigen3-dev
+      - name: Configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DDUALMESH_BUILD_PYTHON=OFF -DDUALMESH_ENABLE_MPI=ON
+      - name: Build
+        run: cmake --build build -j
+      - name: Distributed tests
+        run: |
+          for n in 1 2 3 4; do
+            mpirun --oversubscribe -n $n ./build/dualmesh_parallel_tests
+          done
+
+  python:
+    name: Python ${{ matrix.python-version }} (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.9", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: pip install .[all,test]
+      - name: Verification suite
+        run: pytest -q
+      - name: Examples
+        run: |
+          python examples/cooling_fin.py
+          python examples/custom_kernel.py
+          python examples/functionally_graded_beam.py
+          python examples/transient_slab.py
+          python examples/natural_convection.py
+      - name: Command line
+        run: |
+          dualmesh --version
+          dualmesh list --module heat_transfer
+          dualmesh describe HeatConduction
+          cd examples && dualmesh run bus_bar.yaml
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install tools
+        run: pip install ruff
+      - name: Ruff
+        run: ruff check python tests examples
+      - name: clang-format
+        run: |
+          sudo apt-get update && sudo apt-get install -y clang-format
+          find include src python/bindings tests/cpp -name '*.h' -o -name '*.cpp' \
+            | xargs clang-format --dry-run --Werror
+
+  docs:
+    name: Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Install
+        run: |
+          sudo apt-get update && sudo apt-get install -y libeigen3-dev
+          pip install .[docs,all]
+      - name: Build documentation
+        run: sphinx-build -b html docs docs/_build/html
+      - uses: actions/upload-artifact@v4
+        with:
+          name: documentation
+          path: docs/_build/html

dualmesh_multiphysics-0.1.0/.github/workflows/wheels.yml

@@ -0,0 +1,63 @@
+name: Wheels
+
+# Binary wheels, so that `pip install dualmesh-multiphysics` needs no compiler.
+#
+# The wheels are built on every tag that starts with "v" and on demand, and are
+# kept as workflow artifacts.  Publishing to PyPI is the last job; it runs only
+# for a tag, and uses PyPI's trusted publishing, which has to be enabled once
+# for the repository on pypi.org (Publishing -> Add a new publisher) before the
+# first release.
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+jobs:
+  wheels:
+    name: Wheels (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-15-intel, macos-14, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pypa/cibuildwheel@v4.2.1
+        env:
+          CIBW_BUILD: "cp39-* cp310-* cp311-* cp312-* cp313-*"
+          CIBW_SKIP: "*-musllinux_* *-win32 *-manylinux_i686"
+          CIBW_TEST_EXTRAS: "test"
+          CIBW_TEST_COMMAND: >-
+            pytest {project}/tests/python -q -x
+            --ignore={project}/tests/python/test_mms.py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  sdist:
+    name: Source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  publish:
+    name: Publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

dualmesh_multiphysics-0.1.0/.gitignore

@@ -0,0 +1,44 @@
+# build artefacts
+build/
+build-*/
+_build/
+dist/
+*.egg-info/
+*.so
+*.pyd
+*.dylib
+*.o
+*.a
+CMakeCache.txt
+CMakeFiles/
+
+# python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+.venv/
+venv/
+
+# results
+*.vtu
+*.pvtu
+*.pvd
+*.csv
+*.e
+*.exo
+!examples/**/*.csv
+
+# editors and systems
+.vscode/
+.idea/
+.DS_Store
+
+# OpenFOAM cases
+verification/openfoam/run/
+
+# generated by the documentation build
+docs/objects.rst
+
+# generated when the documentation is built
+docs/syntax/

dualmesh_multiphysics-0.1.0/.readthedocs.yaml

@@ -0,0 +1,28 @@
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+  apt_packages:
+    - cmake
+    - libeigen3-dev
+  jobs:
+    post_checkout:
+      - git fetch --unshallow || true
+
+python:
+  install:
+    - method: pip
+      path: .
+      extra_requirements:
+        - docs
+        - all
+
+sphinx:
+  configuration: docs/conf.py
+  fail_on_warning: false
+
+formats:
+  - pdf
+  - htmlzip

dualmesh_multiphysics-0.1.0/CHANGELOG.md

@@ -0,0 +1,167 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project uses
+[semantic versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+dualmesh is now described, and organised, as what it is: a multiphysics
+framework for heat transfer, solid mechanics and fluid dynamics, in which the
+finite element method, two finite volume methods and the dual mesh control
+domain method are four discretisations of one problem description.
+
+### Added
+
+- **Four new element types**: the serendipity `Quad8` and `Hex20`, the
+  triangular prism `Wedge6` and the pyramid `Pyramid5` (with Bedrosian's
+  rational basis). Meshes may mix types freely. Every type works with the
+  finite element and cell-centred finite volume methods; the dual mesh and
+  vertex-centred methods, which need node-centred control domains, accept the
+  prism (whose dual is the triangle's median dual times a half-segment) and
+  refuse the serendipity elements and the pyramid with the reason and the
+  methods that do accept them. `Mesh.second_order(serendipity=True)`,
+  generators for all four, uniform refinement of prisms and pyramids, and
+  meshio reading and writing.
+- **Systematic verification by manufactured solutions**: `dualmesh.mms`
+  derives the forcing of a chosen solution symbolically (diffusion,
+  advection, reaction, time derivative, linear elasticity; Cartesian,
+  axisymmetric and spherical) and runs convergence studies;
+  `Problem.error_norms` measures the L2 error and the H1 seminorm. The suite
+  runs 161 studies and every observed order matches the theory of its method.
+- **Coupled heat transfer and flow**: `HeatConvection` (the flow carries the
+  heat) and `BoussinesqBuoyancy` (the temperature drives the flow), with
+  `physics.add_boussinesq_buoyancy`. The natural convection benchmark of de
+  Vahl Davis is reproduced to within 0.2 % in the Nusselt number
+  (`examples/natural_convection.py`).
+- **Overlapping Schwarz**: the distributed preconditioners now work on
+  subdomains that overlap by `overlap` layers of elements (default 1), with
+  fully assembled subdomain matrices exchanged between ranks, an exact or
+  incomplete subdomain solve (`subdomain_solver`), and the two levels combined
+  multiplicatively. The iteration count of the default no longer grows with
+  the number of processes: 23 to 25 iterations from 1 to 16 ranks on a 48 by 48
+  Poisson problem. With `linear_solver="cg"` the symmetric (classical) forms
+  are used.
+- **Automatic linear solver** (`linear_solver="automatic"`, the new default):
+  a direct factorisation where it is cheap and BiCGSTAB with a new ILU(0)
+  preconditioner where it is not, falling back to the direct solver if the
+  iteration fails. Also `"gmres"` and the `preconditioner` option (`ilu`,
+  `ilut`, `jacobi`, `none`). On a three-dimensional elasticity system of 36 000
+  unknowns the solve fell from 18 s to 0.3 s.
+- `Problem.linear_system()` returns the residual and the Jacobian as NumPy and
+  SciPy objects, for use with other solvers.
+- Expressions are compiled by a C++ parser (`ParsedFunction`), and a string
+  that is not the name of a registered function is compiled as an expression.
+- The command-line driver runs an input file under `mpirun` with the
+  distributed solver (configured by a `parallel` block), accepts `threads`, and
+  refuses an unknown block or setting with a suggestion.
+- "Did you mean" suggestions for misspelled object types, parameters,
+  variables, boundaries, blocks and solver options.
+- A continuous-integration job that runs the distributed tests on 1 to 4
+  processes, and a workflow that builds binary wheels.
+- Documentation: a scope chapter that defines the package as a multiphysics
+  framework and compares it honestly with MOOSE and COMSOL; a
+  manufactured-solutions chapter; the new elements, solvers and
+  preconditioners; the current MOOSE citation (MOOSE 4.0, 2025).
+
+### Changed
+
+- **The structural module is merged into solid mechanics.** Beams and plates
+  are the reduced theories of solid mechanics and are now registered in the
+  `solid_mechanics` module, next to continuum elasticity.
+- **The default distributed preconditioner is `two_level_schwarz` with an
+  overlap of one element layer** (it was `jacobi`).
+- **The cell-centred finite volume method has an exact Jacobian**: the
+  non-orthogonal correction is differentiated through the least-squares
+  stencils instead of being lagged, so Newton's method converges
+  quadratically on skewed meshes.
+- **Efficiency**: element geometry is mapped once per integration point and
+  reference-element data are cached; the derivative arrays of the automatic
+  differentiation are copied only as far as they are used and their loops
+  vectorise; symmetric quadrature rules on triangles, tetrahedra and prisms
+  replace the collapsed tensor rules for the finite element method (8 points
+  instead of 27 on a tetrahedron); Gauss rules are tabulated. On the bundled
+  benchmark (three-dimensional elasticity on 8000 `Hex8` elements) the
+  assembly of every method is about three times faster on one thread; the
+  Python test suite runs in about 60 % of its former time.
+- All element types use the VTK node numbering, so files need no permutation.
+- Package metadata points to the GitHub repository.
+
+### Fixed
+
+- **The θ-method evaluated the old part of the residual at the new time**,
+  which cost Crank-Nicolson its second order whenever a coefficient or a
+  source depends on time (serial and distributed).
+- **The Schwarz preconditioners factorised each rank's partial local matrix**
+  instead of the fully assembled subdomain matrix, which is why they stopped
+  converging at eight ranks.
+- **The penalty formulation of incompressible flow locked on the
+  vertex-centred finite volume method**: the two-point gradient correction was
+  applied to the reduced-integration term. It is no longer, and the
+  cell-centred method, on which the formulation cannot work, now refuses it.
+- **A compiled expression passed as a parameter was evaluated through
+  Python**, because pybind11's function test is Python's `callable()`, which
+  also serialised the assembly onto one thread.
+- **Thermal stress in plane strain was wrong by a factor of `1 + nu`.** The
+  stiffness matrix left the out-of-plane column empty, so the thermal strain
+  subtracted from the out-of-plane normal strain never reached the in-plane
+  rows. For a fully restrained body the code gave
+  `E alpha dT / [(1 + nu)(1 - 2 nu)]` where the correct value is
+  `E alpha dT / (1 - 2 nu)`. Plane stress was unaffected.
+- **A Python callable passed directly to a parameter no longer deadlocks the
+  threaded assembly.**
+- **The cell-centred finite volume method is refused by the distributed
+  solver** instead of returning a wrong answer.
+- **The distributed BiCGSTAB detects near-breakdown and restarts.**
+- The Python test suite no longer imports the source tree instead of the
+  installed package when the extension has not been built in place.
+
+### Earlier unreleased work
+
+- **Quadratic elements** `Edge3`, `Tri6`, `Quad9`, `Tet10` and `Hex27`, with
+  the dual mesh built for each; **adaptive mesh refinement** by gradient
+  recovery, marking and longest-edge bisection; the automatic quadrature
+  order; `DUALMESH_MAX_AD_DERIVATIVES`; the manual reorganised into a user
+  guide and a theory manual with every method cited to its primary source.
+
+## [0.1.0] - 2026-09-18
+
+The first release: the framework, five physics modules, and a verification
+suite that reproduces the published results of Reddy's book.
+
+### Added
+
+- **Framework**: the canonical conservation form `-div F + S = 0`; the median
+  dual mesh for `Edge2`, `Tri3`, `Quad4`, `Tet4` and `Hex8`; assembly for the
+  dual mesh control domain method and for the Galerkin finite element method
+  from the same kernels; forward-mode automatic differentiation for exact
+  Jacobians; per-kernel quadrature (Gauss, midpoint, trapezoid, Simpson,
+  nodal, interface, control-domain trapezoid) and selective reduced
+  integration; Cartesian, axisymmetric and spherical coordinates; blocks
+  (subdomains), side sets and node sets.
+- **Solvers**: Newton's method, direct (Picard) iteration with relaxation,
+  load stepping, steady and transient (θ-method) executioners, sparse LU,
+  BiCGSTAB and conjugate gradient linear solvers.
+- **Heat transfer module**: conduction with temperature-dependent
+  conductivity, volumetric heating, heat capacity, convective, radiative and
+  prescribed-flux boundary conditions.
+- **Solid mechanics module**: linear elasticity (plane stress, plane strain,
+  axisymmetric, three-dimensional), traction and pressure boundary conditions,
+  stress and strain as material properties.
+- **Structural module**: mixed Euler–Bernoulli beam, displacement and mixed
+  Timoshenko beams, first-order axisymmetric circular plate, first-order
+  rectangular plate, functionally graded sections, von Kármán nonlinearity.
+- **Fluids module**: penalty formulation of the Stokes and Navier–Stokes
+  equations with recovered pressure.
+- **Meshing**: line, rectangle, box and annulus generators with graded
+  spacing, uniform refinement, geometric side sets and node sets, and readers
+  and writers for Gmsh, Exodus, VTK, Abaqus and the other formats meshio
+  supports.
+- **Python interface**: `Problem`, mesh generators, physics helpers,
+  post-processing, functionally graded stiffness formulas, and base classes
+  for kernels, boundary conditions and materials written in Python.
+- **Command line**: `dualmesh run input.yaml`, `dualmesh list`,
+  `dualmesh describe <type>`.
+- **Verification**: the published dual mesh results of Chapters 3, 5, 6, 7, 8,
+  9 and 10 of Reddy's book, plus patch tests, conservation tests and
+  cross-verification against OpenFOAM.

dualmesh_multiphysics-0.1.0/CITATION.cff

@@ -0,0 +1,37 @@
+cff-version: 1.2.0
+title: "dualmesh: a multiphysics framework for heat transfer, solid mechanics and fluid dynamics"
+message: "If you use this software, please cite both the software and the method (see references)."
+type: software
+version: 0.1.0
+license: LGPL-2.1-or-later
+repository-code: "https://github.com/MohamedAbdulHameed/dualmesh"
+url: "https://dualmesh.readthedocs.io"
+abstract: >-
+  dualmesh is a multiphysics framework for heat transfer, solid mechanics and
+  fluid dynamics. Coupled problems are solved monolithically by Newton's method
+  with exact Jacobians from automatic differentiation, and the same problem
+  definition is discretised by the Galerkin finite element method, the
+  vertex-centred or cell-centred finite volume method, or the dual mesh control
+  domain method (DMCDM) of J. N. Reddy. The library is written in
+  C++17 with Python bindings, is organized as a modular framework of kernels,
+  boundary conditions and materials, and is verified against the published
+  results of Reddy's book and against OpenFOAM.
+keywords:
+  - dual mesh control domain method
+  - finite element method
+  - finite volume method
+  - fluid dynamics
+  - solid mechanics
+  - heat transfer
+  - multiphysics
+authors:
+  - name: "The dualmesh developers"
+references:
+  - type: book
+    title: "Computational Methods in Engineering: Finite Difference, Finite Volume, Finite Element, and Dual Mesh Control Domain Methods"
+    authors:
+      - family-names: Reddy
+        given-names: "J. N."
+    publisher:
+      name: "CRC Press"
+    year: 2024

dualmesh_multiphysics-0.1.0/CMakeLists.txt

@@ -0,0 +1,141 @@
+cmake_minimum_required(VERSION 3.18)
+project(dualmesh VERSION 0.1.0 LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Build type" FORCE)
+endif()
+
+option(DUALMESH_BUILD_PYTHON "Build the Python extension module" ON)
+option(DUALMESH_BUILD_TESTS "Build the C++ unit tests" ON)
+option(DUALMESH_ENABLE_OPENMP "Thread the assembly loops with OpenMP" ON)
+option(DUALMESH_ENABLE_MPI "Build the distributed (MPI) solver" OFF)
+option(DUALMESH_ENABLE_METIS "Use METIS for mesh partitioning when available" ON)
+# Automatic differentiation seeds one derivative slot per element node and
+# variable, so the default of 48 covers, for example, Quad9 with five fields,
+# Hex8 with six and Hex27 with one.  Raise it for a multi-field problem on a
+# Hex27 mesh; every ADReal grows with it, so raising it costs memory and
+# assembly time everywhere.
+set(DUALMESH_MAX_AD_DERIVATIVES 48 CACHE STRING
+    "Maximum seeded derivatives per element (nodes per element x variables)")
+
+# ---- dependencies ---------------------------------------------------------
+# Eigen is header-only.  A system installation is used when there is one
+# (macOS: `brew install eigen`; Debian/Ubuntu: `apt install libeigen3-dev`);
+# otherwise the headers are downloaded into the build tree.
+find_package(Eigen3 3.3 QUIET NO_MODULE)
+if(NOT Eigen3_FOUND)
+  set(DUALMESH_EIGEN_VERSION 3.4.0)
+  set(DUALMESH_EIGEN_DIR ${CMAKE_BINARY_DIR}/_deps/eigen-${DUALMESH_EIGEN_VERSION})
+  if(NOT EXISTS ${DUALMESH_EIGEN_DIR}/Eigen/Dense)
+    set(DUALMESH_EIGEN_ARCHIVE ${CMAKE_BINARY_DIR}/_deps/eigen.tar.gz)
+    message(STATUS "Eigen not found; downloading Eigen ${DUALMESH_EIGEN_VERSION}")
+    file(DOWNLOAD
+      https://gitlab.com/libeigen/eigen/-/archive/${DUALMESH_EIGEN_VERSION}/eigen-${DUALMESH_EIGEN_VERSION}.tar.gz
+      ${DUALMESH_EIGEN_ARCHIVE}
+      EXPECTED_HASH SHA256=8586084f71f9bde545ee7fa6d00288b264a2b7ac3607b974e54d13e7162c1c72
+      STATUS DUALMESH_EIGEN_DOWNLOAD)
+    list(GET DUALMESH_EIGEN_DOWNLOAD 0 DUALMESH_EIGEN_DOWNLOAD_CODE)
+    if(NOT DUALMESH_EIGEN_DOWNLOAD_CODE EQUAL 0)
+      list(GET DUALMESH_EIGEN_DOWNLOAD 1 DUALMESH_EIGEN_DOWNLOAD_MESSAGE)
+      message(FATAL_ERROR
+        "Could not download Eigen (${DUALMESH_EIGEN_DOWNLOAD_MESSAGE}).\n"
+        "Install it instead — 'brew install eigen' on macOS, "
+        "'apt install libeigen3-dev' on Debian or Ubuntu — or point CMake at an "
+        "existing copy with -DEigen3_DIR=<path to the Eigen3 CMake package>.")
+    endif()
+    file(ARCHIVE_EXTRACT INPUT ${DUALMESH_EIGEN_ARCHIVE}
+         DESTINATION ${CMAKE_BINARY_DIR}/_deps)
+  endif()
+  add_library(Eigen3::Eigen INTERFACE IMPORTED)
+  set_target_properties(Eigen3::Eigen PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES ${DUALMESH_EIGEN_DIR})
+endif()
+
+# ---- optional parallel dependencies ------------------------------------------
+# OpenMP threads the element assembly loop; it is optional, and without it the
+# library builds and runs exactly as before, on one thread.
+if(DUALMESH_ENABLE_OPENMP)
+  find_package(OpenMP COMPONENTS CXX QUIET)
+  if(NOT OpenMP_CXX_FOUND)
+    message(STATUS "OpenMP not found; the assembly will run on one thread")
+  endif()
+endif()
+
+# METIS gives better partitions than the built-in geometric partitioner for
+# unstructured meshes.  It is what libMesh, and therefore MOOSE, uses.
+if(DUALMESH_ENABLE_METIS)
+  find_path(METIS_INCLUDE_DIR metis.h)
+  find_library(METIS_LIBRARY NAMES metis)
+  if(METIS_INCLUDE_DIR AND METIS_LIBRARY)
+    message(STATUS "METIS found: ${METIS_LIBRARY}")
+  else()
+    message(STATUS "METIS not found; using the built-in mesh partitioners")
+  endif()
+endif()
+
+if(DUALMESH_ENABLE_MPI)
+  find_package(MPI COMPONENTS CXX REQUIRED)
+endif()
+
+# ---- core library ------------------------------------------------------------
+file(GLOB_RECURSE DUALMESH_SOURCES CONFIGURE_DEPENDS ${PROJECT_SOURCE_DIR}/src/*.cpp)
+add_library(dualmesh_core STATIC ${DUALMESH_SOURCES})
+target_include_directories(dualmesh_core PUBLIC ${PROJECT_SOURCE_DIR}/include)
+target_link_libraries(dualmesh_core PUBLIC Eigen3::Eigen)
+target_compile_definitions(dualmesh_core
+                           PUBLIC DUALMESH_MAX_AD_DERIVATIVES=${DUALMESH_MAX_AD_DERIVATIVES})
+if(MSVC)
+  target_compile_options(dualmesh_core PRIVATE /W3 /bigobj)
+  target_compile_definitions(dualmesh_core PUBLIC _USE_MATH_DEFINES)
+else()
+  target_compile_options(dualmesh_core PRIVATE -Wall -Wextra -Wno-unused-parameter)
+endif()
+if(DUALMESH_ENABLE_OPENMP AND OpenMP_CXX_FOUND)
+  target_link_libraries(dualmesh_core PUBLIC OpenMP::OpenMP_CXX)
+endif()
+if(DUALMESH_ENABLE_METIS AND METIS_INCLUDE_DIR AND METIS_LIBRARY)
+  target_include_directories(dualmesh_core PRIVATE ${METIS_INCLUDE_DIR})
+  target_link_libraries(dualmesh_core PRIVATE ${METIS_LIBRARY})
+  target_compile_definitions(dualmesh_core PRIVATE DUALMESH_HAVE_METIS)
+endif()
+if(DUALMESH_ENABLE_MPI)
+  target_link_libraries(dualmesh_core PUBLIC MPI::MPI_CXX)
+  target_compile_definitions(dualmesh_core PUBLIC DUALMESH_HAVE_MPI)
+endif()
+
+# ---- command-line driver --------------------------------------------------------
+# (the Python package provides the full input-file driver: `dualmesh run input.yaml`)
+
+# ---- tests ---------------------------------------------------------------------
+if(DUALMESH_BUILD_TESTS)
+  enable_testing()
+  add_executable(dualmesh_unit_tests tests/cpp/unit_tests.cpp)
+  target_link_libraries(dualmesh_unit_tests PRIVATE dualmesh_core)
+  add_test(NAME unit_tests COMMAND dualmesh_unit_tests)
+  add_executable(dualmesh_benchmark tests/cpp/benchmark.cpp)
+  target_link_libraries(dualmesh_benchmark PRIVATE dualmesh_core)
+  add_executable(dualmesh_parallel_tests tests/cpp/parallel_tests.cpp)
+  target_link_libraries(dualmesh_parallel_tests PRIVATE dualmesh_core)
+  add_test(NAME parallel_tests COMMAND dualmesh_parallel_tests)
+endif()
+
+# ---- Python module ---------------------------------------------------------------
+if(DUALMESH_BUILD_PYTHON)
+  find_package(Python 3.8 COMPONENTS Interpreter Development.Module REQUIRED)
+  find_package(pybind11 CONFIG QUIET)
+  if(NOT pybind11_FOUND)
+    execute_process(COMMAND ${Python_EXECUTABLE} -m pybind11 --cmakedir
+                    OUTPUT_VARIABLE pybind11_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
+    find_package(pybind11 CONFIG REQUIRED)
+  endif()
+  pybind11_add_module(_core MODULE python/bindings/module.cpp)
+  target_link_libraries(_core PRIVATE dualmesh_core)
+  if(SKBUILD)
+    install(TARGETS _core LIBRARY DESTINATION dualmesh)
+  else()
+    set_target_properties(_core PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/python/dualmesh)
+  endif()
+endif()

dualmesh_multiphysics-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,62 @@
+# Contributing to dualmesh
+
+Thank you for considering a contribution. This document explains how to build
+the project, what is expected of a change, and how the code is organized.
+
+## Building and testing
+
+```console
+git clone https://github.com/MohamedAbdulHameed/dualmesh.git
+cd dualmesh
+pip install -e .[all,test]
+
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j
+ctest --test-dir build --output-on-failure   # C++ unit tests
+pytest                                       # verification suite
+```
+
+`cmake --build` also places the Python extension in `python/dualmesh`, so
+`PYTHONPATH=$PWD/python` is enough to use the package from a source tree.
+
+## What a change should include
+
+- **Tests.** New physics needs a verification case with a reference value that
+  comes from somewhere trustworthy: a published table (cite it in a comment,
+  as the existing tests do), an analytical solution, or a convergence study.
+  Bug fixes need a test that fails before the fix.
+- **Documentation.** New objects are documented by their own parameter
+  descriptions (`addRequired`/`addOptional` and `setClassDescription`), which
+  is what `dualmesh describe` and the object reference in the documentation
+  print. Anything conceptually new belongs in `docs/theory.rst` as well.
+- **A note in `CHANGELOG.md`** under "Unreleased".
+
+## Style
+
+- C++ follows the MOOSE conventions: two-space indentation, `_member`
+  variables, `camelCase` functions, `PascalCase` types, `.clang-format` in the
+  repository root (`clang-format -i` before committing).
+- Python follows PEP 8 with descriptive, unabbreviated names: `num_elements`,
+  `thermal_conductivity`, `transverse_displacement` — not `ne`, `k`, `w`.
+  `ruff check python tests` and `ruff format` are configured in
+  `pyproject.toml`.
+- Parameter names in `validParams` are the user interface: spell them out, and
+  give each one a sentence that explains what it means physically.
+
+## Adding physics
+
+A kernel supplies a flux, a source, or both, for the canonical form
+`-div F + S = 0`; see `docs/developing.rst` for a worked example and for how
+registration works. Prototyping in Python (`dm.PythonKernel`) is encouraged:
+the interface is the same, so a model that works can be moved to C++ almost
+unchanged.
+
+## Reporting problems
+
+Please open an issue with the smallest input that reproduces the behaviour, the
+version (`python -c "import dualmesh; print(dualmesh.__version__)"`), and the
+platform. A failing test case is the most useful bug report of all.
+
+## Licence
+
+Contributions are accepted under the LGPL-2.1-or-later licence of the project.