line_mute

function of dascore.proc.mute

line_mute(
    patch: Patch ,
    smooth = None,
    invert: bool = False,
    relative: bool = True,
    **kwargs ,
)-> ‘PatchType’

Mute (zero out) data in a region specified by one or more lines.

Each dimension accepts two boundary specifications that define the mute region. Boundaries can be scalar values or length-2 sequences.

Parameters

Parameter	Description
patch	The patch instance.
smooth	Parameter controlling smoothing of the mute envelope. Defines the sigma Can be: - None: sharp mute - float (0.0-1.0): fraction of dimension range (e.g., 0.01 = 1%) which is applied independently to each dimension involved in the mute. - int: Indicates number of samples for each dimension. - Quantity with units, indicates values along a single dimension. Only applicable if a single dimension is specified. - dict: {dim: taper_value} for dimension-specific smooth values which can be any of the above.

invert	If True, invert the taper such that the values outside the defined region are set to 0.
relative	If True (default), values are relative to coordinate edges. Positive values are offsets from start, negative from end.
**kwargs	Dimension specifications as (boundary_1, boundary_2) pairs. Each boundary can be: - Scalar: constant value (defines plane perpendicular to dimension) - Length-2 sequence: coordinates defining a straight line (2D only) - None or …: edge of coordinate (min or max)

Examples

import dascore as dc

# An example patch full of 1s with time on y axis and distance on x.
patch = dc.get_example_patch().full(1)

# Mute first 0.5s (relative to start by default)
muted = patch.line_mute(time=(0, 0.5))

# Mute everything except middle section
kept = patch.line_mute(time=(0.2, -0.2), invert=True)

# 1D Mute with smoothed absolute units for time.
muted = patch.line_mute(time=(0.2, 0.8), smooth=0.02 * dc.units.s)

# Classic first break mute: mute early arrivals
# Line from (t=0, d=0) to (t=0.3, d=300) defines velocity=1000 m/s
# The other line (defined by time=0 and distance=None) is t=0 (over all
# distances).
muted = patch.line_mute(
    time=(0, [0, 0.3]),
    distance=(None, [0, 300]),
    smooth=0.02,
)

# Mute late arrivals: from velocity line to a vertical line with
# with distance=0 (over all times).
muted = patch.line_mute(
    time=([0, 0.3], None),
    distance=([0, 300], 0),
)

# Mute wedge between two velocity lines
muted = patch.line_mute(
    time=([0, 0.375], [0, 0.25]),
    distance=([0, 300], [0, 300]),
)

# Mute wedge outside two velocity lines
muted = patch.line_mute(
    time=([0, 0.375], [0, 0.25]),
    distance=([0, 300], [0, 300]),
    invert=True,
)

# Apply custom tapering
ones = patch.full(1.0)
envelope = ones.line_mute(
    time=([0, 0.375], [0, 0.25]),
    distance=([0, 300], [0, 300]),
)
# Knock down edges with rolling mean along the time dimension.
smooth = envelope.rolling(time=5, samples=True).mean()
# Then multiply the two patches.
result = patch * smooth

Note

By relative=True (the default) means values are offsets from coordinate edges. Use relative=False for absolute coordinate values.
Currently, mute doesn’t support more than 2 dimensions, and 2D mutes require straight-line boundaries.
For more control over boundary smoothing, use a patch with one values then apply custom tapering/smoothing before multiplying with the original patch. See example section for more details.

See Also