Measure wellbore storage and when it ends

The early hours of a drawdown on a log-log plot: the storage coefficient from the unit slope, the dimensionless storage, the time storage ends by the (60 + 3.5 s) CD rule, and permeability from the radial plateau that follows.

Open in the workbench

Engineering use cases UC-PTA-003 (Evaluate Wellbore Storage) and UC-PTA-009 (Interpret Flow Regimes).

When a well opens, the first barrels come out of the wellbore, not the reservoir. While that lasts, Δp and its derivative lie on one unit-slope line, Δp = q B t / (24 C), so any point on it gives C. The rock only takes over once storage has died away: the drawdown rule is tD > (60 + 3.5 s) CD, with CD = 0.8936 C / (φ ct h rw²) (Ahmed, Reservoir Engineering Handbook; Economides et al., Petroleum Production Systems). Before then a semilog line, and the permeability read off it, belongs to the wellbore. FlowRegimeSignatures picks both windows off the Bourdet derivative.

What an engineer learns from it: the unit slope gives C = 0.0101 bbl/psi against the 0.01 of the model. CD is 361, so storage lasts until 0.53 hours, and the pickers find the radial plateau from 0.79 hours, about one and a half log cycles after the unit slope ends at 0.016 hours, the classic rule of thumb. The hump between the two is the skin. The plateau at 8.49 psi gives k = 99.8 mD against 100.

Field units: C in bbl/psi, t in hours, q in STB/d. For a buildup the end-of-storage rule is a different one, 50 CD e^(0.14 s). A storage coefficient that changes during the test (phase segregation, a closing valve) bends the unit slope, and this constant-C model will not match it.

Source

using System;
using System.Linq;
using Team76.Engineering.PTA.Diagnostics;
using Team76.Engineering.PTA.MathFunctions;
using Team76.Engineering.PTA.Models;

public class S : ICalcScript
{
    public ScriptResult Run(ICalcContext ctx)
    {
        // The first hours of a drawdown at 500 STB/d, from the library's model: 100 mD over 50 ft, skin 5, and
        // 0.01 bbl/psi of wellbore storage (a wellbore of fluid expanding as the well opens).
        double q = 500, bo = 1.2, mu = 1.0, h = 50, phi = 0.2, ct = 1e-5, rw = 0.5, k = 100, skin = 5, trueC = 0.01;
        var model = new PtaModel(
            new Fluid { Ul = mu, B = bo },
            new Well { Rw = rw, SkinFactor = skin, C = trueC },
            new Reservoir { K = k, H = h, Porosity = phi, Ct = ct });
        var t = Enumerable.Range(0, 51).Select(i => Math.Pow(10, -3 + i * 0.1)).ToArray();
        var dp = t.Select(x => model.PressureDrop(x, q)).ToArray();

        // The log-log diagnostic, and the windows the slope pickers find on it: unit slope, then the radial plateau.
        var series = LogLogDiagnostic.FromDrawdown(t, dp);
        var storage = FlowRegimeSignatures.FindStorage(series).First();
        var radial = FlowRegimeSignatures.FindIarf(series).Last();

        // On the unit slope the well produces only from its own wellbore: Δp = q B t / (24 C), so C = q B t / (24 Δp).
        double c = q * bo / 24 * t[0] / dp[0];

        // Dimensionless storage CD = 0.8936 C / (φ ct h rw²), and the drawdown rule for its end, tD > (60 + 3.5 s) CD.
        double cd = Dimensionless.WellboreStorageCoefficient(c, phi, ct, h, rw);
        double endOfStorage = Dimensionless.ElapsedTime((60 + 3.5 * skin) * cd, k, phi, mu, ct, rw);

        // The plateau the derivative reaches gives kh: Δp' = 70.6 q B μ / (k h).
        double plateau = series.Points[radial.EndIndex].Bourdet;
        double kFromPlateau = 70.6 * q * bo * mu / (h * plateau);

        var plot = new ScriptChart(
            [
                new ScriptSeries("Δp", t, dp),
                new ScriptSeries("Bourdet derivative", series.Points.Select(p => p.Time).ToArray(), series.Points.Select(p => p.Bourdet).ToArray()),
                new ScriptSeries("Unit slope, C from the early data", t.Take(25).ToArray(), t.Take(25).Select(x => q * bo * x / (24 * c)).ToArray()),
            ],
            title: "Wellbore storage on the diagnostic plot", xLabel: "t (hr)", yLabel: "Δp, Δp' (psi)", xLog: true, yLog: true);

        return ctx.Result()
            .Set("Diagnostic plot", plot)
            .Set("C from the unit slope (bbl/psi)", Math.Round(c, 4))
            .Set("C in the model (bbl/psi)", trueC)
            .Set("CD", Math.Round(cd, 1))
            .Set("Unit slope ends (hr)", Math.Round(storage.EndTime, 4))
            .Set("End of storage, (60 + 3.5 s) CD (hr)", Math.Round(endOfStorage, 2))
            .Set("Radial flow found from (hr)", Math.Round(radial.StartTime, 2))
            .Set("Derivative plateau (psi)", Math.Round(plateau, 2))
            .Set("k from the plateau (mD)", Math.Round(kFromPlateau, 1));
    }
}