Choosing Between Implicit and Explicit Transient Solvers in NPSS

Decision: which transient solver to use in NPSS

When setting up a transient NPSS run you must pick either the implicit Newton‑Raphson solver or the explicit Runge‑Kutta (RK4) solver. The choice affects stability, accuracy, runtime, and the effort needed to get a converged solution.

Useful takeaway

Use the implicit solver for stiff, high‑fidelity engine cycles (e.g., turbine‑combustor interactions) when you can afford a higher per‑step cost but want larger time steps. Use the explicit RK4 solver for mildly transient studies, control‑system tuning, or when you need a simple, easy‑to‑debug setup and can tolerate many small steps.

Constraints that shape the decision

• Required simulation fidelity – high‑fidelity chemistry and rotating machinery benefit from implicit stability.
• Model stiffness – stiff systems (large eigenvalue spread) demand implicit or very small explicit steps.
• Available computational time – implicit needs fewer steps but each step is heavier due to Jacobian assembly.
• Licensing level – the implicit solver is available in NPSS Base; the explicit RK4 solver is also Base, but advanced hybrid options require NPSS Advanced.

Comparison of supported options

h>CPU cost per step

Solver	Stability	Accuracy (typical order)	Typical step count	Best suited for
Implicit Newton‑Raphson	Unconditionally stable for stiff systems	Second‑order (with line search)	Higher (Jacobian assembly, linear solve)	Fewer (larger Δt possible)	Stiff, high‑fidelity engine cycles, turbine‑combustor transients
Explicit Runge‑Kutta 4 (RK4)	Conditionally stable; Δt must satisfy CFL‑like limit	Fourth‑order	Lower (function evaluations only)	Many (small Δt required)	Mildly transient studies, control‑system tuning, quick‑turn experiments

Trade‑offs explained

The implicit solver removes the strict Δt limitation by solving a nonlinear system at each step. This allows you to step through fast dynamics (e.g., fuel‑valve actuation) with a step size limited only by accuracy, not stability. However, each iteration requires forming and factoring the Jacobian; a poor initial guess or badly scaled variables can cause the Newton iteration to stall or diverge, leading to non‑convergence warnings.

The explicit RK4 solver evaluates the model derivatives four times per step and advances the state directly. It is straightforward to implement and debug because there is no linear solve. The downside is that the step size must be small enough to keep the numerical error bounded; for stiff propulsion models this often means Δt on the order of microseconds, which can make a simple transient run take hours or days.

Concrete implementation in an NPSS deck

Place the solver definition inside the <Transient> block of your .npss file. Below are two minimal examples; replace <modelName> with the actual top‑level component name of your deck.

Implicit Newton‑Raphson example

<Transient>
    <Solver type="NewtonRaphson">
        <Tolerance>1e-5</Tolerance>
        <MaxIter>20</MaxIter>
    </Solver>
    <!-- other transient settings (start, stop, output) -->
</Transient>

Run the case from a terminal with sufficient filesystem permissions to read the input files and write output:

npss -i myEngine.npss -o run_implicit

Check the run directory for run_implicit/newton.out (or similar) which contains iteration counts and residual norms. Convergence is indicated when the residual drops below the tolerance within the allowed MaxIter.

Explicit RK4 example

<Transient>
    <Solver type="RungeKutta4">
        <DeltaT>0.001</DeltaT>  
    </Solver>
    <!-- other transient settings -->
</Transient>

Execute similarly:

npss -i myEngine.npss -o run_rk4

Look for run_rk4/rk4.out which logs the step‑by‑step progress. Because the solver is explicit, you will see many more steps; ensure the total simulated time matches your <StopTime> setting.

Validation and practical checks

To confirm that the selected solver behaves as expected, run the NPSS verification case that ships with the installation:

npss -i $NPSSHOME/verification/Turbojet_Transient.npss -o verify_run

Two output files will be produced: verify_run/Turbojet_Transient_newton.out and verify_run/Turbojet_Transient_rk4.out. Compare the thrust‑time history in each file to the reference values given in the NPSS Verification Manual (typically a column labeled Thrust). A match within 1 % over the entire transient interval indicates the solver is working correctly for that case.

If you are using your own model, a quick sanity check is to monitor a key variable (e.g., turbine inlet temperature) and verify that it changes smoothly and stays within physical bounds. Sudden jumps or NaNs often signal solver instability or a bad initial guess for the implicit method.

Limitations and version notes

• The table above reflects NPSS 6.x behavior. NPSS 7.0 introduced a hybrid solver that attempts to switch between implicit and explicit based on stiffness; this option is absent in earlier releases.
• Implicit convergence can be sensitive to variable scaling. If you observe frequent Newton failures, try nondimensionalizing inputs or adjusting the <Scaling> block (if present).
• Explicit RK4 requires the user‑provided Δt to resolve the fastest time constant in the model. An automated Δt estimator is not built‑in; you must estimate it from known frequencies (e.g., blade‑passing frequency) or perform a short trial run.

Summary of steps for the engineer

1. Assess model stiffness and required fidelity.
2. If the model is stiff or you need large Δt, choose implicit Newton‑Raphson; otherwise, pick explicit RK4 for simplicity.
3. Edit the <Transient><Solver> block as shown above.
4. Run the case, check the solver‑specific log for convergence or step count.
5. Validate against the supplied verification case or a known good transient, ensuring key outputs match reference within 1 %.