Black-oil simulation is usually dominated by fully implicit nonlinear solves rather than explicit stencil propagations as in seismic processing. Compute sizing is therefore driven by active cells, unknown count, adaptive time-step behavior, Newton iterations, linear solver iterations, Jacobian sparsity, well-model overhead, memory footprint, and benchmark-derived effective throughput.
The most important practical point: unlike RTM there is no single clean law like \(f_{\max}^4\). Black-oil runtime is mostly an implicit-solver problem. The best end-to-end estimate combines analytic sizing with one representative benchmark-derived effective throughput.
Fill these in.
| Parameter | Symbol | Example |
|---|---|---|
| Total cells in grid | \(N_{\mathrm{cell}}\) | 120,000,000 |
| Active cells | \(N_{\mathrm{act}}\) | 85,000,000 |
| Average connected neighbors per active cell | \(N_{\mathrm{conn}}\) | 6 |
| Black-oil primary variables per active cell | \(N_v\) | 3 |
| Number of wells | \(N_{\mathrm{well}}\) | 400 |
| Well unknowns per well / control block | \(N_{\mathrm{wu}}\) | 2 |
| Total simulated time | \(T_{\mathrm{sim}}\) | 20 years |
| Number of report steps | \(N_{\mathrm{rpt}}\) | 240 |
| Average nonlinear time steps per report step | \(N_{\Delta t/\mathrm{rpt}}\) | 4 |
| Average Newton iterations per time step | \(N_{\mathrm{Nwt}}\) | 5 |
| Average linear iterations per Newton step | \(N_{\mathrm{Lin}}\) | 18 |
| Parameter | Symbol | Example |
|---|---|---|
| Nodes per run | \(N_{\mathrm{node}}\) | 64 |
| Usable memory per node | \(M_{\mathrm{node}}\) | 480 GB |
| Effective sustained simulator throughput | \(P_{\mathrm{node}}\) | \(4.5\times 10^9\) \(N_{\mathrm{nz}}\)-iter/s per node |
| Parallel efficiency at chosen node count | \(\eta_{\mathrm{scale}}\) | 0.72 |
| Cluster utilization | \(U\) | 0.85 |
| Target wall time for the case | \(H_{\mathrm{wall}}\) | 8 hours |
| Number of cases in campaign | \(N_{\mathrm{case}}\) | 120 |
\(P_{\mathrm{node}}\) must be derived empirically from a benchmark or bounded from memory bandwidth.
All quantities in this calibration must correspond to totals over the full simulation run.
A standard three-phase black-oil model tracks water, oil, and gas flow with phase appearance and disappearance handled through formation-volume factors, solution gas–oil ratio, and optionally oil vaporization in gas. Production simulators commonly solve these equations in a fully implicit way, so each time step requires assembly of a nonlinear residual and Jacobian, followed by Newton updates and repeated sparse linear solves.
For compute planning, the physics detail that matters most is not the exact constitutive formula but how many unknowns and couplings it produces. In a standard black-oil formulation, the cell unknown count is usually treated as three primary variables per active cell.
The first quantity that matters is the number of active simulation cells:
where \(f_{\mathrm{act}}\) is the active-cell fraction after removing inactive cells, null regions, pinch-outs handled out of system, and any cells excluded from the flow solve.
Reservoir simulators scale primarily with \(N_{\mathrm{act}}\), not total geometric cells. If local grid refinement, near-well refinement, or fault handling increases the active count or the average neighbor count, cost rises accordingly.
For black-oil, the first-order unknown count is:
and the total unknown count including wells is:
In many field cases, the well-unknown contribution is numerically much smaller than the cell-unknown count, but wells can still have a large impact on nonlinear difficulty and timestep chopping.
The dominant sparse matrix is the Jacobian assembled at each Newton step. For planning, approximate the matrix connectivity using an average number of connected neighboring cells \(N_{\mathrm{conn}}\).
Define the coupled block count per cell as
Then a useful scalar nonzero estimate for the cell-cell Jacobian block is
Adding well couplings gives
with
where \(N_{\mathrm{perf}}\) is the total number of perforations and \(\alpha_{\mathrm{well,nz}}\) is a small formulation-dependent constant. For most large field cases, the cell-cell block still dominates the matrix size.
For a 3-variable black-oil system with approximately 6 neighbors per active cell, \(N_{\mathrm{blk}}\approx 7\) and therefore
scalar nonzeros before accounting for wells and extra coupling structure. Corner-point transmissibility patterns, NNCs, faults, and local refinement can raise this noticeably.
This can easily be pushed 2–3× higher by:
Unlike RTM, black-oil simulation is not usually sized by a CFL-driven fixed time step. Modern simulators use adaptive time stepping, so the right planning quantity is the actual number of accepted nonlinear time steps.
This is one of the most important user inputs. Runtime can vary by multiple × for identical grids purely due to timestep behavior. It depends heavily on controls, well events, saturation fronts, compressibility, schedule changes, convergence tolerances, timestep chop/retry logic, and whether the case includes difficult phases such as gas liberation.
A reservoir case with the same grid can vary by several times in runtime simply because one schedule converges with large stable time steps and another repeatedly chops time steps near control changes, breakthroughs, or phase transitions.
Total Newton solves:
Total linear solves:
where \(N_{\mathrm{Lin}}\) is the average linear iterations per Newton step and
for the number of Krylov iterations.
A useful first-order work model is to count sparse-matrix operations as nonzeros touched per linear iteration. Then total linear-algebra work is
where \(\alpha_{\mathrm{lin}}\) absorbs how much work is done per Krylov iteration including sparse matrix-vector multiply, preconditioner application, vector updates, reductions, and residual evaluation.
If you use CPR-type preconditioning, \(\alpha_{\mathrm{lin}}\) is often much larger than a bare SpMV count because the pressure stage, restriction/prolongation, smoothers, and auxiliary solves all add work. In reality, \(\alpha_{\mathrm{lin}}\) can be 5–20× SpMV as it is dominated by preconditioning cost.
Reservoir simulation cost is not only the linear solver. Each Newton step also includes flux assembly, accumulation terms, relative permeability, capillary pressure, PVT lookups, well equations, and automatic-differentiation/Jacobian construction if used.
Model this separately as
where \(\alpha_{\mathrm{asm}}\) is an empirical per-cell assembly cost.
Total end-to-end work becomes
with \(W_{\mathrm{io}}\) capturing restart/output work and \(W_{\mathrm{sched}}\) capturing schedule parsing, well-control logic, and other non-kernel overheads.
In planning work, the cleanest method is often to replace the detailed constants above with a measured black-oil campaign multiplier.
Then define the normalized case work as
This collapses assembly, well overhead, preconditioner cost, and implementation details into one calibration constant. It is the reservoir-simulation equivalent of using an end-to-end RTM throughput instead of trying to model every stencil and overhead term analytically.
If you size from an analytic nonzero-based throughput, runtime is
where
and \(P_{\mathrm{node}}\) is the sustained per-node effective throughput for the chosen work unit. That work unit must match the numerator. If your work is \(N_{\mathrm{nz}}\)-based, your throughput must also be \(N_{\mathrm{nz}}\)-based. Mixing units, such as \(N_{\mathrm{nz}}\)-based work with FLOP-based throughput, invalidates the estimate.
Common valid choices are:
If instead you benchmark end-to-end directly, use
The accounting quantity needed for campaign planning is
where \(N_{\mathrm{cluster}}\) is the number of nodes required in the cluster to finish the total campaign inside the target wall-clock window \(H_{\mathrm{wall}}\).
Memory can be the dominant feasibility constraint for large black-oil cases. You need enough memory for grid/rock/fluid state, Jacobian, Krylov vectors, preconditioner data structures, halo buffers, wells, and output buffering.
where \(b_{\mathrm{state}}\) includes primary variables, saturations, pressures, mobilities, transmissibilities, PVT properties, relperm/capillary auxiliary arrays, and temporary work arrays.
For example, in double precision with 8-byte values, 4- or 8-byte column indices, and 8-byte row pointers, the Jacobian alone can be very large.
Here \(N_{\mathrm{vec}}\) is the number of simultaneously resident Krylov/work vectors and \(\alpha_{\mathrm{prec}}\) is an empirical multiplier for the chosen preconditioner hierarchy.
where \(\gamma_{\mathrm{mem}}\) is a safety factor for fragmentation, transient peaks during assembly/preconditioning, and implementation overhead. A prudent planning value is usually greater than 1.1 and often closer to 1.2–1.4 for production sizing.
The per-node memory requirement is
Feasibility requires
Black-oil simulators do not strong-scale indefinitely. Communication and coarse-grid / pressure-solve behavior eventually dominate. A useful planning view is
where
Krylov methods and CPR-style preconditioners can suffer from global synchronizations and coarse-stage imbalance, so reservoir simulation often loses efficiency earlier than embarrassingly parallel shot-based seismic workloads.
As subdomains become smaller, each node owns fewer cells but must still exchange boundary values and participate in global reductions. That causes the surface-to-volume ratio and synchronization cost to rise. The result is that runtime usually stops improving long before memory is exhausted.
For procurement or architecture work, the benchmark-derived effective throughput is usually more trustworthy than any fully analytic estimate, because it captures real preconditioner behavior, software overhead, communication, and timestep acceptance patterns.
If you need a compact planning view, use the following:
Those are the black-oil equivalents of the simple seismic sizing laws. They are not exact, but they identify the dominant growth terms correctly.
RTM sizing is dominated by explicit wave-propagation work over a fixed spatial-temporal discretization. Black-oil sizing is dominated by repeated implicit nonlinear solves whose cost depends on convergence behavior. In practice this means: