Welly

welly - Well Data Analysis

The examples are checked with welly 0.5.2. This release imports pkg_resources, so its environment needs setuptools<81. The repository's scientific test requirements record the other tested dependency versions.

Quick Reference

pythonCopy code
from welly import Well, Project

# Load single well
w = Well.from_las('well.las')

# Access data
df = w.df()                      # DataFrame
gr = w.data['GR']                # Curve object
values = gr.values               # numpy array
depth = gr.basis                 # depth array

# Well info
print(w.name, w.uwi)
print(w.data.keys())             # Available curves

# Load multiple wells
p = Project.from_las('wells/*.las')
for well in p:
    print(well.name)

Key Classes

Essential Operations

Access Curve Data

pythonCopy code
gr = w.data['GR']
print(gr.mnemonic, gr.units)     # Metadata
print(gr.start, gr.stop, gr.step)  # Depth range

Process Curves

pythonCopy code
import numpy as np

gr = w.data['GR']

# Clean and filter
gr_clean = gr.despike(window_length=5, z=2)
gr_smooth = gr_clean.apply(window_length=11, func1d=np.nanmean)
w.data['GR'] = gr_clean  # Use the cleaned curve in subsequent well exports.

# Optional dimensionless display array; retain GR's physical API units in w.
values = gr_clean.as_numpy().ravel()
finite = np.isfinite(values)
gr_norm = np.full_like(values, np.nan, dtype=float)
if finite.any() and np.ptp(values[finite]) > 0:
    gr_norm[finite] = (values[finite] - values[finite].min()) / np.ptp(values[finite])
gr_resampled = gr_clean.to_basis(step=0.5)
gr_window = gr_clean.to_basis(start=1500, stop=1510)  # Outside support is NaN.

See the Curve API for despike, apply, and to_basis parameters. Review filtering against thin beds before treating the processed curve as interpretation input.

Work with Formation Tops

pythonCopy code
w.tops = {
    'TopFormationA': 1500.0,
    'TopFormationB': 1750.0,
}

for name, depth in w.tops.items():
    print(f"{name}: {depth} m")

Multi-Well Project

pythonCopy code
from welly import Project

p = Project.from_las('wells/*.las')
print(f"Loaded {len(p)} wells")

# Filter and analyze
for w in p:
    if 'GR' in w.data:
        print(f"{w.name}: GR mean={w.data['GR'].values.mean():.1f}")

Export Data

pythonCopy code
# To DataFrame
df = w.df()

# To LAS file
w.to_las('output.las')

# To CSV
df.to_csv('well_data.csv')

Common Curve Mnemonics

Tips

1. Use Project for multi-well workflows - easier than managing individual files
2. Check units - welly tracks units, ensure consistency
3. Despike before analysis - remove outliers with curve.despike()
4. Resample to common basis - use curve.resample() for cross-well comparison
5. welly extends lasio - all lasio functionality available

When to Use vs Alternatives

Use welly when you need to manage wells as objects with curves, tops, and metadata -- especially for multi-well QC and cross-well analysis via Project.

Use lasio instead when you only need to read/write LAS files, handle malformed headers, or need fine control over LAS formatting.

Use petropy instead when your focus is formation evaluation calculations (shale volume, porosity, water saturation) rather than data management.

Common Workflows

Load and QC a multi-well project

textCopy code
- [ ] Load wells with `Project.from_las('wells/*.las')`
- [ ] Check well count and names: `len(p)`, iterate wells
- [ ] Verify required curves exist in each well (`'GR' in w.data`)
- [ ] Despike and clean noisy curves: `curve.despike()`
- [ ] Resample to common depth basis for cross-well comparison
- [ ] Compute summary statistics per well (mean, min, max)
- [ ] Export cleaned data to LAS or DataFrame

References

• Curve Processing - Despike, smooth, normalize, resample methods
• Project Workflows - Multi-well analysis patterns

Scripts

• scripts/well_qc.py - QC well data for gaps and issues
• scripts/project_stats.py - Compute project-level statistics