Part III: Reservoir & Production Engineering

Chapter 15

Natural Gas Engineering with Python

schedule15 min readfitness_center10 exercises

Why This Chapter Exists

Natural gas accounts for roughly a quarter of global energy consumption, and that share is growing. Unlike oil, which is valued primarily as a liquid fuel, gas serves as feedstock for power generation, petrochemicals, fertiliser production, and increasingly as a transition fuel in decarbonisation strategies. The engineering challenges of gas are distinct from oil: gas is compressible, its properties change dramatically with pressure and temperature, and transporting it requires either pipelines under high pressure or liquefaction at -162°C.

Every calculation in gas engineering starts with one fundamental reality: gas does not behave like an ideal gas. The ideal gas law ( $PV = nRT$ ) is a useful approximation at low pressures, but at the pressures found in reservoirs (3,000–15,000 psi) and pipelines (500–2,000 psi), real gas behaviour deviates significantly. The compressibility factor $Z$ captures that deviation, and getting $Z$ right is the foundation on which every other gas calculation rests.

This chapter builds the core gas engineering toolkit: gas property calculations, well deliverability analysis, and pipeline hydraulics. Each calculation is implemented from the underlying physics so you understand what the equations assume and when they break down.

infoWhat You Will Learn

Calculate gas properties: Z-factor, formation volume factor, compressibility, viscosity, and density
Implement the Standing-Katz correlation and the Dranchuk-Abou-Kassem (DAK) equation of state
Perform gas well deliverability analysis (AOF, IPR)
Size gas pipelines using the General Flow Equation and its simplified forms
Calculate compression requirements for gas gathering and transmission

Gas Properties

The Compressibility Factor (Z)

The real gas equation of state is:

PV = ZnRT

where $Z$ is the compressibility factor — a dimensionless number that corrects the ideal gas law for the behaviour of real gas molecules. At standard conditions (14.7 psia, 60°F), $Z \approx 1.0$ . At reservoir conditions, $Z$ can range from 0.3 to 1.2 depending on pressure, temperature, and gas composition.

$Z$ is calculated using reduced properties --- the ratio of actual conditions to the gas's critical conditions:

P_{pr} = \frac{P}{P_{pc}} \qquad T_{pr} = \frac{T}{T_{pc}}

where $P_{pc}$ and $T_{pc}$ are the pseudo-critical pressure and temperature of the gas mixture, estimated from gas specific gravity using the Sutton correlations:

P_{pc} = 756.8 - 131.0 \times \gamma_g - 3.6 \times \gamma_g^2

T_{pc} = 169.2 + 349.5 \times \gamma_g - 74.0 \times \gamma_g^2

main.py

import numpy as np

def pseudo_critical_properties(gas_sg):
    """
    Estimate pseudo-critical properties from gas specific gravity.
    Uses the Sutton (1985) correlations.

    Parameters
    ----------
    gas_sg : float
        Gas specific gravity (air = 1.0). Typical range: 0.55 to 0.90.

    Returns
    -------
    tuple
        (Ppc in psia, Tpc in deg R)
    """
    Ppc = 756.8 - 131.0 * gas_sg - 3.6 * gas_sg**2
    Tpc = 169.2 + 349.5 * gas_sg - 74.0 * gas_sg**2
    return Ppc, Tpc


# Example: 0.65 gravity gas (typical dry gas)
gamma_g = 0.65
Ppc, Tpc = pseudo_critical_properties(gamma_g)
print(f"Gas specific gravity: {gamma_g}")
print(f"Pseudo-critical pressure: {Ppc:.1f} psia")
print(f"Pseudo-critical temperature: {Tpc:.1f} deg R ({Tpc - 459.67:.1f} deg F)")

Dranchuk-Abou-Kassem (DAK) Z-Factor Correlation

The Standing-Katz chart is the industry-standard graphical method for determining $Z$ from reduced properties. The DAK correlation is an eleven-coefficient equation that fits the Standing-Katz chart to within 1% accuracy for most conditions:

main.py

import numpy as np
from scipy.optimize import brentq
import matplotlib.pyplot as plt

