Couplage de code multi-physique sans précision : alternatives et approches personnalisées

Lorsque vous travaillez avec des simulations multi-physiques, vous devez souvent coupler deux ou plusieurs solveurs spécialisés afin qu’ils échangent des données pendant le calcul. Precice est une bibliothèque de couplage open-source mature pour les simulations multi-physiques partitionnées, en particulier lors de la connexion de solveurs indépendants tels que FIPY, OpenFoam ou Calculix.

Mais le prix n’est pas toujours une option. Vous pouvez travailler dans un environnement où l’installation d’une bibliothèque basée sur C++ avec des liaisons Python n’est pas pratique. Vous pouvez utiliser un solveur commercial qui ne prend pas en charge Precice. Ou votre problème multi-physique peut être suffisamment simple pour qu’un cadre de couplage complet soit exagéré.

Cet article couvre des alternatives pratiques, notamment la mise à jour séquentielle à l’intérieur de FIPY, le fractionnement de l’opérateur, les méthodes d’extrapolation polynomiale et les bibliothèques de couplage à usage général.

Points à retenir clés

• Precice est puissant, mais ce n’est pas la seule option pour le couplage multi-physique. La bonne alternative dépend de la disponibilité du solveur, des préférences linguistiques, de la préparation au HPC et de la complexité du problème.
• Le couplage séquentiel au sein de FIPY fonctionne bien lorsque les deux équations vivent dans le même processus Python. Il est simple, débogable et ne nécessite aucune bibliothèque de couplage externe.
• L’opérateur divise la physique en découpage en résolvant chaque équation séparément. Il est utile lorsque différents processus physiques fonctionnent à différentes échelles de temps.
• Les bibliothèques de couplage à usage général telles que MUI et Moose MultiApps proposent des architectures alternatives avec des compromis de complexité, de prise en charge linguistique et d’évolutivité.
• L’orchestration basée sur les polynomes grâce à des outils tels que Rhapsopy est une approche d’ordre élevé qui adapte les pas de temps à l’aide d’estimations d’erreurs variables.

Partitionné VS monolithique VS couplage séquentiel

Avant de comparer les alternatives, il est utile de clarifier les principales stratégies de couplage. Le couplage multi-physique se divise généralement en trois catégories.

Couplage partitionné

Dans le couplage partitionné, des solveurs distincts communiquent via une interface externe ou une couche de middleware. Les solveurs restent des boîtes noires indépendantes et chaque solveur n’a pas besoin de connaître la structure interne de l’autre.

Precice est l’exemple canonique. Les avantages incluent la réutilisation du code, la flexibilité et la possibilité de coupler des codes commerciaux ou hérités. Le compromis est une surcharge de communication et le besoin de cartographie des mailles, de transfert de données et de coordination de couplage.

Couplage monolithique

Dans le couplage monolithique, toute la physique est résolue ensemble dans un seul solveur et partage souvent la même matrice de système. Cela peut être plus efficace pour les problèmes étroitement couplés, car les non-linéarités sont traitées implicitement.

Le compromis est un effort de développement élevé. Toute la physique doit être implémentée dans un seul cadre. Moose est un framework notable qui prend en charge les flux de travail de style monolithique et propose également des modèles partitionnés via plusieurs applications.

Couplage séquentiel

Le couplage séquentiel fonctionne lorsque toute la physique peut être exprimée dans un cadre de solveur. Dans Fipy, par exemple, vous pouvez résoudre les équations couplées les unes après les autres dans le même processus Python.

Cela évite complètement le middleware externe. Le compromis est que vous perdez la possibilité de coupler des solveurs indépendants écrits dans différentes langues ou maintenus par différentes organisations.

Couplage séquentiel avec balayage FIPY

L’alternative la plus simple à precice est de résoudre séquentiellement des équations couplées dans le même processus Python. FIPY prend en charge ce modèle via les méthodes sweep() et updateOld().

Le motif

L’implémentation standard suit une boucle imbriquée :

