Mondaic
This API reference is not for the latest stable Salvus version.

salvus.mesh.simple_mesh.basic_mesh

Useful meshing classes.

Functions

extrude_domain_ab()

def extrude_domain_ab(
    d: _domain.Domain,
    ab: Optional[AbsorbingBoundaryParameters],
    h_max: List[float],
    side_sets: Optional[List[str]] = None,
    force: bool = False,
) -> Tuple[_domain.Domain, List[str], float]: ...

Extrude the domain to account for absorbing boundaries.

If no absorbing boundaries are passed, the domain is just returned as is (except when force is True — see below).

Returns the extruded domain and a list of realized side sets (i.e. [‘x0’, ‘x1’, ‘y0’] when given ‘all_except_free_surface’ in a 2-D domain).

Parameters
  • d _domain.Domain — The domain to extrude.
  • ab Optional[AbsorbingBoundaryParameters] — The optional absorbing boundaries.
  • h_max List[float] — A list of the element sizes along each dimension.
  • side_sets Optional[List[str]] — The side sets to extrude along.
  • force bool — Force extrusion even if ab is None. Useful for extruding by h_max only — kept to retain legacy behavior.
Returns Tuple[_domain.Domain, List[str], float] — A new domain, along with a list of realized side sets, and a desired extrusion distance in the coordinate system of the domain.

get_domain_radius()

def get_domain_radius(layered_model: lm.LayeredModel) -> float: ...

Get the domain radius from a layered model.

Useful when the radius is set outside of the layered model itself, i.e. in the RADIUS attribute. This can be the case for some BM files.

Parameters
  • layered_model lm.LayeredModel — The layered model.
Returns float — The radius.

get_poissons_ratio()

def get_poissons_ratio(vp: float, vs: float) -> float: ...

Determine Poisson’s ratio from VP and VS.

Parameters
  • vp float — P-wave velocity.
  • vs float — S-wave velocity.
Returns float

rho_from_gardeners()

def rho_from_gardeners(
    vp: Union[numpy.ndarray, float]
) -> Union[numpy.ndarray, float]: ...

Compute density using Gardner’s relationship.

Parameters
  • vp Union[numpy.ndarray, float] — VP array.
Returns Union[numpy.ndarray, float]

rho_from_gardners()

def rho_from_gardners(
    vp: Union[numpy.ndarray, float], alpha: float = 310.0, beta: float = 0.25
) -> Union[numpy.ndarray, float]: ...

Compute density using Gardner’s relationship.

According to Gardner’s equation, density [kg/m3^3] is related to vp [m/s] using ho = lpha v_p^eta, with empirically derived constants lpha and eta. Note that the original work used units of g/cc and ft/s, respectively.

Reference: https://www.subsurfwiki.org/wiki/Gardner%27s_equation

Parameters
  • vp Union[numpy.ndarray, float] — P-wave velocity.
  • alpha float — Gardner’s first contant.
  • beta float — Gardner’s second contant.
Returns Union[numpy.ndarray, float]

vs_from_poisson()

def vs_from_poisson(
    vp: Union[numpy.ndarray, float], poisson_ratio: float = 0.25
) -> Union[numpy.ndarray, float]: ...

Compute VS from VP given a certain Poisson’s ratio.

Parameters
  • vp Union[numpy.ndarray, float] — VP array.
  • poisson_ratio float — Poisson’s ratio to apply.
Returns Union[numpy.ndarray, float]

Classes

AbsorbingBoundaryParameters

class AbsorbingBoundaryParameters(
    salvus.flow.utils.serialization_helpers.SerializationMixin
):
    def __init__(
        self,
        reference_velocity: float,
        number_of_wavelengths: float,
        reference_frequency: float,
        free_surface: Union[bool, List[str]] = True,
    ) -> None: ...

Required information to extend the mesh for absorbing boundaries.

This class encapsulates the parameters required for mesh extrusion in the
presence of absorbing boundary layers. All parameters need to be
specified and will be used in relation to each other to calculate an
appropriate distance by which to extend the mesh.

A good rule of thumb is to extend the domain by 3.5 or more wavelengths
at each boundary which is marked as absorbing. In domain with
heterogeneous velocities some experimentation may be required to find the
optimal settings which balance the performance of the solver (e.g. # of
total elements) with the performance of the absorbing boundaries (e.g.
maximum reflection coefficient).

Initialize the absorbing boundary parameters.

