🤖 machine learning

NewPINNs: Physics-Informing Neural Networks Using Conventional Solvers for Partial Differential Equations

The paper introduces NewPINNs, a novel framework that integrates conventional numerical solvers directly into the training loop of physics-informed neural networks to enforce physical laws and boundary conditions through solver-consistency, thereby overcoming common optimization challenges and loss-weighting sensitivities inherent in standard residual-based approaches.

Original authors: Satish Chandran, Maedeh Makki, Maziar Raissi, Adrien Grenier, Behzad Mohebbi

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Satish Chandran, Maedeh Makki, Maziar Raissi, Adrien Grenier, Behzad Mohebbi

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 trying to teach a student how to navigate a complex maze.

The Old Way (Standard PINNs):
Traditionally, scientists used a method called "Physics-Informed Neural Networks" (PINNs). In this approach, you give the student a map of the maze and a list of strict rules: "You must never hit a wall," "You must follow the wind," and "You must start at the door." You then punish the student every time they make a mistake based on these rules. The problem is that the rules are often conflicting, the math is incredibly hard to balance, and the student gets confused, often giving up or learning the wrong path. It's like trying to teach someone to drive by shouting a thousand different traffic laws at them simultaneously while they are still learning to hold the steering wheel.

The New Way (NewPINNs):
The paper introduces NewPINNs, a smarter way to train these "students" (neural networks). Instead of shouting rules at them, the researchers pair the student with a professional driver (a traditional, proven computer solver).

Here is how the NewPINNs "pull-push" method works, using a simple analogy:

The "Guess and Check" Game

The Student Guesses (The Pull):
The neural network (the student) looks at the starting conditions and makes a guess about what the solution looks like. It says, "I think the water level here will be high, and the wind will blow this way."
The Pro Driver Takes Over (The Push):
Instead of checking if the guess follows a list of abstract rules, the researchers feed that guess into a professional numerical solver. Think of this solver as a highly experienced, unshakeable driver who knows exactly how physics works. The solver takes the student's guess and runs it forward in time or through the maze for a few steps. It says, "Okay, if we start with your guess, here is exactly what happens next according to the laws of physics."
The Comparison (The Lesson):
Now, the student makes a new guess for that next moment. The researchers compare the student's new guess with what the Pro Driver actually produced.
- If the student's guess matches the Pro Driver's result, they are on the right track.
- If they don't match, the student learns: "Oh, I was wrong. The Pro Driver showed me that if I start here, the wind actually pushes me there."
Repeating the Loop:
They do this over and over. The student learns by watching the Pro Driver correct their path. Eventually, the student becomes so good at predicting what the Pro Driver will do that they can skip the driver entirely and just give the correct answer instantly.

Why This is a Big Deal

The paper claims this method solves several headaches that the old method had:

No More "Rule Confusion": The old method tried to balance many different mathematical rules at once, which often caused the training to fail. NewPINNs lets the Pro Driver handle all the complex rules (boundary conditions, physics laws, stability). The student just has to learn to mimic the Pro Driver.
It Works with "Black Box" Tools: The Pro Driver doesn't need to be a math genius that can explain how it solved the problem. It can be a standard, commercial software tool (like those used by engineers to design cars or planes) that the researchers don't even have to modify. They just use it as a "black box" that gives the right answer.
Handling the "Hard Stuff": The paper shows this works even for messy, chaotic situations where the old method usually fails, such as:
- Fluids: Simulating water swirling around a cylinder or air moving over a wing.
- Shocks: Predicting how a dam break creates a sudden, sharp wave.
- 3D Structures: Calculating how a metal beam with holes will bend under pressure.

The "Inverse" Trick (Solving Mysteries)

The paper also shows how to use this for "Inverse Problems." Imagine you see a photo of a car crash (the result) but you don't know how fast the car was going (the cause).

