Caliper-Based Flags

Summary

The caliper measures the borehole diameter, and a hole much larger than the bit or with a rough wall damages the pad-type density and neutron readings. Caliper flags compare the Caliper with the Bit size (excess) and with a smooth trend (rugosity). They are the most direct indicator of Bad hole, with the limitation that a good caliper does not guarantee a good log.

Inputs and outputs

Equations

Excess over bit size. With the caliper \(d_c\) and the bit size \(\dBit\):

Rugosity as a deviation from a smooth trend. The trend \(\dTrend\) is a running median of the caliper over a window much longer than the features of interest (tens of feet):

Rugosity as a running standard deviation. Over a centred window of \(N\) samples (window length \(L\) divided by the sample step, plus one), the standard deviation of the caliper readings \(d_i\) is

Flag. A sample is flagged when either test fails:

The calculator uses the deviation-from-trend form of rugosity, which needs only one sample and a trend. The running-standard-deviation form needs a window of samples and is computed in the worked example. The flag is normally padded by a few samples, as described on the null-out page.

Single-value calculator

Behavior

The excess test is a threshold on the caliper. On the plot the flag turns on when the caliper exceeds the bit size by the limit: at 9.0 in for a limit of 0.5 in, at 9.25 in for 0.75 in and at 10.0 in for 1.5 in, for an 8.5 in bit. A lower limit flags more hole. The rugosity test catches what the excess test misses. At the default inputs the caliper is 9.1 in, only 0.60 in over the 8.5 in bit and below the 0.75 in limit, so the excess test does not flag it, and the caliper is 0.40 in from a trend of 8.7 in, below the 0.5 in rugosity limit, so neither test flags it. A reading of 9.3 in is 0.80 in over the bit, exceeds the limit and is flagged. In the worked example the two tests find different things. The excess test flags 27 samples: the whole washout (40.5 to 51.5 ft) but only four isolated samples of the rough interval. The running standard deviation flags 62 samples: both edges of the washout and most of the rough interval (93 to 112 ft), but not the smooth crest of the washout between 45 and 47 ft. A smooth washout has a low rugosity in its middle, and a rough hole near gauge has a low excess, so the tests are used together.

Parameter guidance

Bit size. Use the bit size for the interval, in inches, for every section of the well. A single bit size for a well drilled with several is a common error: an 8.5 in hole logged with a 12.25 in bit size would be treated as being in gauge and the flag would never fire. If a bit record is unavailable, the mode of the caliper in the cleanest shale of each section is a workable substitute.

Excess limit. Start with 0.5 to 1.0 in over bit size for density and neutron, depending on the tool: a pad tool with a good arm can tolerate a little more. A smaller limit flags more hole. A fixed absolute caliper (for example 12 in) is only sound if every well in the project has the same bit size.

Rugosity limit. Typically 0.1 to 0.5 in. It depends on the window used for the trend or the standard deviation: a window of 5 to 10 ft is common for the standard deviation, and 20 to 50 ft for a trend. Choose the limit by looking at the in-gauge scatter of the caliper in a clean interval and setting the limit at several times that scatter.

Window. The window should be longer than the vertical resolution of the density pad (about 1 to 2 ft) and short enough to follow a real change of hole size. The padding of the flag and its effect on the data lost are on Repair: Null-Out. Other flags that use the logs themselves are on Log-Quality Flags.

Worked example

A synthetic 150 ft caliper at 0.5 ft sampling in an 8.5 in hole, with a smooth washout from 40 to 52 ft (up to 12 in) and a rough interval from 95 to 110 ft near gauge. The three tests are compared.

rng = np.random.default_rng(8)
step = 0.5                                   # ft
depth = np.arange(0, 150, step)
bit = 8.5                                    # in

# Synthetic caliper: in gauge, a smooth washout (40-52 ft), and a rugose, breakout-type interval (95-110 ft)
cali = bit + rng.normal(0, 0.04, depth.size)
wash = (depth >= 40) & (depth < 52)
cali[wash] += 3.5 * np.sin(np.pi * (depth[wash] - 40) / 12) ** 0.5
rug = (depth >= 95) & (depth < 110)
cali[rug] += 0.4 + rng.normal(0, 0.5, rug.sum()).clip(-0.35, None)

def moving(a, n, fn):
    """Centered moving statistic over n samples (n odd), edges padded by reflection."""
    h = n // 2
    w = np.lib.stride_tricks.sliding_window_view(np.pad(a, h, mode="reflect"), n)
    return fn(w, axis=1)