Parameters
  • reference_velocity float — Wave velocity in the absorbing boundary layer.
  • number_of_wavelengths float — Number of wavelengths to pad the domain by.
  • reference_frequency float — Reference frequency for the distance calculation (i.e. the center frequency of the source).
  • free_surface Union[bool, List[str]] — If True, retain a free surface, and don’t mark the top surface (either r1 or z1) as absorbing. For Cartesian domains, one can also pass a list of side sets (i.e. [“z0”, “z1”] in the case of a thin plate) that should be kept as a free surface.
Attributes
distance float

Distance in meters of the absorbing boundaries.

number_of_wavelengths float

Get the stored number of wavelengths.

reference_frequency float

Get the stored reference frequency.

reference_velocity float

Get the stored velocity.

side_sets List[str]

Get the side sets for the schema.

Methods
from_json()
def from_json(d: Dict) -> Any: ...

Recreate the object from a dictionary serialization of its initialization parameters.

Parameters
  • d Dict — Dictionary containing its init parameters and a few other things.
Returns Any
no_sponge_layers()
def no_sponge_layers(
    free_surface: Union[bool, List[str]] = True
) -> AbsorbingBoundaryParameters: ...

Simplified constructor to handle when sponge layers are not desired.

When applied to a mesh will signify that first-order absorbing boundary conditions should be applied at the requisite side, and no domain extrusion / sponge layer attachment should occur

Parameters
  • free_surface Union[bool, List[str]] — If True, retain a free surface, and don’t mark the top surface (either r1 or z1) as absorbing. For Cartesian domains, one can also pass a list of side sets (i.e. [“z0”, “z1”] in the case of a thin plate) that should be kept as a free surface.
Returns AbsorbingBoundaryParameters — An AbsorbingBoundaryParameters object that requests the attachment of first-order absorbing boundary conditions only.
to_json()
def to_json(self, external_file_hash: Optional[str] = None) -> Dict: ...

Serialize the object to dictionary that can be written to JSON.

Parameters
  • external_file_hash Optional[str] — Hash of any external files associated with this object. Can be passed here in which case it will be stored in a centralized location in the JSON file.
Returns Dict

CartesianFromBm2D

class CartesianFromBm2D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian2D,
):
    def __init__(
        self,
        bm_file: Union[pathlib.Path, str],
        x_min: float = 0.0,
        x_max: float,
        y_min: float = 0.0,
        y_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        use_lm: bool = True,
        interlayer_coarsening_policy: Optional[
            lm.meshing_protocol.coarsening_policy.InterlayerCoarseningPolicy
        ] = None,
    ): ...

Class to handle cartesian meshes created from BM files in 2D.

Initialize a mesh from an externally computed BM file. Useful for simple layered models.

Parameters
  • bm_file Union[pathlib.Path, str] — Path to bm file.
  • x_min float — Min extent of the x-dimension in meter.
  • x_max float — Max extent of the x-dimension in meter.
  • y_min float — Min extent of the y-dimension in meter.
  • y_max float — Max extent of the y-dimension in meter.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • use_lm bool — Use the layered meshing backend.
  • interlayer_coarsening_policy Optional[lm.meshing_protocol.coarsening_policy.InterlayerCoarseningPolicy] — Add a custom interlayer coarsening policy to the mesh.

CartesianFromBm3D

class CartesianFromBm3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian3D,
):
    def __init__(
        self,
        bm_file: Union[pathlib.Path, str],
        x_max: float,
        y_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        z_range: Optional[Iterable[float]] = None,
        use_lm: bool = True,
        bm_shift: float = 0.0,
        interlayer_coarsening_policy: Optional[
            lm.meshing_protocol.coarsening_policy.InterlayerCoarseningPolicy
        ] = None,
    ): ...

Class to handle cartesian meshes created from BM files in 3D.

Initialize a mesh from an externally computed BM file. Useful for simple layered models.

Parameters
  • bm_file Union[pathlib.Path, str] — Path to bm file.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • z_range Optional[Iterable[float]] — Range in the vertical direction of the mesh.
  • use_lm bool — Use the layered meshing backend.
  • bm_shift float — Used to offset layered models in project’s UTM domains to retain previous behavior.
  • interlayer_coarsening_policy Optional[lm.meshing_protocol.coarsening_policy.InterlayerCoarseningPolicy] — Add a custom interlayer coarsening policy to the mesh.

CartesianHomogeneousAcoustic2D

class CartesianHomogeneousAcoustic2D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian2D,
):
    def __init__(
        self,
        vp: float,
        rho: float,
        x_max: float,
        y_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        use_lm: bool = True,
    ): ...

Base class to handle homogeneous cartesian acoustic meshes in 2D.

Initialize a simple homogeneous acoustic mesh.

Parameters
  • vp float — P-wave velocity.
  • rho float — Density.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • use_lm bool — Use the layered meshing backend.