def z_factor_DAK(Ppr, Tpr):
    """
    Calculate gas Z-factor using the Dranchuk-Abou-Kassem (1975)
    equation of state.

    This correlation fits the Standing-Katz chart with 11 empirical
    coefficients. Valid for 1.0 ≤ Tpr ≤ 3.0 and 0.2 ≤ Ppr ≤ 15.

    Parameters
    ----------
    Ppr : float
        Pseudo-reduced pressure (dimensionless).
    Tpr : float
        Pseudo-reduced temperature (dimensionless).

    Returns
    -------
    float
        Compressibility factor Z.
    """
    # DAK coefficients
    A1, A2, A3 = 0.3265, -1.0700, -0.5339
    A4, A5, A6 = 0.01569, -0.05165, 0.5475
    A7, A8 = -0.7361, 0.6845
    A9, A10, A11 = 0.1844, 0.2016, 0.1056

    def residual(rho_r):
        """DAK residual function. Z = 0.27 * Ppr / (rho_r * Tpr)"""
        Z = 0.27 * Ppr / (rho_r * Tpr)

        F = (
            A1 + A2/Tpr + A3/Tpr**3 + A4/Tpr**4 + A5/Tpr**5
        ) * rho_r + (
            A6 + A7/Tpr + A8/Tpr**2
        ) * rho_r**2 - A9 * (
            A7/Tpr + A8/Tpr**2
        ) * rho_r**5 + A10 * (
            1 + A11*rho_r**2
        ) * (rho_r**2 / Tpr**3) * np.exp(-A11*rho_r**2) + 1 - Z

        return F

    # Solve for reduced density
    rho_r = brentq(residual, 0.001, 5.0)
    Z = 0.27 * Ppr / (rho_r * Tpr)
    return Z


# Calculate Z-factor across a range of pressures
gamma_g = 0.65
Ppc, Tpc = pseudo_critical_properties(gamma_g)

T_F = 200  # reservoir temperature, deg F
T_R = T_F + 459.67  # convert to Rankine
Tpr = T_R / Tpc

pressures_psia = np.arange(100, 10001, 100)
z_values = []

for P in pressures_psia:
    Ppr = P / Ppc
    try:
        z = z_factor_DAK(Ppr, Tpr)
    except ValueError:
        z = np.nan
    z_values.append(z)

z_values = np.array(z_values)

print(f"Gas SG: {gamma_g}, Temperature: {T_F} deg F")
print(f"Tpr: {Tpr:.3f}")
print()
print(f"{'Pressure (psia)':>16} {'Ppr':>8} {'Z':>8}")
print("-" * 36)
for P, z in zip(pressures_psia[::10], z_values[::10]):
    print(f"{P:>16,} {P/Ppc:>8.3f} {z:>8.4f}")

# Plot
fig, ax = plt.subplots(figsize=(9, 5))
ax.plot(pressures_psia, z_values, 'k-', linewidth=2)
ax.set_xlabel('Pressure (psia)', fontsize=11)
ax.set_ylabel('Z-Factor', fontsize=11)
ax.set_title(f'Gas Compressibility Factor — gamma_g = {gamma_g}, T = {T_F} deg F', fontsize=12)
ax.grid(True, alpha=0.3)
ax.axhline(y=1.0, color='gray', linestyle=':', linewidth=0.8)
plt.tight_layout()
plt.show()

Gas Formation Volume Factor and Density

Once $Z$ is known, the gas formation volume factor $B_g$ (reservoir volume per standard volume) and gas density follow directly:

B_g = \frac{P_{sc} \times Z \times T}{P \times T_{sc}} = \frac{0.02827 \times Z \times T}{P} \quad \text{(res bbl/scf)}

\rho_g = \frac{P \times M_g}{Z \times R \times T} = \frac{2.7 \times \gamma_g \times P}{Z \times T} \quad \text{(lb/ft³)}

main.py

import numpy as np
import pandas as pd

def gas_fvf(P_psia, T_F, Z):
    """Gas formation volume factor (res bbl/scf)."""
    T_R = T_F + 459.67
    return 0.02827 * Z * T_R / P_psia

def gas_density(P_psia, T_F, Z, gas_sg):
    """Gas density (lb/ft³)."""
    T_R = T_F + 459.67
    return 2.7 * gas_sg * P_psia / (Z * T_R)

