Metadata-Version: 2.5
Name: pymhm
Version: 1.3.0
Summary: Composable multiscale hybrid mixed finite element methods
Project-URL: Homepage, https://github.com/ipes-lncc/pymhm
Project-URL: Documentation, https://ipes-lncc.github.io/pymhm/
Project-URL: Repository, https://github.com/ipes-lncc/pymhm
Project-URL: Issues, https://github.com/ipes-lncc/pymhm/issues
Author-email: Diego Volpatto <volpatto@lncc.br>
License-Expression: LGPL-2.1-only
License-File: LICENSE
Keywords: brinkman,darcy,finite-elements,hybrid-mixed,multiscale,scientific-computing
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Science/Research
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Scientific/Engineering :: Mathematics
Classifier: Typing :: Typed
Requires-Python: <3.14,>=3.11
Requires-Dist: fenics-basix>=0.9
Requires-Dist: numpy>=1.26
Requires-Dist: scipy>=1.12
Requires-Dist: threadpoolctl>=3.2
Provides-Extra: amg
Requires-Dist: pyamg>=5.3; extra == 'amg'
Provides-Extra: gpu
Requires-Dist: cupy-cuda12x>=13; (sys_platform == 'linux' or sys_platform == 'win32') and extra == 'gpu'
Requires-Dist: nvmath-python[cu12]<1.1,>=1.0; (sys_platform == 'linux' or sys_platform == 'win32') and extra == 'gpu'
Provides-Extra: intel
Requires-Dist: pypardiso>=0.4; ((sys_platform == 'linux' or sys_platform == 'win32') and (platform_machine == 'x86_64' or platform_machine == 'AMD64')) and extra == 'intel'
Provides-Extra: meshing
Requires-Dist: gmsh>=4.13; extra == 'meshing'
Requires-Dist: meshio>=5.3; extra == 'meshing'
Requires-Dist: netgen-mesher>=6.2; extra == 'meshing'
Provides-Extra: mpi
Requires-Dist: mpi4py>=4; extra == 'mpi'
Provides-Extra: notebooks
Requires-Dist: ipykernel>=6.29; extra == 'notebooks'
Requires-Dist: jupyterlab>=4; extra == 'notebooks'
Requires-Dist: matplotlib>=3.8; extra == 'notebooks'
Requires-Dist: meshio>=5.3; extra == 'notebooks'
Requires-Dist: nbclient>=0.10; extra == 'notebooks'
Requires-Dist: nbconvert>=7; extra == 'notebooks'
Requires-Dist: nbformat>=5.10; extra == 'notebooks'
Requires-Dist: pyamg>=5.3; extra == 'notebooks'
Requires-Dist: pyvista<0.50,>=0.46; extra == 'notebooks'
Requires-Dist: vtk<9.7,>=9.5; extra == 'notebooks'
Provides-Extra: visualization
Requires-Dist: matplotlib>=3.8; extra == 'visualization'
Requires-Dist: pyvista<0.50,>=0.46; extra == 'visualization'
Requires-Dist: vtk<9.7,>=9.5; extra == 'visualization'
Description-Content-Type: text/markdown

# PyMHM

<p align="center">
  <img src="https://raw.githubusercontent.com/ipes-lncc/pymhm/main/docs/assets/branding/pymhm-logo-readme.png" width="720" alt="PyMHM — Composable Multiscale Hybrid Mixed finite element methods in Python">
</p>

