A Dual-Compartment Neural Jump Surrogate for Genetic Inversion of Fractured Reservoirs

Fractured reservoirs behave like two connected tanks. Cracks (fractures) carry fluid quickly but hold little. Dense rock (the matrix) holds most of the fluid but releases it slowly into the cracks. Engineers infer the hidden properties of both tanks by searching for parameters that make a simulator reproduce a well's measured pressures and flow rates. Genetic algorithms do this search well when the misfit surface is rugged. They are population-based optimizers that evolve candidate parameter sets by selection, recombination and random perturbation. Their weakness is cost: they need thousands of simulator runs. Field data add a second problem. Measurements arrive at irregular times, and the well is shut in, choked or reopened on schedules that differ from well to well. Today's pipelines bin these data onto a fixed grid.

We propose a learned stand-in for the simulator, a surrogate, that is fast enough to sit inside a genetic algorithm. It predicts production at any requested timestamp under any operating schedule. Its hidden state is split into a fast "fracture" part and a slow "matrix" part, coupled by a learned transfer term that copies the structure of dual-porosity physics. When the operator changes the well's operation, the state takes a discrete jump. The point of this design is to fix a known mismatch. Neural Jump ODEs, which jump at event times, are proven optimal only when the hidden state is Markovian, meaning the future depends only on the present state. Fractured-reservoir production looks non-Markovian because the matrix drains with long memory. Giving the model an explicit matrix compartment should restore the Markov property, the same way the dual-porosity equations do. That should make the surrogate accurate enough that the optimizer's answer does not drift away from the answer the true simulator would give.

Core Claim

Dual-porosity coupling should be the structural prior of a continuous-time surrogate, not just the physics being simulated. A surrogate with this structure, conditioned on reservoir parameters and on an arbitrary piecewise operating schedule, will do two things on transient fractured-reservoir production with irregular sampling and irregular shut-ins. First, it will produce genetic-algorithm inversions whose parameter estimates and forecasts match those of a genetic algorithm run on the full simulator. Second, it will do so with one to two orders of magnitude fewer full-simulator calls. A generic continuous-time surrogate, or a fixed-grid surrogate interpolated in time, will not meet the first condition because their errors grow during late-time matrix drainage and after shut-ins.

Background and Positioning

On the reservoir side, the parameter-inversion template comes from The Inversion Method of Shale Gas Effective Fracture Network Volume Based on Flow Back Data. That work runs a genetic algorithm over five fracture and matrix parameters of a semi-analytic fractal-tree model, reaching R² = 0.883 (water) and R² = 0.927 (gas) on Southern Sichuan flow-back data. The approach was feasible only because the forward model was cheap and the data were regularized. We keep its optimizer and parameterization but replace the forward model with something that can stand in for a general embedded-fracture simulator.

The embedded discrete fracture model is our expensive simulator. In this method, fractures are planes cut through a regular grid rather than forcing the grid to follow them. Numerical Simulation of a Horizontal Well With Multi-Stage Oval Hydraulic Fractures in Tight Oil Reservoir Based on an EDFM shows it matches fine-grid accuracy with 3,573 rather than 9,261 cells, and it includes stress-dependent fracture permeability. This paper supplies the test setup.

Two papers address the cost of the forward model by other means, and both motivate the work. Automatic Optimization of Multi-Well Multi-Stage Fracturing Treatments couples a dual-permeability simulator to an ensemble approximate-gradient optimizer (StoSAG) and needs 30–50 iterations even for smooth design variables. Constrained energy minimization based upscaling for coupled flow and mechanics shrinks the simulator itself, from 59,124 to 1,393 unknowns at under 1% pressure error. Both still march on the simulator's fixed time steps.

The closest prior surrogate is Machine learning for flux regression in discrete fracture networks. It achieves roughly a 40,000× speedup at about 1.8% error. However, it predicts steady-state fluxes on a fixed geometry and was never placed inside an inversion loop. Our surrogate is transient, conditioned on the operating schedule, and evaluated inside the optimizer.

On the time-series side, three papers supply the method. Neural Jump Ordinary Differential Equations combines continuous hidden-state drift with jumps at event times and proves convergence to the optimal prediction, assuming a Markovian state. It reports 1.33 versus 4.24 for GRU-ODE-Bayes on the Heston benchmark. Neural Jump Stochastic Differential Equations provides the drift-plus-jump formulation and a way to backpropagate through the jumps. Both papers treat the hidden state as a generic vector, and neither has been used on physical systems with known control shocks.