def gas_viscosity_lee(P_psia, T_F, Z, gas_sg):
    """
    Gas viscosity using Lee-Gonzalez-Eakin (1966) correlation.

    Returns viscosity in centipoise (cp).
    """
    T_R = T_F + 459.67
    Mg = 28.97 * gas_sg  # molecular weight
    rho_g = gas_density(P_psia, T_F, Z, gas_sg)  # lb/ft³
    rho_gcc = rho_g / 62.428  # convert to g/cc

    K = (9.4 + 0.02 * Mg) * T_R**1.5 / (209 + 19*Mg + T_R)
    X = 3.5 + 986/T_R + 0.01*Mg
    Y = 2.4 - 0.2*X

    return 1e-4 * K * np.exp(X * rho_gcc**Y)

def gas_compressibility(P_psia, T_F, Z, gas_sg, dP=10):
    """
    Gas isothermal compressibility cg (1/psi).
    Calculated numerically from Z(P).
    """
    Ppc, Tpc = pseudo_critical_properties(gas_sg)
    T_R = T_F + 459.67
    Tpr = T_R / Tpc

    Ppr_plus = (P_psia + dP) / Ppc
    Ppr_minus = (P_psia - dP) / Ppc

    try:
        Z_plus = z_factor_DAK(Ppr_plus, Tpr)
        Z_minus = z_factor_DAK(Ppr_minus, Tpr)
        dZ_dP = (Z_plus - Z_minus) / (2 * dP)
        cg = 1/P_psia - 1/Z * dZ_dP
    except (ValueError, RuntimeError):
        cg = 1/P_psia  # ideal gas approximation as fallback

    return cg


# Gas property table
gamma_g = 0.65
T_F = 200
Ppc, Tpc = pseudo_critical_properties(gamma_g)
T_R = T_F + 459.67
Tpr = T_R / Tpc

pressures = [500, 1000, 2000, 3000, 4000, 5000, 6000, 8000, 10000]
rows = []

for P in pressures:
    Ppr = P / Ppc
    Z = z_factor_DAK(Ppr, Tpr)
    Bg = gas_fvf(P, T_F, Z)
    rho = gas_density(P, T_F, Z, gamma_g)
    mu = gas_viscosity_lee(P, T_F, Z, gamma_g)
    cg = gas_compressibility(P, T_F, Z, gamma_g)

    rows.append({
        "P (psia)": P,
        "Ppr": round(Ppr, 3),
        "Z": round(Z, 4),
        "Bg (bbl/scf)": f"{Bg:.6f}",
        "ρg (lb/ft³)": round(rho, 3),
        "μg (cp)": round(mu, 5),
        "cg (1/psi)": f"{cg:.2e}",
    })

props_table = pd.DataFrame(rows)
print(f"GAS PROPERTY TABLE — gamma_g = {gamma_g}, T = {T_F} deg F")
print("=" * 85)
print(props_table.to_string(index=False))

Gas Well Deliverability

Gas well deliverability testing determines a well's ability to produce against a given back-pressure. The two standard test methods are the backpressure (flow-after-flow) test and the isochronal test.

The deliverability equation has two common forms:

Simplified (backpressure) equation:

q_{sc} = C(P_e^2 - P_{wf}^2)^n

Forchheimer (quadratic) equation:

P_e^2 - P_{wf}^2 = Aq_{sc} + Bq_{sc}^2

where $A$ represents laminar (Darcy) flow resistance and $B$ represents turbulent (non-Darcy) flow resistance near the wellbore.

main.py

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Backpressure test data
# Four stabilized flow rates with corresponding flowing pressures
test_data = {
    "q_sc (Mscf/d)": [2500, 5000, 7500, 10000],
    "Pwf (psia)": [3800, 3550, 3200, 2700],
}
Pe = 4200  # shut-in reservoir pressure, psia

q_test = np.array(test_data["q_sc (Mscf/d)"])
Pwf_test = np.array(test_data["Pwf (psia)"])
delta_P2 = Pe**2 - Pwf_test**2

# Method 1: Simplified backpressure equation
# log(q) = log(C) + n * log(Pe² - Pwf²)
log_q = np.log10(q_test)
log_dP2 = np.log10(delta_P2)

coeffs = np.polyfit(log_dP2, log_q, 1)
n = coeffs[0]
C = 10**coeffs[1]

# Absolute open flow potential (AOF) at Pwf = 14.7 psia
AOF = C * (Pe**2 - 14.7**2)**n

