Well Completion Optimization

Overview

Well Completion Optimization provides quantitative analysis of hydraulic fracturing designs, treatment diagnostics, and completion economics. It implements Nolte-Smith pressure analysis for fracture propagation mode identification, G-function analysis for Diagnostic Fracture Injection Test (DFIT) closure pressure determination, and statistical methods for comparing completion designs across a field. Use it to optimize stage spacing, cluster density, proppant intensity, and fluid systems by correlating completion parameters to production outcomes, to interpret treatment pressures, and to estimate closure stress without external fracture simulation software.

Workflow

<Definition - Fracture diagnostics> Nolte-Smith net-pressure mode identification and DFIT G-function closure analysis, including formulas, slope-to-mode bands, and non-ideal leak-off signatures, are detailed in references/fracture-diagnostics.md. </Definition - Fracture diagnostics>

<Definition - Completion economics and spacing> Completion cost breakdown, EUR and NPV metrics, intensity normalization, stage and cluster spacing physics, limited-entry perforation design, and frac fleet scheduling metrics are detailed in references/completion-economics.md. </Definition - Completion economics and spacing>

<Definition - Statistical comparison> Matched-pair design comparison method, matching criteria, response variables, sample-size guidance, and interpretation guardrails are detailed in references/statistical-comparison.md. The tests run through scripts/completion_stats.py (paired t-test, Wilcoxon signed-rank, and ordinary least squares regression), implemented in pure numpy because the sandbox does not provide scipy or statsmodels. </Definition - Statistical comparison>

<Definition - Bottomhole net pressure> Net pressure is bottomhole pressure above closure stress, not surface pressure: P_net = BHP - P_closure, where BHP = surface_pressure + 0.052*MW*TVD - pipe friction - perforation friction - near-wellbore friction. Nolte-Smith analysis requires this correction. </Definition - Bottomhole net pressure>

<Workflow - Verify Reference Values description="Verify every time-sensitive value before any calculation that uses one." tools=[web_search, url_fetch] triggers=["Before any calculation that uses a price, cost, benchmark, gradient, or regulatory limit"]

1. [Agent] Identify which values the requested analysis needs (prices, service costs, stress gradients, fleet benchmarks, regulatory or disposal limits). Validate: Every needed value is listed and tagged as user-provided, time-sensitive, or a stable physical constant. If fails: List the values and re-classify before continuing.

2. [Agent] For each time-sensitive value not provided by the user, fetch the current value from an authoritative source with web_search then url_fetch, and record the source and date. Validate: Each time-sensitive value has a fetched source from this session or an explicit user-provided value. If fails: Per Rule 1, stop and ask the user to confirm or provide the value.

</Workflow - Verify Reference Values>

<Workflow - Treatment Pressure Analysis description="Interpret hydraulic fracturing treatment pressure with Nolte-Smith log-log net-pressure analysis." tools=[run_python, run_python_with_write, file_read, open_in_session_tab] triggers=["Nolte-Smith", "treatment pressure", "net pressure", "fracture propagation", "screen-out", "mode identification"]

1. [Agent] Read references/fracture-diagnostics.md (Nolte-Smith section) and load the treatment data: time (minutes from pump start), surface treating pressure (psi), slurry rate (bpm), proppant concentration (ppg). Validate: Time and pressure series are present and equal length. If fails: Report the missing or mismatched columns and ask the user for them.

2. [Agent] If bottomhole pressure is not provided, convert surface pressure per <Definition - Bottomhole net pressure> using mud weight, true vertical depth, rate, and pipe geometry. Validate: BHP series is finite and physically plausible (positive, above hydrostatic minus friction). If fails: Recheck inputs and units, then recompute.

3. [Ask user] Confirm the closure pressure estimate and its source (DFIT, LOT, offset wells, or regional stress gradient). If a gradient is used, verify it per <Workflow - Verify Reference Values>. Validate: A closure pressure with a stated source is confirmed. If fails: Do not proceed; net pressure is undefined without closure.

4. [Agent] Compute net pressure, the running log-log slope e, and classify the propagation mode using the slope-to-mode bands in the reference. Also compute the pressure derivative t * dP_net/dt. Validate: Slope and mode arrays align with the time series and modes fall in the defined bands. If fails: Inspect for log-of-nonpositive values and clamp net pressure to a small positive floor.

