{"id":816,"date":"2026-07-30T12:22:32","date_gmt":"2026-07-30T12:22:32","guid":{"rendered":"https:\/\/matforge.org\/?p=816","raw":"https:\/\/matforge.org\/?p=816"},"modified":"2026-07-30T12:22:32","modified_gmt":"2026-07-30T12:22:32","slug":"code-coupling-precice-multi-physics-python","status":"publish","type":"post","link":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/","title":{"rendered":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python","raw":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python"},"content":{"rendered":"<span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 9<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span><h2>TL; DR<\/h2>\n<p>Multiphysische Simulationen erfordern h\u00e4ufig die Kopplung mehrerer spezialisierter L\u00f6ser. Precice ist eine ausgereifte Open-Source-Kopplungsbibliothek, die partitionierte Multiphysik-Simulationen in Python erm\u00f6glicht. Dieses Tutorial zeigt, wie man FIPY mit einem anderen Solver unter Verwendung von Precice koppelt und die Installation, die Implementierung von Adaptern, die Konfiguration und die \u00fcblichen Fallstricke abdeckt. Sie erfahren, wann Sie partitionierte Kopplung verwenden, wie Sie den Datenaustausch einrichten und wie Sie typische Probleme debuggen.<\/p>\n<h2>Einleitung: Wenn ein Solver nicht ausreicht<\/h2>\n<p>Viele wissenschaftliche Probleme beinhalten mehrere physikalische Prozesse, die interagieren. Zum Beispiel:<\/p>\n<ul>\n<li>W\u00e4rme\u00fcbertragung gekoppelt mit Fl\u00fcssigkeitsfluss (konjugierte W\u00e4rme\u00fcbertragung)<\/li>\n<li>Strukturmechanik, die mit der Fluiddynamik interagiert (Fl\u00fcssig-Struktur-Interaktion)<\/li>\n<li>Elektrochemie in Verbindung mit Transportph\u00e4nomenen (Batteriemodellierung)<\/li>\n<\/ul>\n<p>FIPY zeichnet sich durch partielle Differentialgleichungen (PDES) f\u00fcr Transport-, Diffusions- und Phasenfeldprobleme aus. Einige Multiphysik-Szenarien erfordern jedoch die Kopplung von FIPY mit einem spezialisierten Solver f\u00fcr einen anderen Physikbereich &#8211; wie OpenFoam f\u00fcr die Str\u00f6mungsdynamik oder einen benutzerdefinierten Strukturcode.<\/p>\n<p><strong>Codekopplung<\/strong> ist die Praxis, zwei oder mehr unabh\u00e4ngige Simulationscodes zu verbinden, damit sie w\u00e4hrend der Berechnung Daten austauschen. Hier kommt <strong>Precice<\/strong> (partitionierte Kopplungsinfrastruktur f\u00fcr Kontinuumsgleichungen) ins Spiel.<\/p>\n<h3>Warum Precice verwenden?<\/h3>\n<p>Precice bietet:<\/p>\n<ul>\n<li><strong>Sprach-Agnostische Kopplung<\/strong>: Verbinden Sie Solver in C++, Python, Fortran usw.<\/li>\n<li><strong>Flexibles Daten-Mapping<\/strong>: Behandeln Sie die Interpolation von Netz-zu-Mesh zwischen nicht \u00fcbereinstimmenden Gittern<\/li>\n<li><strong>Zeitschritt-Koordination<\/strong>: Unterst\u00fctzung expliziter, impliziter und Quasi-Newton-Kopplungsschemas<\/li>\n<li><strong>Parallele Skalierbarkeit<\/strong>: Entwickelt f\u00fcr Hochleistungs-Computing-Umgebungen<\/li>\n<li><strong>Aktive Community<\/strong>: Einsatz in Forschung und Industrie, mit guter Dokumentation<\/li>\n<\/ul>\n<p>F\u00fcr FIPY-Benutzer \u00f6ffnet Precice die T\u00fcr zu robusten Multi-Physik-Workflows, ohne die Infrastruktur von Grund auf neu aufzubauen.<\/p>\n<h3>Partitionierte vs. monolithische L\u00f6ser<\/h3>\n<p>Verstehen Sie vor dem Eintauchen die beiden Hauptans\u00e4tze f\u00fcr die Multiphysik:<\/p>\n<table>\n<thead>\n<tr>\n<th>Aspekt<\/th>\n<th>partitioniert (Precice)<\/th>\n<th>Monolithisch<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>Struktur<\/strong><\/td>\n<td>Separate Solver \u00fcber Datenaustausch gekoppelt<\/td>\n<td>Einzelne Solver verarbeitet alle Physik zusammen<\/td>\n<\/tr>\n<tr>\n<td><strong>Wiederverwendung von Code<\/strong><\/td>\n<td>Hoch \u2013 vorhandene spezialisierte L\u00f6ser verwenden<\/td>\n<td>Niedrig \u2013 Ben\u00f6tigen Sie eine einheitliche Implementierung<\/td>\n<\/tr>\n<tr>\n<td><strong>Entwicklungsaufwand<\/strong><\/td>\n<td>Moderate \u2013 Adapter schreiben, Kopplung konfigurieren<\/td>\n<td>Sehr hoch \u2013 Implementieren Sie alle Physik in einem Code<\/td>\n<\/tr>\n<tr>\n<td><strong>Leistung<\/strong><\/td>\n<td>Gut, aber Kommunikationsaufwand<\/td>\n<td>M\u00f6glicherweise besser f\u00fcr eng gekoppelte Probleme<\/td>\n<\/tr>\n<tr>\n<td><strong>Flexibilit\u00e4t<\/strong><\/td>\n<td>Einfaches Tauschen oder Upgrade einzelner Solver<\/td>\n<td>Rigid \u2013 \u00c4nderungen wirken sich auf die gesamte Codebasis aus<\/td>\n<\/tr>\n<tr>\n<td><strong>Use Case<\/strong><\/td>\n<td>Reife Solver existieren f\u00fcr jede Physik<\/td>\n<td>Neue oder hochintegrierte Physikmodelle<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Wann partitionierte Kopplung mit dem Precice w\u00e4hlen:<\/strong><\/p>\n<ul>\n<li>Sie haben zuverl\u00e4ssige, optimierte L\u00f6ser f\u00fcr die individuelle Physik (z. B. FIPY f\u00fcr Diffusion, OpenFoam f\u00fcr Flow)<\/li>\n<li>Die Physik ist lose oder m\u00e4\u00dfig gekoppelt<\/li>\n<li>Sie m\u00f6chten vorhandene Codebasen und Communities nutzen<\/li>\n<li>Sie ben\u00f6tigen Flexibilit\u00e4t, um verschiedene Solver-Kombinationen auszuprobieren<\/li>\n<\/ul>\n<p><strong>Wenn monolithisch besser sein k\u00f6nnte:<\/strong><\/p>\n<ul>\n<li>Extrem enge Kopplung, die eine implizite Behandlung auf linearer Algebra-Ebene erfordert<\/li>\n<li>Leistungskritische HPC-Simulationen, bei denen der Kommunikationsaufwand inakzeptabel ist<\/li>\n<li>Sehr neue Physik, in der es noch keinen spezialisierten Solver gibt<\/li>\n<\/ul>\n<p>F\u00fcr viele Forschungsanwendungen ist <strong> die partitionierte Kopplung mit der Pr\u00e4zikation die pragmatische Wahl <\/strong>.<\/p>\n<h2>Konzeptioneller \u00dcberblick: Wie das Precice funktioniert<\/h2>\n<p>Precice folgt einer <strong>Client-Server<\/strong>-Architektur:<\/p>\n<ol>\n<li><strong>Solver A<\/strong> (z. B. FIPY) l\u00e4uft als <strong>Precice-Client<\/strong><\/li>\n<li><strong>Solver B<\/strong> (Ein weiterer Code) l\u00e4uft als ein weiterer <strong>Precice Client<\/strong><\/li>\n<li><strong>Precice<\/strong> l\u00e4uft als separater Prozess (der <strong>Kupplungsdienst<\/strong>), der die Kommunikation und die Datenzuordnung verwaltet<\/li>\n<li>An Kopplungsschnittstellen tauschen Solver Grenzdaten (z. B. Temperatur, W\u00e4rmefluss, Geschwindigkeit) durch<\/li>\n<li>Precice-Handles:\n<ul>\n<li>Mesh-Mapping, wenn Schnittstellennetze nicht \u00fcbereinstimmen<\/li>\n<li>Zeitschritt-Synchronisation<\/li>\n<li> Datenrelaxation und Unterrelaxation zur Verbesserung der Konvergenz<\/li>\n<li>Kopplungsschemas (explizit, implizit, quasi-newton) <\/li>\n<\/ul>\n<\/li>\n<\/ol>\n<p>Der Hauptvorteil: Jeder Solver ist sich der internen Details des anderen nicht bewusst. Sie m\u00fcssen nur wissen, wie Daten an ihrer Grenze \u00fcber die API von Precice gesendet \/ empfangen werden.<\/p>\n<h2>Voraussetzungen<\/h2>\n<p>Stellen Sie vor dem Start sicher, dass Sie Folgendes haben:<\/p>\n<ul>\n<li><strong>Fipy installiert<\/strong> und funktioniert (siehe <a href=\"https:\/\/matforge.org\/installing-and-setting-up-fipy-for-the-first-time\/\">First zum ersten Mal installieren und einrichten<\/a> f\u00fcr die Einrichtungsf\u00fchrung)<\/li>\n<li><strong>Python-Programmiererfahrung<\/strong> mit FIPY (Familiarit\u00e4t mit <a href=\"https:\/\/matforge.org\/what-is-fipy-and-when-should-you-use-it\/\">Fipys Kernkonzepten<\/a> ist unerl\u00e4sslich)<\/li>\n<li><strong>Ein zweiter Solver<\/strong> Bereit zum Kopplung (dieses Tutorial verwendet einen einfachen Python-Solver als Stand-in, aber das gleiche Muster funktioniert mit OpenFoam, Calculix oder anderen Precice-f\u00e4higen Codes)<\/li>\n<li><strong>Precice installiert<\/strong> auf Ihrem System (siehe <a href=\"https:\/\/precice.org\/installation-overview.html\">Installationshandbuch f\u00fcr das Precice<\/a>)<\/li>\n<li><strong>Grundlegendes Verst\u00e4ndnis der Multiphysik<\/strong> (\u00dcbersicht <a href=\"https:\/\/matforge.org\/what-is-scientific-simulation-and-why-it-matters\/\">Was ist wissenschaftliche Simulation und warum? Angelegenheiten <\/a> bei Bedarf)<\/li>\n<\/ul>\n<h2>Schritt 1: Installieren Sie die Python-Bindungen von Precice<\/h2>\n<p>Precice bietet Python-Bindungen an, damit FIPY (oder ein beliebiger Python-Code) als Kopplungsclient fungieren kann.<\/p>\n<pre><code class=\"language-bash\"># Using conda (recommended)\nconda install -c conda-forge precice\n\n# Or using pip\npip install precice\n<\/code><\/pre>\n<p>\u00dcberpr\u00fcfen Sie die Installation:<\/p>\n<pre><code class=\"language-bash\">python -c \"import precice; print('preCICE Python version:', precice.__version__)\"\n<\/code><\/pre>\n<p>Sie sollten die PRECICE-Version ohne Fehler sehen.<\/p>\n<h2>Schritt 2: Entwerfen Sie Ihre Kopplungsschnittstelle<\/h2>\n<p>Identifizieren Sie <strong>wo <\/strong> Die beiden L\u00f6ser interagieren. Gemeinsame Szenarien:<\/p>\n<ul>\n<li><strong>Fipy-Domain<\/strong> \u2192 Temperaturfeld<\/li>\n<li><strong>Andere Solver-Dom\u00e4ne<\/strong> \u2192 W\u00e4rmefluss oder Temperatur<\/li>\n<\/ul>\n<p>definieren:<\/p>\n<ul>\n<li><strong>Interface-Mesh<\/strong> auf jeder Seite (kann unterschiedlich sein)<\/li>\n<li><strong>Kupplungsdaten<\/strong>: Welche Mengen werden ausgetauscht (z. B. <code>Temperature<\/code>, <code>Heat-Flux<\/code>)<\/li>\n<li><strong>Mesh-Skalierung<\/strong>: Stellen Sie sicher, dass die Koordinatensysteme ausrichten<\/li>\n<\/ul>\n<p>F\u00fcr dieses Tutorial koppeln wir einen <strong>Fipy Heat Diffusion <\/strong> Solver mit einem <strong>Simple Python Convective Cooling <\/strong> Solver. Die Schnittstelle ist eine 1D-Linie, in der Temperatur und W\u00e4rmefluss ausgetauscht werden.<\/p>\n<h2>Schritt 3: Schreiben Sie den FIPY-Precice-Adapter<\/h2>\n<p>Der <strong>Adapter<\/strong> ist der Code, der Ihren Solver (FIPY) mit Precice verbindet. Es behandelt:<\/p>\n<ul>\n<li>Initialisierung der Precice-Verbindung<\/li>\n<li>Definieren der Kopplungsschnittstelle<\/li>\n<li>Eingehende Daten vom anderen Solver lesen<\/li>\n<li>Ausgehende Daten zum Senden schreiben<\/li>\n<li>Vorw\u00e4rtskopplungszeitschritt<\/li>\n<\/ul>\n<p>Erstellen Sie eine Datei <code>fipy_precice_adapter.py<\/code>:<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom fipy import CellVariable, Grid1D, DiffusionTerm, TransientTerm\nimport precice\n\n# --- Configuration ---\n# These should match the preCICE configuration file\nCOUPLING_INTERFACE = \"Fluid-Solid\"  # Name of the coupling interface\nCOUPLING_MESH_ID = 0  # ID of the mesh on this solver side\nCOUPLING_DATA_TEMPERATURE_ID = 0\nCOUPLING_DATA_HEATFLUX_ID = 1\n\n# Simulation parameters\nnx = 50\ndx = 1.0\ntotal_time = 10.0\ndt = 0.1\n\n# --- FiPy setup ---\nmesh = Grid1D(nx=nx, dx=dx)\nT = CellVariable(name=\"Temperature\", mesh=mesh, value=300.0)  # Initial temp in K\nk = 1.0  # Thermal conductivity\n\n# Boundary conditions\n# Left boundary: fixed temperature (will be overwritten by coupling)\n# Right boundary: fixed temperature (example)\nT.constrain(300.0, mesh.facesRight)\n\n# Equation: transient diffusion\neq = TransientTerm() == DiffusionTerm(coeff=k)\n\n# --- preCICE setup ---\nsolver_name = \"FiPy-Solver\"\nconfig_file = \"precice-config.xml\"  # Provided separately\n\nprecice_dll = precice.Participant(solver_name, config_file, 0, 0)\n\n# Get the coupling mesh from preCICE\nmesh_vertices = precice_dll.get_mesh_vertices(COUPLING_MESH_ID, COUPLING_INTERFACE)\n# In 1D, mesh_vertices is an array of x-coordinates\n# We'll map these to our FiPy mesh cells\n\n# Main coupling loop\ntime = 0.0\nwhile time &lt; total_time:\n    # 1. Advance FiPy one time step (without coupling first)\n    eq.solve(var=T, dt=dt)\n    \n    # 2. Read incoming data from the other solver (e.g., heat flux)\n    # preCICE expects data at the coupling interface vertices\n    heat_flux_in = precice_dll.read_data(\n        COUPLING_DATA_HEATFLUX_ID,\n        COUPLING_INTERFACE,\n        mesh_vertices\n    )\n    \n    # 3. Apply received heat flux as Neumann boundary condition on FiPy\n    # This is simplified: in practice you'd map heat_flux_in to FiPy faces\n    # For 1D, we can directly apply to left boundary\n    if len(heat_flux_in) &gt; 0:\n        # Neumann BC: -k * dT\/dx = heat_flux\n        # In FiPy, you can set flux via constrained faces\n        # For simplicity, we'll adjust the left boundary value to mimic flux\n        # A proper implementation would use a FluxBoundaryCondition\n        pass  # Implementation depends on exact boundary treatment\n    \n    # 4. Write outgoing data (temperature) to send to the other solver\n    # Extract temperature at coupling interface cells\n    T_interface = T.value  # In practice, sample at interface mesh locations\n    precice_dll.write_data(\n        COUPLING_DATA_TEMPERATURE_ID,\n        COUPLING_INTERFACE,\n        T_interface[:len(mesh_vertices)]  # ensure matching size\n    )\n    \n    # 5. Advance coupling\n    precice_dll.advance(dt)\n    \n    time += dt\n    print(f\"Time: {time:.2f}, Max T: {T.max():.2f}, Min T: {T.min():.2f}\")\n\nprecice_dll.finalize()\n<\/code><\/pre>\n<p><strong>Wichtige Anmerkungen:<\/strong><\/p>\n<ul>\n<li>Dies ist ein <strong>Minimales Beispiel<\/strong>. Reale Implementierungen ben\u00f6tigen eine ordnungsgem\u00e4\u00dfe Netzzuordnung und Randbedingungsanwendung.<\/li>\n<li>Die Datei <code>precice-config.xml<\/code> definiert Kommunikationseinstellungen, Mesh-IDs und Daten-IDs. Siehe Schritt 4.<\/li>\n<li>Das FIPY-Randbedingungs-Update wird vereinfacht; Implementieren Sie f\u00fcr den Produktionseinsatz den richtigen Neumann BC \u00fcber <code>FaceVariable<\/code> oder eine benutzerdefinierte Einschr\u00e4nkung.<\/li>\n<\/ul>\n<h2>Schritt 4: Erstellen Sie die Konfigurationsdatei f\u00fcr die Pr\u00e4zision<\/h2>\n<p>Precice verwendet eine XML-Konfigurationsdatei (<code>precice-config.xml<\/code>), die definiert:<\/p>\n<ul>\n<li>Teilnehmer (Solver)<\/li>\n<li>Kopplungsschnittstellen<\/li>\n<li>Netz- und Datendefinitionen<\/li>\n<li>Kommunikationseinstellungen<\/li>\n<li>Kopplungsschema (explizit, implizit, quasi-newton)<\/li>\n<\/ul>\n<p>Eine minimale Konfiguration f\u00fcr die FIPY + Python Solver-Kopplung:<\/p>\n<pre><code class=\"language-xml\">&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;\n&lt;precice-configuration&gt;\n  &lt;schema&gt;https:\/\/precice.org\/schemas\/coupling-schema-2.2.xsd&lt;\/schema&gt;\n\n  &lt;!-- Parallel settings --&gt;\n  &lt;parallel&gt;\n    &lt;exchange comm-world=\"true\" \/&gt;\n  &lt;\/parallel&gt;\n\n  &lt;!-- Coupling participants --&gt;\n  &lt;participants&gt;\n    &lt;participant name=\"FiPy-Solver\"&gt;\n      &lt;use-mesh name=\"Fluid-Solid-Mesh-FiPy\" provide=\"true\" \/&gt;\n      &lt;use-data name=\"Temperature\" from=\"FiPy-Solver\" \/&gt;\n      &lt;use-data name=\"Heat-Flux\" to=\"FiPy-Solver\" \/&gt;\n    &lt;\/participant&gt;\n    &lt;participant name=\"SimpleSolver\"&gt;\n      &lt;use-mesh name=\"Fluid-Solid-Mesh-Simple\" provide=\"true\" \/&gt;\n      &lt;use-data name=\"Temperature\" to=\"SimpleSolver\" \/&gt;\n      &lt;use-data name=\"Heat-Flux\" from=\"SimpleSolver\" \/&gt;\n    &lt;\/participant&gt;\n  &lt;\/participants&gt;\n\n  &lt;!-- Coupling interfaces --&gt;\n  &lt;coupling-scheme:serial-explicit&gt;\n    &lt;participants first=\"FiPy-Solver\" second=\"SimpleSolver\" \/&gt;\n    &lt;exchange&gt;\n      &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n      &lt;data name=\"Heat-Flux\" mesh=\"Fluid-Solid-Mesh-Simple\" \/&gt;\n    &lt;\/exchange&gt;\n    &lt;max-time&gt;10.0&lt;\/max-time&gt;\n    &lt;max-iterations&gt;10&lt;\/max-iterations&gt;\n  &lt;\/coupling-scheme:serial-explicit&gt;\n\n  &lt;!-- Meshes --&gt;\n  &lt;mesh name=\"Fluid-Solid-Mesh-FiPy\" from=\"FiPy-Solver\" \/&gt;\n  &lt;mesh name=\"Fluid-Solid-Mesh-Simple\" from=\"SimpleSolver\" \/&gt;\n\n  &lt;!-- Data --&gt;\n  &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n  &lt;data name=\"Heat-Flux\" mesh=\"Fluid-Solid-Mesh-Simple\" \/&gt;\n\n&lt;\/precice-configuration&gt;\n<\/code><\/pre>\n<p>Schl\u00fcsselelemente:<\/p>\n<ul>\n<li>Zwei Teilnehmer: <code>FiPy-Solver<\/code> und <code>SimpleSolver<\/code><\/li>\n<li>Datenaustausch: <code>Temperature<\/code> (FIPY \u2192 SimpleSolver) und <code>Heat-Flux<\/code> (Simplesolver \u2192 FIPY)<\/li>\n<li><code>serial-explicit<\/code> Kopplung: einfaches explizites Zeitsteppen (gut zum Starten)<\/li>\n<li><code>max-iterations<\/code> steuert, wie viele Unteriterationen pro Zeitschritt (bei impliziten Schemata)<\/li>\n<\/ul>\n<p>F\u00fcr eine erweiterte Kopplung ist Folgendes zu beachten:<\/p>\n<ul>\n<li><code>serial-implicit<\/code> mit Quasi-Newton-Beschleunigung f\u00fcr engere Kopplung<\/li>\n<li>Unter-Entspannungsfaktoren zur Verbesserung der Konvergenz<\/li>\n<li>Netzverbindungsdefinitionen, wenn die Netze nicht ausrichten<\/li>\n<\/ul>\n<h2>Schritt 5: Implementieren Sie den zweiten Solver (einfaches Beispiel)<\/h2>\n<p>Um die Kupplung zu testen, ben\u00f6tigen Sie einen zweiten Solver. Hier ist ein minimaler Python-Solver, der W\u00e4rmefluss mit FIPY austauscht:<\/p>\n<p><code>solver_simple.py<\/code>:<\/p>\n<pre><code class=\"language-python\">import numpy as np\nimport precice\n\n# Configuration\nCOUPLING_INTERFACE = \"Fluid-Solid\"\nCOUPLING_MESH_ID = 0\nCOUPLING_DATA_TEMPERATURE_ID = 0\nCOUPLING_DATA_HEATFLUX_ID = 1\n\nsolver_name = \"SimpleSolver\"\nconfig_file = \"precice-config.xml\"\n\nprecice_dll = precice.Participant(solver_name, config_file, 0, 0)\n\n# Simple 1D mesh (could be completely different from FiPy's mesh)\nmesh_vertices = np.array([[0.0], [1.0]])  # Two points at interface\nT_interface = np.array([300.0, 300.0])    # Initial guess\n\ntotal_time = 10.0\ndt = 0.1\ntime = 0.0\n\nwhile time &lt; total_time:\n    # 1. Read incoming temperature from FiPy\n    T_from_fipy = precice_dll.read_data(\n        COUPLING_DATA_TEMPERATURE_ID,\n        COUPLING_INTERFACE,\n        mesh_vertices\n    )\n    \n    # 2. Compute outgoing heat flux (simple Newton's law of cooling)\n    # q = h * (T_fluid - T_solid)\n    h = 10.0  # Heat transfer coefficient\n    T_fluid = 350.0  # Ambient fluid temperature\n    heat_flux = h * (T_fluid - T_from_fipy.mean())\n    \n    # Send same flux to all interface vertices (simplified)\n    heat_flux_out = np.full_like(T_from_fipy, heat_flux)\n    \n    # 3. Write heat flux to send to FiPy\n    precice_dll.write_data(\n        COUPLING_DATA_HEATFLUX_ID,\n        COUPLING_INTERFACE,\n        heat_flux_out\n    )\n    \n    # 4. Advance coupling\n    precice_dll.advance(dt)\n    \n    time += dt\n    print(f\"[SimpleSolver] Time: {time:.2f}, T_fipy: {T_from_fipy.mean():.2f}, q: {heat_flux:.2f}\")\n\nprecice_dll.finalize()\n<\/code><\/pre>\n<p>Dieser einfache Solver stellt eine konvektive K\u00fchlumgebung dar, die einen W\u00e4rmefluss proportional zur Temperaturdifferenz des FIPY-Festk\u00f6rpers anwendet.<\/p>\n<h2>Schritt 6: F\u00fchren Sie die gekoppelte Simulation aus<\/h2>\n<ol>\n<li>Starten Sie beide Solver <strong>Simultaneously<\/strong> (Precice verwaltet ihre Kommunikation):<\/li>\n<\/ol>\n<pre><code class=\"language-bash\"># Terminal 1\npython fipy_precice_adapter.py &amp;\n\n# Terminal 2\npython solver_simple.py &amp;\n<\/code><\/pre>\n<ol start=\"2\">\n<li>Beobachten Sie die Ausgabe. Sie sollten sowohl in den Solvern als auch in den Temperatur- \/ W\u00e4rmeflusswerten die Entwicklung der Zeit vornehmen.<\/li>\n<li>Die Simulation endet, wenn <code>total_time<\/code> erreicht ist oder das Kopplungsschema abgeschlossen ist.<\/li>\n<\/ol>\n<p><strong>Erwartetes Verhalten: <\/strong><\/p>\n<ul>\n<li>Die FIPY-Temperatur sollte von anf\u00e4nglichen 300 K zur K\u00fchlkurve allm\u00e4hlich abnehmen<\/li>\n<li>Der W\u00e4rmefluss von SimpleSolver sollte positiv sein (W\u00e4rme hinterl\u00e4sst FIPY)<\/li>\n<li>Beide Solver sollten rechtzeitig synchronisiert bleiben<\/li>\n<\/ul>\n<h2>Schritt 7: Ergebnisse visualisieren<\/h2>\n<p>Nach dem Laufen k\u00f6nnen Sie das Temperaturprofil von FIPY zeichnen:<\/p>\n<pre><code class=\"language-python\">import matplotlib.pyplot as plt\nfrom fipy import Grid1D, CellVariable, DiffusionTerm\n\n# Re-run simulation while storing history\n# (or modify the adapter to save snapshots to file)\n# Then plot T vs x at final time\n<\/code><\/pre>\n<h2>Fehlerbehebung: H\u00e4ufige Probleme und L\u00f6sungen<\/h2>\n<table>\n<thead>\n<tr>\n<th>Symptom<\/th>\n<th>wahrscheinlich Ursache<\/th>\n<th>L\u00f6sung<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>precice: error: XML file not found<\/code><\/td>\n<td>Konfigurationsdatei fehlt oder falscher Pfad<\/td>\n<td>Stellen Sie sicher, dass <code>precice-config.xml<\/code> im Arbeitsverzeichnis ist oder den vollst\u00e4ndigen Pfad angibt<\/td>\n<\/tr>\n<tr>\n<td><code>Mesh vertex count mismatch<\/code><\/td>\n<td>FIPY- und PRECICE-Schnittstellennetze haben unterschiedliche Anzahl von Scheitelpunkten<\/td>\n<td>check <code>get_mesh_vertices()<\/code> Gibt die erwartete Anzahl zur\u00fcck; korrekt zuordnen<\/td>\n<\/tr>\n<tr>\n<td><code>Data not found in configuration<\/code><\/td>\n<td>Datenname oder ID stimmt nicht mit XML \u00fcberein<\/td>\n<td>\u00dcberpr\u00fcfen Sie <code>COUPLING_DATA_*<\/code> Konstanten mit <code>&lt;data name=\"...\"&gt;<\/code> Eintr\u00e4gen<\/td>\n<\/tr>\n<tr>\n<td><code>Coupling diverges (temperatures explode)<\/code><\/td>\n<td>Unterentspannung erforderlich oder explizites Schema instabil<\/td>\n<td>F\u00fcgen Sie <code>&lt;relaxation value=\"0.5\"\/&gt;<\/code> in XML hinzu oder wechseln Sie zur impliziten Kopplung<\/td>\n<\/tr>\n<tr>\n<td><code>Time step mismatch<\/code><\/td>\n<td>Solver verwenden unterschiedliche <code>dt<\/code>-Werte<\/td>\n<td>Achten Sie darauf, dass beide die gleiche <code>dt<\/code> verwenden oder die Pr\u00e4zisionskontrollzeit (<code>precice_dll.advance(dt)<\/code>)<\/td>\n<\/tr>\n<tr>\n<td><code>Segmentation fault in preCICE<\/code><\/td>\n<td>Nicht \u00fcbereinstimmende Precice-Versionen zwischen den Teilnehmern<\/td>\n<td>Installieren Sie Precice neu, um sicherzustellen, dass alle Teilnehmer die gleiche Version verwenden<\/td>\n<\/tr>\n<tr>\n<td><code>FiPy boundary not updating<\/code><\/td>\n<td>Adapter nicht richtig angelegt<\/td>\n<td>Implementieren Sie die richtige Neumann-Randbedingung mit <code>FaceVariable<\/code> oder \u00e4ndern Sie den Gleichungsquellenbegriff<\/td>\n<\/tr>\n<tr>\n<td><code>Communication timeout<\/code><\/td>\n<td>Ein Solver ist abgest\u00fcrzt oder blockiert<\/td>\n<td>\u00dcberpr\u00fcfen Sie, ob beide L\u00f6ser ausgef\u00fchrt werden. Stellen Sie sicher, dass sie <code>advance()<\/code>  regelm\u00e4\u00dfig anrufen<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Debugging-Tipps:<\/strong><\/p>\n<ul>\n<li>F\u00fchren Sie Solver mit der Umgebungsvariablen <code>PRECICE_DEBUG=1<\/code> f\u00fcr ausf\u00fchrliche Protokolle aus<\/li>\n<li>Beginnen Sie mit einem groben Netz und einer kurzen Gesamtzeit, um schnell zu testen<\/li>\n<li>Verwenden Sie <code>serial-explicit<\/code> Kopplung zuerst (am meisten nachgeben), bevor Sie implizite Schemata ausprobieren<\/li>\n<li>Validieren Sie zuerst jeden Solver <strong> ohne Kopplung<\/strong>, um sicherzustellen, dass er eigenst\u00e4ndig funktioniert<\/li>\n<\/ul>\n<h2>Fortgeschrittene Themen<\/h2>\n<p>Sobald die Grundkopplung funktioniert, erkunden Sie:<\/p>\n<h3>Implizite Kopplung mit Quasi-Newton<\/h3>\n<p>Bei eng gekoppelten Problemen k\u00f6nnen explizite Schemata viele Subitationen erfordern oder instabil werden. Precice unterst\u00fctzt <strong>Implizite Kopplung<\/strong> mit Quasi-Newton-Beschleunigung:<\/p>\n<pre><code class=\"language-xml\">&lt;coupling-scheme:serial-implicit&gt;\n  &lt;participants first=\"FiPy-Solver\" second=\"SimpleSolver\" \/&gt;\n  &lt;exchange&gt;\n    &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n    &lt;data name=\"Heat-Flux\" mesh=\"Fluid-Solid-Mesh-Simple\" \/&gt;\n  &lt;\/exchange&gt;\n  &lt;max-time&gt;10.0&lt;\/max-time&gt;\n  &lt;max-iterations&gt;10&lt;\/max-iterations&gt;\n  &lt;convergence-measure&gt;\n    &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n  &lt;\/convergence-measure&gt;\n  &lt;relaxation value=\"0.5\"\/&gt;\n&lt;\/coupling-scheme:serial-implicit&gt;\n<\/code><\/pre>\n<h3>Mesh-to-Mesh-Mapping<\/h3>\n<p>Wenn das Schnittstellennetz von FIPY nicht mit dem Mesh des anderen Solver \u00fcbereinstimmt, f\u00fchrt Precice <strong>Mesh-Mapping<\/strong> durch (Interpolation). Sie k\u00f6nnen die Zuordnungsmethode in XML konfigurieren:<\/p>\n<pre><code class=\"language-xml\">&lt;mesh name=\"Fluid-Solid-Mesh-FiPy\" from=\"FiPy-Solver\"&gt;\n  &lt;use-data name=\"Temperature\" \/&gt;\n  &lt;mapping:nearest-neighbor \/&gt;\n&lt;\/mesh&gt;\n<\/code><\/pre>\n<p>Optionen: <code>nearest-neighbor<\/code>, <code>linear<\/code>, <code>rbf<\/code> (radiale Basisfunktionen). W\u00e4hlen Sie basierend auf Netzqualit\u00e4t und Physik.<\/p>\n<h3>Umgang mit nicht \u00fcbereinstimmenden Zeitschritten<\/h3>\n<p>Precice erm\u00f6glicht es jedem Solver, seinen eigenen Zeitschritt zu verwenden, w\u00e4hrend er an den Kopplungsschnittstellen koordiniert wird. Setzen Sie <code>dt<\/code> unabh\u00e4ngig in jedem Solver; Precice interpoliert Daten nach Bedarf. Gro\u00dfe Unterschiede k\u00f6nnen jedoch die Genauigkeit verringern.<\/p>\n<h2>Leistungs\u00fcberlegungen<\/h2>\n<ul>\n<li><strong>Kommunikations-Overhead<\/strong> kann bei kleinen Problemen dominieren. Profil, um sicherzustellen, dass die Kopplung nicht der Engpass ist.<\/li>\n<li><strong>Under-Relaxation<\/strong> (<code>&lt;relaxation&gt;<\/code> in XML) verbessert die Stabilit\u00e4t, verlangsamt aber die Konvergenz.<\/li>\n<li><strong>Mesh-Aufl\u00f6sung<\/strong> auf der Schnittstelle wirkt sich auf die Zuordnungsgenauigkeit aus. Verwenden Sie ausreichend raffinierte Schnittstellennetze.<\/li>\n<li><strong>Parallel-Skalierung<\/strong>: Precice arbeitet mit MPI-f\u00e4higen L\u00f6sern. Stellen Sie sicher, dass sowohl FIPY (mit PETSC) als auch der andere Solver parallel laufen.<\/li>\n<\/ul>\n<h2>N\u00e4chste Schritte<\/h2>\n<p>Nach dem Mastern der Grundkopplung:<\/p>\n<ol>\n<li><strong>Versuchen Sie einen echten zweiten Solver<\/strong> (z.<\/li>\n<li><strong>Entdecken Sie erweiterte Kopplungsschemata<\/strong> (<code>serial-implicit<\/code>, <code>multi<\/code>)<\/li>\n<li><strong>Add more Physics<\/strong> (z. B. drei Solver: Thermisch, fl\u00fcssig, strukturell)<\/li>\n<li><strong>Implementieren Sie die richtigen Randbedingungen<\/strong> in FIPY unter Verwendung von <code>FaceVariable<\/code> oder benutzerdefinierten Begriffen<\/li>\n<li><strong>Leistung optimieren<\/strong> mit paralleler Ausf\u00fchrung und Profilerstellung<\/li>\n<li><strong>Studienfallstudien<\/strong> Wie thermische Fl\u00fcssigkeitskupplung oder Fluid-Struktur-Wechselwirkung<\/li>\n<\/ol>\n<p>F\u00fcr tieferes FIPY-Wissen finden Sie <a href=\"https:\/\/matforge.org\/from-equations-to-simulations-the-modeling-pipeline\/\">Aus Gleichungen zu Simulationen: The Modeling Pipeline<\/a> und <a href=\"https:\/\/matforge.org\/finite-volume-method-explained-simply\/\">Finite Volume-Methode einfach erkl\u00e4rt <\/a>.<\/p>\n<h2>weiterlesen<\/h2>\n<ul>\n<li><strong><a href=\"https:\/\/matforge.org\/what-is-fipy-and-when-should-you-use-it\/\">Was ist FIPY und wann sollten Sie es verwenden?<\/a><\/strong> \u2013 FIPY-Grundlagen und Anwendungsf\u00e4lle<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/installing-and-setting-up-fipy-for-the-first-time\/\">Erstmals installieren und einrichten<\/a><\/strong> \u2013 Umgebungseinrichtung und Fehlerbehebung<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/what-is-scientific-simulation-and-why-it-matters\/\">Was ist wissenschaftliche Simulation und warum es wichtig ist<\/a><\/strong> \u2013 Simulationsmethodik und Best Practices<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/from-equations-to-simulations-the-modeling-pipeline\/\">Von Gleichungen zu Simulationen: Die Modellierungspipeline<\/a><\/strong> \u2013 End-to-End-Workflow von Gleichungen zu validierten Ergebnissen<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/finite-volume-method-explained-simply\/\">Finite-Volumen-Methode einfach erkl\u00e4rt<\/a><\/strong> \u2013 numerische Kernmethode hinter FIPY<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/understanding-phase-field-models-in-materials-science\/\">Phasenfeldmodelle in der Materialwissenschaft verstehen<\/a><\/strong> \u2013 Multi-Physics-Phasenfeld-Anwendungen<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/why-issue-tracking-is-critical-in-scientific-projects\/\">Warum das Issue-Tracking in wissenschaftlichen Projekten von entscheidender Bedeutung ist<\/a><\/strong> \u2013 Reproduzierbarkeit und Kollaborationspraktiken<\/li>\n<\/ul>\n<h2>Ben\u00f6tigen Sie Hilfe bei Ihrem Multiphysik-Projekt?<\/h2>\n<p>Die Erstellung robuster gekoppelter Simulationen erfordert ein umfassendes Fachwissen sowohl bei numerischen Methoden als auch bei der Softwareintegration. Wenn Sie ein komplexes Multiphysik-Problem angehen und eine Anleitung ben\u00f6tigen:<\/p>\n<ul>\n<li>Entwerfen eines Kopplungs-Workflows mit PRECICE<\/li>\n<li>Implementieren von FIPY-Adaptern f\u00fcr Ihre spezifische Physik<\/li>\n<li>Debuggen von Konvergenzproblemen<\/li>\n<li>Optimieren der Leistung f\u00fcr gro\u00df angelegte Simulationen<\/li>\n<\/ul>\n<p><strong>Matforge bietet Beratungsdienste<\/strong> f\u00fcr Forschungssoftware-Workflows an. Wir unterst\u00fctzen Sie bei der Einrichtung zuverl\u00e4ssiger, reproduzierbarer Multi-Physik-Simulationen, die auf Ihr Projekt zugeschnitten sind. <a href=\"https:\/\/matforge.org\/\"> Besuchen Sie die Matforge-Homepage<\/a>, um mehr zu erfahren und Ihre spezifischen Bed\u00fcrfnisse zu besprechen.<\/p>\n<hr>\n<h2>Zusammenfassung<\/h2>\n<ul>\n<li><strong>Precice<\/strong> Erm\u00f6glicht partitionierte Multi-Physik-Kopplung, so dass FIPY mit anderen Solvern zusammenarbeiten kann<\/li>\n<li><strong>Partitionierter Ansatz<\/strong> ist praktisch f\u00fcr die Forschung: Bestehende Codes wiederverwenden, Flexibilit\u00e4t beibehalten<\/li>\n<li><strong>Schl\u00fcsselschritte<\/strong>: Installieren Sie Precice, schreiben Sie Adapter, konfigurieren Sie XML, implementieren Sie den Grenzdatenaustausch<\/li>\n<li><strong>Simple starten<\/strong>: explizite Kopplung mit einem minimalen Beispiel, dann geht es zu impliziten Schemata<\/li>\n<li><strong>Validieren<\/strong> Zuerst jeder Solver eigenst\u00e4ndig, dann zusammen<\/li>\n<li><strong>Monitor<\/strong> Konvergenz und ggf. Unterentspannung verwenden<\/li>\n<\/ul>\n<p>Mit dieser Grundlage k\u00f6nnen Sie FIPY auf praktisch jedes Multi-Physik-Szenario erweitern.<\/p>\n","protected":false,"raw":"<h2>TL; DR<\/h2>\n<p>Multiphysische Simulationen erfordern h\u00e4ufig die Kopplung mehrerer spezialisierter L\u00f6ser. Precice ist eine ausgereifte Open-Source-Kopplungsbibliothek, die partitionierte Multiphysik-Simulationen in Python erm\u00f6glicht. Dieses Tutorial zeigt, wie man FIPY mit einem anderen Solver unter Verwendung von Precice koppelt und die Installation, die Implementierung von Adaptern, die Konfiguration und die \u00fcblichen Fallstricke abdeckt. Sie erfahren, wann Sie partitionierte Kopplung verwenden, wie Sie den Datenaustausch einrichten und wie Sie typische Probleme debuggen.<\/p>\n<h2>Einleitung: Wenn ein Solver nicht ausreicht<\/h2>\n<p>Viele wissenschaftliche Probleme beinhalten mehrere physikalische Prozesse, die interagieren. Zum Beispiel:<\/p>\n<ul>\n<li>W\u00e4rme\u00fcbertragung gekoppelt mit Fl\u00fcssigkeitsfluss (konjugierte W\u00e4rme\u00fcbertragung)<\/li>\n<li>Strukturmechanik, die mit der Fluiddynamik interagiert (Fl\u00fcssig-Struktur-Interaktion)<\/li>\n<li>Elektrochemie in Verbindung mit Transportph\u00e4nomenen (Batteriemodellierung)<\/li>\n<\/ul>\n<p>FIPY zeichnet sich durch partielle Differentialgleichungen (PDES) f\u00fcr Transport-, Diffusions- und Phasenfeldprobleme aus. Einige Multiphysik-Szenarien erfordern jedoch die Kopplung von FIPY mit einem spezialisierten Solver f\u00fcr einen anderen Physikbereich - wie OpenFoam f\u00fcr die Str\u00f6mungsdynamik oder einen benutzerdefinierten Strukturcode.<\/p>\n<p><strong>Codekopplung<\/strong> ist die Praxis, zwei oder mehr unabh\u00e4ngige Simulationscodes zu verbinden, damit sie w\u00e4hrend der Berechnung Daten austauschen. Hier kommt <strong>Precice<\/strong> (partitionierte Kopplungsinfrastruktur f\u00fcr Kontinuumsgleichungen) ins Spiel.<\/p>\n<h3>Warum Precice verwenden?<\/h3>\n<p>Precice bietet:<\/p>\n<ul>\n<li><strong>Sprach-Agnostische Kopplung<\/strong>: Verbinden Sie Solver in C++, Python, Fortran usw.<\/li>\n<li><strong>Flexibles Daten-Mapping<\/strong>: Behandeln Sie die Interpolation von Netz-zu-Mesh zwischen nicht \u00fcbereinstimmenden Gittern<\/li>\n<li><strong>Zeitschritt-Koordination<\/strong>: Unterst\u00fctzung expliziter, impliziter und Quasi-Newton-Kopplungsschemas<\/li>\n<li><strong>Parallele Skalierbarkeit<\/strong>: Entwickelt f\u00fcr Hochleistungs-Computing-Umgebungen<\/li>\n<li><strong>Aktive Community<\/strong>: Einsatz in Forschung und Industrie, mit guter Dokumentation<\/li>\n<\/ul>\n<p>F\u00fcr FIPY-Benutzer \u00f6ffnet Precice die T\u00fcr zu robusten Multi-Physik-Workflows, ohne die Infrastruktur von Grund auf neu aufzubauen.<\/p>\n<h3>Partitionierte vs. monolithische L\u00f6ser<\/h3>\n<p>Verstehen Sie vor dem Eintauchen die beiden Hauptans\u00e4tze f\u00fcr die Multiphysik:<\/p>\n<table>\n<thead>\n<tr>\n<th>Aspekt<\/th>\n<th>partitioniert (Precice)<\/th>\n<th>Monolithisch<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><strong>Struktur<\/strong><\/td>\n<td>Separate Solver \u00fcber Datenaustausch gekoppelt<\/td>\n<td>Einzelne Solver verarbeitet alle Physik zusammen<\/td>\n<\/tr>\n<tr>\n<td><strong>Wiederverwendung von Code<\/strong><\/td>\n<td>Hoch \u2013 vorhandene spezialisierte L\u00f6ser verwenden<\/td>\n<td>Niedrig \u2013 Ben\u00f6tigen Sie eine einheitliche Implementierung<\/td>\n<\/tr>\n<tr>\n<td><strong>Entwicklungsaufwand<\/strong><\/td>\n<td>Moderate \u2013 Adapter schreiben, Kopplung konfigurieren<\/td>\n<td>Sehr hoch \u2013 Implementieren Sie alle Physik in einem Code<\/td>\n<\/tr>\n<tr>\n<td><strong>Leistung<\/strong><\/td>\n<td>Gut, aber Kommunikationsaufwand<\/td>\n<td>M\u00f6glicherweise besser f\u00fcr eng gekoppelte Probleme<\/td>\n<\/tr>\n<tr>\n<td><strong>Flexibilit\u00e4t<\/strong><\/td>\n<td>Einfaches Tauschen oder Upgrade einzelner Solver<\/td>\n<td>Rigid \u2013 \u00c4nderungen wirken sich auf die gesamte Codebasis aus<\/td>\n<\/tr>\n<tr>\n<td><strong>Use Case<\/strong><\/td>\n<td>Reife Solver existieren f\u00fcr jede Physik<\/td>\n<td>Neue oder hochintegrierte Physikmodelle<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Wann partitionierte Kopplung mit dem Precice w\u00e4hlen:<\/strong><\/p>\n<ul>\n<li>Sie haben zuverl\u00e4ssige, optimierte L\u00f6ser f\u00fcr die individuelle Physik (z. B. FIPY f\u00fcr Diffusion, OpenFoam f\u00fcr Flow)<\/li>\n<li>Die Physik ist lose oder m\u00e4\u00dfig gekoppelt<\/li>\n<li>Sie m\u00f6chten vorhandene Codebasen und Communities nutzen<\/li>\n<li>Sie ben\u00f6tigen Flexibilit\u00e4t, um verschiedene Solver-Kombinationen auszuprobieren<\/li>\n<\/ul>\n<p><strong>Wenn monolithisch besser sein k\u00f6nnte:<\/strong><\/p>\n<ul>\n<li>Extrem enge Kopplung, die eine implizite Behandlung auf linearer Algebra-Ebene erfordert<\/li>\n<li>Leistungskritische HPC-Simulationen, bei denen der Kommunikationsaufwand inakzeptabel ist<\/li>\n<li>Sehr neue Physik, in der es noch keinen spezialisierten Solver gibt<\/li>\n<\/ul>\n<p>F\u00fcr viele Forschungsanwendungen ist <strong> die partitionierte Kopplung mit der Pr\u00e4zikation die pragmatische Wahl <\/strong>.<\/p>\n<h2>Konzeptioneller \u00dcberblick: Wie das Precice funktioniert<\/h2>\n<p>Precice folgt einer <strong>Client-Server<\/strong>-Architektur:<\/p>\n<ol>\n<li><strong>Solver A<\/strong> (z. B. FIPY) l\u00e4uft als <strong>Precice-Client<\/strong><\/li>\n<li><strong>Solver B<\/strong> (Ein weiterer Code) l\u00e4uft als ein weiterer <strong>Precice Client<\/strong><\/li>\n<li><strong>Precice<\/strong> l\u00e4uft als separater Prozess (der <strong>Kupplungsdienst<\/strong>), der die Kommunikation und die Datenzuordnung verwaltet<\/li>\n<li>An Kopplungsschnittstellen tauschen Solver Grenzdaten (z. B. Temperatur, W\u00e4rmefluss, Geschwindigkeit) durch<\/li>\n<li>Precice-Handles: <ul> <li>Mesh-Mapping, wenn Schnittstellennetze nicht \u00fcbereinstimmen<\/li> <li>Zeitschritt-Synchronisation<\/li> <li> Datenrelaxation und Unterrelaxation zur Verbesserung der Konvergenz<\/li> <li>Kopplungsschemas (explizit, implizit, quasi-newton) <\/li> <\/ul><\/li>\n<\/ol>\n<p>Der Hauptvorteil: Jeder Solver ist sich der internen Details des anderen nicht bewusst. Sie m\u00fcssen nur wissen, wie Daten an ihrer Grenze \u00fcber die API von Precice gesendet \/ empfangen werden.<\/p>\n<h2>Voraussetzungen<\/h2>\n<p>Stellen Sie vor dem Start sicher, dass Sie Folgendes haben:<\/p>\n<ul>\n<li><strong>Fipy installiert<\/strong> und funktioniert (siehe <a href=\"https:\/\/matforge.org\/installing-and-setting-up-fipy-for-the-first-time\/\">First zum ersten Mal installieren und einrichten<\/a> f\u00fcr die Einrichtungsf\u00fchrung)<\/li>\n<li><strong>Python-Programmiererfahrung<\/strong> mit FIPY (Familiarit\u00e4t mit <a href=\"https:\/\/matforge.org\/what-is-fipy-and-when-should-you-use-it\/\">Fipys Kernkonzepten<\/a> ist unerl\u00e4sslich)<\/li>\n<li><strong>Ein zweiter Solver<\/strong> Bereit zum Kopplung (dieses Tutorial verwendet einen einfachen Python-Solver als Stand-in, aber das gleiche Muster funktioniert mit OpenFoam, Calculix oder anderen Precice-f\u00e4higen Codes)<\/li>\n<li><strong>Precice installiert<\/strong> auf Ihrem System (siehe <a href=\"https:\/\/precice.org\/installation-overview.html\">Installationshandbuch f\u00fcr das Precice<\/a>)<\/li>\n<li><strong>Grundlegendes Verst\u00e4ndnis der Multiphysik<\/strong> (\u00dcbersicht <a href=\"https:\/\/matforge.org\/what-is-scientific-simulation-and-why-it-matters\/\">Was ist wissenschaftliche Simulation und warum? Angelegenheiten <\/a> bei Bedarf)<\/li>\n<\/ul>\n<h2>Schritt 1: Installieren Sie die Python-Bindungen von Precice<\/h2>\n<p>Precice bietet Python-Bindungen an, damit FIPY (oder ein beliebiger Python-Code) als Kopplungsclient fungieren kann.<\/p>\n<pre><code class=\"language-bash\"># Using conda (recommended)\nconda install -c conda-forge precice\n\n# Or using pip\npip install precice\n<\/code><\/pre>\n<p>\u00dcberpr\u00fcfen Sie die Installation:<\/p>\n<pre><code class=\"language-bash\">python -c \"import precice; print('preCICE Python version:', precice.__version__)\"\n<\/code><\/pre>\n<p>Sie sollten die PRECICE-Version ohne Fehler sehen.<\/p>\n<h2>Schritt 2: Entwerfen Sie Ihre Kopplungsschnittstelle<\/h2>\n<p>Identifizieren Sie <strong>wo <\/strong> Die beiden L\u00f6ser interagieren. Gemeinsame Szenarien:<\/p>\n<ul>\n<li><strong>Fipy-Domain<\/strong> \u2192 Temperaturfeld<\/li>\n<li><strong>Andere Solver-Dom\u00e4ne<\/strong> \u2192 W\u00e4rmefluss oder Temperatur<\/li>\n<\/ul>\n<p>definieren:<\/p>\n<ul>\n<li><strong>Interface-Mesh<\/strong> auf jeder Seite (kann unterschiedlich sein)<\/li>\n<li><strong>Kupplungsdaten<\/strong>: Welche Mengen werden ausgetauscht (z. B. <code>Temperature<\/code>, <code>Heat-Flux<\/code>)<\/li>\n<li><strong>Mesh-Skalierung<\/strong>: Stellen Sie sicher, dass die Koordinatensysteme ausrichten<\/li>\n<\/ul>\n<p>F\u00fcr dieses Tutorial koppeln wir einen <strong>Fipy Heat Diffusion <\/strong> Solver mit einem <strong>Simple Python Convective Cooling <\/strong> Solver. Die Schnittstelle ist eine 1D-Linie, in der Temperatur und W\u00e4rmefluss ausgetauscht werden.<\/p>\n<h2>Schritt 3: Schreiben Sie den FIPY-Precice-Adapter<\/h2>\n<p>Der <strong>Adapter<\/strong> ist der Code, der Ihren Solver (FIPY) mit Precice verbindet. Es behandelt:<\/p>\n<ul>\n<li>Initialisierung der Precice-Verbindung<\/li>\n<li>Definieren der Kopplungsschnittstelle<\/li>\n<li>Eingehende Daten vom anderen Solver lesen<\/li>\n<li>Ausgehende Daten zum Senden schreiben<\/li>\n<li>Vorw\u00e4rtskopplungszeitschritt<\/li>\n<\/ul>\n<p>Erstellen Sie eine Datei <code>fipy_precice_adapter.py<\/code>:<\/p>\n<pre><code class=\"language-python\">import numpy as np\nfrom fipy import CellVariable, Grid1D, DiffusionTerm, TransientTerm\nimport precice\n\n# --- Configuration ---\n# These should match the preCICE configuration file\nCOUPLING_INTERFACE = \"Fluid-Solid\"  # Name of the coupling interface\nCOUPLING_MESH_ID = 0  # ID of the mesh on this solver side\nCOUPLING_DATA_TEMPERATURE_ID = 0\nCOUPLING_DATA_HEATFLUX_ID = 1\n\n# Simulation parameters\nnx = 50\ndx = 1.0\ntotal_time = 10.0\ndt = 0.1\n\n# --- FiPy setup ---\nmesh = Grid1D(nx=nx, dx=dx)\nT = CellVariable(name=\"Temperature\", mesh=mesh, value=300.0)  # Initial temp in K\nk = 1.0  # Thermal conductivity\n\n# Boundary conditions\n# Left boundary: fixed temperature (will be overwritten by coupling)\n# Right boundary: fixed temperature (example)\nT.constrain(300.0, mesh.facesRight)\n\n# Equation: transient diffusion\neq = TransientTerm() == DiffusionTerm(coeff=k)\n\n# --- preCICE setup ---\nsolver_name = \"FiPy-Solver\"\nconfig_file = \"precice-config.xml\"  # Provided separately\n\nprecice_dll = precice.Participant(solver_name, config_file, 0, 0)\n\n# Get the coupling mesh from preCICE\nmesh_vertices = precice_dll.get_mesh_vertices(COUPLING_MESH_ID, COUPLING_INTERFACE)\n# In 1D, mesh_vertices is an array of x-coordinates\n# We'll map these to our FiPy mesh cells\n\n# Main coupling loop\ntime = 0.0\nwhile time &lt; total_time:\n    # 1. Advance FiPy one time step (without coupling first)\n    eq.solve(var=T, dt=dt)\n    \n    # 2. Read incoming data from the other solver (e.g., heat flux)\n    # preCICE expects data at the coupling interface vertices\n    heat_flux_in = precice_dll.read_data(\n        COUPLING_DATA_HEATFLUX_ID,\n        COUPLING_INTERFACE,\n        mesh_vertices\n    )\n    \n    # 3. Apply received heat flux as Neumann boundary condition on FiPy\n    # This is simplified: in practice you'd map heat_flux_in to FiPy faces\n    # For 1D, we can directly apply to left boundary\n    if len(heat_flux_in) &gt; 0:\n        # Neumann BC: -k * dT\/dx = heat_flux\n        # In FiPy, you can set flux via constrained faces\n        # For simplicity, we'll adjust the left boundary value to mimic flux\n        # A proper implementation would use a FluxBoundaryCondition\n        pass  # Implementation depends on exact boundary treatment\n    \n    # 4. Write outgoing data (temperature) to send to the other solver\n    # Extract temperature at coupling interface cells\n    T_interface = T.value  # In practice, sample at interface mesh locations\n    precice_dll.write_data(\n        COUPLING_DATA_TEMPERATURE_ID,\n        COUPLING_INTERFACE,\n        T_interface[:len(mesh_vertices)]  # ensure matching size\n    )\n    \n    # 5. Advance coupling\n    precice_dll.advance(dt)\n    \n    time += dt\n    print(f\"Time: {time:.2f}, Max T: {T.max():.2f}, Min T: {T.min():.2f}\")\n\nprecice_dll.finalize()\n<\/code><\/pre>\n<p><strong>Wichtige Anmerkungen:<\/strong><\/p>\n<ul>\n<li>Dies ist ein <strong>Minimales Beispiel<\/strong>. Reale Implementierungen ben\u00f6tigen eine ordnungsgem\u00e4\u00dfe Netzzuordnung und Randbedingungsanwendung.<\/li>\n<li>Die Datei <code>precice-config.xml<\/code> definiert Kommunikationseinstellungen, Mesh-IDs und Daten-IDs. Siehe Schritt 4.<\/li>\n<li>Das FIPY-Randbedingungs-Update wird vereinfacht; Implementieren Sie f\u00fcr den Produktionseinsatz den richtigen Neumann BC \u00fcber <code>FaceVariable<\/code> oder eine benutzerdefinierte Einschr\u00e4nkung.<\/li>\n<\/ul>\n<h2>Schritt 4: Erstellen Sie die Konfigurationsdatei f\u00fcr die Pr\u00e4zision<\/h2>\n<p>Precice verwendet eine XML-Konfigurationsdatei (<code>precice-config.xml<\/code>), die definiert:<\/p>\n<ul>\n<li>Teilnehmer (Solver)<\/li>\n<li>Kopplungsschnittstellen<\/li>\n<li>Netz- und Datendefinitionen<\/li>\n<li>Kommunikationseinstellungen<\/li>\n<li>Kopplungsschema (explizit, implizit, quasi-newton)<\/li>\n<\/ul>\n<p>Eine minimale Konfiguration f\u00fcr die FIPY + Python Solver-Kopplung:<\/p>\n<pre><code class=\"language-xml\">&lt;?xml version=\"1.0\" encoding=\"UTF-8\"?&gt;\n&lt;precice-configuration&gt;\n  &lt;schema&gt;https:\/\/precice.org\/schemas\/coupling-schema-2.2.xsd&lt;\/schema&gt;\n\n  &lt;!-- Parallel settings --&gt;\n  &lt;parallel&gt;\n    &lt;exchange comm-world=\"true\" \/&gt;\n  &lt;\/parallel&gt;\n\n  &lt;!-- Coupling participants --&gt;\n  &lt;participants&gt;\n    &lt;participant name=\"FiPy-Solver\"&gt;\n      &lt;use-mesh name=\"Fluid-Solid-Mesh-FiPy\" provide=\"true\" \/&gt;\n      &lt;use-data name=\"Temperature\" from=\"FiPy-Solver\" \/&gt;\n      &lt;use-data name=\"Heat-Flux\" to=\"FiPy-Solver\" \/&gt;\n    &lt;\/participant&gt;\n    &lt;participant name=\"SimpleSolver\"&gt;\n      &lt;use-mesh name=\"Fluid-Solid-Mesh-Simple\" provide=\"true\" \/&gt;\n      &lt;use-data name=\"Temperature\" to=\"SimpleSolver\" \/&gt;\n      &lt;use-data name=\"Heat-Flux\" from=\"SimpleSolver\" \/&gt;\n    &lt;\/participant&gt;\n  &lt;\/participants&gt;\n\n  &lt;!-- Coupling interfaces --&gt;\n  &lt;coupling-scheme:serial-explicit&gt;\n    &lt;participants first=\"FiPy-Solver\" second=\"SimpleSolver\" \/&gt;\n    &lt;exchange&gt;\n      &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n      &lt;data name=\"Heat-Flux\" mesh=\"Fluid-Solid-Mesh-Simple\" \/&gt;\n    &lt;\/exchange&gt;\n    &lt;max-time&gt;10.0&lt;\/max-time&gt;\n    &lt;max-iterations&gt;10&lt;\/max-iterations&gt;\n  &lt;\/coupling-scheme:serial-explicit&gt;\n\n  &lt;!-- Meshes --&gt;\n  &lt;mesh name=\"Fluid-Solid-Mesh-FiPy\" from=\"FiPy-Solver\" \/&gt;\n  &lt;mesh name=\"Fluid-Solid-Mesh-Simple\" from=\"SimpleSolver\" \/&gt;\n\n  &lt;!-- Data --&gt;\n  &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n  &lt;data name=\"Heat-Flux\" mesh=\"Fluid-Solid-Mesh-Simple\" \/&gt;\n\n&lt;\/precice-configuration&gt;\n<\/code><\/pre>\n<p>Schl\u00fcsselelemente:<\/p>\n<ul>\n<li>Zwei Teilnehmer: <code>FiPy-Solver<\/code> und <code>SimpleSolver<\/code><\/li>\n<li>Datenaustausch: <code>Temperature<\/code> (FIPY \u2192 SimpleSolver) und <code>Heat-Flux<\/code> (Simplesolver \u2192 FIPY)<\/li>\n<li><code>serial-explicit<\/code> Kopplung: einfaches explizites Zeitsteppen (gut zum Starten)<\/li>\n<li><code>max-iterations<\/code> steuert, wie viele Unteriterationen pro Zeitschritt (bei impliziten Schemata)<\/li>\n<\/ul>\n<p>F\u00fcr eine erweiterte Kopplung ist Folgendes zu beachten:<\/p>\n<ul>\n<li><code>serial-implicit<\/code> mit Quasi-Newton-Beschleunigung f\u00fcr engere Kopplung<\/li>\n<li>Unter-Entspannungsfaktoren zur Verbesserung der Konvergenz<\/li>\n<li>Netzverbindungsdefinitionen, wenn die Netze nicht ausrichten<\/li>\n<\/ul>\n<h2>Schritt 5: Implementieren Sie den zweiten Solver (einfaches Beispiel)<\/h2>\n<p>Um die Kupplung zu testen, ben\u00f6tigen Sie einen zweiten Solver. Hier ist ein minimaler Python-Solver, der W\u00e4rmefluss mit FIPY austauscht:<\/p>\n<p><code>solver_simple.py<\/code>:<\/p>\n<pre><code class=\"language-python\">import numpy as np\nimport precice\n\n# Configuration\nCOUPLING_INTERFACE = \"Fluid-Solid\"\nCOUPLING_MESH_ID = 0\nCOUPLING_DATA_TEMPERATURE_ID = 0\nCOUPLING_DATA_HEATFLUX_ID = 1\n\nsolver_name = \"SimpleSolver\"\nconfig_file = \"precice-config.xml\"\n\nprecice_dll = precice.Participant(solver_name, config_file, 0, 0)\n\n# Simple 1D mesh (could be completely different from FiPy's mesh)\nmesh_vertices = np.array([[0.0], [1.0]])  # Two points at interface\nT_interface = np.array([300.0, 300.0])    # Initial guess\n\ntotal_time = 10.0\ndt = 0.1\ntime = 0.0\n\nwhile time &lt; total_time:\n    # 1. Read incoming temperature from FiPy\n    T_from_fipy = precice_dll.read_data(\n        COUPLING_DATA_TEMPERATURE_ID,\n        COUPLING_INTERFACE,\n        mesh_vertices\n    )\n    \n    # 2. Compute outgoing heat flux (simple Newton's law of cooling)\n    # q = h * (T_fluid - T_solid)\n    h = 10.0  # Heat transfer coefficient\n    T_fluid = 350.0  # Ambient fluid temperature\n    heat_flux = h * (T_fluid - T_from_fipy.mean())\n    \n    # Send same flux to all interface vertices (simplified)\n    heat_flux_out = np.full_like(T_from_fipy, heat_flux)\n    \n    # 3. Write heat flux to send to FiPy\n    precice_dll.write_data(\n        COUPLING_DATA_HEATFLUX_ID,\n        COUPLING_INTERFACE,\n        heat_flux_out\n    )\n    \n    # 4. Advance coupling\n    precice_dll.advance(dt)\n    \n    time += dt\n    print(f\"[SimpleSolver] Time: {time:.2f}, T_fipy: {T_from_fipy.mean():.2f}, q: {heat_flux:.2f}\")\n\nprecice_dll.finalize()\n<\/code><\/pre>\n<p>Dieser einfache Solver stellt eine konvektive K\u00fchlumgebung dar, die einen W\u00e4rmefluss proportional zur Temperaturdifferenz des FIPY-Festk\u00f6rpers anwendet.<\/p>\n<h2>Schritt 6: F\u00fchren Sie die gekoppelte Simulation aus<\/h2>\n<ol>\n<li>Starten Sie beide Solver <strong>Simultaneously<\/strong> (Precice verwaltet ihre Kommunikation):<\/li>\n<\/ol>\n<pre><code class=\"language-bash\"># Terminal 1\npython fipy_precice_adapter.py &amp;\n\n# Terminal 2\npython solver_simple.py &amp;\n<\/code><\/pre>\n<ol start=\"2\">\n<li>Beobachten Sie die Ausgabe. Sie sollten sowohl in den Solvern als auch in den Temperatur- \/ W\u00e4rmeflusswerten die Entwicklung der Zeit vornehmen.<\/li>\n<li>Die Simulation endet, wenn <code>total_time<\/code> erreicht ist oder das Kopplungsschema abgeschlossen ist.<\/li>\n<\/ol>\n<p><strong>Erwartetes Verhalten: <\/strong><\/p>\n<ul>\n<li>Die FIPY-Temperatur sollte von anf\u00e4nglichen 300 K zur K\u00fchlkurve allm\u00e4hlich abnehmen<\/li>\n<li>Der W\u00e4rmefluss von SimpleSolver sollte positiv sein (W\u00e4rme hinterl\u00e4sst FIPY)<\/li>\n<li>Beide Solver sollten rechtzeitig synchronisiert bleiben<\/li>\n<\/ul>\n<h2>Schritt 7: Ergebnisse visualisieren<\/h2>\n<p>Nach dem Laufen k\u00f6nnen Sie das Temperaturprofil von FIPY zeichnen:<\/p>\n<pre><code class=\"language-python\">import matplotlib.pyplot as plt\nfrom fipy import Grid1D, CellVariable, DiffusionTerm\n\n# Re-run simulation while storing history\n# (or modify the adapter to save snapshots to file)\n# Then plot T vs x at final time\n<\/code><\/pre>\n<h2>Fehlerbehebung: H\u00e4ufige Probleme und L\u00f6sungen<\/h2>\n<table>\n<thead>\n<tr>\n<th>Symptom<\/th>\n<th>wahrscheinlich Ursache<\/th>\n<th>L\u00f6sung<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>precice: error: XML file not found<\/code><\/td>\n<td>Konfigurationsdatei fehlt oder falscher Pfad<\/td>\n<td>Stellen Sie sicher, dass <code>precice-config.xml<\/code> im Arbeitsverzeichnis ist oder den vollst\u00e4ndigen Pfad angibt<\/td>\n<\/tr>\n<tr>\n<td><code>Mesh vertex count mismatch<\/code><\/td>\n<td>FIPY- und PRECICE-Schnittstellennetze haben unterschiedliche Anzahl von Scheitelpunkten<\/td>\n<td>check <code>get_mesh_vertices()<\/code> Gibt die erwartete Anzahl zur\u00fcck; korrekt zuordnen<\/td>\n<\/tr>\n<tr>\n<td><code>Data not found in configuration<\/code><\/td>\n<td>Datenname oder ID stimmt nicht mit XML \u00fcberein<\/td>\n<td>\u00dcberpr\u00fcfen Sie <code>COUPLING_DATA_*<\/code> Konstanten mit <code>&lt;data name=\"...\"&gt;<\/code> Eintr\u00e4gen<\/td>\n<\/tr>\n<tr>\n<td><code>Coupling diverges (temperatures explode)<\/code><\/td>\n<td>Unterentspannung erforderlich oder explizites Schema instabil<\/td>\n<td>F\u00fcgen Sie <code>&lt;relaxation value=\"0.5\"\/&gt;<\/code> in XML hinzu oder wechseln Sie zur impliziten Kopplung<\/td>\n<\/tr>\n<tr>\n<td><code>Time step mismatch<\/code><\/td>\n<td>Solver verwenden unterschiedliche <code>dt<\/code>-Werte<\/td>\n<td>Achten Sie darauf, dass beide die gleiche <code>dt<\/code> verwenden oder die Pr\u00e4zisionskontrollzeit (<code>precice_dll.advance(dt)<\/code>)<\/td>\n<\/tr>\n<tr>\n<td><code>Segmentation fault in preCICE<\/code><\/td>\n<td>Nicht \u00fcbereinstimmende Precice-Versionen zwischen den Teilnehmern<\/td>\n<td>Installieren Sie Precice neu, um sicherzustellen, dass alle Teilnehmer die gleiche Version verwenden<\/td>\n<\/tr>\n<tr>\n<td><code>FiPy boundary not updating<\/code><\/td>\n<td>Adapter nicht richtig angelegt<\/td>\n<td>Implementieren Sie die richtige Neumann-Randbedingung mit <code>FaceVariable<\/code> oder \u00e4ndern Sie den Gleichungsquellenbegriff<\/td>\n<\/tr>\n<tr>\n<td><code>Communication timeout<\/code><\/td>\n<td>Ein Solver ist abgest\u00fcrzt oder blockiert<\/td>\n<td>\u00dcberpr\u00fcfen Sie, ob beide L\u00f6ser ausgef\u00fchrt werden. Stellen Sie sicher, dass sie <code>advance()<\/code>  regelm\u00e4\u00dfig anrufen<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p><strong>Debugging-Tipps:<\/strong><\/p>\n<ul>\n<li>F\u00fchren Sie Solver mit der Umgebungsvariablen <code>PRECICE_DEBUG=1<\/code> f\u00fcr ausf\u00fchrliche Protokolle aus<\/li>\n<li>Beginnen Sie mit einem groben Netz und einer kurzen Gesamtzeit, um schnell zu testen<\/li>\n<li>Verwenden Sie <code>serial-explicit<\/code> Kopplung zuerst (am meisten nachgeben), bevor Sie implizite Schemata ausprobieren<\/li>\n<li>Validieren Sie zuerst jeden Solver <strong> ohne Kopplung<\/strong>, um sicherzustellen, dass er eigenst\u00e4ndig funktioniert<\/li>\n<\/ul>\n<h2>Fortgeschrittene Themen<\/h2>\n<p>Sobald die Grundkopplung funktioniert, erkunden Sie:<\/p>\n<h3>Implizite Kopplung mit Quasi-Newton<\/h3>\n<p>Bei eng gekoppelten Problemen k\u00f6nnen explizite Schemata viele Subitationen erfordern oder instabil werden. Precice unterst\u00fctzt <strong>Implizite Kopplung<\/strong> mit Quasi-Newton-Beschleunigung:<\/p>\n<pre><code class=\"language-xml\">&lt;coupling-scheme:serial-implicit&gt;\n  &lt;participants first=\"FiPy-Solver\" second=\"SimpleSolver\" \/&gt;\n  &lt;exchange&gt;\n    &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n    &lt;data name=\"Heat-Flux\" mesh=\"Fluid-Solid-Mesh-Simple\" \/&gt;\n  &lt;\/exchange&gt;\n  &lt;max-time&gt;10.0&lt;\/max-time&gt;\n  &lt;max-iterations&gt;10&lt;\/max-iterations&gt;\n  &lt;convergence-measure&gt;\n    &lt;data name=\"Temperature\" mesh=\"Fluid-Solid-Mesh-FiPy\" \/&gt;\n  &lt;\/convergence-measure&gt;\n  &lt;relaxation value=\"0.5\"\/&gt;\n&lt;\/coupling-scheme:serial-implicit&gt;\n<\/code><\/pre>\n<h3>Mesh-to-Mesh-Mapping<\/h3>\n<p>Wenn das Schnittstellennetz von FIPY nicht mit dem Mesh des anderen Solver \u00fcbereinstimmt, f\u00fchrt Precice <strong>Mesh-Mapping<\/strong> durch (Interpolation). Sie k\u00f6nnen die Zuordnungsmethode in XML konfigurieren:<\/p>\n<pre><code class=\"language-xml\">&lt;mesh name=\"Fluid-Solid-Mesh-FiPy\" from=\"FiPy-Solver\"&gt;\n  &lt;use-data name=\"Temperature\" \/&gt;\n  &lt;mapping:nearest-neighbor \/&gt;\n&lt;\/mesh&gt;\n<\/code><\/pre>\n<p>Optionen: <code>nearest-neighbor<\/code>, <code>linear<\/code>, <code>rbf<\/code> (radiale Basisfunktionen). W\u00e4hlen Sie basierend auf Netzqualit\u00e4t und Physik.<\/p>\n<h3>Umgang mit nicht \u00fcbereinstimmenden Zeitschritten<\/h3>\n<p>Precice erm\u00f6glicht es jedem Solver, seinen eigenen Zeitschritt zu verwenden, w\u00e4hrend er an den Kopplungsschnittstellen koordiniert wird. Setzen Sie <code>dt<\/code> unabh\u00e4ngig in jedem Solver; Precice interpoliert Daten nach Bedarf. Gro\u00dfe Unterschiede k\u00f6nnen jedoch die Genauigkeit verringern.<\/p>\n<h2>Leistungs\u00fcberlegungen<\/h2>\n<ul>\n<li><strong>Kommunikations-Overhead<\/strong> kann bei kleinen Problemen dominieren. Profil, um sicherzustellen, dass die Kopplung nicht der Engpass ist.<\/li>\n<li><strong>Under-Relaxation<\/strong> (<code>&lt;relaxation&gt;<\/code> in XML) verbessert die Stabilit\u00e4t, verlangsamt aber die Konvergenz.<\/li>\n<li><strong>Mesh-Aufl\u00f6sung<\/strong> auf der Schnittstelle wirkt sich auf die Zuordnungsgenauigkeit aus. Verwenden Sie ausreichend raffinierte Schnittstellennetze.<\/li>\n<li><strong>Parallel-Skalierung<\/strong>: Precice arbeitet mit MPI-f\u00e4higen L\u00f6sern. Stellen Sie sicher, dass sowohl FIPY (mit PETSC) als auch der andere Solver parallel laufen.<\/li>\n<\/ul>\n<h2>N\u00e4chste Schritte<\/h2>\n<p>Nach dem Mastern der Grundkopplung:<\/p>\n<ol>\n<li><strong>Versuchen Sie einen echten zweiten Solver<\/strong> (z.<\/li>\n<li><strong>Entdecken Sie erweiterte Kopplungsschemata<\/strong> (<code>serial-implicit<\/code>, <code>multi<\/code>)<\/li>\n<li><strong>Add more Physics<\/strong> (z. B. drei Solver: Thermisch, fl\u00fcssig, strukturell)<\/li>\n<li><strong>Implementieren Sie die richtigen Randbedingungen<\/strong> in FIPY unter Verwendung von <code>FaceVariable<\/code> oder benutzerdefinierten Begriffen<\/li>\n<li><strong>Leistung optimieren<\/strong> mit paralleler Ausf\u00fchrung und Profilerstellung<\/li>\n<li><strong>Studienfallstudien<\/strong> Wie thermische Fl\u00fcssigkeitskupplung oder Fluid-Struktur-Wechselwirkung<\/li>\n<\/ol>\n<p>F\u00fcr tieferes FIPY-Wissen finden Sie <a href=\"https:\/\/matforge.org\/from-equations-to-simulations-the-modeling-pipeline\/\">Aus Gleichungen zu Simulationen: The Modeling Pipeline<\/a> und <a href=\"https:\/\/matforge.org\/finite-volume-method-explained-simply\/\">Finite Volume-Methode einfach erkl\u00e4rt <\/a>.<\/p>\n<h2>weiterlesen<\/h2>\n<ul>\n<li><strong><a href=\"https:\/\/matforge.org\/what-is-fipy-and-when-should-you-use-it\/\">Was ist FIPY und wann sollten Sie es verwenden?<\/a><\/strong> \u2013 FIPY-Grundlagen und Anwendungsf\u00e4lle<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/installing-and-setting-up-fipy-for-the-first-time\/\">Erstmals installieren und einrichten<\/a><\/strong> \u2013 Umgebungseinrichtung und Fehlerbehebung<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/what-is-scientific-simulation-and-why-it-matters\/\">Was ist wissenschaftliche Simulation und warum es wichtig ist<\/a><\/strong> \u2013 Simulationsmethodik und Best Practices<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/from-equations-to-simulations-the-modeling-pipeline\/\">Von Gleichungen zu Simulationen: Die Modellierungspipeline<\/a><\/strong> \u2013 End-to-End-Workflow von Gleichungen zu validierten Ergebnissen<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/finite-volume-method-explained-simply\/\">Finite-Volumen-Methode einfach erkl\u00e4rt<\/a><\/strong> \u2013 numerische Kernmethode hinter FIPY<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/understanding-phase-field-models-in-materials-science\/\">Phasenfeldmodelle in der Materialwissenschaft verstehen<\/a><\/strong> \u2013 Multi-Physics-Phasenfeld-Anwendungen<\/li>\n<li><strong><a href=\"https:\/\/matforge.org\/why-issue-tracking-is-critical-in-scientific-projects\/\">Warum das Issue-Tracking in wissenschaftlichen Projekten von entscheidender Bedeutung ist<\/a><\/strong> \u2013 Reproduzierbarkeit und Kollaborationspraktiken<\/li>\n<\/ul>\n<h2>Ben\u00f6tigen Sie Hilfe bei Ihrem Multiphysik-Projekt?<\/h2>\n<p>Die Erstellung robuster gekoppelter Simulationen erfordert ein umfassendes Fachwissen sowohl bei numerischen Methoden als auch bei der Softwareintegration. Wenn Sie ein komplexes Multiphysik-Problem angehen und eine Anleitung ben\u00f6tigen:<\/p>\n<ul>\n<li>Entwerfen eines Kopplungs-Workflows mit PRECICE<\/li>\n<li>Implementieren von FIPY-Adaptern f\u00fcr Ihre spezifische Physik<\/li>\n<li>Debuggen von Konvergenzproblemen<\/li>\n<li>Optimieren der Leistung f\u00fcr gro\u00df angelegte Simulationen<\/li>\n<\/ul>\n<p><strong>Matforge bietet Beratungsdienste<\/strong> f\u00fcr Forschungssoftware-Workflows an. Wir unterst\u00fctzen Sie bei der Einrichtung zuverl\u00e4ssiger, reproduzierbarer Multi-Physik-Simulationen, die auf Ihr Projekt zugeschnitten sind. <a href=\"https:\/\/matforge.org\/\"> Besuchen Sie die Matforge-Homepage<\/a>, um mehr zu erfahren und Ihre spezifischen Bed\u00fcrfnisse zu besprechen.<\/p>\n<hr>\n<h2>Zusammenfassung<\/h2>\n<ul>\n<li><strong>Precice<\/strong> Erm\u00f6glicht partitionierte Multi-Physik-Kopplung, so dass FIPY mit anderen Solvern zusammenarbeiten kann<\/li>\n<li><strong>Partitionierter Ansatz<\/strong> ist praktisch f\u00fcr die Forschung: Bestehende Codes wiederverwenden, Flexibilit\u00e4t beibehalten<\/li>\n<li><strong>Schl\u00fcsselschritte<\/strong>: Installieren Sie Precice, schreiben Sie Adapter, konfigurieren Sie XML, implementieren Sie den Grenzdatenaustausch<\/li>\n<li><strong>Simple starten<\/strong>: explizite Kopplung mit einem minimalen Beispiel, dann geht es zu impliziten Schemata<\/li>\n<li><strong>Validieren<\/strong> Zuerst jeder Solver eigenst\u00e4ndig, dann zusammen<\/li>\n<li><strong>Monitor<\/strong> Konvergenz und ggf. Unterentspannung verwenden<\/li>\n<\/ul>\n<p>Mit dieser Grundlage k\u00f6nnen Sie FIPY auf praktisch jedes Multi-Physik-Szenario erweitern.<\/p>\n"},"excerpt":{"rendered":"<p><span class=\"span-reading-time rt-reading-time\" style=\"display: block;\"><span class=\"rt-label rt-prefix\">Reading Time: <\/span> <span class=\"rt-time\"> 9<\/span> <span class=\"rt-label rt-postfix\">minutes<\/span><\/span>TL; DR Multiphysische Simulationen erfordern h\u00e4ufig die Kopplung mehrerer spezialisierter L\u00f6ser. Precice ist eine ausgereifte Open-Source-Kopplungsbibliothek, die partitionierte Multiphysik-Simulationen in Python erm\u00f6glicht. Dieses Tutorial zeigt, wie man FIPY mit einem anderen Solver unter Verwendung von Precice koppelt und die Installation, die Implementierung von Adaptern, die Konfiguration und die \u00fcblichen Fallstricke abdeckt. Sie erfahren, wann Sie [&hellip;]<\/p>\n","protected":false,"raw":""},"author":6,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_locale":"de_DE","_original_post":"https:\/\/matforge.org\/?p=216","iawp_total_views":3,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-816","post","type-post","status-publish","format-standard","hentry","category-fipy-documentation-examples-development","de-DE"],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v28.3 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python - matforge.org<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python - matforge.org\" \/>\n<meta property=\"og:description\" content=\"Reading Time:  9 minutesTL; DR Multiphysische Simulationen erfordern h\u00e4ufig die Kopplung mehrerer spezialisierter L\u00f6ser. Precice ist eine ausgereifte Open-Source-Kopplungsbibliothek, die partitionierte Multiphysik-Simulationen in Python erm\u00f6glicht. Dieses Tutorial zeigt, wie man FIPY mit einem anderen Solver unter Verwendung von Precice koppelt und die Installation, die Implementierung von Adaptern, die Konfiguration und die \u00fcblichen Fallstricke abdeckt. Sie erfahren, wann Sie [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/\" \/>\n<meta property=\"og:site_name\" content=\"matforge.org\" \/>\n<meta property=\"article:published_time\" content=\"2026-07-30T12:22:32+00:00\" \/>\n<meta name=\"author\" content=\"steven\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"steven\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"14\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/\"},\"author\":{\"name\":\"steven\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\"},\"headline\":\"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python\",\"datePublished\":\"2026-07-30T12:22:32+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/\"},\"wordCount\":1839,\"commentCount\":0,\"articleSection\":[\"FIPY: Dokumentation, Beispiele &amp; Entwicklung\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/\",\"url\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/\",\"name\":\"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python - matforge.org\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\"},\"datePublished\":\"2026-07-30T12:22:32+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\"},\"breadcrumb\":{\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/matforge.org\\\/de\\\/code-coupling-precice-multi-physics-python\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/matforge.org\\\/de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#website\",\"url\":\"https:\\\/\\\/matforge.org\\\/\",\"name\":\"matforge.org\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/matforge.org\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/matforge.org\\\/#\\\/schema\\\/person\\\/8f690fb596d657b12994b83caa788f03\",\"name\":\"steven\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g\",\"caption\":\"steven\"},\"url\":\"https:\\\/\\\/matforge.org\\\/author\\\/steven\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python - matforge.org","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/","og_locale":"de_DE","og_type":"article","og_title":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python - matforge.org","og_description":"Reading Time:  9 minutesTL; DR Multiphysische Simulationen erfordern h\u00e4ufig die Kopplung mehrerer spezialisierter L\u00f6ser. Precice ist eine ausgereifte Open-Source-Kopplungsbibliothek, die partitionierte Multiphysik-Simulationen in Python erm\u00f6glicht. Dieses Tutorial zeigt, wie man FIPY mit einem anderen Solver unter Verwendung von Precice koppelt und die Installation, die Implementierung von Adaptern, die Konfiguration und die \u00fcblichen Fallstricke abdeckt. Sie erfahren, wann Sie [&hellip;]","og_url":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/","og_site_name":"matforge.org","article_published_time":"2026-07-30T12:22:32+00:00","author":"steven","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"steven","Gesch\u00e4tzte Lesezeit":"14\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/#article","isPartOf":{"@id":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/"},"author":{"name":"steven","@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03"},"headline":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python","datePublished":"2026-07-30T12:22:32+00:00","mainEntityOfPage":{"@id":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/"},"wordCount":1839,"commentCount":0,"articleSection":["FIPY: Dokumentation, Beispiele &amp; Entwicklung"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/","url":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/","name":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python - matforge.org","isPartOf":{"@id":"https:\/\/matforge.org\/#website"},"datePublished":"2026-07-30T12:22:32+00:00","author":{"@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03"},"breadcrumb":{"@id":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/matforge.org\/de\/code-coupling-precice-multi-physics-python\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/matforge.org\/de\/"},{"@type":"ListItem","position":2,"name":"Code-Kopplung mit Pr\u00e4zise: Multiphysik-Simulationen in Python"}]},{"@type":"WebSite","@id":"https:\/\/matforge.org\/#website","url":"https:\/\/matforge.org\/","name":"matforge.org","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/matforge.org\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Person","@id":"https:\/\/matforge.org\/#\/schema\/person\/8f690fb596d657b12994b83caa788f03","name":"steven","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/d46cfcd83a298f27e8d66bfa035514fefca7652f26bd3ef7402f82b68a41ec0f?s=96&d=mm&r=g","caption":"steven"},"url":"https:\/\/matforge.org\/author\/steven\/"}]}},"_links":{"self":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/816","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/comments?post=816"}],"version-history":[{"count":1,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/816\/revisions"}],"predecessor-version":[{"id":992,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/posts\/816\/revisions\/992"}],"wp:attachment":[{"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/media?parent=816"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/categories?post=816"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/matforge.org\/wp-json\/wp\/v2\/tags?post=816"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}