Stats
Actions
Tags
Design and analyze artificial lift systems for oil and gas wells including rod pumping, electric submersible pumps, gas lift, and plunger lift. Covers liquid loading prediction using Turner and Coleman critical velocity criteria, rod pump design per API RP 11L including polished rod load, gearbox torque, pump displacement and fillage, ESP selection and sizing including stage count, total dynamic head, motor horsepower and cable losses, gas lift design including single-point injection pressure, valve spacing by pressure traverse, kickoff requirements, and GLR effect on flowing gradient, and plunger lift cycle timing. Use when determining if a well is liquid loading, selecting an artificial lift method, sizing an ESP or rod pump, designing a gas lift system, or calculating lift performance for PNGE production courses. Trigger phrases include liquid loading, Turner criteria, rod pump design, ESP sizing, polished rod load, gas lift valve spacing, plunger lift timing, pump-off control, artificial lift selection, critical flow rate, or PBHFP calculation.
How this skill is triggered — by the user, by Claude, or both
Slash command
/pnge-well-engineering:artificial-liftThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Production engineering skill for sizing and analyzing artificial lift systems.
Production engineering skill for sizing and analyzing artificial lift systems. Covers the full selection-and-design workflow from liquid loading diagnosis through pump or gas lift sizing.
Important: Pump curves and valve trim tables are vendor-specific. Use these equations for scoping and selection — final design requires vendor performance curves and software (PIPESIM, PROSPER, or equivalent).
def turner_critical_velocity(sigma_lv, rho_l, rho_g):
"""
v_crit = 1.593 * sigma_lv^0.25 * (rho_l - rho_g)^0.25 / rho_g^0.5
sigma_lv: gas-liquid interfacial tension (dynes/cm) -- ~60 for water/gas
rho_l: liquid density (lb/ft3) -- 62.4 freshwater, 68–72 brine
rho_g: gas density at flowing conditions (lb/ft3)
Returns: critical velocity (ft/s)
"""
return 1.593 * sigma_lv**0.25 * (rho_l - rho_g)**0.25 / rho_g**0.5
def gas_density(p_psia, T_f, sg_gas=0.65, z=0.9):
"""Gas density at flowing conditions (lb/ft3)."""
return (28.97 * sg_gas * p_psia) / (10.73 * (T_f + 459.67) * z)
def critical_flow_rate_mscfd(v_crit, p_psia, T_f, id_in, z=0.9, sg=0.65):
"""
q_crit (Mscf/d) = 3.067 * P * v_crit * A / (T * Z)
id_in: tubing ID (inches)
"""
import math
A_ft2 = math.pi * (id_in / 24.0)**2 # ft2 (id/2 in feet)
T_R = T_f + 459.67
return 3.067 * p_psia * v_crit * A_ft2 / (T_R * z)
Coleman et al. (1991) modification: multiply Turner velocity by 0.77 for wells with low liquid-gas ratios or dry gas. More conservative threshold.
Appalachian Marcellus liquid loading signs:
def rod_pump_displacement(dp_in, s_in, n_spm, pump_eff=0.80):
"""
PD = 0.1166 * dp^2 * S * N * eff (bbl/day)
dp_in: plunger diameter (inches): 1.25, 1.5, 1.75, 2.0, 2.25, 2.5
s_in: stroke length at pump (inches) -- approximately surface stroke * kr
n_spm: strokes per minute
pump_eff: volumetric efficiency (0.7–0.95 typical)
"""
return 0.1166 * dp_in**2 * s_in * n_spm * pump_eff
def rod_string_weight(rod_sizes, rod_lengths):
"""
Rod unit weights (lb/ft): #75=1.63, #86=1.99, #97=2.56, #108=3.05, #119=3.60
rod_sizes: list of tuples (size_code, lb_per_ft)
rod_lengths: corresponding lengths (ft)
Returns: buoyed weight in fluid (SG_fluid=1.0 default)
"""
w_air = sum(w * L for (_, w), L in zip(rod_sizes, rod_lengths))
return w_air
def peak_polished_rod_load(w_rod_buoyed, fo, wf):
"""
PPRL = W_rf + Fo + WF (simplified)
w_rod_buoyed: buoyed rod weight (lb)
fo: fluid load = 0.340 * dp_in^2 * net_lift_ft (lb) for fresh water
wf: dynamic load factor (typically 0.25–0.40 * w_rod_buoyed)
"""
return w_rod_buoyed + fo + wf
def fluid_load(dp_in, net_lift_ft, fluid_sg=1.0):
"""Fo = 0.340 * dp^2 * H * SG (lb)"""
return 0.340 * dp_in**2 * net_lift_ft * fluid_sg
| Grade | Min Yield (psi) | Min UTS (psi) | Service |
|---|---|---|---|
| C (Grade C) | 60,000 | 90,000 | Non-corrosive |
| D (Grade D) | 115,000 | 140,000 | Non-corrosive deep wells |
| K (Grade K) | 55,000 | 90,000 | Corrosive (H2S) |
| API D mod. | 115,000 | 140,000 | Sucker rod steel standard |
def esp_tdh(pump_depth_ft, wellhead_pressure_psi, intake_pressure_psi,
fluid_sg=1.0):
"""
TDH (ft) = net_lift + friction_loss + wellhead_head
net_lift = pump_depth - (intake_pressure * 2.31 / sg)
Simplified: TDH = (pump_depth * sg / 2.31) + (Pwh - Pintake) * 2.31/sg
Returns TDH in feet of fluid.
"""
lift = pump_depth_ft - intake_pressure_psi * 2.31 / fluid_sg
wh_head = wellhead_pressure_psi * 2.31 / fluid_sg
return max(0.0, lift + wh_head)
def esp_motor_hp(q_bpd, tdh_ft, fluid_sg=1.0,
pump_eff=0.65, motor_eff=0.93, cable_loss_frac=0.05):
"""
HP = Q(gpm) * TDH(ft) * SG / (3960 * pump_eff * motor_eff * (1-cable_loss))
q_bpd: flow rate (bbl/day)
"""
q_gpm = q_bpd * 0.02917 # bbl/day to gpm
return (q_gpm * tdh_ft * fluid_sg /
(3960 * pump_eff * motor_eff * (1 - cable_loss_frac)))
def esp_stage_count(tdh_ft, head_per_stage_ft):
"""Number of stages needed to achieve TDH."""
import math
return math.ceil(tdh_ft / head_per_stage_ft)
ESP selection notes:
def glr_gradient(glr_scf_per_bbl, p_psi, T_f, oil_api=35, wc=0.0):
"""
Approximate flowing gradient (psi/ft) for a given GLR.
Uses simplified mixture density approach.
glr_scf_per_bbl: producing gas-liquid ratio
Returns: approximate gradient (psi/ft)
Note: use Beggs-Brill or Hagedorn-Brown for rigorous calculation.
"""
rho_oil = (141.5 / (oil_api + 131.5)) * 62.4 # lb/ft3
rho_water = 64.0 # lb/ft3 (brine ~67)
rho_liquid = (1 - wc) * rho_oil + wc * rho_water
# Approximate in-situ gas volume fraction
gas_vol_frac = glr_scf_per_bbl / (5.615 * (p_psi / 14.7))
rho_mix = rho_liquid * (1 - gas_vol_frac) + 0.05 * gas_vol_frac
return rho_mix / 144.0 # psi/ft
def gas_lift_injection_pressure(depth_ft, surface_injection_psi,
gas_sg=0.65, T_avg_f=150.0):
"""
Approximate bottomhole injection pressure.
P_inj_BH = P_inj_surface + gradient * depth
Gas gradient approx: 0.0085 * SG * depth / 1000 (psi/ft * ft)
"""
gas_grad_psi_per_ft = 0.433 * gas_sg * (14.7 / (14.7 + surface_injection_psi / 2))
return surface_injection_psi + gas_grad_psi_per_ft * depth_ft
def minimum_glr_for_lift(depth_ft, target_bfpd, api=35):
"""
Rough minimum GLR (scf/bbl) to lift fluid to surface.
~200 scf/bbl per 1000 ft of lift as a starting approximation.
"""
return 200 * depth_ft / 1000.0
def plunger_minimum_glr(depth_ft, liquid_per_cycle_bbl=1.0):
"""
Minimum casing GLR needed:
GLR_min = (A + B * depth_ft) * liquid_per_cycle
A = 30, B = 0.12 (typical constants)
Returns: min GLR in scf/bbl
"""
A, B = 30.0, 0.12
return (A + B * depth_ft) * liquid_per_cycle_bbl
def plunger_rise_velocity(p_casing_psi, p_tubing_psi, plunger_weight_lb=10.0,
id_in=2.441):
"""
Approximate plunger rise velocity (ft/min).
Driving force = (P_cas - P_tub) * A_tubing - W_plunger - W_fluid
Rough empirical: v_rise = k * (P_cas - P_min) where k ~ 1.5 ft/min per psi
"""
dp = p_casing_psi - p_tubing_psi
k = 1.5 # ft/min per psi of differential
return max(0.0, k * dp)
Plunger lift selection criteria:
| Condition | Preferred Lift | Notes |
|---|---|---|
| Liquid loading gas well, low volume | Plunger lift | Low cost, no power |
| Liquid loading gas well, moderate volume | Velocity string | Reduce tubing ID |
| Oil well, < 2,000 bbl/day, < 8,000 ft | Rod pump | Most common onshore |
| Oil well, high rate, deep, deviated | ESP | High rate, limited run life |
| Oil well, multiple zones | Gas lift | Flexible, no downhole equipment |
| CO2 flood or gassy well | Gas lift (avoid ESP) | Gas handling advantage |
## Artificial Lift Assessment — [Well Name / API]
**Formation:** [Name] | **Depth:** X,XXX ft | **Current Rate:** XXX bbl/day gas/oil
### Liquid Loading Check (Gas Wells)
| Tubing ID (in) | Critical Velocity (ft/s) | Critical Rate (Mscf/d) | Current Rate | Loading? |
|----------------|--------------------------|------------------------|--------------|---------|
| 2.441 | | | | YES/NO |
### Recommended Lift Method: [Rod Pump / ESP / Gas Lift / Plunger]
**Rationale:** [brief justification]
### Design Summary
| Parameter | Value | Units |
|-----------|-------|-------|
| Pump displacement | | bbl/day |
| Motor HP (ESP) | | HP |
| Stages needed | | count |
| PPRL (rod pump) | | lb |
| Injection pressure (gas lift) | | psia |
### Confidence: [HIGH / MEDIUM / LOW]
| Condition | Cause | Action |
|---|---|---|
| Critical velocity > actual velocity | Normal production | No lift needed yet |
| TDH negative | Intake pressure > hydrostatic + wellhead | Check input pressures |
| Stage count > 300 | Very deep or high TDH | Consider multistage or smaller pump series |
| GLR below minimum | Insufficient gas for gas lift | Consider ESP or rod pump |
npx claudepluginhub jpfielding/claude.pnge --plugin pnge-well-engineeringGuides creation, editing, and verification of skills for AI coding agents using test-driven development with subagent scenarios. Use when authoring or debugging skills.