Neural Latent Arbitrary Lagrangian-Eulerian Grids for Fluid-Solid Interaction

This paper introduces Fisale, a data-driven framework that leverages multiscale latent Arbitrary Lagrangian-Eulerian grids and a partitioned coupling module to effectively model complex, nonlinear two-way fluid-solid interactions across diverse 2D and 3D scenarios.

The Gist

🌊 The Big Problem: When Water Hits a Wall (or a Wing)

Imagine you are watching a movie of a hurricane hitting a skyscraper, or blood flowing through a heart valve. In the real world, the wind pushes the building, making it sway, and that swaying changes how the wind flows around it. This is called Fluid-Solid Interaction (FSI).

• Fluid: The moving stuff (water, air, blood).
• Solid: The stationary or moving stuff (a bridge, a wing, a heart valve).

The Challenge:
Most computer simulations treat the solid object like a rigid statue. They say, "Okay, the wind blows, but the building doesn't move." This is easy to calculate but wrong.
In reality, things bend, twist, and vibrate. When a flexible wing bends, it changes the airflow, which changes the pressure, which bends the wing more. It's a chaotic, two-way dance.

Existing AI models are great at predicting the wind, or great at predicting the building, but they struggle to learn the dance between them. They often get confused, lose track of where the boundary is, or crash when the bending gets too extreme.

🚀 The Solution: Enter "Fisale"

The authors created a new AI framework called Fisale. Think of it as a super-smart choreographer for this fluid-solid dance. It doesn't just guess; it understands the rules of the dance by borrowing ideas from old-school physics and giving them a modern AI upgrade.

Here is how Fisale works, broken down into three simple concepts:

1. The "Magic Grid" (Latent ALE Grids)

The Analogy: Imagine a trampoline.

• Old Way: You try to track every single grain of sand on the trampoline (too hard!) or you try to track every single air molecule (impossible!).
• Fisale's Way: Fisale creates a "Magic Grid" (a net) that floats in the space between the air and the object.
  • This grid is special. It's not stuck to the air (Eulerian) and it's not stuck to the object (Lagrangian). It's Arbitrary.
  • The Trick: If the object bends, the grid bends with it. If the air rushes in, the grid stretches. It acts like a flexible, invisible skin that hugs both the fluid and the solid, keeping them connected.
  • Multiscale: Fisale uses two of these grids at once: a coarse one (like a wide-angle camera) to see the big picture, and a fine one (like a zoom lens) to see the tiny details where the bending happens.

2. The "Special Guest" (Explicit Interface Modeling)

The Analogy: A diplomatic summit.

• In many AI models, the "Solid" and the "Fluid" sit at the same table and try to talk to each other directly. But they speak different languages! The solid talks about stress and strain; the fluid talks about pressure and velocity. They often misunderstand each other.
• Fisale's Way: Fisale introduces a Third Party: The Interface.
  • It treats the boundary where the wind hits the wing as a distinct character with its own voice.
  • Instead of forcing the wind and the wing to talk directly, they both talk to the Interface. The Interface listens to the wind, tells the wing what to do, listens to the wing, and tells the wind how to flow.
  • This prevents the AI from getting confused about "who is who" when the shapes get messy.

3. The "Step-by-Step" Dance (Partitioned Coupling)

The Analogy: Learning a complex dance routine.

• Old Way (Monolithic): The AI tries to learn the entire dance in one giant leap. "Move left, spin, jump, twist!" It often trips over its own feet.
• Fisale's Way (Partitioned): The AI breaks the dance into small, manageable steps.
  1. Step 1: The wind pushes the wing. (Update the solid).
  2. Step 2: The wing moves, so the grid shifts. (Update the grid).
  3. Step 3: The new grid shape changes how the wind flows. (Update the fluid).
  4. Step 4: The wind and wing check in with the Interface to make sure they agree. (Update the interface).
  • It repeats these small steps over and over (iteratively). This allows the AI to handle complex, non-linear movements without getting overwhelmed.

🏆 Why It Matters (The Results)

The authors tested Fisale on three tough real-world scenarios:

1. Oscillating Beam: A flexible beam in a river that vibrates wildly.
2. Venous Valve: A heart valve opening and closing (very tricky because it touches itself!).
3. Flexible Wing: An airplane wing bending under wind pressure.

The Outcome:
Fisale beat almost every other AI model.

• It predicted the shape of the bending wing more accurately.
• It didn't crash when the heart valve closed tightly.
• It could even guess what would happen in wind conditions it had never seen before (generalization).

💡 The Takeaway

Think of Fisale as a translator and a choreographer rolled into one.

• It uses a flexible grid to keep the fluid and solid connected.
• It gives the boundary its own voice so nothing gets lost in translation.
• It breaks the problem into small steps so it can learn the complex dance of nature without tripping.

This means we can now use AI to design better airplanes, safer bridges, and even better medical devices, all by simulating how things bend and flow together in a way that was previously too difficult for computers to handle.

Technical Summary

1. Problem Statement

Fluid-Solid Interaction (FSI) involves the complex, two-way coupling between a deformable solid and a surrounding fluid. The solid deforms due to fluid forces, while the fluid flow is altered by the solid's motion and changing geometry.

• Challenges: Existing deep learning methods for FSI are predominantly limited to one-way scenarios (static, rigid solids) or simplified two-way cases.
• Limitations of Current Approaches:
  • Monolithic Modeling: Treating fluid and solid as a single unified domain often fails to capture distinct physical behaviors and bidirectional dependencies, especially under large deformations.
  • Lack of Interface Awareness: Most models do not explicitly model the coupling interface, leading to instability and inaccuracies in predicting dynamic interactions.
  • Mesh Dependency: Traditional numerical methods (e.g., Immersed Boundary Method, ALE) are computationally expensive and mesh-dependent.
  • Scalability: Existing neural operators struggle with the multiscale nature of FSI (e.g., global aerodynamic forces vs. local structural deformations) and the heterogeneity of Lagrangian (solid) and Eulerian (fluid) descriptions.