CartesianHomogeneousAcoustic3D

class CartesianHomogeneousAcoustic3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian3D,
):
    def __init__(
        self,
        vp: float,
        rho: float,
        x_max: float,
        y_max: float,
        z_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        use_lm: bool = True,
    ): ...

Base class to handle homogeneous cartesian acoustic meshes in 3D.

Initialize a simple homogeneous acoustic mesh.

Parameters
  • vp float — P-wave velocity.
  • rho float — Density.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • z_max float — Size of z-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • use_lm bool — Use the layered meshing backend.

CartesianHomogeneousIsotropicElastic2D

class CartesianHomogeneousIsotropicElastic2D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian2D,
):
    def __init__(
        self,
        vp: float,
        vs: float,
        rho: float,
        x_max: float,
        y_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        use_lm: bool = True,
    ): ...

Base class to handle homogeneous cartesian isotropic elastic meshes in 2D.

Initialize a simple homogeneous isotropic elastic mesh.

Parameters
  • vp float — P-wave velocity.
  • vs float — S-wave velocity.
  • rho float — Density.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • use_lm bool — Use the layered meshing backend.

CartesianHomogeneousIsotropicElastic3D

class CartesianHomogeneousIsotropicElastic3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian3D,
):
    def __init__(
        self,
        vp: float,
        vs: float,
        rho: float,
        x_max: float,
        y_max: float,
        z_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        use_lm: bool = True,
    ): ...

Base class to handle homogeneous cartesian isotropic elastic meshes 3D.

Initialize a simple homogeneous isotropic elastic mesh.

Parameters
  • vp float — P-wave velocity.
  • vs float — S-wave velocity.
  • rho float — Density.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • z_max float — Size of z-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • use_lm bool — Use the layered meshing backend.

CartesianHomogeneousIsotropicViscoElastic2D

class CartesianHomogeneousIsotropicViscoElastic2D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian2D,
):
    def __init__(
        self,
        vp: float,
        vs: float,
        rho: float,
        qkappa: float,
        qmu: float,
        x_max: float,
        y_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        use_lm: bool = True,
    ): ...

Base class to handle homogeneous cartesian isotropic elastic meshes in 2D.

Initialize a simple homogeneous isotropic elastic mesh.

Parameters
  • vp float — P-wave velocity.
  • vs float — S-wave velocity.
  • rho float — Density.
  • qkappa float — Qkappa.
  • qmu float — Qmu.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters governing the absorbing boundaries.
  • use_lm bool — Use the layered meshing backend.

CartesianTransverselyIsotropicElastic3D

class CartesianTransverselyIsotropicElastic3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh.Cartesian3D,
):
    def __init__(
        self,
        vpv: float,
        vph: float,
        vsv: float,
        vsh: float,
        eta: float,
        rho: float,
        x_max: float,
        y_max: float,
        z_max: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        use_lm: bool = True,
    ): ...

Base class to handle homogeneous cartesian isotropic elastic meshes 3D.

Initialize a simple homogeneous isotropic elastic mesh.

Parameters
  • vpv float — P-wave velocity (along symmetry axis).
  • vph float — P-wave velocity (perpendicular to symmetry axis).
  • vsv float — P-wave velocity (along symmetry axis).
  • vsh float — P-wave velocity (perpendicular to symmetry axis).
  • eta float — TTI Eta parameter.
  • rho float — Density.
  • x_max float — Size of x-dimension in meters.
  • y_max float — Size of y-dimension in meters.
  • z_max float — Size of z-dimension in meters.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape.
  • use_lm bool — Use the layered meshing backend.

Circular2D

class Circular2D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh._Circular2D,
):
    def __init__(self, radius: float = inf): ...

Base class to handle simple spherical chunk meshes using one of the built in models.

Generate a circular mesh.

Parameters
  • radius float — The radius of the circle in meters.

GlobalBuiltIn3D

class GlobalBuiltIn3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh._Globe3D,
):
    def __init__(
        self,
        model: Union[str, Callable],
        period: float,
        tensor_order: int = 1,
        constant_q_frequency_band: Optional[Tuple[float, float]] = None,
        max_depth_in_meters: Optional[float] = None,
        use_lm: bool = True,
    ): ...

Base class to build global meshes using one of the built in models.

Parameters
  • model Union[str, Callable] — Model name.
  • period float — Mesh period.
  • tensor_order int — Tensor order for the mesh.
  • constant_q_frequency_band Optional[Tuple[float, float]] — A tuple of frequencies (low, high) over which Q should be approximately constant. If not passed, the band will be estimated min_period_in_seconds.
  • max_depth_in_meters Optional[float] — The maximum depth of the mesh. If None, a full sphere will be constructed.
  • use_lm bool — Use the layered meshing backend.