print(f"BACKPRESSURE TEST ANALYSIS")
print(f"{'='*50}")
print(f"  Reservoir pressure (Pe): {Pe:,} psia")
print(f"  Deliverability coefficient (C): {C:.6f}")
print(f"  Deliverability exponent (n): {n:.4f}")
print(f"  Absolute Open Flow (AOF): {AOF:,.0f} Mscf/day")
print()

if n < 0.5 or n > 1.0:
    print(f"  WARNING: n = {n:.4f} is outside the valid range [0.5, 1.0].")
    print(f"  This may indicate non-stabilized test data.")
elif n < 0.6:
    print(f"  n ≈ {n:.2f} indicates significant turbulence near the wellbore.")
elif n > 0.9:
    print(f"  n ≈ {n:.2f} indicates predominantly laminar flow.")
else:
    print(f"  n ≈ {n:.2f} indicates moderate turbulence (typical).")

# Method 2: Forchheimer (quadratic)
# (Pe² - Pwf²)/q = A + B*q
ratio = delta_P2 / q_test
coeffs_q = np.polyfit(q_test, ratio, 1)
B_coeff = coeffs_q[0]
A_coeff = coeffs_q[1]

print(f"\n  Forchheimer A: {A_coeff:.2f} psi²/(Mscf/d)")
print(f"  Forchheimer B: {B_coeff:.6f} psi²/(Mscf/d)²")

# Generate IPR curve
Pwf_range = np.linspace(14.7, Pe, 200)
q_ipr = C * (Pe**2 - Pwf_range**2)**n

fig, axes = plt.subplots(1, 2, figsize=(13, 5))

# IPR curve
axes[0].plot(q_ipr, Pwf_range, 'k-', linewidth=2, label='Gas IPR')
axes[0].plot(q_test, Pwf_test, 'ro', markersize=8, label='Test Points')
axes[0].axhline(y=Pe, color='gray', linestyle=':', linewidth=0.8)
axes[0].plot(AOF, 14.7, 'g^', markersize=10, label=f'AOF = {AOF:,.0f} Mscf/d')
axes[0].set_xlabel('Gas Rate (Mscf/day)', fontsize=11)
axes[0].set_ylabel('Flowing Bottomhole Pressure (psia)', fontsize=11)
axes[0].set_title('Gas Well IPR', fontsize=12)
axes[0].legend(fontsize=9)
axes[0].set_xlim(0)
axes[0].set_ylim(0)
axes[0].grid(True, alpha=0.3)

# Log-log deliverability plot
axes[1].scatter(delta_P2, q_test, color='red', s=60, zorder=5)
dP2_line = np.logspace(np.log10(delta_P2.min()*0.5), np.log10(Pe**2), 100)
q_line = C * dP2_line**n
axes[1].plot(dP2_line, q_line, 'k-', linewidth=1.5)
axes[1].set_xscale('log')
axes[1].set_yscale('log')
axes[1].set_xlabel('Pe² - Pwf² (psia²)', fontsize=11)
axes[1].set_ylabel('Gas Rate (Mscf/day)', fontsize=11)
axes[1].set_title(f'Deliverability Plot — n = {n:.3f}', fontsize=12)
axes[1].grid(True, alpha=0.3, which='both')

plt.tight_layout()
plt.show()

Gas Pipeline Hydraulics

The steady-state flow of gas through a horizontal pipeline is governed by the General Flow Equation:

q_{sc} = 77.54 \times \frac{T_b}{P_b} \times \left[ \frac{(P_1^2 - P_2^2) \times D^5} {f \times \gamma_g \times T_{avg} \times Z_{avg} \times L} \right]^{0.5}

where:

$q_{sc}$ = flow rate at standard conditions (scf/day)
$T_b$ , $P_b$ = base temperature (°R) and pressure (psia)
$P_1$ , $P_2$ = inlet and outlet pressures (psia)
$D$ = pipe internal diameter (inches)
$f$ = Moody friction factor
$\gamma_g$ = gas specific gravity
$T_{avg}$ = average temperature (°R)
$Z_{avg}$ = average Z-factor
$L$ = pipeline length (miles)

Several simplified forms exist for practical use. The Weymouth equation assumes a specific friction factor relationship and is conservative (underpredicts capacity). The Panhandle A equation is commonly used for large-diameter, high-pressure transmission lines.

