Part II: Petroleum Data Engineering

Chapter 8

PVT Correlations and Fluid Properties

schedule15 min readfitness_center10 exercises

Why This Chapter Exists

The oil sitting in a reservoir two miles underground behaves nothing like the oil that comes out at the surface. Down there, it is hot, under enormous pressure, and saturated with dissolved natural gas. As it travels up the wellbore and the pressure drops, that gas comes out of solution — like opening a bottle of carbonated water. The oil shrinks in volume. Its viscosity changes. Its density changes.

Every reservoir engineering calculation — material balance, reserve estimation, production forecasting, facility design — depends on knowing exactly how these fluid properties change with pressure and temperature. If you assume that one barrel of oil underground equals one barrel at the surface, your reserve estimate is wrong. If you assume that viscosity stays constant as pressure drops, your flow model is wrong.

Laboratory PVT analysis provides the definitive measurements, but lab reports take weeks and cost thousands of dollars per sample. For preliminary estimates, screening studies, and cases where lab data is unavailable, empirical correlations provide fluid property estimates from easily measured quantities: API gravity, gas specific gravity, reservoir temperature, and solution gas-oil ratio.

These correlations are not substitutes for lab data. They are tools that give you reasonable answers quickly, and that allow you to run sensitivity analyses before committing to expensive laboratory work. This chapter teaches you to implement them, validate them, and understand their limitations.

infoWhat You'll Learn

Understand what each PVT property represents physically
Implement Standing, Vasquez-Beggs, and Beggs-Robinson correlations
Calculate bubble point pressure, oil formation volume factor, gas solubility, and viscosity
Build a reusable PVT module
Compare correlation accuracy against laboratory data
Understand when correlations fail and why

The Properties That Matter

Bubble Point Pressure (Pb)

When reservoir oil is at high pressure, natural gas is dissolved in it — just as carbon dioxide is dissolved in a sealed bottle of soda. The bubble point pressure is the pressure at which the first bubble of gas comes out of solution. It is the threshold between single-phase oil (above Pb) and two-phase oil-and-gas (below Pb).

Why it matters: Above the bubble point, the reservoir contains only oil, and the production mechanism is liquid expansion — relatively efficient but slow. Below the bubble point, free gas forms in the reservoir, gas production increases, oil production often declines, and the reservoir's energy dissipates much faster. Knowing the bubble point tells you where the reservoir is in its lifecycle and what production strategy to pursue.

Oil Formation Volume Factor (Bo)

One stock-tank barrel of oil at surface conditions occupied more than one barrel in the reservoir because it had gas dissolved in it (which expanded the liquid volume) and because the higher temperature expanded the liquid. The oil formation volume factor (Bo) is the ratio of the oil volume at reservoir conditions to its volume at stock-tank (surface) conditions.

B_o = \frac{\text{Volume at reservoir conditions (RB)}}{\text{Volume at stock-tank conditions (STB)}}

Why it matters: Bo is always greater than 1.0 (typically 1.1 to 2.0). If Bo = 1.35, it means you need 1.35 barrels of reservoir volume to produce 1 barrel at the surface. Reserve calculations must account for this. If you report 10 million barrels of oil in place without specifying whether that is reservoir barrels or stock-tank barrels, the number is meaningless.

Solution Gas-Oil Ratio (Rs)

The solution gas-oil ratio is the volume of gas (measured at standard conditions) dissolved in each barrel of oil at a given pressure and temperature.

R_s = \frac{\text{Volume of dissolved gas (scf)}}{\text{Volume of oil at stock-tank conditions (STB)}}

Why it matters: Rs determines how much gas will be released as pressure drops. It also affects oil viscosity (dissolved gas makes oil less viscous) and Bo (more dissolved gas means more expansion). As reservoir pressure falls below the bubble point, Rs decreases and the oil loses its dissolved gas, becoming thicker, denser, and harder to produce.

Oil Viscosity (μo)

Viscosity is the resistance of a fluid to flow. Water has a viscosity of about 1 centipoise (cp). Light crude oil might be 0.5–5 cp. Heavy crude oil can exceed 10,000 cp.

