Mondaic

salvus.mesh.layered_meshing.interface

salvus.mesh.layered_meshing.interface salvus mesh layered_meshing interface

Classes for different types of interfaces.

Functions

extend_flat()

def extend_flat(da: xr.DataArray, extend_to: xr.DataArray) -> xr.DataArray: ...

Extend an interface past its bounds via the extrusion of its boundaries.

Parameters
  • da xr.DataArray — The DataArray representing the interface to extend.
  • extend_to xr.DataArray — Either a 1- or 2-D tuple of coordinates representing the new bounds.
Returns xr.DataArray — The extended DataArray.

extend_spline()

def extend_spline(
    da: xr.DataArray,
    extend_to: xr.DataArray,
    straight: float = 0.05,
    flat: float = 0.95,
    throw: float = 0.2,
) -> xr.DataArray: ...

Extend an interface past its original bounds via a cubic Hermite spline.

This is useful when a smooth transition to a flat interface is desired. Hermite splines preserve C1 continuity at their boundaries, so extending an interface via this function should result in a minimization of reflections from an abrupt change in tangents.

Parameters
  • da xr.DataArray — The DataArray representing the interface to extend.
  • extend_to xr.DataArray — Either a 1- or 2-D tuple of coordinates representing the new bounds.
  • straight float — Percentage of the extended domain where the slope of the extension matches the slope of the curve at its original edge. Defaults to 0.05.
  • flat float — Percentage of the extended domain after which the slope of the extension is 0.0 (flat). Defaults to 0.95.
  • throw float — Parameter controlling the maximum vertical extent of the extended shape; the vertical extent will be capped at where a perfectly straight extension would be after spanning “throw” percent of the extended domain. Defaults to 0.2.
Returns xr.DataArray — The extended DataArray.

Classes

Depth

class Depth(salvus.mesh.layered_meshing.interface._ElevationAlgebra):
    def __init__(self, value: float) -> None: ...

Declare that a coordinate should be interpreted as depth below a domain’s top surface.

Parameters
  • value float — The depth value.

Height

class Height(salvus.mesh.layered_meshing.interface._ElevationAlgebra):
    def __init__(self, value: float) -> None: ...

Declare that a coordinate should be interpreted as height above a domain’s bottom surface.

Parameters
  • value float — The height value.

Interface

class Interface(builtins.object):
    def __init__(
        self,
        da: xr.DataArray,
        extender: typing.Callable[
            [xr.DataArray, xr.DataArray], xr.DataArray
        ] = salvus.utils.xarray_tools.extrude_like_and_pad,
        interpolation_method: typing.Literal["nearest", "linear"] = "linear",
    ) -> None: ...

Encapsulation of an interface dividing that can be used to divide layers.

Parameters
  • da xr.DataArray — The interface represented as a DataArray.
  • extender typing.Callable[[xr.DataArray, xr.DataArray], xr.DataArray] — A function that can be used extend the boundaries of the interface past its defined extents.
  • interpolation_method typing.Literal['nearest', 'linear'] — The interpolation method used to evaluate the interface between grid points.
Attributes
da_absolute xr.DataArray

Get the DEM in absolute coordinates.

is_flat bool

Query whether the interface is flat.

max_elevation float

Get the interface’s maximum elevation.

min_elevation float

Get the interface’s minimum elevation.

reference_elevation float

Get the interface’s reference elevation.

Methods
from_dataarray()
def from_dataarray(
    da: xr.DataArray,
    extender: typing.Callable[
        [xr.DataArray, xr.DataArray], xr.DataArray
    ] = salvus.utils.xarray_tools.extrude_like_and_pad,
    interpolation_method: typing.Literal["nearest", "linear"] = "linear",
) -> Interface: ...

Construct a generic interface from an xarray DataArray.

Will dispatch to the appropriate interface type based on the DataArray’s dimension and heterogeneity (of lack thereof).

Parameters
  • da xr.DataArray — The data array.
  • extender typing.Callable[[xr.DataArray, xr.DataArray], xr.DataArray] — A function that can be used extend the boundaries of the interface past its defined extents.
  • interpolation_method typing.Literal['nearest', 'linear'] — The interpolation method used to evaluate the interface between grid points.
Returns Interface — A new interface.
extrude_like_and_pad()
def extrude_like_and_pad(
    data: XrType,
    like: xr.Dataset | xr.DataArray,
    rel_tol: float = 0.0001,
    update_bounds: bool = False,
) -> XrType: ...

Extrude like another data array and pad if necessary.

Parameters
  • data XrType — The input data array or set.
  • like xr.Dataset | xr.DataArray — The data array to extrude and pad like.
  • rel_tol float — This tolerance is used to determine whether extrusion needs to occur. It will be multiplied by the smallest difference between coordinate value in data. If data does not fully enclose like, but the difference in extents is less than this tolerance, then no extrusion will occur.
  • update_bounds bool — If True, adjust the coordinate bounds of data so that, for each coordinate, the minimum and maximum values are set to the most extreme values found in either data or like. This is useful for ensuring that small numerical differences (less than the threshold set by rel_tol) do not prevent the coordinates from being treated as matching, effectively “snapping” the bounds to a common range.
Returns XrType
interp_like()
def interp_like(self, like: xr.DataArray) -> typing.Self: ...

Interpolate this interface onto another DataArray’s coordinates.

Will call the interface’s extend method to ensure that it spans the coordinates spanned by other with the desired expansion behavior.

Parameters
  • like xr.DataArray — The DataArray on which to interpolate this interface.
Returns typing.Self — A new interpolated interface.
map()
def map(
    self,
    f: typing.Callable[[xr.DataArray], xr.DataArray],
    as_type: type | None = None,
) -> Interface: ...

Apply a function that modifies the DataArray representation.

All attributes of the DataArray will be kept as is.

Parameters
  • f typing.Callable[[xr.DataArray], xr.DataArray] — The function used to modify the DataArray. Must take and return a DataArray.
  • as_type type | None — Modify the type of the mapped DataArray. Useful for upcasting from a Hyperplane to a heterogeneous container, or vice versa.
Returns Interface — A new interface with a (potentially) modified DataArray representation.
map_representation()
def map_representation(
    self, f: typing.Callable[[xr.DataArray], xr.DataArray]
) -> typing.Self: ...

Transform this interface’s DataArray representation.

Parameters
  • f typing.Callable[[xr.DataArray], xr.DataArray] — Function transform with.
Returns typing.Self — A new, transformed interface.

Relative

class Relative(builtins.float):
    def __init__(self): ...

Declare that a coordinate should be interpreted relative to its bounding interfaces.

Submodules

Used in tutorials