[![Tests](https://github.com/ipes-lncc/pymhm/actions/workflows/tests.yml/badge.svg)](https://github.com/ipes-lncc/pymhm/actions/workflows/tests.yml)
[![Coverage](https://codecov.io/github/ipes-lncc/pymhm/branch/main/graph/badge.svg)](https://app.codecov.io/github/ipes-lncc/pymhm)
[![Lint and Quality](https://github.com/ipes-lncc/pymhm/actions/workflows/lint-and-quality.yml/badge.svg)](https://github.com/ipes-lncc/pymhm/actions/workflows/lint-and-quality.yml)
[![Docs](https://github.com/ipes-lncc/pymhm/actions/workflows/docs.yml/badge.svg)](https://ipes-lncc.github.io/pymhm/)
[![Publish to PyPI](https://github.com/ipes-lncc/pymhm/actions/workflows/publish-pypi.yml/badge.svg)](https://github.com/ipes-lncc/pymhm/actions/workflows/publish-pypi.yml)
[![Version: 1.3.0](https://img.shields.io/badge/version-1.3.0-21918c.svg)](https://github.com/ipes-lncc/pymhm/blob/main/pyproject.toml)
[![Python: 3.11–3.13](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-3776ab.svg)](https://github.com/ipes-lncc/pymhm/blob/main/pyproject.toml)
[![Supported OS](https://img.shields.io/badge/OS-Linux%20%7C%20macOS%20%7C%20Windows-3776ab.svg)](https://github.com/ipes-lncc/pymhm/actions/workflows/tests.yml)
[![License: LGPL-2.1-only](https://img.shields.io/badge/license-LGPL--2.1--only-440154.svg)](https://github.com/ipes-lncc/pymhm/blob/main/LICENSE)

`pymhm` couples user-defined local and global variational equations through
explicitly oriented trace coordinates. Declare the forms, choose a local
provider, then call `assemble` or `solve`. Scalar, vector and mixed fields use
the same interface; a local operator can itself be another multiscale problem.
NumPy/SciPy coefficients and optional FEniCS/UFL forms share this contract.
Basix supplies finite-element bases and tabulation.

Version 1.3.0 is an official release of PyMHM. Built-in workflows
include triangular and polygonal meshes, Cartesian quadrilaterals, tetrahedra,
affine prisms, star-shaped polyhedra and mapped hexahedra. Available equations and approximation
spaces depend on the geometry; the documentation states each verified scope
and distinguishes it from extensions described in the literature.

## Available Methods

Choose the variational method and its admissible approximation spaces independently
of the linear solver and execution backend. **When publishing results obtained
with PyMHM, cite the original publications of every method, reconstruction or
estimator used**, together with the PyMHM version. The [Theoretical Background](docs/theory.md) states degree, geometry and regularity
conditions; each linked tutorial follows the mathematical formulation in code.

| Method | Original publication |
| --- | --- |
| [Primal MHM](docs/tutorials/methods/primal-mhm.md) | [Harder et al. (2013)](https://doi.org/10.1016/j.jcp.2013.03.019) |
| [Mixed H(div) MHM](docs/tutorials/methods/mixed-mhm.md) | [Durán et al. (2019)](https://doi.org/10.1016/j.cma.2019.05.013) |
| [Robin MH](docs/tutorials/methods/robin-mh.md) | [Barrenechea et al. (2024)](https://doi.org/10.1137/22M1542556) |
| [MH²M](docs/tutorials/methods/mh2m.md) | [de Barros et al. (2026, v3)](https://arxiv.org/abs/2404.16978v3) |
| [MsHHO](docs/tutorials/methods/mshho.md) | [Cicuttin, Ern and Lemaire (2019)](https://doi.org/10.1515/cmam-2018-0013); [MHM connection (2022)](https://doi.org/10.1051/m2an/2021082) |
| [Petrov–Galerkin MHM](docs/tutorials/methods/pgmhm.md) | [Fernando et al. (2023)](https://doi.org/10.1007/s40314-023-02304-y) |
| [MHM-USFEM (MHM-UNUSUAL)](docs/tutorials/methods/mhm-usfem.md) | [Santiago et al. (CILAMCE 2025)](https://doi.org/10.55592/cilamce2025.v5i.14270) |
| [Stokes–Brinkman MHM](docs/tutorials/methods/stokes-brinkman.md) | [Araya et al. (2017)](https://doi.org/10.1016/j.cma.2017.05.027) |
| [Oseen MHM](docs/tutorials/methods/oseen.md) | [Araya et al. (2021)](https://doi.org/10.1007/s10444-020-09833-8) |
| [Primal elasticity MHM](docs/tutorials/methods/primal-elasticity.md) | [Harder et al. (2016)](https://doi.org/10.1051/m2an/2015046) |
| [GaLS elasticity MHM](docs/tutorials/methods/gals-elasticity.md) | [Gomes et al. (2024, v1)](https://arxiv.org/abs/2403.16890v1) |
| [Mixed stress elasticity MHM](docs/tutorials/methods/mixed-elasticity.md) | [Devloo et al. (2021)](https://doi.org/10.1051/m2an/2021013) |
| [Conservative transport MHM](docs/tutorials/methods/transient-transport.md) | [Harder et al. (2015)](https://doi.org/10.1137/130938499) |
| [Elastodynamic MHM](docs/tutorials/methods/elastodynamics.md) | [Gomes et al. (2017)](https://doi.org/10.20906/CPS/CILAMCE2017-0399) |
| [Helmholtz MHM](docs/tutorials/methods/helmholtz.md) | [Chaumont-Frelet and Valentin (2020)](https://doi.org/10.1137/19M1255616) |
| [Maxwell MHM](docs/tutorials/methods/maxwell.md) | [Lanteri et al. (2018)](https://doi.org/10.1137/16M110037X) |
| [Unfitted/face-refined MHM](docs/tutorials/methods/unfitted.md) | [Chaumont-Frelet et al. (2026)](https://doi.org/10.1016/j.camwa.2026.01.016) |

Recovery and adaptive strategies complement those discretizations:

| Strategy | Purpose | Original analysis |
| --- | --- | --- |
| [Flux and potential recovery](docs/tutorials/methods/flux-recovery.md) | RT0 equilibration, moment H(div) reconstruction and conforming potentials | [Barrenechea et al. (2026)](https://doi.org/10.1137/24M1673073) |
| [Error indicators](docs/tutorials/methods/error-indicators.md) | Field-specific residual and reconstructed-energy diagnostics | [Araya et al. (2013)](https://doi.org/10.1137/120888223) |
| [Adaptive approximation](docs/tutorials/methods/adaptivity.md) | Independent macro, face, degree and local controls | [Araya et al. (2021)](https://doi.org/10.1093/imanum/drz053) |
| [Recursive MHM](docs/tutorials/methods/recursive-mhm.md) | A multiscale local operator with its own global/local hierarchy | [Harder and Valentin (2016)](https://doi.org/10.1007/978-3-319-41640-3_13) |

The table identifies implemented families, not every theorem or historical
experiment in their papers. The [Gallery](docs/gallery/index.md) records verified
spaces and remaining limitations. RT0 equilibration and moment reconstruction
are distinct operators; a generic indicator does not inherit the reliability
proof of a complete published estimator.

## Installation

Use Python 3.11–3.13 on Linux, macOS or Windows:

```bash
python -m pip install pymhm
```

The base package provides the coefficient interface with NumPy, SciPy and Basix.
Native UFL assembly also requires DOLFINx; installing the symbolic
`fenics-ufl` package with pip does not provide its native assembler. Follow the
[native UFL installation instructions](docs/installation.md#native-ufl-assembly)
for a Conda environment or the locked Pixi `fem` and `introduction` profiles.
Optional extras add CPU AMG,
PARDISO, MPI, CUDA solvers, meshing or visualization; for example,
`python -m pip install "pymhm[amg]"` adds PyAMG.
The [installation guide](docs/installation.md) covers virtual environments,
Windows commands, upgrades and native backend requirements.

## Quick start

Start with the [step-by-step UFL overview](docs/tutorials/overview.md) and the
[introductory course with executed plots](docs/tutorials/notebooks.md). They connect the
mathematical local and global formulations to the code for scalar, vector and
mixed problems.

Install the notebook dependencies, download a notebook from the catalogue and
open it in Jupyter:

```bash
python -m pip install "pymhm[notebooks]"
jupyter lab primal_galerkin.ipynb
```

The distribution contains only the `pymhm` library. A downloaded notebook's
first cell verifies and extracts its separate companion ZIP of importable helpers
and small configurations into a writable workspace. Its data and recorded fields
use separate verified downloads. This workflow needs no checkout or Pixi. Native UFL examples also need the DOLFINx installation described above.
Use the [locked checkout environments](docs/installation.md#from-a-checkout)
for development and the repository's qualified dependency combinations.

The portable coefficient interface follows the same mesh-to-solution workflow:

```python
import numpy as np
from pymhm import (
    CartesianMacroMesh, Equation, FaceSpace, LocalContext, LocalEquations,
    MeshHierarchy, SkeletonSpace, assemble, bind_interface, bind_problem, solve,
)

macro = CartesianMacroMesh(1, 1)
hierarchy = MeshHierarchy(macro, (macro.submesh(0, 2),))
skeleton = SkeletonSpace(macro, tuple(FaceSpace.uniform(0) for _ in macro.faces))
interface = bind_interface(skeleton, convention="value")

def local(context: LocalContext) -> LocalEquations:
    """Declare independent volume and interface equations."""
    return context.equations(
        a=[[2.0]], L=[1.0], b=np.ones((1, 4)), c=-np.ones((4, 1)),
        d=np.eye(4),
    )

problem = bind_problem(hierarchy, interface, local, global_equation=Equation(0, 0))
system = assemble(problem)
solution = solve(system)
print(solution.trace, solution.fields)  # every coordinate is 1/6
```

This small algebraic example declares $2u+\sum_F\lambda_F=1$ and
$-u+\lambda_F=0$ on each face. The binding owns the shared numbering and geometric
maps; the user supplies both equations. The
[variational guide](docs/variational.md) describes UFL forms, retained modes,
physical constraints and recursive problems, and states the supported limits.
For complete control, see the [custom-space tutorial](docs/tutorials/custom-interface.md),
which declares a nonorthogonal basis and its independent trial/test maps.

The wheel contains every `pymhm` runtime module, typing and distribution metadata.
The source distribution also carries the README, license and build metadata
needed to rebuild that wheel independently. Neither archive contains notebooks,
example helpers, case registries, configurations, datasets, computed fields,
figures or comparison tools. These repository files have separate
[notebook companions and data downloads](docs/data.md), with declared SHA-256
identities, provenance and terms. Optional native backends require their separate
dependencies.

The [Windows guide](docs/windows.md) describes native portable-core execution,
SciPy/PyPardiso selection, process workers, installed-wheel checks and the
native DOLFINx/UFL profile. Local FEM assembly uses DOLFINx's CSR/vector
interfaces independently of PETSc; choose compatible numerical solvers through
`SolverConfig`. The locked `fem-intel` profile combines FEM assembly with
PARDISO on Linux and Windows. Native Windows requires an MPI runtime and a
Visual Studio JIT compiler. PETSc/MUMPS solvers and distributed PETSc workflows
use the Unix stack, including WSL2 on a Windows host. CI reports qualify each
platform separately.

## Verified discretizations and integrations

The physical formulations compose public finite-element, material, trace and
linear-algebra operations. Importable providers in `examples.formulations`
declare their local and global equations without invoking predefined solvers;
the [variational guide](docs/variational.md) identifies these operations and
their numerical conventions. Existing solver entry points remain available.
Numerical records and stored coefficient contracts document the verified
discretizations, materials and boundary data; they do not qualify arbitrary
user-defined forms.

- Primal Pk, general triangular RT/BDM and enriched rectangular RT Darcy;
  anisotropic permeability, mixed boundary data and physical pure-Neumann gauges.
- Cartesian Qk Darcy, discrete point wells, and SPE10 Model 2 slices with
  explicit units, checked downloads and geometric material-interface integration.
- Taylor–Hood and residual-consistent equal-order USFEM Stokes–Brinkman/Oseen,
  including spatially variable tensor resistance and prescribed convection.
- Displacement–pressure GaLS elasticity through the incompressible limit,
  Taylor–Hood elasticity, and weakly symmetric enriched BDM/RT stress elasticity.
  All local rigid motions, material derivatives and physical constraints are explicit.
- Conservative variable-coefficient RAD with Galerkin or consistent SUPG locals,
  high-order heat diffusion, backward Euler and Darcy/dispersion coupling.
- Polygonal local partitions and star-shaped polyhedra with original polygonal face
  spaces; tetrahedral Pk operators, tetrahedral/prismatic mixed H(div) families,
  and mapped hexahedral RT Darcy fields.
- MsHHO cell/face moment constructions, recursive local problems, material-fitted integration,
  moment reconstruction, and equation-specific error estimation and adaptation.
- MH²M pressure traces, Robin-local MH, residual Petrov–Galerkin MHM and
  unusual reaction–diffusion stabilization, with independent finite element checks.
- Three-dimensional Taylor–Hood/USFEM flow, GaLS elasticity, MsHHO and
  tetrahedral RT reconstruction with dimension-dependent estimator spaces.
- Full anisotropic mixed stress on polygonal macrocells, arbitrary planar
  material cuts and independently controlled normal/interior H(div) orders.
- Three-dimensional weakly symmetric AFW stress elasticity, including the
  incompressible limit, and Newmark MHM elastodynamics with local subcycling.
- Complex Helmholtz waves with absorbing boundaries and perfectly matched layers;
  transient Maxwell TM and three-dimensional vector fields with explicit CFL controls.
- Independent face partitions and degrees, including continuous subface traces;
  physical local kernel constraints, source/trace factorization reuse and
  conservative RT0 flux equilibration.
- User-defined UFL local operators, explicit local/global form descriptions and
  callable providers; optional mesh import/export with physical tags.
- Basix reference elements, nodal simplex/tensor bases and RT/BDM tabulation,
  with explicit native basis ordering, transformations and coefficient digests.
- PyVista/VTK export and rendering, including broken finite-element fields and
  actual macro-mesh overlays (`python -m pip install "pymhm[visualization]"`).
- SciPy, PETSc, PARDISO, CuPy and cuDSS solvers; CPU PyAMG and optional GPU AmgX.
  AMG local Neumann solves use a compatible SPD complement.
- Deterministic serial/thread/process local execution with bounded batches and
  native thread limits; the coordinator reduces shared-face contributions in
  cell order and retains mesh/DOF metadata for reconstruction.
- Distributed PETSc/MPI assembly, reusable offline operators, resident GPU P1
  batches and augmented CPU/GPU AMG saddle preconditioners.

The [scientific scope](ROADMAP.md#scientific-scope-and-acceptance-criteria) maps each article to implemented paths,
verification evidence and remaining reproduction limits. The stated geometry,
space compatibility and estimator hypotheses are part of each capability.
See [theory](docs/theory.md),
[Bibliography](docs/literature.md), [Gallery](docs/gallery/index.md) and
[performance](docs/performance.md) for assumptions and evidence.

The [visual case gallery](docs/gallery/index.md) compares computed fields with
analytical references, error maps, profiles and convergence expectations.
The [MSL field comparison](docs/cases/reference-comparison.md) checks primal
Darcy fields against MSL_MHM with MSL_CG and MSL_Core. The
[NeoPZ comparison](docs/cases/neopz.md) checks RT0/P0 fields against
[NeoPZ](https://github.com/labmec/neopz) and distinguishes that assembly from
Labmec/MHM's higher-order controller. Each case records the actual spaces and
boundary conventions used in the comparison.
The [GaLS elasticity comparison](docs/cases/elasticity-reference.md) matches
MSL fields over five mesh levels and three local polynomial degrees.
The [SPE10 case](docs/cases/spe10.md) identifies the published layers, spaces and
boundary conditions and compares pressure profiles directly with article data.
The [quarter-five-spot case](docs/cases/quarter-five-spot.md) includes point wells,
an analytical series, and MSL/NeoPZ comparisons for a low-permeability obstacle.

## Reproducible calculations

Git contains sources, scientific JSON records, three compact SPE10 input layers
and the selected figures used by the published documentation. Large computed
fields and intermediate outputs are generated locally and stay outside Git.
The installed distribution contains only the `pymhm` library. Notebook sources,
companions and acquisition metadata are separate repository and website files.
Selected data and recorded figures use verified downloads; current fields and
intermediate outputs are generated in the user's working directory. An
ordinary package installation and core tests require no computed field archives.
[ROADMAP.md](ROADMAP.md) sets implementation and validation priorities,
dependencies and acceptance criteria for the next milestones.

Generate only the cases being evaluated, using their documented public commands;
then check their numerical acceptance before plotting or reporting reproduction.
The [notebook catalogue](notebooks/README.md) groups examples by physical problem
and lists their methods. Start with a small analytical example:

```bash
python -m scripts.run_notebooks darcy/primal_galerkin.ipynb
python -m scripts.run_notebooks flow/introductory_methods.ipynb
# The same examples in the locked checkout environment:
pixi run --locked -e notebooks notebooks-run darcy/primal_galerkin.ipynb
pixi run --locked -e notebooks notebooks-run flow/introductory_methods.ipynb
```

Executed copies retain the problem folders under `build/notebooks`. Historical
numeric IDs also select their notebooks. Analytical patches introduce the API;
they do not replace a published benchmark reproduction.

Inspect the declared calculations before a complete study:

```bash
python -m scripts.run_notebooks 68 --study --plan
```

Current inputs are prepared by their public recipes using the active Python
environment. Pinned raw datasets are downloaded only when the selected case
needs them; checksum and size conventions remain explicit. Complete studies
retain their original cost and numerical scope. Historical external field archives
require their original supplied payloads and are identified separately. Regenerating
a scientific case or replaying its fields requires its documented calculations;
package builds and core tests do not require computed field archives.

## Development

```bash
pixi run --locked -e test-core lint
pixi run --locked -e test-core typecheck
pixi run --locked -e test-core coverage-run
pixi run --locked -e fem test-fem
pixi run --locked -e fem-intel test-fem-portable
pixi run --locked -e meshing test-meshing
pixi run --locked -e packaging build
pixi run --locked -e packaging check-dist
```

After generating and accepting the selected scientific cases, execute their
notebooks and run `pixi run --locked -e docs docs-check`. Inspect the rendered figures and
MathJax in the browser. CI checks documentation markup; scientific acquisition,
notebook execution and full gallery generation require their separate acceptance.

The portable `test-core` environment supports Linux, Windows and macOS. The
complete `test` environment includes the native CPU and GPU integrations and
requires a Linux CUDA host with two NVIDIA devices. Its pinned AmgX setup and
mandatory dependency checks are described in the [development guide](docs/development/contributing.md).
Both suites use all available CPU workers and isolate tests marked `serial`.

CI tests the portable core on Linux x86-64, Windows x86-64 and macOS Apple
Silicon (ARM64). It enforces independent 99% line and branch coverage gates on
the combined Linux core and native FEM measurements from the same revision.
The [development guide](docs/development/contributing.md#coverage) provides the local commands.
Executable notebooks and their companion helpers are separate repository and
website downloads. Optional
dependency contracts and actual native-backend integrations are reported separately.

Dedicated [Tests](https://github.com/ipes-lncc/pymhm/actions/workflows/tests.yml),
[Lint and Quality](https://github.com/ipes-lncc/pymhm/actions/workflows/lint-and-quality.yml)
and [Docs](https://github.com/ipes-lncc/pymhm/actions/workflows/docs.yml) workflows
run independently on pull requests and main-branch pushes. The complete two-GPU
suite is opt-in through manual dispatch. On a validated release tag,
[Publish to PyPI](https://github.com/ipes-lncc/pymhm/actions/workflows/publish-pypi.yml)
validates metadata and runs Tests, Quality and Docs checks in parallel, then
publishes the checked distributions to PyPI, creates the GitHub Release and
deploys the documentation to GitHub Pages.
The Docs workflow also supports manual publication from `main` or a release tag
by enabling its `publish` input.
Maintainers configure the PyPI trusted publisher for `publish-pypi.yml`, Pages
with GitHub Actions as its source and the `github-pages` environment to accept
release tags; see [development](docs/development/contributing.md).

Prepare release notes and synchronize current versions with
`pixi run --locked -e release release-prepare VERSION`, after running
`release-fetch` in the same environment. The task uses git-cliff and preserves
handwritten notes. Official releases use `X.Y.Z` versions and matching `vX.Y.Z`
tags; for example, prepare `1.1.0` and tag `v1.1.0`. Use `--initial` only when no
canonical release tag exists in the fetched main-branch history.

The software is licensed under LGPL-2.1-only. Citation metadata is in `CITATION.cff`.
Original documentation figures and diagrams are licensed under
[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), with attribution to
**IPES Research Group**. Commercial reuse and adaptations are permitted with
attribution and an indication of changes; see the
[figure reuse guide](https://ipes-lncc.github.io/pymhm/licensing/).

## Institutional Support

PyMHM is developed by the
[Innovative Parallel numErical Solvers (IPES)](https://ipes.lncc.br/)
research group and receives institutional support from the
[Laboratório Nacional de Computação Científica (LNCC)](https://www.gov.br/lncc/pt-br),
a research unit of the
[Ministério da Ciência, Tecnologia e Inovação (MCTI)](https://www.gov.br/mcti/pt-br),
Brazil.

<p align="center">
  <a href="https://ipes.lncc.br/">
    <img src="https://raw.githubusercontent.com/ipes-lncc/pymhm/main/docs/assets/institutions/ipes.png" width="300" alt="IPES — Innovative Parallel numErical Solvers">
  </a>
  <a href="https://www.gov.br/lncc/pt-br">
    <img src="https://raw.githubusercontent.com/ipes-lncc/pymhm/main/docs/assets/institutions/lncc-readme.svg" width="190" alt="LNCC — Laboratório Nacional de Computação Científica">
  </a>
  <a href="https://www.gov.br/mcti/pt-br">
    <img src="https://raw.githubusercontent.com/ipes-lncc/pymhm/main/docs/assets/institutions/mcti-readme.svg" width="270" alt="MCTI — Ministério da Ciência, Tecnologia e Inovação">
  </a>
</p>
