🔢 mathematics

Deflation-based preconditioning for immersed finite element methods and immersogeometric analysis

This paper addresses the severe ill-conditioning caused by small cut elements in immersed finite element methods and immersogeometric analysis by demonstrating the limitations of existing preconditioning strategies and proposing a robust deflation-based technique tailored to these challenges.

Original authors: Yannis Voet, Matthias Möller, Pablo Antolin, Cornelis Vuik

Published 2026-04-15

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Yannis Voet, Matthias Möller, Pablo Antolin, Cornelis Vuik

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are an architect trying to build a house. In the old days, you had to draw every single brick and beam perfectly to match the shape of your land. If your land had a weird curve or a jagged rock, you had to cut every brick to fit it exactly. This was slow, expensive, and prone to errors.

Immersed Finite Element Methods (IFEM) are like a modern shortcut. Instead of cutting bricks to fit the land, you lay down a giant, perfect grid of square tiles over the whole area (the "fictitious domain"). Then, you simply tell the computer, "Only keep the parts of the tiles that are inside the house; ignore the rest."

This is incredibly flexible! You can design any crazy shape without re-drawing the grid. However, this shortcut creates a new, nasty problem: The "Tiny Crumb" Issue.

The Problem: Tiny, Unstable Crumbs

When you slice through your perfect grid of tiles, some tiles get cut into tiny, jagged slivers. Imagine a tile that is 99% outside the house and only a tiny 1% inside.

In the math world, these tiny slivers cause a massive headache. They make the computer's calculations "unstable." It's like trying to balance a skyscraper on a single grain of sand. The computer tries to solve the equations, but the numbers get so huge and messy (a problem called ill-conditioning) that the solver gets stuck, takes forever, or crashes completely.

The Old Solutions: Band-Aids and Hacks

Scientists have tried to fix this for years with various "band-aids":

The "Fake Weight" Method (Stabilization): They add a fake, heavy weight to the tiny slivers to make them feel bigger. Problem: This changes the physics of the house. You aren't solving the problem you set out to solve; you're solving a slightly different, "heavier" version.
The "Glue" Method (Polynomial Extension): They try to glue the tiny sliver to its big neighbor so they act as one big piece. Problem: This is tricky to do without messing up the math, and sometimes the glue fails.
The "Block" Method (Schwarz Preconditioning): They group the tiny slivers into blocks and try to solve the blocks separately. Problem: The paper shows that if the cut happens in a specific, unlucky way (like a "middle cut" or a "corner cut"), these blocks get confused and the method fails.

The New Solution: The "Deflation" Vacuum Cleaner

The authors of this paper propose a new, elegant solution called Deflation-based Preconditioning.

Think of the computer's calculation as a room full of people trying to find the exit.

The Problem: Most people are moving fine, but a few people are stuck in a tiny, dark corner (the tiny slivers). Because they are stuck, they keep bumping into everyone else, slowing down the whole room.
The Old Way: You try to push the stuck people out or glue them to the wall.
The Deflation Way: You realize, "Hey, we know exactly where those stuck people are!" You simply lift them out of the room (mathematically speaking) and solve the problem for the rest of the crowd first. Once the main crowd is moving smoothly, you put the stuck people back in and solve their tiny problem separately.

In technical terms, the method identifies the "bad" basis functions (the ones supported only on tiny cuts) and creates a special "vacuum" that removes their influence from the main calculation. It treats the problem globally, rather than trying to patch it locally.

Why is this a Big Deal?

The authors didn't just invent a new tool; they also proved that the old tools were flawed. They created specific, tricky geometric shapes (like a house with a roof ridge cut exactly in the middle of a grid line) to show that the popular "Block" and "Glue" methods would fail.

Their new "Deflation" method, however, works like a charm on these tricky shapes. It doesn't change the physics of the house, it doesn't require complex glue, and it handles the tiny crumbs effortlessly.

The Takeaway

This paper is like finding a master key for a very difficult lock. It shows that instead of trying to force the tiny, broken pieces to fit (which breaks the math), we should simply acknowledge them, isolate them, and solve the rest of the puzzle first. This makes complex engineering simulations—like designing car parts, airplane wings, or medical implants—much faster, more accurate, and much less likely to crash.

In short: When your geometry is cut into tiny, messy pieces, don't try to patch the mess. Just vacuum it out, solve the clean part, and then deal with the dust separately. That's the power of deflation.

1. Problem Statement

Immersed Finite Element Methods (IFEM) and Immersogeometric Analysis (IGA) allow for the simulation of complex geometries by embedding them into a simple, unfitted background mesh. While this avoids the time-consuming process of generating body-fitted meshes, it introduces a critical numerical challenge: severe ill-conditioning of the system matrices.

Root Cause: When the physical domain boundary cuts through background elements, it creates "trimmed" elements with arbitrarily small volume fractions ( $\eta$ ). Basis functions supported only on these small elements lead to extremely small eigenvalues in the system matrix (stiffness or mass matrix).
Consequences: This ill-conditioning causes iterative solvers (like Conjugate Gradient) to converge extremely slowly or stagnate.
Limitations of Existing Solutions:
- Stabilization methods (e.g., $\alpha$ -stabilization, Ghost Penalty): Modify the variational formulation or approximation space, potentially introducing errors or altering the physical problem.
- Polynomial Extension/Aggregation: Modify the basis functions to extend support, which changes the approximation space.
- Existing Preconditioners (Jacobi, SIPIC, Schwarz): While they preserve the original formulation, the paper argues they are not robust. Specifically, SIPIC (Symmetric Incomplete Permuted Inverse Cholesky) fails to detect certain near-linear dependencies, and Schwarz preconditioners rely on block selection strategies that are not universally robust against complex cut configurations.

2. Methodology and Analysis