1. Déclarez les variables avec hasOld=True afin qu’elles puissent stocker les valeurs précédentes pour les termes transitoires.
2. Appelez updateOld() une fois par pas de temps physique pour verrouiller l’état actuel en tant qu’ancienne valeur.
3. Appelez eq.sweep() à plusieurs reprises dans une boucle interne jusqu’à ce que les résidus convergent.

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)

Quand cela fonctionne le mieux

• Les deux physiques peuvent être exprimées en PDE à l’intérieur de FIPY.
• Vous avez besoin d’un prototypage ou d’un débogage rapide sans dépendances externes.
• Le système couplé a une non-linéarité modérée qui converge avec le balayage itératif.
• Vous résolvez des modèles de champ de phase, des systèmes de réaction de diffusion ou des problèmes de transport couplés.

Quand ça échoue

• Vous devez coupler des solveurs écrits en C++, Fortran ou dans d’autres langues.
• La physique est si étroitement couplée que les balayages séquentielles nécessitent trop d’itérations.
• Vos solveurs sont des exécutables distincts de différentes organisations.
• Vous avez besoin d’une mise à l’échelle parallèle à mémoire distribuée sur plusieurs nœuds de calcul.

Approches de partage des opérateurs

La division de l’opérateur, également appelée pas fractionnaire, décompose un système couplé en sous-étapes séquentielles. Chaque sous-étape résout un modèle physique. Ceci est utile lorsque les processus physiques fonctionnent à différentes échelles de temps.

Fraction additive vs multiplicative

La division additive décompose une équation en opérateurs distincts et résout chaque contribution indépendamment. Le fractionnement multiplicatif s’applique aux opérateurs de manière séquentielle avec un ordre défini, qui est important lorsque les opérateurs ne font pas la navette.

Pour les workflows multi-physiques, la division additive est souvent plus facile à appliquer. Chaque modèle physique peut utiliser son propre solveur optimisé, et la logique de couplage reste modulaire.

Bibliothèques de partage d’opérateurs Python

Plusieurs outils et exemples orientés Python prennent en charge les flux de travail de partage des opérateurs :

• Pythos est une bibliothèque Python pour la division systématique des équations différentielles. Il prend en charge des modèles tels que la séparation de Strang, des méthodes implicites et explicites et le pas de temps adaptatif.
• Venise est un algorithme de fractionnement d’opérateurs multi-échelle qui utilise la division Strang avec des pas de temps adaptatifs. Il est pertinent lorsque la physique couplée fonctionne sur différentes échelles de temps.
• Methods-splitting-opérateur fournit des scripts Python autonomes pour un usage éducatif. Ces scripts sont utiles pour l’apprentissage mais ne sont pas prêts pour la production.

FIPY avec fractionnement de l’opérateur

Vous pouvez également combiner FIPY avec la division de l’opérateur manuellement. Un système de diffusion-réaction peut être divisé en une étape de diffusion et une étape de réaction :

# 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)

Le schéma de base est exact au premier ordre. Pour une précision du second ordre, utilisez la division Strang : diffusion en demi-étape, réaction complète, puis diffusion en demi-étape.

Bibliothèques de couplage à usage général

Si vous avez besoin d’un couplage partitionné mais que vous ne pouvez pas utiliser de prix, il existe plusieurs alternatives.

MUI : Interface universelle multi-échelle

mui est une bibliothèque C++ uniquement pour le couplage des solveurs hétérogènes. Il traite les données échangées comme des nuages de points et gère automatiquement l’interpolation spatiale et temporelle.

Les principales caractéristiques comprennent :

• Représentation ponctuelle. MUI peut transférer des données sans avoir besoin d’un solveur pour connaître la connectivité maillée d’un autre solveur.
• Interpolation spatiale et temporelle. Les outils d’interpolation intégrés aident les solveurs à communiquer à différentes échelles.
• Envoi intelligent. Cet algorithme limite la communication aux domaines qui se chevauchent et réduit la communication inutile entre tous.
• Support linguistique. MUI est écrit en C++ et propose des wrappers pour Python, Fortran et C.