main.py

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def pipeline_capacity_general(P1, P2, D_in, L_miles, gamma_g, T_avg_F,
                               Z_avg, efficiency=0.92):
    """
    General Flow Equation for gas pipeline capacity.

    Parameters
    ----------
    P1 : float
        Inlet pressure (psia).
    P2 : float
        Outlet pressure (psia).
    D_in : float
        Pipe internal diameter (inches).
    L_miles : float
        Pipeline length (miles).
    gamma_g : float
        Gas specific gravity.
    T_avg_F : float
        Average gas temperature (deg F).
    Z_avg : float
        Average compressibility factor.
    efficiency : float
        Pipeline efficiency factor (0 to 1).

    Returns
    -------
    float
        Flow rate (MMscf/day).
    """
    Tb = 520  # base temperature, deg R (60 deg F)
    Pb = 14.73  # base pressure, psia
    T_avg_R = T_avg_F + 459.67

    # Assume fully turbulent friction factor (Weymouth approximation)
    f = 0.032 / (D_in**(1/3))

    q_scfd = 77.54 * (Tb/Pb) * (
        (P1**2 - P2**2) * D_in**5 /
        (f * gamma_g * T_avg_R * Z_avg * L_miles)
    )**0.5

    return q_scfd * efficiency / 1e6  # convert to MMscf/day


def weymouth(P1, P2, D_in, L_miles, gamma_g, T_avg_F, Z_avg, E=0.92):
    """Weymouth equation for gas pipeline capacity (MMscf/day)."""
    Tb = 520
    Pb = 14.73
    T_R = T_avg_F + 459.67

    q = 433.5 * (Tb/Pb) * E * (
        (P1**2 - P2**2) * D_in**(16/3) /
        (gamma_g * T_R * Z_avg * L_miles)
    )**0.5

    return q / 1e6


def panhandle_a(P1, P2, D_in, L_miles, gamma_g, T_avg_F, Z_avg, E=0.92):
    """Panhandle A equation for gas pipeline capacity (MMscf/day)."""
    Tb = 520
    Pb = 14.73
    T_R = T_avg_F + 459.67

    q = 435.87 * E * (Tb/Pb)**1.0788 * (
        (P1**2 - P2**2) / (gamma_g**0.8539 * T_R * Z_avg * L_miles)
    )**0.5394 * D_in**2.6182

    return q / 1e6


# Pipeline sizing example
# Requirement: deliver 200 MMscf/day over 150 km
P1 = 1000       # inlet pressure, psia
P2 = 600        # delivery pressure, psia
L_miles = 150 * 0.621371  # 150 km in miles
gamma_g = 0.65
T_avg_F = 80
Z_avg = 0.92

# Test different pipe diameters
diameters = [16, 20, 24, 30, 36, 42]
target_rate = 200  # MMscf/day

print("PIPELINE SIZING ANALYSIS")
print(f"  Inlet pressure:    {P1:,} psia")
print(f"  Delivery pressure: {P2:,} psia")
print(f"  Length:            150 km ({L_miles:.1f} miles)")
print(f"  Gas gravity:       {gamma_g}")
print(f"  Target rate:       {target_rate} MMscf/day")
print()
print(f"{'Diameter (in)':>14} {'General':>10} {'Weymouth':>10} {'Panhandle A':>12} {'Meets Target':>14}")
print("-" * 65)

for D in diameters:
    q_gen = pipeline_capacity_general(P1, P2, D, L_miles, gamma_g, T_avg_F, Z_avg)
    q_wey = weymouth(P1, P2, D, L_miles, gamma_g, T_avg_F, Z_avg)
    q_pan = panhandle_a(P1, P2, D, L_miles, gamma_g, T_avg_F, Z_avg)
    meets = "Yes" if min(q_gen, q_wey) >= target_rate else "No"
    print(f"{D:>14} {q_gen:>10.1f} {q_wey:>10.1f} {q_pan:>12.1f} {meets:>14}")

# Plot capacity vs diameter
fig, ax = plt.subplots(figsize=(9, 5))
D_range = np.linspace(12, 48, 100)
q_gen_range = [pipeline_capacity_general(P1, P2, d, L_miles, gamma_g, T_avg_F, Z_avg) for d in D_range]
q_wey_range = [weymouth(P1, P2, d, L_miles, gamma_g, T_avg_F, Z_avg) for d in D_range]

