Choke Size Calculation: The Gilbert Equation

By Saad Iqbal

Picture a production engineer on a Tuesday afternoon, a well test sheet in one hand and a calculator in the other, nudging a bean size up one notch, down one notch, trying to land a flowing wellhead pressure the pipeline won’t reject. It is the kind of arithmetic that eats twenty minutes and still leaves you guessing whether 22/64″ or 24/64″ is the right call. The choke size calculation you are about to automate removes that guesswork entirely: given a liquid rate, a gas-liquid ratio, and a target wellhead pressure, the Gilbert equation hands you a bean size in one line of code — and this tutorial shows you exactly how to get there, by hand first, then in Python.

What You’ll Need Before You Start

Prerequisites

A well test or production data point: gross liquid rate (STB/d), producing gas-liquid ratio (scf/STB), and the target or measured flowing wellhead pressure (psig).
The downstream flowline or separator pressure, so you can confirm the flow through the choke is critical (sonic) — the Gilbert-family correlations are only valid under that condition.
Python 3.9+ with NumPy installed (pip install numpy), available free from python.org.
Comfort with basic algebra — every step below is arithmetic you can check on a phone calculator.

If you haven’t yet built the inflow performance side of this picture, it’s worth reading Nodal Analysis: Find Your Well’s Operating Point first — the choke is simply the last restriction the fluid sees after the reservoir and tubing have already had their say.

Step 1: Confirm the Flow Through the Choke Is Critical

Gilbert’s equation, and the Ros, Baxendell, and Achong correlations that followed it, were all fitted to critical (sonic) flow data. In critical flow, the fluid velocity at the choke throat hits the local speed of sound, which means downstream pressure changes can no longer influence the rate upstream — the choke “decouples” the wellhead from the flowline. The field rule of thumb used throughout the industry is that flow is critical when the downstream pressure is below roughly 70% of the upstream pressure:

P₂ / P₁ ≤ 0.70 → critical flow, correlation applies

Why this matters: if you skip this check and the well is actually in subcritical flow (a long, low-pressure-drop flowline, for instance), the Gilbert equation will hand you a confident, precise, and wrong answer. For our well, the flowline runs at 300 psig against a wellhead target of 650 psig: 300/650 = 0.46, comfortably under 0.70, so we’re clear to proceed.

Step 2: Gather the Well Data the Equation Actually Needs

Four numbers drive every choke-sizing correlation. Why each one matters:

Gross liquid rate, qₗ (STB/d) — oil plus water. Get this from the most recent well test, not a nameplate number.
Producing gas-liquid ratio, GLR (scf/STB) — higher GLR means more gas energy helping push liquid through the bean, so for the same pressure drop you can run a smaller choke.
Target wellhead pressure, P_wh (psig) — usually set by the flowline or separator inlet requirement plus a safety margin.
Choke/bean size, S (64ths of an inch) — this is the unknown we’re solving for.

For this worked example: qₗ = 800 STB/d, GLR = 600 scf/STB, target P_wh = 650 psig.

Step 3: Apply the Gilbert Equation and Solve for Choke Size

Gilbert’s 1954 correlation, still the first one taught in every nodal analysis course, is:

P_wh = 10.00 · qₗ · GLR^0.546 / S^1.89

with P_wh in psig, qₗ in STB/d, GLR in scf/STB, and S in 64ths of an inch. Rearranged to solve for the bean size we actually want:

S = [ 10.00 · qₗ · GLR^0.546 / P_wh ]^1/1.89

Plugging in our numbers:

GLR^0.546 = 600^0.546 = 32.87
S = [ 10.00 × 800 × 32.87 / 650 ]^1/1.89 = [ 404.6 ]^0.529 ≈ 23.97

Since chokes come in standard sizes, you’d round up to the nearest available bean — 24/64″ (0.375 in). Why round up rather than down: undersizing (rounding down) would force a higher wellhead pressure than you can actually hold without choking back flow more than planned, while a slightly larger bean than the exact arithmetic answer still keeps you in critical flow and errs toward not restricting production unnecessarily.

Step 4: Automate the Calculation and Check the Sensitivity

Doing this by hand for one well is fine. Doing it for forty wells every time a test comes back is exactly the kind of repetitive arithmetic Python exists to remove. The function below solves for choke size given rate, GLR, and target pressure, and then sweeps a range of standard bean sizes so you can see how sensitive predicted rate is to bean size — useful when you’re choosing between two adjacent standard sizes.

import numpy as np