The authors employ a rigorous analytical and numerical approach to diagnose the failure of existing methods and propose a new solution.

A. Theoretical Analysis of Ill-Conditioning

The paper provides a deep theoretical analysis of the condition number ( $\kappa$ ) of the Jacobi (diagonal scaling) preconditioned matrix.

1D Analysis:
- For Lagrange bases, the condition number scales as $\kappa \sim \eta^{-2(p-1)}$ , where $p$ is the polynomial degree.
- For B-spline bases, the condition number remains independent of $\eta$ (bounded) even for $C^0$ continuity. This is a counter-intuitive finding attributed to the specific local regularity of B-spline basis functions across knots, which prevents the formation of near-linear dependencies that plague Lagrange bases.
2D Analysis:
- The behavior depends heavily on the cut configuration. The authors identify three types:
  1. Sliver-cut: Cuts along one direction.
  2. Corner-cut: Cuts around a corner.
  3. Middle-cut: Cuts through the middle of an element (pathological).
- Key Finding: For B-splines, "sliver" and "corner" cuts are well-conditioned after Jacobi scaling. However, "middle-cuts" (Configuration c) can still cause ill-conditioning, with scaling rates depending on the continuity ( $k$ ) and the position of the cut relative to knots.
- Conclusion: Diagonal scaling alone is insufficient for general 2D configurations, particularly for Lagrange bases or specific B-spline cut scenarios.

B. Critique of Existing Preconditioners

The authors construct specific counter-examples (e.g., rotated squares with holes, multiple ridges) to demonstrate the failure of:

SIPIC: Fails to detect near-linear dependencies involving three or more vectors that do not show strong pairwise correlations.
Schwarz Preconditioners: Even with advanced block selection strategies (based on intersecting supports), they fail to completely eliminate small eigenvalues in pathological cut configurations, leading to linear growth in the condition number as $\eta \to 0$ .

C. Proposed Solution: Deflation-Based Preconditioning

The authors propose a Deflation-based Preconditioner combined with Jacobi scaling.

Concept: Deflation removes the influence of the smallest eigenvalues (which cause the ill-conditioning) by projecting the system onto the orthogonal complement of the subspace spanned by the corresponding eigenvectors.
Construction of the Deflation Matrix ( $Z$ ):
- Instead of computing expensive eigenvectors, the authors construct $Z$ purely based on geometry.
- They identify "weakly supported" basis functions (those supported only on cut elements).
- The columns of $Z$ are simply the canonical basis vectors corresponding to these weakly supported functions.
- Rank-Reduction: A heuristic is introduced to reduce the size of $Z$ . It groups basis functions that share nearly identical active supports and filters out those that are "cured" by simple diagonal scaling, retaining only the truly pathological ones.
Algorithm: The method uses the Deflated Preconditioned Conjugate Gradient (DPCG) algorithm. It solves a small coarse system (involving the deflation matrix) and a projected system iteratively.

3. Key Contributions

Rigorous Scaling Analysis: The paper provides the first detailed derivation of condition number scaling relations for Jacobi preconditioning in both 1D and 2D, distinguishing between Lagrange and B-spline bases and various cut configurations. It reveals that B-splines are inherently more robust to trimming than Lagrange bases in 1D, but 2D "middle-cuts" remain problematic.
Counter-Examples: The authors provide concrete, realistic counter-examples demonstrating that state-of-the-art preconditioners (SIPIC and Schwarz) are not robust for all trimming scenarios, challenging the assumption that they are sufficient.
Geometric Deflation Strategy: The paper introduces a novel, geometry-based construction of the deflation matrix that avoids the need for explicit eigenvector computation. This makes the method computationally feasible and easy to implement.
Rank-Reduction Heuristic: A practical algorithm to minimize the size of the deflation subspace without sacrificing robustness, significantly improving efficiency.

4. Numerical Results

The proposed method was tested on various problems (L2 projection, Poisson equation, wave propagation) with varying polynomial degrees ( $p$ ), mesh sizes ( $h$ ), and cut configurations.

Condition Number:
- Jacobi: Condition number grows rapidly as $\eta \to 0$ .
- SIPIC/Schwarz: Reduce the growth rate but still exhibit linear or sub-linear growth; small eigenvalues persist.
- Deflation: The condition number of the deflated system remains bounded and independent of $\eta$ , effectively eliminating the ill-conditioning caused by trimming.
Solver Convergence:
- Iterative solvers using Jacobi, SIPIC, or Schwarz often stagnate or require thousands of iterations for small $\eta$ .
- The Deflation-based preconditioner achieves convergence in a number of iterations that is independent of the cut configuration and the volume fraction $\eta$ .
Robustness: The method successfully handled complex geometries (e.g., waveguides with multiple spikes, rotated lattices) where other methods failed to converge within reasonable iteration limits.

5. Significance

Preservation of Physics: Unlike stabilization methods, deflation does not alter the variational formulation or the approximation space. It preserves the original solution accuracy while solving the linear system efficiently.
Implementation Simplicity: The deflation matrix is constructed from simple geometric criteria (support of basis functions) and consists of columns of the identity matrix, making it easy to integrate into existing IFEM/IGA codes.
Robustness: It offers a truly robust solution to the "small cut element" problem, a major bottleneck in the industrial adoption of immersed methods.
Future Directions: The authors note that while deflation solves the trimming-induced ill-conditioning, it does not address $p$ -dependency (conditioning related to high polynomial degrees). They suggest combining this deflation strategy with $h,p$ -robust multigrid preconditioners for a complete solution.

In summary, this paper establishes that deflation is the most effective strategy for handling the ill-conditioning inherent in immersed finite element methods, outperforming existing stabilization and preconditioning techniques by mathematically isolating and removing the specific eigenmodes responsible for the numerical instability.