2. Methodology: Fisale Framework

The authors propose Fisale, a purely data-driven framework inspired by classical numerical methods: the Arbitrary Lagrangian-Eulerian (ALE) method and Partitioned Coupling Algorithms.

Core Components:

1. Explicit Interface Modeling:

   • Unlike previous works that merge domains, Fisale treats the fluid, solid, and coupling interface as three distinct, parallel components. This allows the model to explicitly learn the dynamics specific to the interface.

2. Multiscale Latent ALE Grids:

   • Concept: Instead of solving directly on heterogeneous meshes, Fisale projects all physical quantities onto a set of latent ALE grids.
   • Initialization: These grids are initialized via a "regular grid seeding" followed by a geometry-aware offset. The offset is calculated based on the distance to fluid, solid, and interface points, ensuring grid nodes cluster around regions of interest (interfaces).
   • ALE Principle: The grid evolves in latent space with a motion decoupled from both material points (Lagrangian) and fixed spatial coordinates (Eulerian), providing a unified representation for cross-domain physics.
   • Multiscale: The framework employs parallel pathways with different grid resolutions ($H$ pathways). Coarse grids capture global structures, while fine grids handle local interactions and deformations.

3. Partitioned Coupling Module (PCM):

   • Inspired by classical partitioned solvers, the PCM decomposes the complex nonlinear problem into sequential substeps within a deep learning architecture.
   • Four-Step Iterative Process:
     1. Update Solid State: Uses cross-attention to update the solid based on current fluid and interface states.
     2. Update Grid Coordinates: Applies a learned, velocity-based Laplacian smoothing strategy to update the latent grid positions, mimicking mesh motion to accommodate deformation.
     3. Update Fluid State: Updates the fluid state based on the new solid and grid positions using cross-attention.
     4. Update Interface Influence: Uses self-attention to align and reconcile information across all three domains (fluid, solid, interface).
   • Stacking: Multiple PCM layers are stacked to progressively refine the solution and capture complex interdependencies.

4. Encoding and Decoding:

   • Encoding: Physical quantities are projected from the original observation space to the latent ALE grid using attention-based weighted interpolation.
   • Decoding: Updated features are projected back to the original space for aggregation across different scales.

3. Key Contributions

• Novel Architecture: Introduction of Fisale, the first purely data-driven framework to explicitly model the coupling interface as an independent component alongside fluid and solid, utilizing multiscale latent ALE grids.
• Partitioned Learning Strategy: Adaptation of classical partitioned coupling algorithms into a deep learning module (PCM) that iteratively solves sub-problems, effectively handling strong nonlinearity and bidirectional coupling.
• Unified Representation: Development of a geometry-aware latent ALE grid that bridges the gap between Lagrangian (solid) and Eulerian (fluid) descriptions, enabling mesh-independent learning.
• State-of-the-Art Performance: Demonstration of superior accuracy and stability across diverse, challenging FSI benchmarks compared to over 10 advanced baselines (including Neural Operators, Transformers, and GNNs).

4. Experimental Results

The framework was evaluated on three reality-related, challenging FSI tasks:

| Task | Description | Challenge | Metric | Performance |
| :--- | :--- | :--- | :--- :--- |
| Structure Oscillation | Elastic beam in flow (FLUSTRUK-A). | Strong two-way coupling, self-sustained oscillation. | Relative L2 | Best (0.0066 mean error). Outperformed CoDA-NO and LNO, especially in fluid prediction. |
| Venous Valve | Opening/closing of heart valves. | Large deformation, contact discontinuities, autoregressive simulation. | RMSE | Best across all quantities (Geometry, Stress, Pressure, Velocity). Maintained stability over long rollouts where others failed. |
| Flexible Wing | 3D wing deformation under airflow. | Steady-state inference, massive mesh points (>35k), geometry-dependent loading. | Relative L2 | Best (0.0136 mean error). Successfully handled large-scale data where baselines like GINO and CoDANO degraded significantly. |

• Out-of-Distribution (OOD) Generalization: Fisale demonstrated robust generalization on Reynolds numbers ($Re=4000$) not seen during training ($Re \in \{200, 400, 2000\}$), attributed to its ability to capture flow patterns across scales.
• Efficiency: Despite the complex architecture, Fisale maintains competitive inference times and significantly lower GPU memory usage compared to GNN-based and Transformer-based baselines, particularly on large meshes.

5. Significance

• Bridging Physics and AI: Fisale successfully translates the robust logic of classical numerical methods (ALE and partitioned coupling) into a neural architecture, offering a new paradigm for scientific machine learning.
• Solving the "Two-Way" Gap: It addresses a critical gap in the literature by effectively handling two-way FSI with large deformations, a scenario where most existing deep learning models fail or require simplifying assumptions.
• Scalability: The multiscale latent grid approach allows the model to scale to high-resolution 3D problems (e.g., flexible wings) without the computational explosion typical of monolithic neural operators.
• Practical Impact: The ability to accurately simulate complex interactions (like blood flow in veins or aircraft wing deformation) has immediate applications in biomedical engineering, aerospace design, and civil engineering, potentially accelerating the design cycle and reducing reliance on expensive traditional solvers.

In conclusion, Fisale represents a significant advancement in learning-based PDE solvers, offering a flexible, accurate, and scalable solution for the most challenging fluid-solid interaction problems.