def gilbert_choke_size(q_l, glr, p_wh, C=10.00, b=1.89, c=0.546):
    """
    Solve the Gilbert (1954) choke equation for required bean size.
    q_l  : gross liquid rate, STB/d
    glr  : producing gas-liquid ratio, scf/STB
    p_wh : target flowing wellhead pressure, psig
    Returns bean size S in 64ths of an inch.
    """
    return (C * q_l * glr**c / p_wh) ** (1.0 / b)

def gilbert_rate(S, glr, p_wh, C=10.00, b=1.89, c=0.546):
    """Forward model: predicted liquid rate for a given bean size S."""
    return (p_wh * S**b) / (C * glr**c)

q_l, glr, p_wh = 800.0, 600.0, 650.0
S_required = gilbert_choke_size(q_l, glr, p_wh)
print(f"Required bean size: {S_required:.2f} / 64 in")

# Sensitivity sweep across standard bean sizes
for S in [16, 20, 24, 28, 32, 36, 40]:
    q_pred = gilbert_rate(S, glr, p_wh)
    print(f"  S = {S:>2}/64 in  ->  predicted q_L = {q_pred:,.0f} STB/d")

Running this prints Required bean size: 23.97 / 64 in, matching the hand calculation exactly, and the sensitivity sweep shows predicted rate climbing from 373 STB/d at a 16/64″ bean to 2,108 STB/d at 40/64″ — a reminder that choke performance is highly nonlinear, and the difference between adjacent standard sizes can swing your rate by hundreds of barrels a day.

Step 5: Why Trust One Correlation When You Can Check Four?

Gilbert isn’t the only game in town. Ros, Baxendell, and Achong published their own versions of the same functional form, each fitted to a different field’s data — Shell’s lab data, Middle East wells, and Trinidad wells respectively. Running all four against the same inputs tells you how much the answer actually depends on which correlation your spreadsheet happens to use:

correlations = {
    "Gilbert":   (10.00, 1.89, 0.546),
    "Ros":       (17.40, 2.00, 0.500),
    "Baxendell": (9.56,  1.93, 0.546),
    "Achong":    (3.82,  1.88, 0.650),
}

for name, (C, b, c) in correlations.items():
    S = (C * q_l * glr**c / p_wh) ** (1.0 / b)
    q_at_24 = (p_wh * 24.0**b) / (C * glr**c)
    print(f"{name:10s}  S_required = {S:5.2f} /64 in   "
          f"q_L at 24/64 bean = {q_at_24:,.0f} STB/d")

For our well, the four correlations call for bean sizes between 20.8/64″ and 24.0/64″, and at a fixed 24/64″ bean they predict rates from roughly 803 to 1,047 STB/d — close enough to agree on “24/64″ is reasonable,” different enough that you shouldn’t treat any single correlation’s output as gospel without a field check. This is also the point where it’s worth skimming Vogel IPR Equation: Calculate AOF and the IPR Curve — the choke only matters in the context of what the reservoir can actually deliver into it.

What Result Should You Expect?

For qₗ = 800 STB/d, GLR = 600 scf/STB, and a 650 psig wellhead target, you should land on a bean size in the 20–24/64″ range depending on correlation, with Gilbert itself pointing to 24/64″. If your number comes out below 8/64″ or above 64/64″, you’re outside the range these correlations were fitted to (roughly 300–5,000 scf/STB GLR and 8–64 in choke sizes) and the answer isn’t trustworthy.

Sanity Check Your Answer

Plug your computed S back into the forward form of the equation along with your GLR and target P_wh, and confirm it returns your original qₗ within a percent or two — the gilbert_rate() function above does exactly this. If it doesn’t round-trip, check for a units mix-up before trusting the result; GLR entered in Mscf/STB instead of scf/STB is the single most common mistake. It’s also worth pasting your final formula into an AI assistant such as ChatGPT or Claude and asking it to check your unit conversions line by line before you commit the number to a drawdown program.

Common Pitfalls

Using the equation outside critical flow. If your flowline pressure is above roughly 70% of wellhead pressure, none of these four correlations apply — you need a subcritical multiphase flow model instead, and the pressure drop downstream deserves its own check with something like the Beggs and Brill correlation.
Mixing up scf/STB and Mscf/STB for GLR. A factor-of-1000 error here produces a choke size that’s wildly wrong but still looks plausible at a glance.
Trusting a single correlation blindly. As Step 5 shows, Gilbert, Ros, Baxendell, and Achong can disagree by 20–30% on predicted rate for the same bean. Calibrate against your own field’s choke performance data whenever you have it.

If you want to extend this into a broader petroleum-engineering automation stack, petropt is a free Python library covering PVT correlations, decline curves, and material balance that pairs well with the choke-sizing functions above.