Los Datos

Trabajamos con datos de producción de gas de un pozo real con 480 días de historial:

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

data = pd.read_csv('REH_18.csv')
DAYS = data['DAYS'].values
RATE = data['RATE'].values

print(f"Registros: {len(data)}")

Registros: 480

print(f"Rango de días: {DAYS.min()} - {DAYS.max()}")

Rango de días: 1 - 480

print(f"Gasto máximo: {RATE.max():.2f}")

Gasto máximo: 6.00

print(f"Gasto final: {RATE[-1]:.2f}")

Gasto final: 0.51

print(data.head(10))

   DAYS  RATE
0     1   2.3
1     2   3.0
2     3   3.2
3     4   3.0
4     5   3.2
5     6   4.2
6     7   4.3
7     8   4.3
8     9   4.3
9    10   4.3

data <- read.csv('REH_18.csv')
DAYS <- data$DAYS
RATE <- data$RATE

cat(sprintf("Registros: %d\n", nrow(data)))

Registros: 480

cat(sprintf("Rango de días: %d - %d\n", min(DAYS), max(DAYS)))

Rango de días: 1 - 480

cat(sprintf("Gasto máximo: %.2f\n", max(RATE)))

Gasto máximo: 6.00

cat(sprintf("Gasto final: %.2f\n", tail(RATE, 1)))

Gasto final: 0.51

head(data, 10)

   DAYS RATE
1     1  2.3
2     2  3.0
3     3  3.2
4     4  3.0
5     5  3.2
6     6  4.2
7     7  4.3
8     8  4.3
9     9  4.3
10   10  4.3

El pozo muestra un periodo inicial de incremento (primeros ~17 días, posiblemente limpieza o apertura gradual) seguido de una declinación sostenida. Para el ajuste usaremos todos los datos, aunque en la práctica se podría filtrar el periodo transitorio inicial.

Visualización de los Datos

• Python
• R