Two further papers serve as the main alternative designs. Multi-Time Attention Networks handles irregular times by attending to fixed reference times and trains more than 85× faster than ODE-RNN. Interpolation-Prediction Networks first interpolates irregular inputs onto smooth trends, short transients and observation intensity. We use both as competing surrogate architectures.

Research Program

The surrogate maps reservoir parameters $\theta$ and an operating schedule $u(t)$ (a piecewise-constant rate or pressure control) to predicted observations at arbitrary times. Its hidden state is split into a fracture block $z_f$ and $K$ nested matrix blocks $z_m^{(1)},\dots,z_m^{(K)}$. Between control changes, the state evolves as

$$\frac{dz_f}{dt} = a_\theta(z_f, u) + \sum_{k} T^{(k)}_\theta\big(z_m^{(k)}, z_m^{(k-1)}\big)\Big|_{k=1}, \qquad \frac{dz_m^{(k)}}{dt} = -\omega_\theta\, T^{(k)}_\theta\big(z_m^{(k)}, z_m^{(k-1)}\big) + T^{(k+1)}_\theta\big(z_m^{(k+1)}, z_m^{(k)}\big).$$

Here $z_m^{(0)}\equiv z_f$, and $T^{(K+1)}\equiv 0$. Each $T^{(k)}$ is a small network constrained to be antisymmetric in its two arguments, so that whatever leaves one compartment enters the next. $\omega_\theta$ is a learned storage ratio. Each $T^{(k)}$ is the transfer from compartment $k$ to the compartment nearer the fracture, so the matrix drains outward in steps. The first matrix block, $k=1$, is the only one that exchanges directly with the fracture block, which is why only $T^{(1)}$ appears in the fracture equation.

The nesting mirrors how multi-compartment dual-porosity models represent slow, non-pseudo-steady matrix drainage. With $K=0$ the model reduces to a generic jump-ODE surrogate. At each control change $t_c$, the fracture block jumps, $z_f \leftarrow z_f + j_\theta(z_f, u(t_c^-), u(t_c^+))$, and the matrix blocks carry over unchanged. This builds in the physical fact that a shut-in changes fracture pressure abruptly while the matrix responds slowly. A decoder then reads rates and bottom-hole pressure from $z_f$ at whatever timestamps the field data contain.

Training data come from embedded-fracture simulations in the setup of the tight-oil horizontal-well study. Each run samples parameters (fracture conductivity, matrix permeability, storage ratio, stress-sensitivity coefficient, fracture half-length) and a random schedule with irregular shut-ins and rate changes. Simulator output is subsampled at irregular times with dropouts.

The inversion loop is a real-coded genetic algorithm whose fitness is the misfit at the observed timestamps only, with no binning. Surrogate error can mislead the search, so we use standard surrogate management. Each generation, the top few individuals are re-evaluated with the true simulator, and those runs are added to a growing set used to fine-tune the surrogate. The fixed total budget of true-simulator calls is the key cost axis.

Because the population ends with many good fits, we also report how spread out the final set of acceptable parameter vectors is. Distinct parameter sets can produce near-identical production curves, so the inversion should report that ambiguity rather than a single point.

Baselines

The naive reference is the prior: forecasts from the prior-mean parameters, plus a genetic algorithm run on data binned to weekly averages with forward-fill. The binned run tests whether native irregular handling matters at all. It uses the same true-simulator budget, with the simulator reporting on the weekly grid.

The strongest competitor is a genetic algorithm run directly on the embedded-fracture simulator, with the simulator set to report exactly at the observed timestamps. This is the practice in Tang et al. extended to a full simulator, and it carries no surrogate bias. We run it twice. The first run uses the same budget of true-simulator calls as our method, to test efficiency. The second uses a ten-times-larger budget and serves as the reference answer, to test fidelity. Population size and mutation rates are tuned with an identical small grid for every genetic-algorithm variant.

On the analogous field problem, the only reported result is R² = 0.883 for water and 0.927 for gas flow-back, from Tang et al.'s genetic algorithm on the Sichuan data. If that dataset can be obtained, we report the same R² metric on it. For inversion on our embedded-fracture setup, we found no reported result on Lacuna.

The strongest surrogate competitors fall into three groups.

