"How long will this CFD run take?" — the question every engineer asks before hitting Solve, and the one nobody can answer confidently. Guess too low and you blow your deadline (or your cloud-compute budget); guess too high and you over-provision expensive HPC nodes. This free CFD Time-Step & Runtime Estimator turns that guess into an engineering estimate: enter your CFL target, mesh size, physical time and core count, and it computes the stable time step, the number of steps, and a wall-clock time — plus a calibration mode that uses a short test run to make the estimate genuinely accurate.
Table of Contents
The Runtime Estimator
Use Estimate mode for a first-principles projection, or Calibrate mode to back-calculate your solver's true speed from a short test run (far more accurate). All times are for transient simulations.
⏱️ CFD Time-Step & Runtime Estimator
Why Estimate Runtime?
A runtime estimate is one of the most practically valuable things you can compute before a CFD job — yet it's rarely taught. Knowing it lets you:
- Plan deadlines — will this finish overnight, or take a week?
- Budget cloud/HPC cost — core-hours translate directly to money on AWS, Azure or a cluster allocation.
- Right-size the hardware — find the core count that's fast and efficient.
- Sanity-check the setup — an absurd estimate often reveals a meshing or time-step mistake.
Step 1: The CFL Time Step
For a transient simulation, the time step is set by the Courant–Friedrichs–Lewy (CFL) condition:
where Δx is the smallest cell size and U the maximum velocity. The Courant number measures how many cells information crosses per step. For explicit solvers, CFL must stay below 1; implicit solvers tolerate more but accuracy still limits it. This is the same quantity explored in depth in our CFL / Courant number calculator — the estimator builds directly on it.
Step 2: Number of Time Steps
Simply the physical time you want to simulate divided by the time step. Want 2 seconds of physics at a 1×10−4 s step? That's 20,000 steps — every one of which the solver must grind through.
Step 3: Cost Per Step
Each time step costs roughly:
The per-cell time folds in the inner iterations (pressure–velocity coupling), turbulence model, and solver overhead. It typically ranges from about 1–20 microseconds per cell per step on modern CPUs — but it varies so much by solver and physics that measuring it beats guessing (see calibration below).
Step 4: Parallel Scaling
Finally, running on multiple cores divides the work — but never perfectly:
Parallel efficiency captures the communication overhead between cores. It's typically 50–80% up to tens or hundreds of cores, and it drops when there are too few cells per core.
| Cells per core | Typical efficiency |
|---|---|
| < 20,000 | Poor — communication-bound |
| 20,000 – 100,000 | Good — the sweet spot |
| > 200,000 | Fine, but you could add cores |
The Calibration Trick
Here's what makes this estimator trustworthy rather than a wild guess. The one uncertain number is the solve time per cell per step — so measure it instead of guessing:
- Run your real case for just a few time steps (say 10–50).
- Note the wall time it took and the cores/efficiency used.
- The calculator back-solves your solver's true per-cell speed.
- It then projects the full run using that calibrated value.
Worked Example
Transient case: CFL = 1, Δx = 2 mm, U = 30 m/s, simulate 1 s, mesh 2,000,000 cells, 16 cores at 75% efficiency, ~2 µs/cell/step:
- Δt = 1 × 0.002 / 30 = 6.67×10−5 s
- Steps = 1 / 6.67e-5 = 15,000
- Single-core time = 15,000 × 2,000,000 × 2e-6 s = 60,000 core-s (16.7 core-hr)
- Wall = 60,000 / (16 × 0.75) = 5,000 s ≈ 1.4 hr
- Cells/core = 2,000,000 / 16 = 125,000 — good efficiency range ✓
Common Mistakes
- Guessing the per-cell time. It varies 10× by solver/physics — calibrate from a short run.
- Ignoring the mesh–timestep coupling. Finer cells shrink Δt too, so cost grows faster than cell count.
- Assuming 100% parallel scaling. Efficiency is 50–80%, and worse with few cells per core.
- Forgetting inner iterations. Each step may need several — fold them into the per-cell time.
- Timing from a tiny sample with heavy start-up. Initialisation/I-O can dominate 5–10 steps; use enough steps.
- Neglecting I/O and write intervals. Frequent field writes add real wall-clock time.
- Using someone else's scaling. Scaling is solver- and hardware-specific — test your own.
Frequently Asked Questions
How do you estimate CFD simulation time?
Find the CFL time step, count steps as physical time / Δt, multiply cells by a per-cell solve time for the cost per step, multiply by steps for single-core time, then divide by cores × efficiency for wall-clock time. Calibrate the per-cell time from a short test run for accuracy.
How is the CFD time step calculated from the CFL number?
Δt = CFL · Δx / U, where Δx is the smallest cell and U the max velocity. Explicit solvers need CFL < 1; implicit allow more but accuracy still limits it.
Why does CFD take so long to run?
Runtime = steps × cost/step. Fine meshes raise both cell count and step count (smaller Δt), so cost grows faster than cells alone. Inner iterations and physics models add more per-cell cost.
Does doubling the cores halve the runtime?
Only at 100% efficiency. Real efficiency is 50–80% and falls with too few cells per core, so beyond a point extra cores give diminishing returns.
What is a good number of cells per core?
Roughly 20,000–100,000 cells per core for good efficiency. Too few and communication dominates; the ideal depends on solver and hardware, so run a short scaling test.
How accurate is a CFD runtime estimate?
First-principles gives the right order of magnitude. Calibrating from a short test run — measuring real per-cell speed — typically brings it within a modest margin.
Conclusion
Estimating CFD runtime is a chain of four simple steps: the CFL time step, the number of steps, the cost per step, and parallel scaling. Do it from first principles for a ballpark, then calibrate from a short test run to turn that ballpark into a dependable plan. Either way, you'll walk into your next simulation knowing roughly what it will cost in time and money — instead of hitting Solve and hoping.
Use the estimator above before your next transient run, keep an eye on your cells-per-core, and let a quick calibration make the number one you can actually schedule around.
For more CFD, meshing and simulation tutorials plus free engineering calculators, explore Free CFD Tutorial. If this tool helped you, please share it with your fellow CFD engineers and students.