ax.plot(D_range, q_gen_range, 'k-', linewidth=2, label='General Flow Equation')
ax.plot(D_range, q_wey_range, 'b--', linewidth=1.5, label='Weymouth')
ax.axhline(y=target_rate, color='r', linestyle=':', linewidth=1.5, label=f'Target: {target_rate} MMscf/d')
ax.set_xlabel('Pipe Diameter (inches)', fontsize=11)
ax.set_ylabel('Pipeline Capacity (MMscf/day)', fontsize=11)
ax.set_title('Gas Pipeline Capacity vs. Diameter', fontsize=12)
ax.legend(fontsize=9)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Gas Compression

When pipeline pressure drop exceeds the available upstream pressure, or when gathering low-pressure gas for transmission, compression is required. The key calculations are compression ratio, number of stages, power requirement, and discharge temperature.

main.py

import numpy as np

def compression_power(q_mmscfd, P_suction, P_discharge, T_suction_F,
                       Z_avg, gamma_g, k=1.28, eta_adiabatic=0.82):
    """
    Calculate gas compression horsepower.

    Parameters
    ----------
    q_mmscfd : float
        Gas flow rate (MMscf/day).
    P_suction : float
        Suction pressure (psia).
    P_discharge : float
        Discharge pressure (psia).
    T_suction_F : float
        Suction temperature (deg F).
    Z_avg : float
        Average Z-factor across compressor.
    gamma_g : float
        Gas specific gravity.
    k : float
        Ratio of specific heats (Cp/Cv). ~1.28 for natural gas.
    eta_adiabatic : float
        Adiabatic efficiency (typically 0.75-0.85).

    Returns
    -------
    dict
        Compression results.
    """
    T_s = T_suction_F + 459.67  # Rankine
    r = P_discharge / P_suction  # compression ratio

    # Check if staging is needed (r > 4 typically requires multiple stages)
    max_ratio_per_stage = 4.0
    n_stages = int(np.ceil(np.log(r) / np.log(max_ratio_per_stage)))
    r_per_stage = r**(1/n_stages)

    # Adiabatic head per stage
    # HP = (q * Ts * Zs / eta) * (k/(k-1)) * [(r^((k-1)/k)) - 1]
    exponent = (k - 1) / k

    # Total power (HP) using gas horsepower equation
    hp_per_mmscfd = (
        (3.0303 / eta_adiabatic) *
        (k / (k - 1)) *
        T_s * Z_avg *
        (r_per_stage**exponent - 1) *
        n_stages
    )

    total_hp = hp_per_mmscfd * q_mmscfd

    # Discharge temperature per stage
    T_discharge_R = T_s * r_per_stage**exponent
    T_discharge_F = T_discharge_R - 459.67

    return {
        "Overall ratio": round(r, 2),
        "Stages": n_stages,
        "Ratio/stage": round(r_per_stage, 2),
        "Total HP": round(total_hp, 0),
        "HP/MMscf/d": round(hp_per_mmscfd, 0),
        "T_discharge (deg F)": round(T_discharge_F, 1),
    }


# Example: compress 50 MMscf/d from gathering pressure to pipeline pressure
result = compression_power(
    q_mmscfd=50,
    P_suction=200,
    P_discharge=1000,
    T_suction_F=80,
    Z_avg=0.95,
    gamma_g=0.65,
)

print("COMPRESSION REQUIREMENTS")
print("=" * 45)
for key, val in result.items():
    print(f"  {key:<22} {val}")

# Compare compression costs for different discharge pressures
print(f"\n{'Discharge (psia)':>18} {'Ratio':>8} {'Stages':>8} {'HP':>10} {'Cost ($/yr)':>14}")
print("-" * 60)
for P_out in [400, 600, 800, 1000, 1200, 1500]:
    res = compression_power(50, 200, P_out, 80, 0.95, 0.65)
    annual_cost = res["Total HP"] * 8760 * 0.08  # $0.08/HP-hr
    print(f"{P_out:>18,} {res['Overall ratio']:>8} {res['Stages']:>8} {res['Total HP']:>10,.0f} ${annual_cost:>13,.0f}")

Exercises

fitness_center

Exercise 15.1Practice

-- Z-Factor Sensitivity

Calculate and plot Z vs. pressure (100–10,000 psia) for gas gravities of 0.55, 0.65, 0.75, and 0.85 at 200°F. How does gas composition (heavier = high...

arrow_forward