MUI est utile lorsque vous devez coupler des solveurs avec des discrétisations fondamentalement différentes, telles que FEM, FVM, DEM ou SPH.

Choisissez MUI plutôt que lorsque vous avez besoin d’une interface légère intégrée ou lorsque les différences de connectivité maillées rendent l’infrastructure de couplage standard trop lourde.

Tenez-vous-en à Precice lorsque vous avez besoin d’une mise à l’échelle parallèle mature, d’une accélération quasi-newton pour les problèmes fortement couplés et d’un écosystème d’adaptateurs plus large.

Multi-applications et systèmes de transfert d’orignal

L’orignal peut résoudre des systèmes entièrement couplés, mais ses systèmes MultiApps et Transfer prennent également en charge les approches partitionnées. Moose crée des sous-applications qui transmettent des données de champ dans les deux sens.

Moose prend en charge plusieurs styles de couplage :

• Flux de travail entièrement couplés où toute la physique est résolue en une seule itération non linéaire.
• Des flux de travail de type Picard ou Newton étroitement couplés où les sous-applications physiques s’exécutent à chaque pas de temps.
• Flux de travail échelonnés où chaque physique progresse indépendamment et échange des données à des limites définies.

L’orignal est principalement axé sur le C++. Les outils Python existent, mais l’écosystème est moins python que les flux de travail construits autour de Fipy ou Precice.

Couplage polynomial avec Rhapsopy

rhapsopy utilise des approximations polynomiales des variables de couplage au fil du temps. Au lieu d’échanger une seule valeur à chaque étape de couplage, chaque sous-système s’intègre en utilisant une approximation polynomiale de son entrée à partir de l’autre sous-système.

Comment cela fonctionne

Au cours d’une étape de couplage, chaque sous-système est intégré à son propre solveur tout en utilisant des variables d’entrée approximées de manière polynomiale. À la fin de l’étape, de nouvelles variables de couplage sont calculées et les polynômes sont mis à jour.

Cette approche peut aider à :

1. précision. Les approximations polynomiales d’ordre supérieur capturent mieux les changements temporels que l’extrapolation constante ou linéaire.
2. Pas de temps adaptatif. Les estimations d’erreurs provenant d’approximations polynomiales peuvent guider la taille du pas de temps de couplage.
3. Couplage explicite et implicite. Les versions implicites peuvent améliorer la stabilité, mais nécessitent la résolution d’un problème de point fixe à chaque étape.

Statut actuel

Rhapsopy est actuellement mieux considéré comme un outil de démonstration pour les problèmes à petite échelle. Il est prometteur pour les utilisateurs de Python qui souhaitent un couplage adaptatif de haut niveau, mais ce n’est pas encore une solution HPC à grande échelle mature.

Couplage natif COMSOL

COMSOL Multiphysics utilise un modèle différent. Au lieu de coupler des solveurs externes, COMSOL définit nativement les couplages multiphysiques dans le même environnement logiciel.

Les utilisateurs de COMSOL peuvent :

• Définir des conditions d’interface telles que la continuité du flux de chaleur ou l’équilibre des contraintes.
• Utilisez des stratégies de solution entièrement couplées pour des problèmes non linéaires.
• Basculez entre des stratégies séparées et entièrement couplées en fonction de la complexité du problème.

Ceci est simple pour les utilisateurs déjà présents dans COMSOL. Le compromis est le verrouillage du fournisseur. Le couplage des solveurs externes nécessite généralement des interfaces spécifiques à COMSOL, des flux de travail Livelink ou des ponts de script.

Résumé de la comparaison

Guide de décision pratique

Utilisez ce guide de décision lorsque vous ne pouvez pas ou ne souhaitez pas utiliser Precice.