In the old way, this was very hard.
With NewPINNs, the system guesses a speed, runs it through the Pro Driver to see what the crash would look like, and compares it to the real photo. It keeps adjusting the speed guess until the simulated crash matches the real photo perfectly. The paper shows this works even if the photo is blurry or noisy.

The Bottom Line

The authors are essentially saying: Stop trying to teach the AI the laws of physics directly. Instead, let the AI learn by watching a trusted, proven computer program do the work. The AI learns to become a "twin" of that program—fast, accurate, and capable of solving complex problems without getting stuck on the math.

The paper demonstrates this success across various scenarios, from 2D fluid flow to 3D solid mechanics, proving that this "student learns from the pro" approach is a robust way to solve difficult engineering and science problems.

Technical Summary: NewPINNs – Physics-Informing Neural Networks Using Conventional Solvers

Problem Statement

Solving partial differential equations (PDEs) is fundamental to scientific and engineering disciplines, yet analytical solutions are rarely available for complex systems. While traditional numerical methods (Finite Difference, Finite Volume, Finite Element) have long provided accurate solutions, they can be computationally expensive for repeated queries. Deep learning approaches, specifically Physics-Informed Neural Networks (PINNs), have emerged as a data-efficient alternative by embedding physical laws directly into the loss function via automatic differentiation.

However, standard PINNs face significant structural limitations that hinder their reliability in complex scenarios:

Optimization Difficulties: The loss landscape is a complex, non-convex weighted sum of PDE residuals, boundary conditions (BCs), and initial conditions (ICs), often leading to convergence failures in stiff or multi-scale systems.
Hyperparameter Sensitivity: Balancing competing loss terms requires delicate, problem-specific tuning of scalar weights.
Spectral Bias: Neural networks tend to learn low-frequency functions first, struggling with high-frequency dynamics or sharp gradients where PDE residuals provide weak gradient signals.
Differentiability Constraints: Many "hybrid" approaches require differentiable solvers, limiting the use of established, optimized commercial black-box solvers.

Methodology: The NewPINNs Framework

The authors introduce NewPINNs, a framework that fundamentally alters how physics is injected into neural networks. Instead of minimizing PDE residuals derived via automatic differentiation, NewPINNs couples the neural network directly with a conventional numerical solver in a closed-loop "pull-push" training procedure.

Core Mechanism

The Pull: The neural network ( $f_{NN}$ ) generates a candidate solution state (e.g., a field $u$ at time $t_n$ or a steady-state guess).
The Push: This candidate state is fed into a traditional numerical solver ( $S$ ) (e.g., FVM, FEM) as an initial condition or iterate. The solver advances the state to $t_{n+1}$ or performs $N_s$ iterations toward equilibrium, enforcing boundary conditions and physical laws implicitly through its discretization.
Solver-Consistency Loss: The training objective minimizes the discrepancy between the network's prediction at the next step and the solver-evolved state.
- Transient Systems: The loss compares $f_{NN}(t_{n+1})$ with $S[f_{NN}(t_n)]$ . An additional term enforces the initial condition.
- Steady-State Systems: The loss compares the network's output $f_{NN}(\alpha)$ with the result of applying the solver for a small number of iterations $N_s$ to that same output. The network learns to produce states that are fixed points (or near-fixed points) of the solver.
- Optimization-Based Steady-State: For problems defined by energy minimization (e.g., elasticity), the solver is reinterpreted as an iterative optimizer. The network learns to produce fields that satisfy the discrete equilibrium equations (first-order optimality) under the solver's update rule.

Key Distinctions

Black-Box Solver: The solver is treated as a non-differentiable operator. It does not participate in gradient computation; gradients flow only through the neural network. This allows the use of legacy, highly optimized commercial solvers (e.g., COMSOL, Ansys, NGSolve, FiPy) without modification.
No Explicit Residuals: The framework eliminates the need for explicit PDE residual terms and boundary condition penalties in the loss function, as these are enforced by the solver itself.
Inverse Problems: The framework extends to inverse problems by jointly optimizing the network weights and unknown physical parameters. The inverse loss matches the network's prediction to noisy observations, while the forward solver-consistency loop ensures the solution remains physically admissible.