Ver código

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(DAYS, RATE, s=8, alpha=0.6, color='#2d8a4e', label='Datos')
ax.set_xlabel('Tiempo (días)', fontsize=12)
ax.set_ylabel('Qg', fontsize=12)
ax.set_title('Datos de Producción', fontsize=14, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Ver código

library(ggplot2)

ggplot(data, aes(x = DAYS, y = RATE)) +
  geom_point(color = "#2d8a4e", size = 1.5, alpha = 0.6) +
  labs(x = "Tiempo (días)", y = "Qg",
       title = "Datos de Producción") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Ajuste del Modelo Hiperbólico

El modelo hiperbólico es el más general de los tres y tiene 3 parámetros a estimar: , y . Usamos regresión no lineal para encontrar los valores que minimizan el error cuadrático.

# Definir la función del modelo
def hyperbolic(t, qi, b, Di):
    return qi / ((1 + b * Di * t) ** (1/b))

# Ajustar con curve_fit (regresión no lineal)
coef_hyp, cov_hyp = curve_fit(hyperbolic, DAYS, RATE,
                               p0=[6, 0.5, 0.01],    # valores iniciales
                               maxfev=10000)

qi_h, b_h, Di_h = coef_hyp
print(f"qi = {qi_h:.4f}")

qi = 5.2213

print(f"b  = {b_h:.4f}")

b  = 0.5029

print(f"Di = {Di_h:.6f}")

Di = 0.011202

# Ajustar modelo hiperbólico
fit_hyp <- nls(RATE ~ qi / ((1 + b * Di * DAYS)^(1/b)),
               data = data,
               start = list(qi = 6, b = 0.5, Di = 0.01),
               control = nls.control(maxiter = 1000))

coef_hyp <- coef(fit_hyp)
cat(sprintf("qi = %.4f\n", coef_hyp["qi"]))

qi = 5.2212

cat(sprintf("b  = %.4f\n", coef_hyp["b"]))

b  = 0.5029

cat(sprintf("Di = %.6f\n", coef_hyp["Di"]))

Di = 0.011202

Ajuste del Modelo Exponencial

El exponencial tiene solo 2 parámetros ( y ) y asume declinación constante:

def exponential(t, qi, Di):
    return qi * np.exp(-Di * t)

coef_exp, cov_exp = curve_fit(exponential, DAYS, RATE, p0=[6, 0.005])
qi_e, Di_e = coef_exp
print(f"qi = {qi_e:.4f}")

qi = 4.6442

print(f"Di = {Di_e:.6f}")

Di = 0.006850

fit_exp <- nls(RATE ~ qi * exp(-Di * DAYS),
               data = data,
               start = list(qi = 6, Di = 0.005))

coef_exp <- coef(fit_exp)
cat(sprintf("qi = %.4f\n", coef_exp["qi"]))

qi = 4.6442

cat(sprintf("Di = %.6f\n", coef_exp["Di"]))

Di = 0.006850

Ajuste del Modelo Armónico

El armónico también tiene 2 parámetros y es el caso particular donde :

def harmonic(t, qi, Di):
    return qi / (1 + Di * t)

coef_har, cov_har = curve_fit(harmonic, DAYS, RATE, p0=[6, 0.01])
qi_a, Di_a = coef_har
print(f"qi = {qi_a:.4f}")

qi = 5.6238

print(f"Di = {Di_a:.6f}")

Di = 0.017930

fit_har <- nls(RATE ~ qi / (1 + Di * DAYS),
               data = data,
               start = list(qi = 6, Di = 0.01))

coef_har <- coef(fit_har)
cat(sprintf("qi = %.4f\n", coef_har["qi"]))

qi = 5.6239

cat(sprintf("Di = %.6f\n", coef_har["Di"]))

Di = 0.017931

Comparación Visual de los 3 Modelos

• Python
• R

Ver código

# Predicciones
hyp_pred = hyperbolic(DAYS, *coef_hyp)
exp_pred = exponential(DAYS, *coef_exp)
har_pred = harmonic(DAYS, *coef_har)

fig, ax = plt.subplots(figsize=(12, 7))
ax.scatter(DAYS, RATE, s=8, alpha=0.4, color='gray', label='Datos', zorder=1)
ax.plot(DAYS, hyp_pred, '-', lw=2.5, color='#2d8a4e', label='Hiperbólico', zorder=3)
ax.plot(DAYS, exp_pred, '--', lw=2, color='#c0392b', label='Exponencial', zorder=2)
ax.plot(DAYS, har_pred, '-.', lw=2, color='#2980b9', label='Armónico', zorder=2)

ax.set_xlabel('Tiempo (días)', fontsize=12)
ax.set_ylabel('Qg', fontsize=12)
ax.set_title('Ajuste de Curvas de Declinación — Modelos de Arps', fontsize=14, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Ver código

# Predicciones
data$hyp_pred <- predict(fit_hyp)
data$exp_pred <- predict(fit_exp)
data$har_pred <- predict(fit_har)

ggplot(data, aes(x = DAYS)) +
  geom_point(aes(y = RATE), color = "gray", size = 1, alpha = 0.4) +
  geom_line(aes(y = hyp_pred, color = "Hiperbólico"), linewidth = 1.2) +
  geom_line(aes(y = exp_pred, color = "Exponencial"), linewidth = 1, linetype = "dashed") +
  geom_line(aes(y = har_pred, color = "Armónico"), linewidth = 1, linetype = "dotdash") +
  scale_color_manual(values = c("Hiperbólico" = "#2d8a4e",
                                 "Exponencial" = "#c0392b",
                                 "Armónico" = "#2980b9")) +
  labs(x = "Tiempo (días)", y = "Qg", color = "Modelo",
       title = "Ajuste de Curvas de Declinación — Modelos de Arps") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Pronóstico y EUR

La verdadera utilidad del DCA es pronosticar la producción futura y estimar las reservas recuperables (EUR). Extendemos los modelos hasta 1,000 días (520 días más allá de los datos):

• Python
• R

Ver código

# Pronóstico extendido
t_forecast = np.arange(1, 1001)
hyp_fc = hyperbolic(t_forecast, *coef_hyp)
exp_fc = exponential(t_forecast, *coef_exp)
har_fc = harmonic(t_forecast, *coef_har)

# EUR (producción acumulada)
EUR_hyp = np.sum(hyp_fc)
EUR_exp = np.sum(exp_fc)
EUR_har = np.sum(har_fc)

fig, ax = plt.subplots(figsize=(12, 7))

# Zona de pronóstico
ax.axvspan(480, 1000, alpha=0.08, color='orange', label='Pronóstico')

ax.scatter(DAYS, RATE, s=8, alpha=0.4, color='gray', zorder=1)
ax.plot(t_forecast, hyp_fc, '-', lw=2.5, color='#2d8a4e',
        label=f'Hiperbólico (EUR={EUR_hyp:.0f})')
ax.plot(t_forecast, exp_fc, '--', lw=2, color='#c0392b',
        label=f'Exponencial (EUR={EUR_exp:.0f})')
ax.plot(t_forecast, har_fc, '-.', lw=2, color='#2980b9',
        label=f'Armónico (EUR={EUR_har:.0f})')

ax.axvline(x=480, color='orange', ls=':', alpha=0.5)
ax.set_xlabel('Tiempo (días)', fontsize=12)
ax.set_ylabel('Qg', fontsize=12)
ax.set_title('Pronóstico de Producción y EUR', fontsize=14, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3)
ax.set_xlim(0, 1050)

(0.0, 1050.0)

Ver código

plt.tight_layout()
plt.show()

Ver código

t_fc <- 1:1000
qi_h <- coef(fit_hyp)["qi"]; b_h <- coef(fit_hyp)["b"]; Di_h <- coef(fit_hyp)["Di"]
qi_e <- coef(fit_exp)["qi"]; Di_e <- coef(fit_exp)["Di"]
qi_a <- coef(fit_har)["qi"]; Di_a <- coef(fit_har)["Di"]

fc <- data.frame(
  t = t_fc,
  hyp = qi_h / ((1 + b_h * Di_h * t_fc)^(1/b_h)),
  exp = qi_e * exp(-Di_e * t_fc),
  har = qi_a / (1 + Di_a * t_fc)
)

EUR_hyp <- sum(fc$hyp)
EUR_exp <- sum(fc$exp)
EUR_har <- sum(fc$har)

cat(sprintf("EUR Hiperbólico: %.0f\n", EUR_hyp))

EUR Hiperbólico: 791

Ver código

cat(sprintf("EUR Exponencial: %.0f\n", EUR_exp))

EUR Exponencial: 675

Ver código

cat(sprintf("EUR Armónico:    %.0f\n", EUR_har))

EUR Armónico:    920

Ver código

library(tidyr)
fc_long <- pivot_longer(fc, cols = c(hyp, exp, har),
                         names_to = "Modelo", values_to = "Qg")
fc_long$Modelo <- factor(fc_long$Modelo,
                          levels = c("hyp", "exp", "har"),
                          labels = c("Hiperbólico", "Exponencial", "Armónico"))

ggplot() +
  annotate("rect", xmin = 480, xmax = 1000, ymin = -Inf, ymax = Inf,
           alpha = 0.08, fill = "orange") +
  geom_point(data = data, aes(x = DAYS, y = RATE), color = "gray", size = 1, alpha = 0.4) +
  geom_line(data = fc_long, aes(x = t, y = Qg, color = Modelo, linetype = Modelo),
            linewidth = 1) +
  scale_color_manual(values = c("Hiperbólico" = "#2d8a4e",
                                 "Exponencial" = "#c0392b",
                                 "Armónico" = "#2980b9")) +
  geom_vline(xintercept = 480, color = "orange", linetype = "dotted", alpha = 0.5) +
  labs(x = "Tiempo (días)", y = "Qg",
       title = "Pronóstico de Producción y EUR") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Tabla Resumen de Resultados

# R-cuadrado
SS_res_hyp = np.sum((RATE - hyp_pred)**2)
SS_res_exp = np.sum((RATE - exp_pred)**2)
SS_res_har = np.sum((RATE - har_pred)**2)
SS_tot = np.sum((RATE - np.mean(RATE))**2)

R2_hyp = 1 - SS_res_hyp / SS_tot
R2_exp = 1 - SS_res_exp / SS_tot
R2_har = 1 - SS_res_har / SS_tot

print(f"{'Parámetro':<15} {'Exponencial':>14} {'Hiperbólico':>14} {'Armónico':>14}")

Parámetro          Exponencial    Hiperbólico       Armónico

print("-" * 59)

-----------------------------------------------------------

print(f"{'qi':<15} {qi_e:>14.4f} {qi_h:>14.4f} {qi_a:>14.4f}")

qi                      4.6442         5.2213         5.6238

print(f"{'b':<15} {'0 (fijo)':>14} {b_h:>14.4f} {'1 (fijo)':>14}")

b                     0 (fijo)         0.5029       1 (fijo)

print(f"{'Di':<15} {Di_e:>14.6f} {Di_h:>14.6f} {Di_a:>14.6f}")

Di                    0.006850       0.011202       0.017930

print(f"{'R²':<15} {R2_exp:>14.4f} {R2_hyp:>14.4f} {R2_har:>14.4f}")

R²                      0.8350         0.8600         0.8397

print(f"{'EUR (1000 d)':<15} {EUR_exp:>14.0f} {EUR_hyp:>14.0f} {EUR_har:>14.0f}")

EUR (1000 d)               675            791            920

# R-cuadrado
SS_tot <- sum((RATE - mean(RATE))^2)
R2_hyp <- 1 - sum(residuals(fit_hyp)^2) / SS_tot
R2_exp <- 1 - sum(residuals(fit_exp)^2) / SS_tot
R2_har <- 1 - sum(residuals(fit_har)^2) / SS_tot

results <- data.frame(
  Parámetro = c("qi", "b", "Di", "R²", "EUR (1000 d)"),
  Exponencial = c(sprintf("%.4f", qi_e), "0 (fijo)",
                  sprintf("%.6f", Di_e), sprintf("%.4f", R2_exp),
                  sprintf("%.0f", EUR_exp)),
  Hiperbólico = c(sprintf("%.4f", qi_h), sprintf("%.4f", b_h),
                  sprintf("%.6f", Di_h), sprintf("%.4f", R2_hyp),
                  sprintf("%.0f", EUR_hyp)),
  Armónico = c(sprintf("%.4f", qi_a), "1 (fijo)",
               sprintf("%.6f", Di_a), sprintf("%.4f", R2_har),
               sprintf("%.0f", EUR_har))
)

knitr::kable(results, caption = "Comparación de modelos de Arps", align = 'lrrr')

Observaciones:

• El modelo hiperbólico tiene el mejor R² (0.86) ya que tiene un parámetro más de libertad ()
• El valor ajustado de es consistente con yacimientos de gas convencional (típicamente entre 0.3 y 0.7)
• El exponencial es el más conservador: predice el menor EUR (675) y declina más rápido
• El armónico es el más optimista: predice el mayor EUR (920) y declina más lento
• La diferencia entre EUR exponencial y armónico es de ~36% — esta incertidumbre es importante para la evaluación económica

Descarga

• 📥 REH_18.csv — Datos de producción (480 días)

Referencias

• Arps, J.J. (1945). Analysis of Decline Curves. Transactions of the AIME, 160(1), 228-247.
• Ahmed, T. (2019). Reservoir Engineering Handbook, 5th ed. Gulf Professional Publishing.
• Sun, H. (2015). Advanced Production Decline Analysis and Application. Gulf Professional Publishing.

Los Datos

Trabajamos con datos de producción de gas de un pozo real con 480 días de historial:

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

data = pd.read_csv('REH_18.csv')
DAYS = data['DAYS'].values
RATE = data['RATE'].values

print(f"Registros: {len(data)}")

Registros: 480

print(f"Rango de días: {DAYS.min()} - {DAYS.max()}")

Rango de días: 1 - 480

print(f"Gasto máximo: {RATE.max():.2f}")

Gasto máximo: 6.00

print(f"Gasto final: {RATE[-1]:.2f}")

Gasto final: 0.51

print(data.head(10))

   DAYS  RATE
0     1   2.3
1     2   3.0
2     3   3.2
3     4   3.0
4     5   3.2
5     6   4.2
6     7   4.3
7     8   4.3
8     9   4.3
9    10   4.3

data <- read.csv('REH_18.csv')
DAYS <- data$DAYS
RATE <- data$RATE

cat(sprintf("Registros: %d\n", nrow(data)))

Registros: 480

cat(sprintf("Rango de días: %d - %d\n", min(DAYS), max(DAYS)))

Rango de días: 1 - 480

cat(sprintf("Gasto máximo: %.2f\n", max(RATE)))

Gasto máximo: 6.00

cat(sprintf("Gasto final: %.2f\n", tail(RATE, 1)))

Gasto final: 0.51

head(data, 10)

   DAYS RATE
1     1  2.3
2     2  3.0
3     3  3.2
4     4  3.0
5     5  3.2
6     6  4.2
7     7  4.3
8     8  4.3
9     9  4.3
10   10  4.3

El pozo muestra un periodo inicial de incremento (primeros ~17 días, posiblemente limpieza o apertura gradual) seguido de una declinación sostenida. Para el ajuste usaremos todos los datos, aunque en la práctica se podría filtrar el periodo transitorio inicial.

Visualización de los Datos

• Python
• R

Ver código

fig, ax = plt.subplots(figsize=(10, 6))
ax.scatter(DAYS, RATE, s=8, alpha=0.6, color='#2d8a4e', label='Datos')
ax.set_xlabel('Tiempo (días)', fontsize=12)
ax.set_ylabel('Qg', fontsize=12)
ax.set_title('Datos de Producción', fontsize=14, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Ver código

library(ggplot2)

ggplot(data, aes(x = DAYS, y = RATE)) +
  geom_point(color = "#2d8a4e", size = 1.5, alpha = 0.6) +
  labs(x = "Tiempo (días)", y = "Qg",
       title = "Datos de Producción") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Ajuste del Modelo Hiperbólico

El modelo hiperbólico es el más general de los tres y tiene 3 parámetros a estimar: , y . Usamos regresión no lineal para encontrar los valores que minimizan el error cuadrático.

# Definir la función del modelo
def hyperbolic(t, qi, b, Di):
    return qi / ((1 + b * Di * t) ** (1/b))

# Ajustar con curve_fit (regresión no lineal)
coef_hyp, cov_hyp = curve_fit(hyperbolic, DAYS, RATE,
                               p0=[6, 0.5, 0.01],    # valores iniciales
                               maxfev=10000)

qi_h, b_h, Di_h = coef_hyp
print(f"qi = {qi_h:.4f}")

qi = 5.2213

print(f"b  = {b_h:.4f}")

b  = 0.5029

print(f"Di = {Di_h:.6f}")

Di = 0.011202

# Ajustar modelo hiperbólico
fit_hyp <- nls(RATE ~ qi / ((1 + b * Di * DAYS)^(1/b)),
               data = data,
               start = list(qi = 6, b = 0.5, Di = 0.01),
               control = nls.control(maxiter = 1000))

coef_hyp <- coef(fit_hyp)
cat(sprintf("qi = %.4f\n", coef_hyp["qi"]))

qi = 5.2212

cat(sprintf("b  = %.4f\n", coef_hyp["b"]))

b  = 0.5029

cat(sprintf("Di = %.6f\n", coef_hyp["Di"]))

Di = 0.011202

Ajuste del Modelo Exponencial

El exponencial tiene solo 2 parámetros ( y ) y asume declinación constante:

def exponential(t, qi, Di):
    return qi * np.exp(-Di * t)

coef_exp, cov_exp = curve_fit(exponential, DAYS, RATE, p0=[6, 0.005])
qi_e, Di_e = coef_exp
print(f"qi = {qi_e:.4f}")

qi = 4.6442

print(f"Di = {Di_e:.6f}")

Di = 0.006850

fit_exp <- nls(RATE ~ qi * exp(-Di * DAYS),
               data = data,
               start = list(qi = 6, Di = 0.005))

coef_exp <- coef(fit_exp)
cat(sprintf("qi = %.4f\n", coef_exp["qi"]))

qi = 4.6442

cat(sprintf("Di = %.6f\n", coef_exp["Di"]))

Di = 0.006850

Ajuste del Modelo Armónico

El armónico también tiene 2 parámetros y es el caso particular donde :

def harmonic(t, qi, Di):
    return qi / (1 + Di * t)

coef_har, cov_har = curve_fit(harmonic, DAYS, RATE, p0=[6, 0.01])
qi_a, Di_a = coef_har
print(f"qi = {qi_a:.4f}")

qi = 5.6238

print(f"Di = {Di_a:.6f}")

Di = 0.017930

fit_har <- nls(RATE ~ qi / (1 + Di * DAYS),
               data = data,
               start = list(qi = 6, Di = 0.01))

coef_har <- coef(fit_har)
cat(sprintf("qi = %.4f\n", coef_har["qi"]))

qi = 5.6239

cat(sprintf("Di = %.6f\n", coef_har["Di"]))

Di = 0.017931

Comparación Visual de los 3 Modelos

• Python
• R

Ver código

# Predicciones
hyp_pred = hyperbolic(DAYS, *coef_hyp)
exp_pred = exponential(DAYS, *coef_exp)
har_pred = harmonic(DAYS, *coef_har)

fig, ax = plt.subplots(figsize=(12, 7))
ax.scatter(DAYS, RATE, s=8, alpha=0.4, color='gray', label='Datos', zorder=1)
ax.plot(DAYS, hyp_pred, '-', lw=2.5, color='#2d8a4e', label='Hiperbólico', zorder=3)
ax.plot(DAYS, exp_pred, '--', lw=2, color='#c0392b', label='Exponencial', zorder=2)
ax.plot(DAYS, har_pred, '-.', lw=2, color='#2980b9', label='Armónico', zorder=2)

ax.set_xlabel('Tiempo (días)', fontsize=12)
ax.set_ylabel('Qg', fontsize=12)
ax.set_title('Ajuste de Curvas de Declinación — Modelos de Arps', fontsize=14, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Ver código

# Predicciones
data$hyp_pred <- predict(fit_hyp)
data$exp_pred <- predict(fit_exp)
data$har_pred <- predict(fit_har)

ggplot(data, aes(x = DAYS)) +
  geom_point(aes(y = RATE), color = "gray", size = 1, alpha = 0.4) +
  geom_line(aes(y = hyp_pred, color = "Hiperbólico"), linewidth = 1.2) +
  geom_line(aes(y = exp_pred, color = "Exponencial"), linewidth = 1, linetype = "dashed") +
  geom_line(aes(y = har_pred, color = "Armónico"), linewidth = 1, linetype = "dotdash") +
  scale_color_manual(values = c("Hiperbólico" = "#2d8a4e",
                                 "Exponencial" = "#c0392b",
                                 "Armónico" = "#2980b9")) +
  labs(x = "Tiempo (días)", y = "Qg", color = "Modelo",
       title = "Ajuste de Curvas de Declinación — Modelos de Arps") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Pronóstico y EUR

La verdadera utilidad del DCA es pronosticar la producción futura y estimar las reservas recuperables (EUR). Extendemos los modelos hasta 1,000 días (520 días más allá de los datos):

• Python
• R

Ver código

# Pronóstico extendido
t_forecast = np.arange(1, 1001)
hyp_fc = hyperbolic(t_forecast, *coef_hyp)
exp_fc = exponential(t_forecast, *coef_exp)
har_fc = harmonic(t_forecast, *coef_har)

# EUR (producción acumulada)
EUR_hyp = np.sum(hyp_fc)
EUR_exp = np.sum(exp_fc)
EUR_har = np.sum(har_fc)

fig, ax = plt.subplots(figsize=(12, 7))

# Zona de pronóstico
ax.axvspan(480, 1000, alpha=0.08, color='orange', label='Pronóstico')

ax.scatter(DAYS, RATE, s=8, alpha=0.4, color='gray', zorder=1)
ax.plot(t_forecast, hyp_fc, '-', lw=2.5, color='#2d8a4e',
        label=f'Hiperbólico (EUR={EUR_hyp:.0f})')
ax.plot(t_forecast, exp_fc, '--', lw=2, color='#c0392b',
        label=f'Exponencial (EUR={EUR_exp:.0f})')
ax.plot(t_forecast, har_fc, '-.', lw=2, color='#2980b9',
        label=f'Armónico (EUR={EUR_har:.0f})')

ax.axvline(x=480, color='orange', ls=':', alpha=0.5)
ax.set_xlabel('Tiempo (días)', fontsize=12)
ax.set_ylabel('Qg', fontsize=12)
ax.set_title('Pronóstico de Producción y EUR', fontsize=14, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3)
ax.set_xlim(0, 1050)

(0.0, 1050.0)

Ver código

plt.tight_layout()
plt.show()

Ver código

t_fc <- 1:1000
qi_h <- coef(fit_hyp)["qi"]; b_h <- coef(fit_hyp)["b"]; Di_h <- coef(fit_hyp)["Di"]
qi_e <- coef(fit_exp)["qi"]; Di_e <- coef(fit_exp)["Di"]
qi_a <- coef(fit_har)["qi"]; Di_a <- coef(fit_har)["Di"]

fc <- data.frame(
  t = t_fc,
  hyp = qi_h / ((1 + b_h * Di_h * t_fc)^(1/b_h)),
  exp = qi_e * exp(-Di_e * t_fc),
  har = qi_a / (1 + Di_a * t_fc)
)

EUR_hyp <- sum(fc$hyp)
EUR_exp <- sum(fc$exp)
EUR_har <- sum(fc$har)

cat(sprintf("EUR Hiperbólico: %.0f\n", EUR_hyp))

EUR Hiperbólico: 791

Ver código

cat(sprintf("EUR Exponencial: %.0f\n", EUR_exp))

EUR Exponencial: 675

Ver código

cat(sprintf("EUR Armónico:    %.0f\n", EUR_har))

EUR Armónico:    920

Ver código

library(tidyr)
fc_long <- pivot_longer(fc, cols = c(hyp, exp, har),
                         names_to = "Modelo", values_to = "Qg")
fc_long$Modelo <- factor(fc_long$Modelo,
                          levels = c("hyp", "exp", "har"),
                          labels = c("Hiperbólico", "Exponencial", "Armónico"))

ggplot() +
  annotate("rect", xmin = 480, xmax = 1000, ymin = -Inf, ymax = Inf,
           alpha = 0.08, fill = "orange") +
  geom_point(data = data, aes(x = DAYS, y = RATE), color = "gray", size = 1, alpha = 0.4) +
  geom_line(data = fc_long, aes(x = t, y = Qg, color = Modelo, linetype = Modelo),
            linewidth = 1) +
  scale_color_manual(values = c("Hiperbólico" = "#2d8a4e",
                                 "Exponencial" = "#c0392b",
                                 "Armónico" = "#2980b9")) +
  geom_vline(xintercept = 480, color = "orange", linetype = "dotted", alpha = 0.5) +
  labs(x = "Tiempo (días)", y = "Qg",
       title = "Pronóstico de Producción y EUR") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Tabla Resumen de Resultados

# R-cuadrado
SS_res_hyp = np.sum((RATE - hyp_pred)**2)
SS_res_exp = np.sum((RATE - exp_pred)**2)
SS_res_har = np.sum((RATE - har_pred)**2)
SS_tot = np.sum((RATE - np.mean(RATE))**2)

R2_hyp = 1 - SS_res_hyp / SS_tot
R2_exp = 1 - SS_res_exp / SS_tot
R2_har = 1 - SS_res_har / SS_tot

print(f"{'Parámetro':<15} {'Exponencial':>14} {'Hiperbólico':>14} {'Armónico':>14}")

Parámetro          Exponencial    Hiperbólico       Armónico

print("-" * 59)

-----------------------------------------------------------

print(f"{'qi':<15} {qi_e:>14.4f} {qi_h:>14.4f} {qi_a:>14.4f}")

qi                      4.6442         5.2213         5.6238

print(f"{'b':<15} {'0 (fijo)':>14} {b_h:>14.4f} {'1 (fijo)':>14}")

b                     0 (fijo)         0.5029       1 (fijo)

print(f"{'Di':<15} {Di_e:>14.6f} {Di_h:>14.6f} {Di_a:>14.6f}")

Di                    0.006850       0.011202       0.017930

print(f"{'R²':<15} {R2_exp:>14.4f} {R2_hyp:>14.4f} {R2_har:>14.4f}")

R²                      0.8350         0.8600         0.8397

print(f"{'EUR (1000 d)':<15} {EUR_exp:>14.0f} {EUR_hyp:>14.0f} {EUR_har:>14.0f}")

EUR (1000 d)               675            791            920

# R-cuadrado
SS_tot <- sum((RATE - mean(RATE))^2)
R2_hyp <- 1 - sum(residuals(fit_hyp)^2) / SS_tot
R2_exp <- 1 - sum(residuals(fit_exp)^2) / SS_tot
R2_har <- 1 - sum(residuals(fit_har)^2) / SS_tot

results <- data.frame(
  Parámetro = c("qi", "b", "Di", "R²", "EUR (1000 d)"),
  Exponencial = c(sprintf("%.4f", qi_e), "0 (fijo)",
                  sprintf("%.6f", Di_e), sprintf("%.4f", R2_exp),
                  sprintf("%.0f", EUR_exp)),
  Hiperbólico = c(sprintf("%.4f", qi_h), sprintf("%.4f", b_h),
                  sprintf("%.6f", Di_h), sprintf("%.4f", R2_hyp),
                  sprintf("%.0f", EUR_hyp)),
  Armónico = c(sprintf("%.4f", qi_a), "1 (fijo)",
               sprintf("%.6f", Di_a), sprintf("%.4f", R2_har),
               sprintf("%.0f", EUR_har))
)

knitr::kable(results, caption = "Comparación de modelos de Arps", align = 'lrrr')

Observaciones:

• El modelo hiperbólico tiene el mejor R² (0.86) ya que tiene un parámetro más de libertad ()
• El valor ajustado de es consistente con yacimientos de gas convencional (típicamente entre 0.3 y 0.7)
• El exponencial es el más conservador: predice el menor EUR (675) y declina más rápido
• El armónico es el más optimista: predice el mayor EUR (920) y declina más lento
• La diferencia entre EUR exponencial y armónico es de ~36% — esta incertidumbre es importante para la evaluación económica

Descarga

• 📥 REH_18.csv — Datos de producción (480 días)

Referencias

• Arps, J.J. (1945). Analysis of Decline Curves. Transactions of the AIME, 160(1), 228-247.
• Ahmed, T. (2019). Reservoir Engineering Handbook, 5th ed. Gulf Professional Publishing.
• Sun, H. (2015). Advanced Production Decline Analysis and Application. Gulf Professional Publishing.

Las Tres Regiones de la Curva

La curva IPR compuesta se divide en 3 regiones, cada una con su ecuación:

Datos del Ejemplo

Datos de entrada. Ejemplo de Brown (1984).

Parámetro	Valor	Unidades
Presión de yacimiento ()	2,550	psi
Presión de burbuja ()	2,100	psi
Presión de fondo fluyente (prueba)	2,300	psi
Gasto total (prueba)	500	b/d
Fracción de agua ()	0.50	—

Parámetros Calculados

A partir de los datos de la prueba se calculan los parámetros base:

Parámetros intermedios.

Parámetro	Fórmula	Valor
Índice de productividad ()		2.0 b/d/psi
Gasto al punto de burbuja ()		900 b/d
Gasto máximo de aceite ()		3,233.33 b/d
Presión en ()		466.67 psi
Gasto máximo total ()		Calculado

Código: R y Python

• Python
• R

Ver código

import numpy as np
import matplotlib.pyplot as plt

# === DATOS DE ENTRADA ===
Pr = 2550       # Presión de yacimiento (psi)
Pb = 2100       # Presión de burbuja (psi)
Pwf_test = 2300 # Pwf de la prueba (psi)
Qt_test = 500   # Gasto total de la prueba (b/d)
Fw = 0.5        # Fracción de agua
Fo = 1 - Fw     # Fracción de aceite

# === PARÁMETROS CALCULADOS ===
J = Qt_test / (Pr - Pwf_test)               # Índice de productividad
qb = J * (Pr - Pb)                           # Gasto al punto de burbuja
qomax = qb + J * Pb / 1.8                    # Gasto máximo de aceite

# Cálculo de tan(alpha) y tan(beta)
CD = (Fo * 0.125 * Pb * (np.sqrt(81 - 80 * (0.999 * qomax - qb) / (qomax - qb)) - 1)
      + Fw * (Pr - (0.999 * qomax) / J) - Fw * (Pr - qomax / J))
CG = 0.001 * qomax
tan_a = CG / CD
tan_b = 1 / tan_a

# Presión y gasto máximo total
PwfG = Fw * (Pr - qomax / J)
qtmax = qomax + Fw * (Pr - qomax / J) * tan_a

print(f"J       = {J:.2f} b/d/psi")

J       = 2.00 b/d/psi

Ver código

print(f"qb      = {qb:.2f} b/d")

qb      = 900.00 b/d

Ver código

print(f"qomax   = {qomax:.2f} b/d")

qomax   = 3233.33 b/d

Ver código

print(f"PwfG    = {PwfG:.2f} psi")

PwfG    = 466.67 psi

Ver código

print(f"tan(α)  = {tan_a:.4f}")

tan(α)  = 0.4097

Ver código

print(f"tan(β)  = {tan_b:.4f}")

tan(β)  = 2.4409

Ver código

print(f"qtmax   = {qtmax:.2f} b/d")

qtmax   = 3424.52 b/d

Ver código

# === FUNCIONES AUXILIARES ===
def calc_A(Pwf, Fo, Pb, Pr, Fw):
    return (Pwf + 0.125 * Fo * Pb - Fw * Pr) / (0.125 * Fo * Pb)

def calc_B(Fw, Fo, Pb, J):
    return Fw / (0.125 * Fo * Pb * J)

def calc_C(A, B, qomax, qb):
    return 2 * A * B + 80 / (qomax - qb)

def calc_D(A, qb, qomax):
    return A**2 - 80 * (qb / (qomax - qb)) - 81

# === CALCULAR IPR COMPUESTA ===
pwf_vec = np.array([0, 200, 350, 600, 1000, 1400, 1500, 1700, 2100, 2300, 2400, 2550])

qt_vec = np.zeros_like(pwf_vec, dtype=float)

for i, pwf in enumerate(pwf_vec):
    if pwf >= Pb:
        # Región 1: Lineal (monofásica)
        qt_vec[i] = J * (Pr - pwf)
    elif pwf >= PwfG:
        # Región 2: Bifásica (Vogel + PI)
        A = calc_A(pwf, Fo, Pb, Pr, Fw)
        B = calc_B(Fw, Fo, Pb, J)
        C = calc_C(A, B, qomax, qb)
        D = calc_D(A, qb, qomax)
        if B != 0:
            qt_vec[i] = (-C + np.sqrt(C**2 - 4 * B**2 * D)) / (2 * B**2)
        else:
            qt_vec[i] = -D / C
    else:
        # Región 3: Extensión lineal
        qt_vec[i] = (PwfG + qomax * tan_b - pwf) / tan_b

# === TABLA DE RESULTADOS ===
print(f"{'Pwf (psi)':>10} {'qt (b/d)':>12}")

 Pwf (psi)     qt (b/d)

Ver código

print("-" * 24)

------------------------

Ver código

for p, q in zip(pwf_vec, qt_vec):
    print(f"{p:10.0f} {q:12.2f}")

         0      3424.52
       200      3342.58
       350      3281.13
       600      3159.86
      1000      2758.15
      1400      2177.33
      1500      2012.26
      1700      1662.93
      2100       900.00
      2300       500.00
      2400       300.00
      2550         0.00

Ver código

# === GRÁFICO ===
# Para evitar quiebres numéricos en los cambios de región,
# se construye la curva por segmentos e incluyendo exactamente Pb y PwfG.

def qt_composite_single(pwf):
    if pwf >= Pb:
        return J * (Pr - pwf)
    elif pwf >= PwfG:
        A = calc_A(pwf, Fo, Pb, Pr, Fw)
        B = calc_B(Fw, Fo, Pb, J)
        C = calc_C(A, B, qomax, qb)
        D = calc_D(A, qb, qomax)
        discriminant = max(C**2 - 4 * B**2 * D, 0)
        if B != 0:
            return (-C + np.sqrt(discriminant)) / (2 * B**2)
        return -D / C
    else:
        return (PwfG + qomax * tan_b - pwf) / tan_b

pwf_reg3 = np.linspace(0, PwfG, 80)
pwf_reg2 = np.linspace(PwfG, Pb, 120)
pwf_reg1 = np.linspace(Pb, Pr, 80)
pwf_smooth = np.unique(np.concatenate([pwf_reg3, pwf_reg2, pwf_reg1]))
qt_smooth = np.array([qt_composite_single(p) for p in pwf_smooth])

fig, ax = plt.subplots(figsize=(10, 7))
ax.plot(qt_smooth, pwf_smooth, '-', lw=2.5, color='#2d8a4e', label=f'Composite IPR (Fw={Fw})')
ax.plot(qt_vec, pwf_vec, 'o', ms=6, color='#c0392b', label='Puntos calculados', zorder=5)

# Líneas de referencia
ax.axhline(y=Pb, color='gray', ls='--', alpha=0.5, lw=0.8)
ax.text(100, Pb + 30, f'Pb = {Pb} psi', fontsize=9, color='gray')
ax.axhline(y=PwfG, color='gray', ls='--', alpha=0.5, lw=0.8)
ax.text(100, PwfG + 30, f'PwfG = {PwfG:.0f} psi', fontsize=9, color='gray')

# Puntos especiales
ax.plot(qb, Pb, 's', ms=10, color='#e67e22', zorder=6)
ax.annotate(f'qb = {qb:.0f}', xy=(qb, Pb), xytext=(qb+200, Pb+100),
            fontsize=9, arrowprops=dict(arrowstyle='->', color='#e67e22'), color='#e67e22')
ax.plot(qomax, PwfG, 's', ms=10, color='#8e44ad', zorder=6)
ax.annotate(f'qomax = {qomax:.0f}', xy=(qomax, PwfG), xytext=(qomax-800, PwfG+200),
            fontsize=9, arrowprops=dict(arrowstyle='->', color='#8e44ad'), color='#8e44ad')

ax.set_xlabel('Gasto total, qt (b/d)', fontsize=12)
ax.set_ylabel('Presión de fondo fluyente, Pwf (psi)', fontsize=12)
ax.set_title('Curva IPR Compuesta — Método de Brown (1984)', fontsize=14, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(True, alpha=0.3)
ax.set_xlim(left=0)

(0.0, 3595.747525657348)

Ver código

ax.set_ylim(bottom=0)

(0.0, 2677.5)

Ver código

plt.tight_layout()
plt.show()

Ver código

library(ggplot2)

# === DATOS DE ENTRADA ===
Pr <- 2550       # Presión de yacimiento (psi)
Pb <- 2100       # Presión de burbuja (psi)
Pwf_test <- 2300 # Pwf de la prueba (psi)
Qt_test <- 500   # Gasto total de la prueba (b/d)
Fw <- 0.5        # Fracción de agua
Fo <- 1 - Fw     # Fracción de aceite

# === PARÁMETROS CALCULADOS ===
J <- Qt_test / (Pr - Pwf_test)
qb <- J * (Pr - Pb)
qomax <- qb + J * Pb / 1.8

CD <- Fo * 0.125 * Pb * (sqrt(81 - 80 * (0.999 * qomax - qb) / (qomax - qb)) - 1) +
      Fw * (Pr - (0.999 * qomax) / J) - Fw * (Pr - qomax / J)
CG <- 0.001 * qomax
tana <- CG / CD
tanb <- 1 / tana

PwfG <- Fw * (Pr - qomax / J)
qtmax <- qomax + Fw * (Pr - qomax / J) * tana

cat(sprintf("J       = %.2f b/d/psi\n", J))

J       = 2.00 b/d/psi

Ver código

cat(sprintf("qb      = %.2f b/d\n", qb))

qb      = 900.00 b/d

Ver código

cat(sprintf("qomax   = %.2f b/d\n", qomax))

qomax   = 3233.33 b/d

Ver código

cat(sprintf("PwfG    = %.2f psi\n", PwfG))

PwfG    = 466.67 psi

Ver código

cat(sprintf("tan(α)  = %.4f\n", tana))

tan(α)  = 0.4097

Ver código

cat(sprintf("tan(β)  = %.4f\n", tanb))

tan(β)  = 2.4409

Ver código

cat(sprintf("qtmax   = %.2f b/d\n", qtmax))

qtmax   = 3424.52 b/d

Ver código

# === FUNCIONES AUXILIARES ===
A_IPR_c <- function(Pwf, Fw, Pb, Pr) {
  Fo <- 1 - Fw
  (Pwf + 0.125 * Fo * Pb - Fw * Pr) / (0.125 * Fo * Pb)
}

B_IPR_c <- function(Fw, Pb, J) {
  Fo <- 1 - Fw
  Fw / (0.125 * Fo * Pb * J)
}

C_IPR_c <- function(Pwf, Fw, Pb, Pr, J, qomax, qb) {
  A <- A_IPR_c(Pwf, Fw, Pb, Pr)
  B <- B_IPR_c(Fw, Pb, J)
  2 * A * B + 80 / (qomax - qb)
}

D_IPR_c <- function(Pwf, Fw, Pb, Pr, J, qomax, qb) {
  A <- A_IPR_c(Pwf, Fw, Pb, Pr)
  A^2 - 80 * (qb / (qomax - qb)) - 81
}

# === CALCULAR IPR COMPUESTA ===
pwf <- c(0, 200, 350, 600, 1000, 1400, 1500, 1700, 2100, 2300, 2400, 2550)

A <- A_IPR_c(pwf, Fw, Pb, Pr)
B <- B_IPR_c(Fw, Pb, J)
C <- C_IPR_c(pwf, Fw, Pb, Pr, J, qomax, qb)
D <- D_IPR_c(pwf, Fw, Pb, Pr, J, qomax, qb)

qt <- ifelse(pwf >= Pb, J * (Pr - pwf),
        ifelse(pwf >= PwfG & pwf < Pb,
          ifelse(rep(B, length(pwf)) != 0,
                 (-C + sqrt(C^2 - 4 * B^2 * D)) / (2 * B^2), -D / C),
          ifelse(pwf < PwfG, (PwfG + qomax * tanb - pwf) / tanb, 0)))

IPR <- data.frame(pwf = pwf, qt = qt)

# === GRÁFICO ===
ggplot(IPR, aes(x = qt, y = pwf)) +
  geom_line(color = "#2d8a4e", linewidth = 1.2) +
  geom_point(color = "#c0392b", size = 3) +
  geom_hline(yintercept = Pb, linetype = "dashed", color = "gray", alpha = 0.6) +
  geom_hline(yintercept = PwfG, linetype = "dashed", color = "gray", alpha = 0.6) +
  annotate("text", x = 100, y = Pb + 40, label = paste("Pb =", Pb, "psi"),
           color = "gray", size = 3.5) +
  annotate("text", x = 100, y = PwfG + 40, label = paste("PwfG =", round(PwfG), "psi"),
           color = "gray", size = 3.5) +
  labs(x = "Gasto total, qt (b/d)",
       y = "Presión de fondo fluyente, Pwf (psi)",
       title = "Curva IPR Compuesta — Método de Brown (1984)") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Ver código

knitr::kable(IPR, col.names = c("Pwf (psi)", "qt (b/d)"),
             caption = "Composite IPR, Fw = 0.5", digits = 2)

Composite IPR, Fw = 0.5

Pwf (psi)	qt (b/d)
0	3424.52
200	3342.58
350	3281.13
600	3159.86
1000	2758.15
1400	2177.33
1500	2012.26
1700	1662.93
2100	900.00
2300	500.00
2400	300.00
2550	0.00

Cómo Hacerlo en Excel

El mismo cálculo se puede replicar en Excel sin macros:

Paso 1 — Datos de entrada

Coloca los datos en celdas fijas:

Celda	Contenido	Valor
B1		2550
B2		2100
B3		2300
B4		500
B5		0.5

Paso 2 — Parámetros calculados

Celda	Fórmula	Resultado
B7 ()	=B4/(B1-B3)	2.00
B8 ()	=B7*(B1-B2)	900
B9 ()	=B8+B7*B2/1.8	3,233.33
B10 ()	=1-B5	0.50
B11 ()	=B5*(B1-B9/B7)	458.33

=SI(A13>=B2, B7*(B1-A13),
  SI(A13>=B11,
    SI(D13<>0,(-C13+RAIZ(C13^2-4*D13^2*E13))/(2*D13^2),-E13/C13),
    (B11+B9*F13-A13)/F13))

Análisis de Sensibilidad: Efecto de

Un ejercicio muy útil es generar la curva IPR para diferentes valores de y observar cómo el incremento de agua afecta la productividad del pozo.

• Python
• R

Ver código

fig, ax = plt.subplots(figsize=(10, 7))

fw_values = [0.0, 0.25, 0.50, 0.75]
colors_fw = ['#2d8a4e', '#2980b9', '#e67e22', '#c0392b']

def composite_ipr_curve(fw, n=250):
    """Calcula qt(Pwf) para la IPR compuesta evitando discontinuidades numéricas."""
    fo = 1 - fw
    qb_s = J * (Pr - Pb)
    qomax_s = qb_s + J * Pb / 1.8
    pwf_s = np.linspace(0, Pr, n)
    qt_s = np.zeros_like(pwf_s)

    # Caso límite: solo aceite -> Vogel bajo Pb + línea sobre Pb
    if np.isclose(fw, 0):
        for i, p in enumerate(pwf_s):
            if p >= Pb:
                qt_s[i] = J * (Pr - p)
            else:
                r = p / Pb
                qt_s[i] = qb_s + (qomax_s - qb_s) * (1 - 0.2 * r - 0.8 * r**2)
        return pwf_s, qt_s

    CD_s = (fo * 0.125 * Pb * (np.sqrt(81 - 80 * (0.999 * qomax_s - qb_s) / (qomax_s - qb_s)) - 1)
            + fw * (Pr - (0.999 * qomax_s) / J) - fw * (Pr - qomax_s / J))
    tan_a_s = (0.001 * qomax_s) / CD_s
    tan_b_s = 1 / tan_a_s
    PwfG_s = fw * (Pr - qomax_s / J)

    for i, p in enumerate(pwf_s):
        if p >= Pb:
            qt_s[i] = J * (Pr - p)
        elif p >= PwfG_s:
            A = (p + 0.125 * fo * Pb - fw * Pr) / (0.125 * fo * Pb)
            B = fw / (0.125 * fo * Pb * J)
            C = 2 * A * B + 80 / (qomax_s - qb_s)
            D = A**2 - 80 * (qb_s / (qomax_s - qb_s)) - 81
            disc = max(C**2 - 4 * B**2 * D, 0)
            qt_s[i] = (-C + np.sqrt(disc)) / (2 * B**2)
        else:
            qt_s[i] = (PwfG_s + qomax_s * tan_b_s - p) / tan_b_s

    return pwf_s, qt_s

for fw, color in zip(fw_values, colors_fw):
    pwf_s, qt_s = composite_ipr_curve(fw)
    ax.plot(qt_s, pwf_s, '-', lw=2, color=color, label=f'Fw = {fw}')

ax.set_xlabel('Gasto total, qt (b/d)', fontsize=12)
ax.set_ylabel('Pwf (psi)', fontsize=12)
ax.set_title('Análisis de Sensibilidad — Efecto de Fw', fontsize=14, fontweight='bold')
ax.legend(fontsize=11)
ax.grid(True, alpha=0.3)
ax.set_xlim(left=0)

(0.0, 3894.8509102138864)

Ver código

ax.set_ylim(bottom=0)

(0.0, 2677.5)

Ver código

plt.tight_layout()
plt.show()

Ver código

fw_values <- c(0.0, 0.25, 0.50, 0.75)

calc_composite_ipr <- function(fw_val, n = 250) {
  fo_val <- 1 - fw_val
  qb_s <- J * (Pr - Pb)
  qomax_s <- qb_s + J * Pb / 1.8
  pwf_s <- seq(0, Pr, length.out = n)
  qt_s <- numeric(length(pwf_s))

  # Caso límite: solo aceite -> Vogel bajo Pb + línea sobre Pb
  if (isTRUE(all.equal(fw_val, 0))) {
    for (i in seq_along(pwf_s)) {
      p <- pwf_s[i]
      if (p >= Pb) {
        qt_s[i] <- J * (Pr - p)
      } else {
        r <- p / Pb
        qt_s[i] <- qb_s + (qomax_s - qb_s) * (1 - 0.2 * r - 0.8 * r^2)
      }
    }
    return(data.frame(pwf = pwf_s, qt = qt_s, Fw = factor(fw_val)))
  }

  CD_s <- fo_val * 0.125 * Pb *
    (sqrt(81 - 80 * (0.999 * qomax_s - qb_s) / (qomax_s - qb_s)) - 1) +
    fw_val * (Pr - (0.999 * qomax_s) / J) -
    fw_val * (Pr - qomax_s / J)

  tana_s <- (0.001 * qomax_s) / CD_s
  tanb_s <- 1 / tana_s
  PwfG_s <- fw_val * (Pr - qomax_s / J)

  for (i in seq_along(pwf_s)) {
    p <- pwf_s[i]

    if (p >= Pb) {
      qt_s[i] <- J * (Pr - p)
    } else if (p >= PwfG_s) {
      A_s <- (p + 0.125 * fo_val * Pb - fw_val * Pr) / (0.125 * fo_val * Pb)
      B_s <- fw_val / (0.125 * fo_val * Pb * J)
      C_s <- 2 * A_s * B_s + 80 / (qomax_s - qb_s)
      D_s <- A_s^2 - 80 * (qb_s / (qomax_s - qb_s)) - 81
      disc <- max(C_s^2 - 4 * B_s^2 * D_s, 0)
      qt_s[i] <- (-C_s + sqrt(disc)) / (2 * B_s^2)
    } else {
      qt_s[i] <- (PwfG_s + qomax_s * tanb_s - p) / tanb_s
    }
  }

  data.frame(pwf = pwf_s, qt = qt_s, Fw = factor(fw_val))
}

all_data <- do.call(rbind, lapply(fw_values, calc_composite_ipr))

ggplot(all_data, aes(x = qt, y = pwf, color = Fw, group = Fw)) +
  geom_line(linewidth = 1.2) +
  scale_color_manual(values = c("#2d8a4e", "#2980b9", "#e67e22", "#c0392b")) +
  labs(x = "Gasto total, qt (b/d)", y = "Pwf (psi)",
       title = "Análisis de Sensibilidad — Efecto de Fw",
       color = "Fw") +
  theme_minimal() +
  theme(plot.title = element_text(face = "bold", size = 14))

Observaciones del análisis de sensibilidad:

• Con (solo aceite), la curva es la IPR de Vogel clásica
• A medida que aumenta, la curva se “estira” hacia la derecha: el gasto máximo total aumenta pero gran parte es agua
• La curvatura de la zona bifásica se atenúa con mayor porque el componente lineal del agua domina
• En el extremo (solo agua), la IPR sería una línea recta con pendiente

Referencias

• Brown, K.E. (1984). The Technology of Artificial Lift Methods, Vol. 4. PennWell Books.
• Vogel, J.V. (1968). Inflow Performance Relationships for Solution-Gas Drive Wells. JPT, 20(1).

Video: Paso a Paso en Excel

En este video se muestra el procedimiento completo para crear el gráfico de burbuja en Excel:

Los Datos

Trabajamos con 16 pozos de un campo petrolero. La tabla contiene coordenadas UTM (X, Y) y la producción acumulada de cada fluido:

Resumen rápido del campo:

Paso 1 — Preparar los datos

Los datos ya están organizados en la estructura correcta para el gráfico de burbuja:

• Eje X: Coordenada X del pozo (columna B)
• Eje Y: Coordenada Y del pozo (columna C)
• Tamaño de burbuja: La variable que quieras visualizar — Np (columna D), Wp (columna E) o Gp (columna F)

No necesitas columnas adicionales ni fórmulas. La tabla tal como está es suficiente para crear el gráfico.

Paso 2 — Insertar el gráfico de burbuja

1. Selecciona los datos de las columnas X, Y y Np (columnas B, C y D, incluyendo encabezados): rango B1:D17
2. Ve a Insertar → Gráficos → Otros gráficos → Burbuja (o en versiones recientes: Insertar → Gráfico recomendado → Burbuja)
3. Excel generará automáticamente el gráfico usando X como eje horizontal, Y como eje vertical y Np como tamaño de la burbuja

Paso 3 — Configurar las series de datos

Si Excel no asigna correctamente las columnas, configúralas manualmente:

1. Click derecho en el gráfico → Seleccionar datos
2. En la serie, hacer click en Editar
3. Configurar:
   • Valores X de la serie: =Hoja1!$B$2:$B$17 (coordenada X)
   • Valores Y de la serie: =Hoja1!$C$2:$C$17 (coordenada Y)
   • Tamaños de la burbuja: =Hoja1!$D$2:$D$17 (Np en MMB)
4. Aceptar

Paso 4 — Agregar etiquetas de pozos

Para identificar cada burbuja con el nombre del pozo:

1. Click en el gráfico → Seleccionar la serie de burbujas
2. Click derecho → Agregar etiquetas de datos
3. Click derecho en las etiquetas → Formato de etiquetas de datos
4. Desmarcar “Valor Y” y marcar ✅ “Valor de celda”
5. Seleccionar el rango de nombres: =Hoja1!$A$2:$A$17
6. Desmarcar las demás opciones para que solo aparezca el nombre del pozo

Opcionalmente, puedes mover las etiquetas manualmente para evitar que se superpongan con las burbujas.

Paso 5 — Formato y presentación

Para que el gráfico se vea profesional:

Título: “Producción Acumulada de Aceite (Np) — Mapa de Burbujas” o similar.

Ejes:

• Eje X: “Coordenada X (m)” — formato numérico sin decimales
• Eje Y: “Coordenada Y (m)” — formato numérico sin decimales
• Ajustar los límites de ambos ejes para que los pozos queden centrados y con un margen adecuado

Burbujas:

• Agregar transparencia (50-70%) para ver superposiciones: Click derecho en las burbujas → Formato de serie de datos → Relleno → Color sólido con transparencia
• Usar un color que resalte: verde para Np, azul para Wp, rojo para Gp

Gridlines: Líneas de cuadrícula suaves para facilitar la lectura de coordenadas.

Paso 6 — Variantes: Wp y Gp

Puedes crear gráficos adicionales cambiando la variable del tamaño de la burbuja:

Para producción de agua (Wp):

• Cambia el rango de tamaño de burbuja a la columna E (Wp)
• Usa color azul para las burbujas
• Título: “Producción Acumulada de Agua (Wp)”

Para producción de gas (Gp):

• Cambia el rango a la columna F (Gp)
• Usa color rojo para las burbujas
• Título: “Producción Acumulada de Gas (Gp)”

Comparar los tres gráficos lado a lado permite identificar patrones. Por ejemplo: ¿los pozos con mayor Np también tienen mayor Wp? ¿Hay pozos con alto Gp pero bajo Np (alto GOR)?

Interpretación del Gráfico

Del gráfico de burbuja con los datos del ejemplo podemos observar:

Pozo-10 es claramente el mayor productor del campo con 63.2 MMB de Np y 138.46 MMMPC de Gp. Se ubica en la zona centro-este del campo.

Pozo-2 es el segundo mayor productor (43.27 MMB) ubicado en la zona noroeste, seguido de Pozo-11 (31.4 MMB) y Pozo-4 (30.0 MMB).

Los pozos Pozo-12, Pozo-5 y Pozo-3 tienen producción muy baja (< 2 MMB), lo cual podría indicar que se encuentran en zonas marginales del yacimiento, tienen problemas de productividad, o fueron pozos de desarrollo tardío.

En cuanto al agua, Pozo-4 es el mayor productor de agua (5.75 MMB) a pesar de no ser el mayor productor de aceite, lo que sugiere un posible avance preferencial del frente de agua en esa zona. Cuatro pozos (3, 5, 12 y 16) no reportan producción de agua.

Aplicaciones adicionales

El gráfico de burbuja no se limita a producción acumulada. Puedes usar el tamaño de burbuja para representar:

• Tasa de producción actual → identifica pozos activos vs inactivos
• GOR o WOR → detecta zonas con problemas de agua o gas
• Presión estática → visualiza el mapa de presiones del campo
• Espesor neto (h) → relaciona producción con calidad de roca
• Reservas remanentes → prioriza ubicaciones para infill drilling

Descarga

• 📥 Grafico_de_burbuja_v2.xlsx — Archivo Excel con los datos de 16 pozos

Principio de superposición

Una prueba de incremento se modela como la superposición de dos cambios de gasto:

1. Primer cambio: de 0 a , iniciando en
2. Segundo cambio: de a 0, iniciando en (momento del cierre)

Debido a que la ecuación de difusividad es lineal, podemos sumar las respuestas individuales de presión para obtener la presión durante el cierre. Esta es la base matemática de los tres métodos que veremos.

Los Datos del Ejemplo

Trabajamos con el Ejemplo del archivo Excel. Los datos del pozo y yacimiento son:

Datos del pozo y yacimiento. Ejemplo 2, Lee & Spivey (2013).

Parámetro	Valor	Unidades
Gasto de producción ()	150	STB/D
Espesor neto ()	50	ft
Porosidad ()	0.20	fracción
Factor volumétrico ()	1.50	RB/STB
Tiempo de producción ()	1,000	hrs
Compresibilidad total ()	5×10⁻⁵	psi⁻¹
Radio del pozo ()	0.33	ft
Viscosidad ()	0.50	cp
Presión al cierre ()	4,404.84	psia

La prueba registró 50 puntos de presión desde hrs hasta hrs.

Paso 1 — Organizar la tabla de datos en Excel

La hoja Ejemplo está organizada con los datos de entrada en las celdas A2:C9 y los datos de la prueba a partir de la fila 11. Necesitas calcular las siguientes columnas auxiliares:

Columnas calculadas. B6 contiene el valor de tp = 1000.

Columna	Contenido	Fórmula (fila 13)
A	(hr)	Dato medido
B	(psia)	Dato medido
C		=LOG10(A13)
D		=(B6+A13)/A13
E		=(B6*A13)/(B6+A13)
F		=LOG10(D13)
G		=LOG10(E13)

Las columnas C, D, E, F y G son los ejes X para cada método:

• MDH usa columna C:
• Horner usa columna F:
• Agarwal usa columna G:

Paso 2 — Método MDH (Miller, Dyes & Hutchinson)

El método MDH es el más sencillo de los tres. Asume que el tiempo de cierre es mucho menor que el tiempo de producción (es decir, ).

Fundamento: Una gráfica de vs mostrará una línea recta durante el periodo de flujo radial infinito (IARF), con pendiente e intercepto .

Paso 3 — Método de Horner

El método de Horner es el más conocido y no requiere la aproximación del MDH, por lo que es más general.

Fundamento: Una gráfica de vs mostrará una línea recta durante IARF. El cociente se conoce como Horner Time Ratio (HTR).

Paso 4 — Método de Tiempo Equivalente de Agarwal

Agarwal (1980) introdujo el concepto de tiempo equivalente () que permite analizar pruebas de incremento como si fueran pruebas de decremento. Esto es especialmente útil para usar curvas tipo de decremento en pruebas de buildup.

Fundamento: El tiempo equivalente se define como:

Una gráfica de vs mostrará una línea recta durante IARF, igual que en un drawdown.

Paso 5 — Comparación de los Tres Métodos

Una de las fortalezas de realizar el análisis por los tres métodos es poder comparar y validar los resultados:

Comparación de resultados por los tres métodos.

Parámetro	MDH	Horner	Agarwal
(psi/ciclo)	22.569	25.203	25.203
(psia)	4,928.50	4,924.88	4,924.90
(md)	16.21	14.52	14.52
	21.82	18.92	18.92

Observaciones:

• Horner y Agarwal dan resultados prácticamente idénticos, lo cual es esperado ya que ambos son exactos (no usan la aproximación de ).
• MDH da una permeabilidad ligeramente mayor y un daño mayor. Esto se debe a que MDH usa una aproximación que es válida solo cuando . En este caso, hrs y los datos llegan hasta hrs, por lo que la condición no se cumple estrictamente para los tiempos largos.
• El factor de daño alto () indica un pozo con daño significativo — candidato a estimulación.

Ecuaciones Resumen

Las ecuaciones clave que se usan en los tres métodos son las mismas, solo cambia el eje X del gráfico:

Permeabilidad:

Factor de daño:

Tiempo equivalente de Agarwal:

Horner Time Ratio:

Tips para Excel

• Línea de tendencia: Usar solo los puntos que pertenecen al IARF. Para seleccionar un subconjunto, puedes crear una serie separada con solo esos puntos.
• Pendiente por fórmula: Si prefieres calcular manualmente en lugar de usar la línea de tendencia, puedes usar dos puntos de la recta: =(B_final - B_inicial) / (LOG10(A_final) - LOG10(A_inicial)). En el Excel del ejemplo: =(B60-B47)/(LOG10(A60)-LOG10(A47)).
• Escala logarítmica: Para que el gráfico se vea como un semilog tradicional, puedes usar la escala logarítmica en el eje X en lugar de graficar el logaritmo calculado: Click derecho en eje X → Formato de eje → ✅ Escala logarítmica.
• Formateo: Usar colores diferentes para cada método facilita la comparación visual.

Descarga

• 📥 Incremento.xlsx — Archivo Excel con los 3 ejemplos resueltos

Referencias

• Lee, J. & Spivey, J. (2013). Applied Well Test Interpretation. SPE Textbook Series.

Estructura del Diagrama

El Stiff usa 4 pares de iones organizados en filas horizontales. Los cationes van a la izquierda y los aniones a la derecha, creando una figura simétrica tipo espejo:

Los Datos de Ejemplo

Trabajamos con análisis de agua de 3 pozos de la hoja Diagrama stiff_EI del archivo Excel adjunto. Los datos ya están en meq/L:

Paso 1 — Organizar la tabla de datos en Excel

Lo primero es organizar los datos con el formato correcto. En la hoja de Excel necesitas:

• Fila 1: Los valores de Y para el gráfico → 1, 2, 3, 4 (uno por cada par de iones)
• Fila 2: Encabezados → Pozo | Fecha | Na | Ca | Mg | Fe | Cl | HCO3 | SO4 | CO3 | Salinidad
• Filas 3-5: Datos de cada pozo en meq/L

La celda C1 contiene y como referencia, y las celdas E1:H1 contienen 1, 2, 3, 4 que serán las coordenadas verticales del gráfico (una por cada par de iones: Na-Cl, Ca-HCO₃, Mg-SO₄, Fe-CO₃).

Paso 2 — Crear el gráfico de dispersión con líneas

El diagrama de Stiff se construye usando dos gráficos de dispersión con líneas (XY Scatter with Straight Lines) superpuestos en uno solo:

• Uno para los cationes (lado izquierdo)
• Otro para los aniones (lado derecho)

Para el primer pozo (POZO-1):

1. Selecciona los datos de los cationes como eje X: Na=275.04, Ca=13.42, Mg=4.24, Fe=2.73
2. Selecciona los valores Y correspondientes: 1, 2, 3, 4
3. Insertar → Gráfico de Dispersión → Dispersión con líneas rectas y marcadores
4. Repite el proceso para los aniones: Cl=256.18, HCO₃=31.45, SO₄=7.81, CO₃=1.00 con los mismos valores Y

Paso 3 — Clave del método: El efecto espejo

Aquí está el truco que hace funcionar todo:

• Los cationes se grafican en orden inverso → se invierte el eje X para que los valores crezcan hacia la izquierda
• Los aniones se mantienen en orden normal → valores crecen hacia la derecha
• Al combinar ambos, se crea la figura tipo espejo característica del Stiff

Para invertir el eje X de los cationes:

1. Click derecho sobre el eje X → Formato de eje
2. En Opciones del eje → marcar ✅ “Valores en orden inverso”
3. En el mismo menú → marcar ✅ “Escala logarítmica” (base 10)
4. Establecer Mínimo = 0.1 y Máximo = 1000

Paso 4 — Combinar cationes y aniones en un solo gráfico

Para lograr el efecto espejo completo en un solo gráfico de Excel:

Método 1 — Dos gráficos alineados (el más fácil):

1. Crea un gráfico de dispersión con los cationes → invierte el eje X (paso anterior)
2. Crea otro gráfico de dispersión con los aniones → eje X normal
3. Redimensiona ambos gráficos al mismo alto y elimina los márgenes internos
4. Colócalos lado a lado perfectamente alineados
5. Agrega cuadros de texto con los nombres de los iones: Na⁺, Ca⁺, Mg⁺, Fe⁺ a la izquierda y Cl, HCO₃, SO₄, CO₃ a la derecha

Paso 5 — Agregar más pozos al diagrama

Para comparar pozos, simplemente agrega más series al mismo gráfico:

1. Click derecho en el gráfico → “Seleccionar datos” → Agregar
2. Agregar los cationes del POZO-2 como nueva serie (Valores X = Na, Ca, Mg, Fe del POZO-2; Valores Y = 1, 2, 3, 4)
3. Agregar los aniones del POZO-2 como otra serie
4. Repetir para el POZO-3
5. Asignar colores consistentes → mismo color para cationes y aniones del mismo pozo

Colores sugeridos:

Paso 6 — Formato final y presentación

Para que el gráfico quede profesional:

1. Título: “Diagrama Stiff” o “Diagrama de Stiff — Campo [Nombre]”
2. Etiquetas de iones: Agregar cuadros de texto con Na⁺, Ca⁺, Mg⁺, Fe⁺ (izquierda) y Cl, HCO₃, SO₄, CO₃ (derecha)
3. Leyenda: Mostrar solo el nombre de cada pozo (no las series individuales de cationes/aniones)
4. Gridlines: Líneas de cuadrícula verticales en escala log (1, 10, 100, 1000)
5. Eje Y: Ocultar los valores numéricos — las etiquetas de iones los reemplazan
6. Línea central: Si usas un solo gráfico, insertar una línea vertical en el centro para separar cationes de aniones

Interpretación del Diagrama

Cada forma de polígono tiene un significado geológico:

Para nuestros 3 pozos:

• POZO-1: Dominancia Na⁺-Cl⁻ (275 y 256 meq/L) → agua clorurada sódica, típica de formación profunda. Salinidad: 14,882 ppm.
• POZO-2: También Na⁺-Cl⁻ dominante pero con menor concentración (174 y 152 meq/L) → misma familia de agua pero más diluida. Salinidad: 8,874 ppm.
• POZO-3: Na⁺-Cl⁻ muy alto (560 meq/L en ambos) → salmuera concentrada, la más salina de los tres. Salinidad: 31,861 ppm.

Los tres pozos producen agua del mismo tipo (clorurada sódica) pero con diferentes concentraciones, lo cual sugiere que están en la misma unidad hidrogeológica pero con diferente grado de concentración o dilución.

Aplicaciones en Ingeniería de Yacimientos

1. Vigilancia de waterflood: Compara el Stiff del agua producida vs el agua de inyección. Si la forma del polígono cambia, el frente de inyección está llegando al pozo.

2. Diagnóstico de comunicación: Si un pozo en la zona A produce agua con el Stiff de la zona B, puede haber comunicación detrás del casing o por fracturas naturales.

3. Monitoreo temporal: Haz un Stiff por trimestre del mismo pozo. Si la forma cambia progresivamente, el tipo de agua está cambiando (mezcla creciente con otra fuente).

4. Complemento del WOR: El WOR te dice cuánta agua produces. El Stiff te dice qué tipo de agua es. Juntos son un diagnóstico mucho más completo.

Descarga

• 📥 Graficos_Stiff.xlsx — Archivo de Excel con los datos y gráficos de ejemplo

Referencias

• Farías Rodríguez, L., & Merola Pilerci, V. (2014). Propiedades de los fluidos del yacimiento. Editorial Reverté.

Los Datos

Trabajamos con un archivo CSV con la siguiente estructura:

Resumen del campo:

• Pozos activos: 12 productores
• Período: Enero 2007 – Abril 2021 (172 meses)
• Producción acumulada de aceite (Np): ~5.9 millones de barriles
• Producción acumulada de agua (Wp): ~229 mil barriles
• Producción acumulada de gas (Gp): ~6.9 millones de Mscf
• Pico de producción del campo: ~60,329 bbl/d (septiembre 2014)

import pandas as pd
import numpy as np

# Cargar datos
df = pd.read_csv('Production_Data.csv')
df['Date'] = pd.to_datetime(df['Date'], format='%d/%m/%Y')
df['Rate'] = pd.to_numeric(df['Rate'], errors='coerce').fillna(0)

# Pivotar a formato ancho
pivot = df.pivot_table(index=['Well','Date'], columns='Fluid', 
                       values='Rate', aggfunc='sum').reset_index()
pivot.columns.name = None
pivot = pivot.fillna(0)

# Totales del campo por mes
field = pivot.groupby('Date')[['Qo','Qg','Qw']].sum().reset_index()
field = field.sort_values('Date')

# Calcular acumuladas
field['Np'] = field['Qo'].cumsum()
field['Gp'] = field['Qg'].cumsum()
field['Wp'] = field['Qw'].cumsum()

# Calcular ratios (evitar división por cero)
field['GOR'] = np.where(field['Qo'] > 0, field['Qg'] / field['Qo'], 0)
field['WOR'] = np.where(field['Qo'] > 0, field['Qw'] / field['Qo'], 0)
field['WC']  = np.where((field['Qo'] + field['Qw']) > 0, 
                         field['Qw'] / (field['Qo'] + field['Qw']) * 100, 0)
field['Qf']  = field['Qo'] + field['Qw']  # Tasa de fluido total

# Conteo de pozos activos por mes
well_count = pivot[pivot['Qo'] > 0].groupby('Date')['Well'].nunique().reset_index()
well_count.columns = ['Date', 'WellCount']
field = field.merge(well_count, on='Date', how='left').fillna(0)

print(f"✅ Datos cargados: {len(field)} meses, {pivot['Well'].nunique()} pozos")

✅ Datos cargados: 172 meses, 12 pozos

print(f"📊 Rango: {field['Date'].min().strftime('%b %Y')} - {field['Date'].max().strftime('%b %Y')}")

📊 Rango: ene. 2007 - abr. 2021

Gráfico 1 — Composite Plot vs Tiempo (Semilog)

El composite plot es el gráfico más importante en el análisis de producción. Combina en un solo panel el gasto de aceite, GOR, corte de agua y conteo de pozos vs tiempo.

¿Qué buscar en este gráfico?

• Tendencias de declinación en el gasto de aceite
• Incrementos de GOR → posible liberación de gas en el yacimiento (por debajo de Pb)
• Incremento de corte de agua → avance del frente de agua
• Correlación con conteo de pozos → ¿el incremento de producción es por nuevos pozos o por mejora de los existentes?

Ver código

import matplotlib.pyplot as plt
import matplotlib.dates as mdates

fig, axes = plt.subplots(4, 1, figsize=(12, 14), sharex=True, 
                          gridspec_kw={'height_ratios': [3, 1.5, 1.5, 1]})
fig.suptitle('CAMPO HOMOL — Composite Plot de Producción', 
             fontsize=16, fontweight='bold', y=0.98)

# Panel 1: Gasto de aceite (semilog) + gasto de fluido
ax1 = axes[0]
mask = field['Qo'] > 0
ax1.semilogy(field.loc[mask, 'Date'], field.loc[mask, 'Qo'], 
             '-', linewidth=1.5, label='Qo (aceite)', color='#2d8a4e')
mask_f = field['Qf'] > 0
ax1.semilogy(field.loc[mask_f, 'Date'], field.loc[mask_f, 'Qf'], 
             '--', linewidth=1, label='Qf (fluido total)', color='#1a5276', alpha=0.6)
ax1.set_ylabel('Tasa (bbl/d)', fontsize=11)
ax1.legend(loc='upper left', fontsize=9)
ax1.grid(True, which='both', alpha=0.3)
ax1.set_ylim(bottom=100)

(100, np.float64(80283.5515235902))

Ver código

# Eje secundario: conteo de pozos
ax1b = ax1.twinx()
ax1b.bar(field['Date'], field['WellCount'], width=25, alpha=0.15, color='gray', label='Pozos activos')
ax1b.set_ylabel('Pozos activos', fontsize=10, color='gray')
ax1b.tick_params(axis='y', labelcolor='gray')
ax1b.set_ylim(0, 20)

(0.0, 20.0)

Ver código

ax1b.legend(loc='upper right', fontsize=9)

# Panel 2: GOR
ax2 = axes[1]
ax2.plot(field.loc[mask, 'Date'], field.loc[mask, 'GOR'], 
         '-', linewidth=1.2, color='#c0392b')
ax2.set_ylabel('GOR', fontsize=11)
ax2.grid(True, alpha=0.3)
ax2.axhline(y=field.loc[mask, 'GOR'].median(), color='#c0392b', 
            linestyle='--', alpha=0.4, linewidth=0.8)

# Panel 3: Corte de agua
ax3 = axes[2]
ax3.plot(field.loc[mask, 'Date'], field.loc[mask, 'WC'], 
         '-', linewidth=1.2, color='#2980b9')
ax3.fill_between(field.loc[mask, 'Date'], 0, field.loc[mask, 'WC'], alpha=0.1, color='#2980b9')
ax3.set_ylabel('Corte de agua (%)', fontsize=11)
ax3.set_ylim(0, 100)

(0.0, 100.0)

Ver código

ax3.grid(True, alpha=0.3)

# Panel 4: WOR
ax4 = axes[3]
mask_wor = (field['WOR'] > 0) & (field['Qo'] > 0)
ax4.semilogy(field.loc[mask_wor, 'Date'], field.loc[mask_wor, 'WOR'], 
             '-', linewidth=1.2, color='#8e44ad')
ax4.set_ylabel('WOR', fontsize=11)
ax4.set_xlabel('Fecha', fontsize=11)
ax4.grid(True, which='both', alpha=0.3)
ax4.xaxis.set_major_formatter(mdates.DateFormatter('%Y'))
ax4.xaxis.set_major_locator(mdates.YearLocator(2))

plt.tight_layout()
plt.show()

Gráfico 2 — Composite Plot vs Np (Producción Acumulada)

Este gráfico es complementario al anterior, pero usa Np en el eje X en lugar del tiempo. Esto elimina los efectos de cierres temporales y permite ver directamente cuánto aceite se ha extraído.

¿Qué buscar?

• La pendiente de la curva qo vs Np indica la tasa de declinación
• El GOR vs Np muestra si hay liberación de gas proporcional a la extracción
• El WOR vs Np permite extrapolar el factor de recuperación final

Ver código

fig, axes = plt.subplots(3, 1, figsize=(12, 11), sharex=True,
                          gridspec_kw={'height_ratios': [3, 1.5, 1.5]})
fig.suptitle('CAMPO HOMOL — Producción vs Np Acumulado', 
             fontsize=16, fontweight='bold', y=0.98)

Np_MM = field['Np'] / 1e6  # En millones

# Panel 1: qo vs Np
ax1 = axes[0]
ax1.semilogy(Np_MM[mask], field.loc[mask, 'Qo'], 
             '-', linewidth=1.5, color='#2d8a4e')
ax1.set_ylabel('Qo (bbl/d)', fontsize=11)
ax1.grid(True, which='both', alpha=0.3)
ax1.set_ylim(bottom=100)

(100, np.float64(80229.79027261313))

Ver código

# Panel 2: GOR vs Np
ax2 = axes[1]
ax2.plot(Np_MM[mask], field.loc[mask, 'GOR'], 
         '-', linewidth=1.2, color='#c0392b')
ax2.set_ylabel('GOR', fontsize=11)
ax2.grid(True, alpha=0.3)

# Panel 3: WC vs Np
ax3 = axes[2]
ax3.plot(Np_MM[mask], field.loc[mask, 'WC'], 
         '-', linewidth=1.2, color='#2980b9')
ax3.fill_between(Np_MM[mask], 0, field.loc[mask, 'WC'], alpha=0.1, color='#2980b9')
ax3.set_ylabel('Corte de agua (%)', fontsize=11)
ax3.set_xlabel('Np acumulado (MMbbl)', fontsize=11)
ax3.set_ylim(0, 100)

(0.0, 100.0)

Ver código

ax3.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Gráfico 3 — Producción Acumulada vs Tiempo

El gráfico de acumuladas permite verificar la consistencia de los datos y relacionar la declinación de producción con los volúmenes totales extraídos.

Ver código

fig, ax1 = plt.subplots(figsize=(12, 6))
fig.suptitle('CAMPO HOMOL — Producción Acumulada', fontsize=16, fontweight='bold')

ax1.plot(field['Date'], field['Np']/1e6, '-', linewidth=2, color='#2d8a4e', label='Np (aceite)')
ax1.plot(field['Date'], field['Wp']/1e6, '-', linewidth=2, color='#2980b9', label='Wp (agua)')
ax1.set_ylabel('Producción acumulada (MMbbl)', fontsize=11)
ax1.legend(loc='upper left', fontsize=10)
ax1.grid(True, alpha=0.3)

ax2 = ax1.twinx()
ax2.plot(field['Date'], field['Gp']/1e6, '-', linewidth=2, color='#c0392b', label='Gp (gas)')
ax2.set_ylabel('Gas acumulado (MMscf)', fontsize=11, color='#c0392b')
ax2.tick_params(axis='y', labelcolor='#c0392b')
ax2.legend(loc='center left', fontsize=10)

ax1.xaxis.set_major_formatter(mdates.DateFormatter('%Y'))
plt.tight_layout()
plt.show()

Gráfico 4 — Purvis Plot (Diagnóstico de Water Drive)

El Purvis plot es una herramienta poderosa para yacimientos con empuje de agua o inyección de agua. Combina en un solo gráfico semi-log: la producción acumulada de fluido, el gasto diario de fluido, el gasto diario de aceite, y el WOR+1, todo vs Np acumulado.

Si el WOR+1 forma una línea recta en escala semilog vs Np, se puede extrapolar para pronosticar la producción futura asumiendo tasa de fluido constante:

Ver código

fig, ax1 = plt.subplots(figsize=(12, 7))
fig.suptitle('CAMPO HOMOL — Purvis Plot', fontsize=16, fontweight='bold')

Np_MM = field['Np'] / 1e6
mask_prod = field['Qo'] > 0

# WOR + 1 en escala semilog
wor_plus1 = field.loc[mask_prod, 'WOR'] + 1
ax1.semilogy(Np_MM[mask_prod], wor_plus1, 'o-', markersize=2, 
             linewidth=1.2, color='#8e44ad', label='WOR + 1')

# Gasto de aceite
ax1.semilogy(Np_MM[mask_prod], field.loc[mask_prod, 'Qo'], 
             '-', markersize=1.5, linewidth=1, color='#2d8a4e', label='Qo (bbl/d)')

# Gasto de fluido
ax1.semilogy(Np_MM[mask_prod], field.loc[mask_prod, 'Qf'], 
             '-', markersize=1.5, linewidth=1, color='#2980b9', label='Qf (bbl/d)', alpha=0.7)

ax1.set_xlabel('Np acumulado (MMbbl)', fontsize=12)
ax1.set_ylabel('Escala logarítmica', fontsize=12)
ax1.legend(fontsize=10)
ax1.grid(True, which='both', alpha=0.3)

plt.tight_layout()
plt.show()

Gráfico 5 — Gp vs Np (Diagnóstico de Solution Gas Drive)

Para yacimientos con empuje por gas en solución, el gráfico de Gp vs Np en escala log-log muestra una tendencia lineal que permite pronosticar la recuperación final. La idea es que cuando se ha producido ~90% del gas en solución, la presión del yacimiento es tan baja que la producción se vuelve antieconómica.

Ver código

fig, ax = plt.subplots(figsize=(10, 7))
fig.suptitle('CAMPO HOMOL — Gp vs Np (Diagnóstico Solution Gas Drive)', 
             fontsize=15, fontweight='bold')

mask_both = (field['Np'] > 0) & (field['Gp'] > 0)
ax.loglog(field.loc[mask_both, 'Np']/1e6, field.loc[mask_both, 'Gp']/1e6, 
          '-', markersize=3, linewidth=1.2, color='#c0392b')

ax.set_xlabel('Np acumulado (MMbbl)', fontsize=12)
ax.set_ylabel('Gp acumulado (MMscf)', fontsize=12)
ax.grid(True, which='both', alpha=0.3)

plt.tight_layout()
plt.show()

Gráfico 6 — Producción Individual por Pozo (Stacked Area)

Para el análisis de producción es fundamental ver la contribución de cada pozo a la producción total del campo. El gráfico de área apilada permite identificar qué pozos son los principales contribuyentes y cuándo entran/salen de producción.

# Preparar datos por pozo
well_monthly = pivot.pivot_table(index='Date', columns='Well', values='Qo', aggfunc='sum').fillna(0)
well_monthly = well_monthly.sort_index()

# Ordenar pozos por producción total (mayor a menor) para mejor visualización
well_order = well_monthly.sum().sort_values(ascending=False).index.tolist()
well_monthly = well_monthly[well_order]

fig, ax = plt.subplots(figsize=(14, 7))
fig.suptitle('CAMPO HOMOL — Producción de Aceite por Pozo (Área Apilada)', 
             fontsize=15, fontweight='bold')

colors = plt.cm.tab20(np.linspace(0, 1, len(well_order)))
ax.stackplot(well_monthly.index, well_monthly.T, labels=well_order, colors=colors, alpha=0.8)

ax.set_ylabel('Qo total (bbl/d)', fontsize=12)
ax.set_xlabel('Fecha', fontsize=12)
ax.legend(loc='upper right', fontsize=8, ncol=3, framealpha=0.9)
ax.grid(True, alpha=0.2)
ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y'))

plt.tight_layout()
plt.show()