1. Toutes les physiques sont-elles exprimables dans Fipy ? Utilisez le balayage séquentiel. C’est le chemin le plus simple et ne nécessite aucune dépendance externe.
2. Votre physique fonctionne-t-elle à des échelles de temps très différentes ? Essayez le fractionnement de l’opérateur. Le découplage permet à chaque physique d’utiliser son propre pas de temps.
3. associez-vous des solveurs à des discrétisations fondamentalement différentes ? Considérez MUI. Sa représentation ponctuelle peut gérer le couplage maillage à mesh et maillage à particules.
4. Travaillez-vous en C++ ou dans l’écosystème Moose ? Les multi-applications Moose offrent des options monolithiques, étroitement couplées et décalées à l’intérieur d’un même framework.
5. Avez-vous besoin d’un pas de temps adaptatif basé sur des erreurs de couplage ? Essayez Rhapsopy pour des expériences à petite échelle ou surveillez son développement pour des flux de travail plus importants.
6. Utilisez-vous un solveur commercial ? Vérifiez s’il possède des fonctions multiphysiques natives ou s’il prend en charge les bibliothèques de couplage externes.

Ce que nous recommandons

Pour les utilisateurs de FIPY travaillant en Python, la recommandation dépend de la complexité du problème.

• Couplage simple, tel que la réaction-réaction, le champ de phase ou le transport : utilisez un balayage séquentiel avec sweep(). Il est simple et ne nécessite aucune dépendance externe.
• Complexité modérée, telle que des solveurs externes faiblement couplés ou différentes échelles de temps : utilisez la division d’un opérateur avec une bibliothèque structurée telle que Pythos.
• Complexité élevée, comme les solveurs étroitement couplés dans différentes langues : utilisez le prix lorsque cela est possible. Les alternatives n’offrent pas encore la même maturité, l’évolutivité parallèle ou l’accélération de convergence.

Si Precice n’est pas disponible, la meilleure option suivante dépend de votre environnement. Pour la recherche universitaire sans accès au HPC, la conception d’en-tête de MUI peut être plus facile à intégrer. Pour les simulations de production nécessitant une mise à l’échelle parallèle, Precice reste l’option la plus solide si vous pouvez l’utiliser.

Ce qu’il faut éviter

• Échange de données manuel en boucles sans itération ni critère de convergence. Cela peut diverger ou produire des résultats inexacts.
• Extrapolation des variables de couplage sans contrôle des erreurs. L’utilisation de la valeur de couplage du pas de temps précédent comme valeur actuelle n’est que précise du premier ordre et peut être instable pour les problèmes fortement couplés.
• négliger la sous-relaxation. Pour le couplage non linéaire, incluez des paramètres de sous-relaxation pour réduire la divergence du solveur.
• En supposant des échelles de balayage séquentielles. Le couplage séquentiel à l’intérieur d’un processus Python ne sera pas mis à l’échelle sur les nœuds de calcul à mémoire distribuée.

Guides connexes

• Code couplage avec precice : simulations multi-physiques en Python : installation, mise en œuvre de l’adaptateur et configuration lorsque Le prix est disponible.
• Élargir FIPY avec des modules personnalisés – organiser le code PDE réutilisable, les termes source et les modèles couplés dans Fipy.
• Qu’est-ce que FIPY et quand devriez-vous l’utiliser ? – FONDEMENT ET CAS D’UTILISATION.
• Comprendre les modèles de champs de phase dans la science des matériaux — Applications multiphysiques en champ de phase.
• Gestion des problèmes de PDE à grande échelle : stratégies, solveurs et études de cas HPC : stratégies pour mettre à l’échelle des flux de travail de simulation complexes.

Besoin d’aide pour concevoir votre flux de travail multi-physique ?

Le choix de la bonne approche de couplage dépend de vos solveurs, contraintes et complexité du problème. Matforge propose des services de consultation pour la conception de logiciels de recherche et de simulation. Nous pouvons vous aider à évaluer les compromis entre le prix, le couplage séquentiel, le fractionnement des opérateurs et d’autres approches pour votre problème spécifique multiphysique.

Visitez Matforge Homepage pour en savoir plus sur les services de consultation et les flux de travail de recherche.