Key Contributions

Novel Training Paradigm: Proposes a solver-consistency training loop that replaces residual-based loss functions with a "pull-push" interaction between the network and a conventional solver.
Solver Agnosticism: Demonstrates that established numerical solvers can be used as black-box constraint operators, removing the requirement for differentiable physics or custom solver implementations.
Mitigation of PINN Failure Modes: By delegating physics enforcement to the solver, the method avoids optimization pathologies, sensitivity to loss weighting, and spectral bias associated with standard PINNs.
Broad Applicability: The framework is validated across diverse numerical discretizations (Finite Volume and Finite Element), problem types (steady-state and transient), and physical regimes (linear, nonlinear, hyperbolic, and elliptic).

Experimental Results

The authors evaluated NewPINNs on six benchmark problems using Finite Volume (FVM) and Finite Element (FEM) solvers:

2D Fokker–Planck Equation (FVM): A steady-state convection-diffusion problem. The network learned the equilibrium Boltzmann density across a range of potential parameters ( $\alpha \in [1, 2]$ ) with $L_2$ errors below $5 \times 10^{-3}$ .
2D Lid-Driven Cavity (FEM): A high-Reynolds number ( $Re \in [2000, 3000]$ ) fluid flow problem known to be difficult for standard PINNs. NewPINNs successfully captured primary recirculation and secondary corner vortices, with RMS errors below $10^{-2}$ .
1D Variable-Coefficient Advection (FVM): A transient hyperbolic problem with discontinuous initial data. The network accurately tracked the propagation and deformation of Gaussian and top-hat profiles.
Inverse Advection Problem: Recovered the unknown advection parameter from noisy observations (5–15% noise) with absolute errors below 0.5%, demonstrating robustness in parameter identification.
2D Flow Past a Cylinder (FEM): A transient problem involving periodic von Kármán vortex shedding ( $Re \in [50, 100]$ ). Using sinusoidal time embeddings, the network captured oscillatory wake dynamics and pressure fields, with errors remaining low across the parameter range.
Radial Dam Break (FVM): A nonlinear hyperbolic system with discontinuous shocks. The network reproduced the outward-moving bore and inward rarefaction, handling sharp features without spurious oscillations.
3D Linear Elasticity (FEM): A vector-valued steady-state problem on a perforated beam. The network learned the displacement field for varying Poisson's ratios, achieving ~4% RMS error relative to the displacement magnitude.

In all cases, the inverse problems successfully recovered unknown parameters from noisy data, leveraging the forward solver-consistency constraints to maintain physical validity.

Significance and Claims

The paper claims that NewPINNs offers a principled alternative to standard PINNs by shifting the burden of physical enforcement, boundary condition satisfaction, and numerical stability to established, robust numerical solvers.

Physical Validity without Residuals: The network learns to produce "physically admissible" states by being repeatedly exposed to the solver's action, effectively learning a surrogate (or "twin") of the solver that respects the underlying discretization's stability and invariance properties.
Robustness: The approach mitigates common PINN failure modes, particularly in stiff, nonlinear, and high-Reynolds number regimes where residual-based methods often fail.
Practicality: By treating solvers as black boxes, the framework allows researchers to leverage decades of development in commercial and open-source numerical software without needing to derive differentiable versions of these solvers.
Limitations: The authors note that training may require solver-admissible initialization (e.g., Kaiming initialization) and warm-starting strategies, particularly for strongly nonlinear or discontinuous systems, to ensure the solver can successfully advance the network's initial predictions.

The work concludes that solver-coupled learning is a flexible approach for constructing reusable scientific surrogates and solving parameter-identification problems across computational physics and engineering, bridging the gap between data-driven learning and classical numerical analysis.