# 1. Exceedance over bit size
excess = cali - bit
flag_excess = excess > 0.75                  # 3/4 in over bit size

# 2. Rugosity as a running standard deviation over 5 ft
n5 = int(5 / step) + 1
rug_sd = moving(cali, n5, np.std)
flag_sd = rug_sd > 0.2

# 3. Rugosity as deviation from a smooth trend (running median over 25 ft)
n25 = int(25 / step) + 1
trend = moving(cali, n25, np.median)
dev = np.abs(cali - trend)
flag_dev = dev > 0.5

def intervals(flag):
    d = np.diff(np.r_[0, flag.astype(int), 0])
    return [(depth[a], depth[b - 1]) for a, b in zip(np.where(d == 1)[0], np.where(d == -1)[0])]

for name, f in (("exceedance > 0.75 in", flag_excess), ("running sd (5 ft) > 0.2 in", flag_sd),
                ("deviation from trend > 0.5 in", flag_dev)):
    iv = ", ".join(f"{a:.1f}-{b:.1f}" for a, b in intervals(f)) or "none"
    print(f"{name:30s} {f.sum():3d} samples  intervals (ft): {iv}")

either = flag_excess | flag_sd
print(f"\nexceedance OR running sd: {either.sum()} of {depth.size} samples ({either.mean():.1%}) flagged")
print(f"max caliper {cali.max():.2f} in at {depth[cali.argmax()]:.1f} ft; in-gauge scatter sd = {np.std(cali[(depth < 35)]):.3f} in")

Output

exceedance > 0.75 in            27 samples  intervals (ft): 40.5-51.5, 95.5-95.5, 97.5-97.5, 106.0-106.0, 109.5-109.5
running sd (5 ft) > 0.2 in      62 samples  intervals (ft): 38.0-45.0, 47.0-54.0, 93.0-98.0, 99.0-100.0, 103.5-112.0
deviation from trend > 0.5 in   28 samples  intervals (ft): 40.5-51.5, 95.5-95.5, 97.5-97.5, 106.0-106.0, 107.0-107.0, 109.5-109.5

exceedance OR running sd: 65 of 300 samples (21.7%) flagged
max caliper 11.99 in at 46.5 ft; in-gauge scatter sd = 0.044 in

Assumptions and limitations

• The caliper is calibrated and recorded on the same depth as the density and neutron. A caliper offset of a few feet shifts the flag from the damaged interval.
• A caliper reading large means a bad hole, and a caliper in gauge means a good one. The second is often false: mud cake, a gentle key seat or a hole that is rounded but oversize everywhere can leave the pad in poor contact with a good-looking caliper.
• The bit size is known for each interval.
• A single-arm caliper measures a diameter in one direction; in an elliptical hole it can read in gauge when the hole is oversize in the other direction. A multi-arm tool gives better information.
• Rugosity is a proxy for the roughness the pad sees, which is smaller than the caliper window.

QC checks

• Flags coincide with intervals where the density correction is large and the bulk density is low (see the log-quality flags page).
• Flagged intervals are visible as caliper excursions on a log plot, and the in-gauge intervals are not flagged.
• The caliper in clean shale equals the bit size to within a few hundredths of an inch; if it does not, the bit size or the caliper calibration is wrong.
• The share of the well flagged is plausible. A flag on more than a third of a section means a limit is wrong or the hole is genuinely poor and the data will be of little use.
• Check flag boundaries on thin beds: a washed-out shale next to a tight limestone should not flag the limestone.

Going Deeper

The caliper is a mechanical measurement of the wall, and it correlates with the quality of a pad reading but does not determine it. Mud type, mudcake and pad force matter. Density corrections ('DRHO') integrate the information of the two detectors and are a better direct measure of pad quality, which is why caliper flags are best used with the log-quality flags. Rugosity measures are used in geomechanics for borehole-breakout detection, where the same measurements are interpreted for stress direction; the caliper window for that use is longer. Several arms and image logs give a more complete picture of the hole shape than a single caliper.

References

1. Asquith, G. and Krygowski, D., 2004. Basic Well Log Analysis, 2nd edition. AAPG Methods in Exploration Series 16, American Association of Petroleum Geologists, Tulsa, OK.
2. Rider, M. and Kennedy, M., 2011. The Geological Interpretation of Well Logs, 3rd edition. Rider-French Consulting Ltd, Sutherland, UK.

Python reference implementation

Related methods

• Log-Quality Flags
• Coal and Salt Identification
• Repair: Null-Out
• Repair: Regression-Based
• Repair: Machine-Learning Infill