The first is a fixed-grid multi-output network in the style of Berrone et al.. It maps parameters plus an encoded schedule to production on a dense uniform grid, which is then linearly interpolated to the observation times.

The second group is two generic continuous-time surrogates, both with the same parameter conditioning, training set and parameter count as ours:

  • an mTAN decoder (Shukla & Marlin 2021);
  • a single-block jump ODE (our model with $K=0$, essentially NJ-ODE with control jumps).

The third is CMA-ES, an evolution strategy that adapts a Gaussian search distribution. It replaces the genetic algorithm, uses our surrogate, and gets the same budget. This separates the choice of optimizer from the choice of surrogate.

The ablations that isolate the key ingredient vary three things: the number of matrix blocks ($K = 0, 1, 2, 4$), whether the antisymmetric transfer constraint is on or off, and whether jumps are taken at control changes or the schedule is fed only as a continuous input.

Our method beats the field if two conditions hold. First, at equal true-simulator budget, its parameter error and held-out forecast error are no worse than the reference genetic algorithm's. Second, every surrogate competitor shows a significantly larger gap to the reference, tested across 30 synthetic wells with paired comparisons.

Why not just…?

Why not just run the genetic algorithm on the simulator, which can already report at any timestamp? This is the most serious alternative. The honest answer is that irregular timestamps alone do not require a learned model, because a simulator can be told to report at exactly the observed times. A surrogate is justified only by cost. Tang et al. could evaluate their model directly because it was a simplified analytic tree. Our equal-budget comparison against the direct-simulator genetic algorithm settles this. If the direct run reaches comparable parameter error within the same number of calls, the surrogate is unnecessary at this problem size, and we will say so. We expect the surrogate to matter more as the number of parameters grows, so we repeat the test at five and at twelve parameters.

Why not just train a fixed-grid surrogate and interpolate? Production curves are smooth during steady drainage, so this may work well there. The likely failure is right after shut-ins and rate changes at arbitrary times, where pressure moves fastest and where the fixed grid either misses the event or must be made very fine. To test this, we measure surrogate error in windows after control events separately from error in steady-drainage windows.

Why not just use a generic continuous-time model such as mTAN or a plain jump ODE? mTAN is faster to train (Shukla & Marlin 2021) and may be accurate early on. Our hypothesis is that, without a slow compartment, both generic models misfit late-time matrix drainage. The $K=0$ case violates the Markov assumption on which NJ-ODE rests. Errors that grow at late times bias the inferred matrix parameters in particular. The $K$-sweep and the comparison of how each parameter's error breaks down test this directly. If mTAN matches us on matrix-parameter recovery, the structural prior is not doing the work we claim.

Why not just use gradient-based history matching through the differentiable surrogate? Our surrogate is differentiable, so this is cheap to try, and we include multi-start gradient descent as a check. Multi-start descent returns one optimum per start. The genetic population, by contrast, is meant to recover the set of parameters that fit equally well. We compare how much of the reference set of acceptable fits each method covers.

Proposed Experiments

Sanity checks. Before inversion, we check that our jump-ODE implementation reproduces the Heston result (1.33) reported for NJ-ODE. We also measure surrogate accuracy on held-out embedded-fracture runs with unseen schedules. Error is reported separately in early, post-shut-in and late-drainage windows.

Main experiment. We run synthetic inversions on 30 embedded-fracture wells. Each has irregular sampling (roughly 50–90% of a dense daily record dropped) and irregular shut-ins. We report four outcomes:

  • error in the recovered parameters, normalized by each parameter's prior range;
  • forecast error on the final 30% of the record, which the inversion never saw;
  • the number of true-simulator calls needed to come within a set tolerance of the reference answer;
  • coverage of the reference set of acceptable fits.

Decisive check. The decisive check is the late-drainage window. If matrix compartments are the reason the surrogate works, then the gap between $K=0$ and $K\geq1$ should be small early and grow with time. The corresponding error in the inferred storage ratio and matrix permeability should follow the same pattern. If that pattern does not appear, the dual-porosity structure is decorative and the core claim fails.

Field test. As a field-facing test, we would apply the full pipeline to Sichuan flow-back data at their native irregular timestamps, if the data are accessible. We would compare against Tang et al.'s R² values and their 0.705 correlation between the inferred effective fracture network volume and the volume estimated from microseismic monitoring.