5. [Agent] Produce an annotated log-log plot (net pressure vs time with color-coded mode regions, slope on a secondary axis, rate and proppant overlaid, key events labeled) with run_python_with_write, then open it with open_in_session_tab. Validate: The image file exists and opens in a session tab. If fails: Regenerate the figure and retry the open.

6. [Agent] Summarize observed modes, screen-out risk, and recommendations for future treatments, noting the closure-stress sensitivity if closure was uncertain (Rule 5). Validate: The summary names each mode observed and ties recommendations to it. If fails: Re-derive the summary from the mode classification.

</Workflow - Treatment Pressure Analysis>

<Workflow - DFIT G-Function Analysis description="Determine closure pressure and leak-off behavior from Diagnostic Fracture Injection Test decline data." tools=[run_python, run_python_with_write, file_read, open_in_session_tab] triggers=["DFIT", "G-function", "closure pressure", "minifrac", "diagnostic injection", "leak-off", "ISIP"]

1. [Agent] Read references/fracture-diagnostics.md (G-function section) and load the DFIT data: time (minutes from shut-in) and pressure (psi). Identify pumping time (tp) and ISIP. Validate: Shut-in time and pressure series present; tp positive; ISIP identified by extrapolating early decline to zero shut-in time. If fails: Ask the user for tp and the pump-off point.

2. [Agent] Compute the G-function, dP/dG, and the superposition derivative G*dP/dG per the reference formulas. Validate: G increases monotonically and the derivatives are finite. If fails: Check the shut-in time ordering and units, then recompute.

3. [Agent] Generate the Castillo plot (P vs G), the superposition derivative plot (G*dP/dG vs G), and the semilog derivative plot with run_python_with_write, then open them with open_in_session_tab. Validate: Each figure exists and opens in a session tab. If fails: Regenerate the figures and retry.

4. [Agent] Identify closure pressure where G*dP/dG departs the horizontal trend, cross-validate against the sqrt(shut-in time) plot, and report Pc, ISIP, net ISIP, and the closure gradient. State the interpretation framework used. Validate: Pc lies between hydrostatic and ISIP and the framework is named. If fails: Re-pick the departure point and re-state the framework.

5. [Agent] Flag non-ideal behaviors (pressure-dependent leak-off hump, tip extension, multiple closures) and check whether the constant-pressure assumption holds (Rule 4). Validate: Each flagged signature references the diagnostic curve feature that supports it. If fails: Re-examine the derivative curves before reporting.

</Workflow - DFIT G-Function Analysis>

<Workflow - Completion Design Comparison description="Compare completion designs with matched-pair statistics and multiple regression, controlling for geology." tools=[run_python, run_python_with_write, file_read, open_in_session_tab] triggers=["compare completions", "design comparison", "A/B test", "matched pair", "proppant loading optimization", "stage spacing optimization", "which design is better"]

1. [Agent] Read references/statistical-comparison.md and load the completion database (well, formation, landing zone, lateral length, stage and cluster counts, proppant lbs, fluid bbl, completion date, EUR or production metrics, completion cost, and a reservoir-quality proxy such as porosity*h). Validate: The matching variables from the reference and at least one response variable are present. If fails: Report the missing columns and ask the user to supply them.

2. [Agent] Normalize parameters per lateral foot (proppant per ft, fluid per ft, stages per 1000 ft, clusters per stage, EUR per ft, EUR per dollar, cost per ft). Validate: Normalized columns are finite and positive. If fails: Check for zero lateral length or missing costs.

3. [Agent] Form matched pairs on the reference matching criteria, then confirm the groups are balanced on formation, reservoir quality, lateral length, vintage, and spacing. Validate: Group means of the control variables are within the reference tolerances; pair count meets the sample-size guidance. If fails: Report the imbalance and label any downstream result as confounded.

4. [Agent] Run the paired t-test and Wilcoxon signed-rank test from scripts/completion_stats.py on the response variable, and run the multiple regression to isolate each design parameter's effect after controlling for geology. Validate: The script returns p-values and regression terms without importing scipy or statsmodels. If fails: Confirm the script is called from its path and inputs are numeric.