Globe3D

class Globe3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh._Globe3D,
):
    def __init__(self, radius: float = inf): ...

Base class to handle simple spherical chunk meshes using one of the built in models.

Generate a spherical mesh.

Parameters
  • radius float — The radius of the sphere in meters.

SphericalChunkBuiltIn3D

class SphericalChunkBuiltIn3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh._SphericalChunk3D,
):
    def __init__(
        self,
        model: Union[str, Callable],
        period: float,
        latitude_extent: float,
        longitude_extent: float,
        tensor_order: int = 1,
        latitude_center: float = 0.0,
        longitude_center: float = 0.0,
        elements_per_wavelength: float = 2.0,
        minimum_radius_in_km: float = 3755.0,
        ab_params: Optional[
            salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters
        ] = None,
        constant_q_frequency_band: Optional[Tuple[float, float]] = None,
        use_lm: bool = True,
    ): ...

Base class to handle simple spherical chunk meshes using one of the built in models.

Get a spherical chunk mesh based on a 1-D background model.

This function returns a spherical chunk mesh with a 1-D model attached to it. The 1-D model is necessary, at it is used to set the element sizes and adjust the double and tripling layers with depth. It also defines a series of strict spherical discontinuities which the mesh will honour. Once the mesh is returned, one can then overwrite the background model with their own 3-D model as desired.

Parameters
  • model Union[str, Callable] — The name of the 1-D background model.
  • period float — The minimum seismic period for which to generate the mesh. This value is used in conjunction with elements_per_wavelength to control the accuracy of the simulation.
  • latitude_extent float — The latitudinal extent of the mesh from its center in degrees.
  • longitude_extent float — The longitudinal extent of the mesh from its center in degrees.
  • tensor_order int — The order of the model representation (1, 2, or 4). See the “Model Order” tutorial on the website for more details.
  • latitude_center float — The latitudinal center of the mesh in degrees.
  • longitude_center float — The longitudinal center of the mesh in degrees. elements_per_wavelength: Given the 1-D background model and period as specified, ensure that there are at least this many elements per minimum wavelength throughout the mesh volume.
  • elements_per_wavelength float — The desired elements per wavelength for the to be created mesh.
  • minimum_radius_in_km float — Minimum radius of the mesh in kilometers.
  • ab_params Optional[salvus.mesh.simple_mesh.basic_mesh.AbsorbingBoundaryParameters] — Parameters controlling the extrusion of the domain for the purposes of adding absorbing boundaries.
  • constant_q_frequency_band Optional[Tuple[float, float]] — A tuple of frequencies (low, high) over which Q should be approximately constant. If not passed, the band will be estimated min_period_in_seconds.
  • use_lm bool — Use the layered meshing backend.

SphericalFromBm3D

class SphericalFromBm3D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh._Globe3D,
):
    def __init__(
        self,
        bm_file: Union[str, pathlib.Path, Callable],
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        constant_q_frequency_band: Optional[Tuple[float, float]] = None,
        use_lm: bool = True,
    ): ...

Class to handle cartesian meshes created from BM files in 3D.

Initialize a mesh from an externally computed BM file. Useful for simple layered models.

Parameters
  • bm_file Union[str, pathlib.Path, Callable] — Path to bm file.
  • max_frequency float — Maximum expected frequency in mesh.
  • elements_per_wavelength float — Elements per mimimum wavelength.
  • tensor_order int — Order of the GLL model and shape mapping.
  • constant_q_frequency_band Optional[Tuple[float, float]] — A tuple of frequencies (low, high) over which Q should be approximately constant. If not passed, the band will be estimated min_period_in_seconds.
  • use_lm bool — Use the layered meshing backend.

SphericalHomogeneousAcoustic2D

class SphericalHomogeneousAcoustic2D(
    salvus.mesh.simple_mesh.basic_mesh._MigratedBasicMeshProtocol,
    salvus.mesh.simple_mesh._Circular2D,
):
    def __init__(
        self,
        vp: float,
        rho: float,
        radius: float,
        max_frequency: float,
        elements_per_wavelength: float = 2.0,
        tensor_order: int = 1,
        use_lm: bool = True,
    ): ...

Base class to handle simple spherical chunk meshes using one of the built in models.

Parameters
  • vp float — vp velocity
  • rho float — density
  • radius float — Radius of the sphere.
  • max_frequency float — Mesh frequency.
  • elements_per_wavelength float — The number of elements per wavelength.
  • tensor_order int — Tensor order of the mesh.
  • use_lm bool — Use the layered meshing backend.