Why it matters: Viscosity directly controls how fast oil flows through rock (Darcy's law has viscosity in the denominator). Lower viscosity means easier flow, higher production rates, and better recovery. Viscosity depends on pressure, temperature, and the amount of gas dissolved in the oil. All three change during production, so viscosity changes too.

Gas Z-Factor

Real gases do not obey the ideal gas law (PV = nRT). The Z-factor (compressibility factor) corrects for this:

PV = ZnRT

Why it matters: Gas volume calculations, gas reserves estimation, pipeline sizing, and compression design all require the Z-factor. Using Z = 1.0 (the ideal gas assumption) produces significant errors at reservoir pressures and temperatures.

Standing's Correlations

M.B. Standing published correlations in 1947 based on 105 experimental data points from California crude oils. Despite their age, they remain widely used for light to medium gravity oils because they are simple, transparent, and reasonably accurate within their applicability range.

Bubble Point Pressure

P_b = 18.2 \left( \left(\frac{R_s}{\gamma_g}\right)^{0.83} \times 10^{(0.00091 \times T - 0.0125 \times API)} - 1.4 \right)

where:

$R_s$ = solution gas-oil ratio (scf/STB)
$\gamma_g$ = gas specific gravity (air = 1.0)
$T$ = reservoir temperature (°F)
$API$ = oil API gravity

Oil Formation Volume Factor

B_o = 0.972 + 1.47 \times 10^{-4} \left( R_s \sqrt{\frac{\gamma_g}{\gamma_o}} + 1.25 \times T \right)^{1.175}

where $\gamma_o$ is the oil specific gravity, calculated from API gravity:

\gamma_o = \frac{141.5}{API + 131.5}

main.py

import numpy as np

def standing_bubble_point(Rs, gamma_g, T_F, API):
    """
    Standing (1947) correlation for bubble point pressure.

    Parameters
    ----------
    Rs : float or array — Solution GOR (scf/STB)
    gamma_g : float — Gas specific gravity (air = 1.0)
    T_F : float — Reservoir temperature (°F)
    API : float — Oil API gravity

    Returns
    -------
    Pb : float or array — Bubble point pressure (psia)
    """
    exponent = 0.00091 * T_F - 0.0125 * API
    Pb = 18.2 * ((Rs / gamma_g)**0.83 * 10**exponent - 1.4)
    return Pb


def standing_Bo(Rs, gamma_g, gamma_o, T_F):
    """
    Standing (1947) correlation for oil formation volume factor.

    Parameters
    ----------
    Rs : float or array — Solution GOR (scf/STB)
    gamma_g : float — Gas specific gravity
    gamma_o : float — Oil specific gravity
    T_F : float — Reservoir temperature (°F)

    Returns
    -------
    Bo : float or array — Oil FVF (RB/STB)
    """
    F = Rs * np.sqrt(gamma_g / gamma_o) + 1.25 * T_F
    Bo = 0.972 + 1.47e-4 * F**1.175
    return Bo


def api_to_sg(API):
    """Convert API gravity to specific gravity."""
    return 141.5 / (API + 131.5)


# Example: OML 58 Niger Delta crude oil
API = 32.0           # medium gravity crude
gamma_g = 0.75       # gas specific gravity
T_F = 185.0          # reservoir temperature, °F
Rs = 550.0           # solution GOR, scf/STB

gamma_o = api_to_sg(API)

Pb = standing_bubble_point(Rs, gamma_g, T_F, API)
Bo = standing_Bo(Rs, gamma_g, gamma_o, T_F)

print("STANDING CORRELATIONS — OML 58 Niger Delta Crude")
print(f"  Input:")
print(f"    API gravity:      {API}°")
print(f"    Gas SG:           {gamma_g}")
print(f"    Temperature:      {T_F} °F")
print(f"    Solution GOR:     {Rs} scf/STB")
print(f"    Oil SG:           {gamma_o:.4f}")
print()
print(f"  Results:")
print(f"    Bubble point:     {Pb:,.0f} psia")
print(f"    Bo at Pb:         {Bo:.4f} RB/STB")
print()
print(f"  Interpretation:")
print(f"    Every STB of surface oil occupied {Bo:.3f} barrels in the reservoir.")
print(f"    Gas will start coming out of solution below {Pb:,.0f} psia.")

Vasquez-Beggs Correlations

Vasquez and Beggs (1980) developed correlations from over 6,000 measurements, a much larger dataset than Standing's. Their correlations use different coefficients depending on whether the API gravity is above or below 30° — a recognition that light and medium-heavy oils behave differently.

Solution GOR (Rs)

For API ≤ 30:

R_s = C_1 \cdot \gamma_{gs} \cdot P^{C_2} \cdot \exp\left(\frac{-C_3 \cdot API}{T + 460}\right)

where $C_1 = 0.0362$ , $C_2 = 1.0937$ , $C_3 = 25.724$ .

For API > 30: $C_1 = 0.0178$ , $C_2 = 1.187$ , $C_3 = 23.931$ .

$\gamma_{gs}$ is the gas gravity corrected to a separator pressure of 100 psig.

main.py

def vasquez_beggs_Rs(P, T_F, API, gamma_gs):
    """
    Vasquez-Beggs (1980) correlation for solution gas-oil ratio.

    Parameters
    ----------
    P : float or array — Pressure (psia)
    T_F : float — Temperature (°F)
    API : float — Oil API gravity
    gamma_gs : float — Gas SG corrected to 100 psig separator

    Returns
    -------
    Rs : float or array — Solution GOR (scf/STB)
    """
    if API <= 30:
        C1, C2, C3 = 0.0362, 1.0937, 25.724
    else:
        C1, C2, C3 = 0.0178, 1.187, 23.931

    Rs = C1 * gamma_gs * P**C2 * np.exp(-C3 * API / (T_F + 460))
    return Rs


def vasquez_beggs_Bo(Rs, T_F, API, gamma_gs):
    """
    Vasquez-Beggs (1980) correlation for oil FVF.

    Parameters
    ----------
    Rs : float or array — Solution GOR (scf/STB)
    T_F : float — Temperature (°F)
    API : float — Oil API gravity
    gamma_gs : float — Gas SG corrected to 100 psig separator

    Returns
    -------
    Bo : float or array — Oil FVF (RB/STB)
    """
    if API <= 30:
        C1, C2, C3 = 4.677e-4, 1.751e-5, -1.811e-8
    else:
        C1, C2, C3 = 4.67e-4, 1.1e-5, 1.337e-9

    Bo = 1.0 + C1 * Rs + (T_F - 60) * (API / gamma_gs) * C2 + C3 * Rs * (T_F - 60) * (API / gamma_gs)
    return Bo


# Compare Standing and Vasquez-Beggs across a pressure range
pressures = np.arange(500, 5001, 500)
gamma_gs = 0.75  # assuming separator correction is negligible here

print("CORRELATION COMPARISON — Rs and Bo vs. Pressure")
print(f"{'P (psia)':>10} {'Rs_VB':>10} {'Rs_Stand*':>12} {'Bo_VB':>10}")
print("-" * 46)

for P in pressures:
    Rs_vb = vasquez_beggs_Rs(P, T_F, API, gamma_gs)
    Bo_vb = vasquez_beggs_Bo(Rs_vb, T_F, API, gamma_gs)
    print(f"{P:>10,} {Rs_vb:>10.0f} {'—':>12} {Bo_vb:>10.4f}")

print()
print("* Standing's Pb correlation gives Rs at Pb;")
print("  Vasquez-Beggs gives Rs as a function of pressure directly.")

Oil Viscosity — Beggs-Robinson

Oil viscosity is calculated in two steps:

Dead oil viscosity ( $\mu_{od}$ ) — the viscosity of oil with no dissolved gas, which depends only on temperature and API gravity.
Live oil viscosity ( $\mu_o$ ) — the viscosity after accounting for dissolved gas, which reduces viscosity.

Dead Oil Viscosity (Beggs-Robinson, 1975)

\mu_{od} = 10^X - 1

where $X = Y \cdot T^{-1.163}$ and $Y = 10^{(3.0324 - 0.02023 \times API)}$

Live Oil Viscosity (Beggs-Robinson)

\mu_o = A \cdot \mu_{od}^B

where $A = 10.715 \cdot (R_s + 100)^{-0.515}$ and $B = 5.44 \cdot (R_s + 150)^{-0.338}$

main.py

def beggs_robinson_dead_oil(T_F, API):
    """Dead oil viscosity (no dissolved gas), in centipoise."""
    Y = 10**(3.0324 - 0.02023 * API)
    X = Y * T_F**(-1.163)
    mu_od = 10**X - 1
    return mu_od


def beggs_robinson_live_oil(mu_od, Rs):
    """Live oil viscosity (with dissolved gas), in centipoise."""
    A = 10.715 * (Rs + 100)**(-0.515)
    B = 5.44 * (Rs + 150)**(-0.338)
    mu_o = A * mu_od**B
    return mu_o


# Calculate for our OML 58 Niger Delta crude
mu_dead = beggs_robinson_dead_oil(T_F, API)
mu_live = beggs_robinson_live_oil(mu_dead, Rs)

print("OIL VISCOSITY — Beggs-Robinson")
print(f"  Dead oil viscosity (no gas):  {mu_dead:.2f} cp")
print(f"  Live oil viscosity ({Rs:.0f} scf/STB gas): {mu_live:.2f} cp")
print()
print(f"  The dissolved gas reduced viscosity by {(1 - mu_live/mu_dead)*100:.0f}%.")
print(f"  This is why reservoir engineers care about keeping pressure")
print(f"  above the bubble point — losing dissolved gas makes the oil")
print(f"  thicker and harder to produce.")

# Show how viscosity changes as gas comes out of solution
print()
print("VISCOSITY vs. DISSOLVED GAS")
print(f"{'Rs (scf/STB)':>14} {'μ_live (cp)':>12} {'Reduction':>10}")
print("-" * 40)
for rs in [0, 100, 200, 300, 400, 500, 600]:
    mu = beggs_robinson_live_oil(mu_dead, rs)
    reduction = (1 - mu/mu_dead) * 100
    print(f"{rs:>14} {mu:>12.2f} {reduction:>9.0f}%")

Gas Z-Factor — Standing-Katz via DAK

The Standing-Katz chart (1942) relates the gas compressibility factor (Z) to pseudo-reduced pressure and temperature. The Dranchuk-Abou-Kassem (DAK) correlation provides a mathematical fit to this chart, suitable for computation.

main.py

def pseudocritical_properties(gamma_g):
    """
    Sutton (1985) correlations for pseudo-critical properties.

    Parameters
    ----------
    gamma_g : float — Gas specific gravity (air = 1.0)

    Returns
    -------
    Ppc : float — Pseudo-critical pressure (psia)
    Tpc : float — Pseudo-critical temperature (°R)
    """
    Ppc = 756.8 - 131.0 * gamma_g - 3.6 * gamma_g**2
    Tpc = 169.2 + 349.5 * gamma_g - 74.0 * gamma_g**2
    return Ppc, Tpc


def z_factor_DAK(Ppr, Tpr, tol=1e-8, max_iter=100):
    """
    Dranchuk-Abou-Kassem (1975) correlation for gas Z-factor.

    Uses Newton-Raphson iteration to solve the implicit equation.

    Parameters
    ----------
    Ppr : float — Pseudo-reduced pressure (P / Ppc)
    Tpr : float — Pseudo-reduced temperature (T / Tpc)

    Returns
    -------
    Z : float — Gas compressibility factor
    """
    # DAK coefficients
    A1, A2, A3, A4 = 0.3265, -1.0700, -0.5339, 0.01569
    A5, A6, A7, A8 = -0.05165, 0.5475, -0.7361, 0.1844
    A9, A10, A11 = 0.1056, 0.6134, 0.7210

    # Initial guess
    Z = 1.0

    for _ in range(max_iter):
        rho_r = 0.27 * Ppr / (Z * Tpr)

        # DAK equation: f(Z) = 0
        c1 = A1 + A2/Tpr + A3/Tpr**3 + A4/Tpr**4 + A5/Tpr**5
        c2 = A6 + A7/Tpr + A8/Tpr**2
        c3 = A9 * (A7/Tpr + A8/Tpr**2)
        c4 = A10 * (1 + A11*rho_r**2) * (rho_r**2/Tpr**3) * np.exp(-A11*rho_r**2)

        f = (Z - 1 - c1*rho_r - c2*rho_r**2 + c3*rho_r**5 - c4)

        # Derivative for Newton-Raphson
        d_rho_dZ = -rho_r / Z
        df = (1 - c1*d_rho_dZ - 2*c2*rho_r*d_rho_dZ
              + 5*c3*rho_r**4*d_rho_dZ
              - A10/Tpr**3 * d_rho_dZ * rho_r
              * (2*rho_r*(1 + A11*rho_r**2) - 2*A11*rho_r**3)
              * np.exp(-A11*rho_r**2))

        Z_new = Z - f / df
        if abs(Z_new - Z) < tol:
            return Z_new
        Z = Z_new

    return Z  # return last estimate if not converged


# Example: Natural gas at reservoir conditions
gamma_g_gas = 0.70  # lean natural gas
P_res = 3500        # psia
T_res_F = 200       # °F
T_res_R = T_res_F + 460  # convert to Rankine

Ppc, Tpc = pseudocritical_properties(gamma_g_gas)
Ppr = P_res / Ppc
Tpr = T_res_R / Tpc

Z = z_factor_DAK(Ppr, Tpr)

print("GAS Z-FACTOR — DAK Correlation")
print(f"  Gas SG:    {gamma_g_gas}")
print(f"  Pressure:  {P_res} psia")
print(f"  Temperature: {T_res_F} °F ({T_res_R} °R)")
print(f"  Ppc:       {Ppc:.1f} psia")
print(f"  Tpc:       {Tpc:.1f} °R")
print(f"  Ppr:       {Ppr:.3f}")
print(f"  Tpr:       {Tpr:.3f}")
print(f"  Z-factor:  {Z:.4f}")
print()
print(f"  If we assumed ideal gas (Z=1.0), the gas volume")
print(f"  calculation would be off by {abs(1-Z)*100:.1f}%.")

Building a PVT Module

Packaging all correlations into a single module makes them reusable across projects.

main.py

class PVTFluid:
    """
    PVT fluid property calculator using empirical correlations.

    Stores fluid and reservoir parameters and provides methods
    for all standard PVT properties.
    """

    def __init__(self, API, gamma_g, T_F, Rs_at_Pb=None, Rw=None):
        self.API = API
        self.gamma_g = gamma_g
        self.gamma_o = 141.5 / (API + 131.5)
        self.T_F = T_F
        self.Rs_at_Pb = Rs_at_Pb

    def bubble_point(self, Rs=None):
        """Standing correlation for bubble point pressure (psia)."""
        Rs = Rs if Rs is not None else self.Rs_at_Pb
        if Rs is None:
            raise ValueError("Rs required for bubble point calculation")
        return standing_bubble_point(Rs, self.gamma_g, self.T_F, self.API)

    def Rs(self, P, method="vasquez_beggs"):
        """Solution gas-oil ratio at pressure P (scf/STB)."""
        Pb = self.bubble_point()
        if np.any(P >= Pb):
            # Above bubble point, Rs is constant at Rs_at_Pb
            if np.isscalar(P):
                return self.Rs_at_Pb if P >= Pb else vasquez_beggs_Rs(
                    P, self.T_F, self.API, self.gamma_g)
            result = np.where(
                P >= Pb,
                self.Rs_at_Pb,
                vasquez_beggs_Rs(P, self.T_F, self.API, self.gamma_g)
            )
            return result
        return vasquez_beggs_Rs(P, self.T_F, self.API, self.gamma_g)

    def Bo(self, P):
        """Oil formation volume factor at pressure P (RB/STB)."""
        Rs_at_P = self.Rs(P)
        return standing_Bo(Rs_at_P, self.gamma_g, self.gamma_o, self.T_F)

    def viscosity(self, P):
        """Live oil viscosity at pressure P (cp)."""
        Rs_at_P = self.Rs(P)
        mu_dead = beggs_robinson_dead_oil(self.T_F, self.API)
        return beggs_robinson_live_oil(mu_dead, Rs_at_P)

    def summary(self, P):
        """Print a complete PVT summary at a given pressure."""
        Rs_val = self.Rs(P)
        Bo_val = self.Bo(P)
        mu_val = self.viscosity(P)
        Pb_val = self.bubble_point()

        print(f"PVT SUMMARY AT {P:,.0f} psia")
        print(f"  API:          {self.API}°")
        print(f"  Gas SG:       {self.gamma_g}")
        print(f"  Temperature:  {self.T_F} °F")
        print(f"  Bubble Point: {Pb_val:,.0f} psia")
        print(f"  Rs:           {Rs_val:,.0f} scf/STB")
        print(f"  Bo:           {Bo_val:.4f} RB/STB")
        print(f"  Viscosity:    {mu_val:.2f} cp")
        state = "Undersaturated (above Pb)" if P >= Pb_val else "Saturated (below Pb)"
        print(f"  State:        {state}")


# Create a fluid object for our OML 58 Niger Delta crude
fluid = PVTFluid(API=32, gamma_g=0.75, T_F=185, Rs_at_Pb=550)

# Summary at current reservoir pressure
fluid.summary(4200)
print()

# Summary after depletion
fluid.summary(2000)

The PVTFluid class encapsulates all the correlations in one place. You create it once with your fluid parameters and then call methods at any pressure. This is the kind of tool that saves time every day in a reservoir engineering workflow — instead of rebuilding spreadsheet formulas for each project, you instantiate the class and call fluid.Bo(3000).

Comparing Correlations to Laboratory Data

Correlations are approximations. They were derived from specific datasets (California crudes, Gulf Coast crudes, Middle Eastern crudes) and may not apply to every fluid. The only way to know how well a correlation works for your reservoir is to compare it against laboratory PVT measurements when they are available.

main.py

import pandas as pd

# Simulated lab PVT data (a differential liberation experiment)
lab_data = pd.DataFrame({
    "P_psia": [4500, 4000, 3500, 3200, 3000, 2500, 2000, 1500, 1000, 500],
    "Rs_lab": [550, 550, 550, 550, 490, 385, 290, 200, 120, 50],
    "Bo_lab": [1.348, 1.348, 1.348, 1.348, 1.305, 1.235, 1.178, 1.130, 1.088, 1.048],
    "mu_lab": [0.72, 0.70, 0.68, 0.67, 0.78, 1.05, 1.42, 1.95, 2.80, 4.50],
})

# The bubble point from lab data is 3200 psia (where Rs starts decreasing)
Pb_lab = 3200

# Calculate correlation predictions at the same pressures
fluid_check = PVTFluid(API=32, gamma_g=0.75, T_F=185, Rs_at_Pb=550)

lab_data["Rs_corr"] = [fluid_check.Rs(p) for p in lab_data["P_psia"]]
lab_data["Bo_corr"] = [fluid_check.Bo(p) for p in lab_data["P_psia"]]
lab_data["mu_corr"] = [fluid_check.viscosity(p) for p in lab_data["P_psia"]]

# Error analysis
lab_data["Rs_err_%"] = abs(lab_data["Rs_corr"] - lab_data["Rs_lab"]) / lab_data["Rs_lab"] * 100
lab_data["Bo_err_%"] = abs(lab_data["Bo_corr"] - lab_data["Bo_lab"]) / lab_data["Bo_lab"] * 100

print("CORRELATION vs. LABORATORY DATA")
print("=" * 75)
print(lab_data[["P_psia", "Rs_lab", "Rs_corr", "Rs_err_%",
                "Bo_lab", "Bo_corr", "Bo_err_%"]].round(2).to_string(index=False))

print()
print(f"Average Rs error: {lab_data['Rs_err_%'].mean():.1f}%")
print(f"Average Bo error: {lab_data['Bo_err_%'].mean():.1f}%")
print()

Pb_corr = fluid_check.bubble_point()
print(f"Bubble point — Lab: {Pb_lab} psia, Correlation: {Pb_corr:,.0f} psia, "
      f"Error: {abs(Pb_corr - Pb_lab)/Pb_lab*100:.1f}%")

If the average error exceeds 10–15%, the correlation may not be appropriate for this fluid. Options include tuning the correlation coefficients to match your lab data, using a different correlation set, or building a custom regression from your own PVT database.

Summary

This chapter covered the PVT properties that underpin all reservoir engineering calculations:

Bubble point pressure marks the transition from undersaturated to saturated conditions. Below it, gas comes out of solution and reservoir behaviour changes fundamentally.
Oil formation volume factor (Bo) converts between reservoir and surface volumes. Ignoring it produces wrong reserve estimates.
Solution GOR (Rs) quantifies how much gas is dissolved in the oil at a given pressure. It controls Bo, viscosity, and production behaviour.
Oil viscosity decreases with dissolved gas and increases with pressure depletion below the bubble point. It directly affects flow rates and recovery.
Gas Z-factor corrects the ideal gas law for real gas behaviour. Essential for gas volume calculations.
Correlations are approximations. Standing, Vasquez-Beggs, and Beggs-Robinson are industry standards, but they must be validated against laboratory data when available.

The next chapter uses these fluid properties in combination with production data to forecast how a well's output changes over time — decline curve analysis.

Exercises

fitness_center

Exercise 8.1Practice

Standing vs. Vasquez-Beggs Rs Predictions

For an OML 58 crude oil with API = 28°, γg = 0.80, T = 220°F, calculate the solution gas-oil ratio (Rs) at pressures of 1000, 2000, 3000, and 4000 psi...

arrow_forward