5. [Agent] Build the report: group summary statistics, box plots by group, a scatter of the design parameter vs response with a fitted line, the test results with p-values, and the economic impact (delta EUR times verified price). Write figures with run_python_with_write and open them with open_in_session_tab. Validate: Every statistical claim carries a p-value and a significance label. If fails: Re-derive the claims from the script output.

6. [Agent] State the recommendation with a confidence qualifier. Flag results with p greater than 0.05 as inconclusive (Rule 7). Validate: The recommendation matches the significance findings. If fails: Reconcile the wording with the p-values.

</Workflow - Completion Design Comparison>

<Workflow - Completion Economics description="Calculate completion cost metrics and the economic optimum of design intensity." tools=[run_python, run_python_with_write, file_read, web_search, url_fetch, open_in_session_tab] triggers=["completion economics", "EUR per dollar", "NPV", "cost optimization", "frac cost", "completion cost", "ROI"]

1. [Agent] Read references/completion-economics.md and load cost data by well or by stage, categorized into the standard buckets in the reference. Validate: Cost buckets and an EUR or production value are present. If fails: Ask the user for the missing cost or production inputs.

2. [Agent] Verify all time-sensitive prices and costs per <Workflow - Verify Reference Values>. Validate: Every price and cost has a fetched or user-provided source. If fails: Stop and request the values (Rule 1).

3. [Agent] Compute unit economics (EUR per dollar, NPV, NPV per dollar, payout) using verified prices, royalty, opex, and discount rate. Validate: NPV and payout are finite and internally consistent. If fails: Recheck the price, discount, and volume inputs.

4. [Agent] Compute the marginal economics of intensification: incremental EUR per added proppant lb per ft against incremental cost, and the loading where marginal value equals marginal cost. Do not extrapolate beyond the data (Rule 8 and the logarithmic caution in the reference). Validate: The optimum sits inside the observed data range. If fails: State that the optimum is outside the data and cannot be resolved.

5. [Agent] Generate a tornado sensitivity chart (price, proppant cost, EUR uncertainty, discount rate, service-cost environment) with run_python_with_write and open it with open_in_session_tab. Validate: The chart exists and each sensitivity axis is labeled. If fails: Regenerate the chart and retry.

</Workflow - Completion Economics>

<Workflow - Frac Fleet Tracking description="Monitor frac fleet efficiency, identify bottlenecks, and forecast schedule and cost." tools=[run_python, run_python_with_write, file_read, get_current_time, open_in_session_tab] triggers=["frac fleet", "schedule", "fleet efficiency", "stages per day", "zipper", "pump time", "operational tracking"]

1. [Agent] Read references/completion-economics.md (fleet section), get the current date with get_current_time, and load the operations log (date, well, pad, stage, pump and wireline start and end times, NPT events with codes). Validate: Timestamps parse and stage records are ordered. If fails: Report unparseable rows and ask the user to correct them.

2. [Agent] Compute fleet KPIs (stages per day, pump-time percent, average stage duration, wireline-time percent, NPT percent, transition time) per the reference formulas. Validate: Percentages fall between 0 and 100 and durations are positive. If fails: Recheck the time arithmetic and time zones.

3. [Agent] Identify the limiting bottleneck (wireline, sand, water, equipment, or wellbore) from the KPI pattern. Validate: The named bottleneck is supported by the KPI that dominates lost time. If fails: Re-rank the time components.

4. [Agent] Forecast the completion date and remaining cost from remaining stages, current efficiency, and planned maintenance windows. Validate: The forecast date is after the current date and uses verified unit costs. If fails: Recheck remaining-stage count and per-stage rates.

5. [Agent] Produce the fleet dashboard (daily stages, cumulative progress vs plan, efficiency trend, cost-per-stage trend, NPT Pareto) with run_python_with_write and open it with open_in_session_tab. Validate: The dashboard exists and opens in a session tab. If fails: Regenerate and retry.

</Workflow - Frac Fleet Tracking>

Key sources: Nolte and Smith (1981) SPE-8297; Nolte (1979) SPE-8341; Castillo (1987) SPE-16417; Barree et al. (2009) SPE-169539; Economides and Nolte, "Reservoir Stimulation" 3rd Ed.; King (2012) SPE-152596.

• Unit tests (scripts/tests/unit/test_completion_stats.py) provide filesystem-free coverage of the scripts. Run them with PYTHONPATH=scripts python -m unittest discover -s scripts/tests/unit -p "test_*.py".