salvus.mesh.algorithms.unstructured_mesh.metrics

def compute_determinants(mesh: UnstructuredMesh) -> npt.NDArray: ...

Compute the determinant of the Jacobian for each element in the mesh.

def compute_max_velocity_per_element(
    mesh: UnstructuredMesh,
) -> npt.NDArray: ...

Return the per-element maximum P-wave speed from material fields.

This mirrors what SalvusCompute does internally when computing the time step on the solver side: for each element the maximum P-wave velocity is derived from the element’s material coefficients, and the parametrization is selected by which fields are attached to the mesh.

Recognized parametrizations, in order of preference:

1. VP (isotropic, velocity form).
2. VPV and VPH (anisotropic, velocity form) — uses max(VPV, VPH).
3. LAMBDA, MU, RHO (isotropic elastic, linear form) — uses sqrt((lambda + 2 * mu) / rho).
4. M0, M1 (acoustic, linear form) — uses sqrt(M1 / M0).

Fully anisotropic Cij parametrizations are currently not supported (the solver extracts the maximum eigenvalue of the elastic tensor per DOF).

def compute_maximum_edge_length_per_element(
    mesh: UnstructuredMesh, mask: npt.NDArray | None = None
) -> npt.NDArray: ...

Return the max edge size for each element.

def compute_mesh_quality(
    mesh: UnstructuredMesh, quality_metric: str = "edge_aspect_ratio"
) -> npt.NDArray: ...

Compute a few proxies for for mesh quality.

def compute_minimum_edge_length_per_element(
    mesh: UnstructuredMesh,
    mask: npt.NDArray | None = None,
    direction: int | None = None,
    shape_order: int | None = None,
) -> npt.NDArray: ...

Compute the smallest edge-length in an element.

Assumes a first order shape approximation.

def compute_minimum_gll_distance(
    mesh: UnstructuredMesh,
    shape_order: int,
    execution_policy: bindings.ExecutionPolicy = salvus._core.lib.salvus_core_python_bindings.ExecutionPolicy,
    use_bindings: bool = True,
) -> npt.NDArray: ...

Compute the minimum distance between GLL points per element.

Although the mesh is defined at a specific order, the GLL spacing may be computed at any arbitrary order. This is useful when computing spacing for higher order shape functions. For example, Salvus by default uses fourth order shape functions for the wavefield, unless explicitly changed in e.g.:

sn.WaveformSimulationConfiguration(
    spectral_element_order=spectral_element_order,
    ...,
)

To get the spacing required for computing the CFL criterion in those cases, one would need the minimum GLL distance for fourth order shape functions, even if the mesh is first order.

def compute_minimum_time_step_across_meshes(
    meshes: list[UnstructuredMesh],
    courant_number: float | None = None,
    simulation_order: int | None = None,
    execution_policy: bindings.ExecutionPolicy = salvus._core.lib.salvus_core_python_bindings.ExecutionPolicy,
    use_bindings: bool = True,
) -> float: ...

Compute the minimum time step across multiple meshes.

This function iterates over a list of meshes and computes the minimum time step of each one using the compute_time_step function. The lowest time step across all of the queried meshes is then returned.

This is useful for cases where one wishes to use a common time axis across multiple simulations, e.g. for visualizations.

def compute_time_step(
    mesh: UnstructuredMesh,
    max_velocity: npt.NDArray | float,
    courant_number: float | None = None,
    simulation_order: int | None = None,
    attach: bool = False,
    execution_policy: bindings.ExecutionPolicy = salvus._core.lib.salvus_core_python_bindings.ExecutionPolicy,
    use_bindings: bool = True,
) -> tuple[float, npt.NDArray]: ...

Compute the time step for the given mesh and velocity.

The time step is estimated by means of the Courant-Friedrichs-Lewy (CFL) condition, which relates the time step to the spatial discretization and the wave propagation speed. This implementation accounts for deformed higher-order element.

Note that this implementation by defaults uses a shape order of 4 if not specified. This is the default order at which Salvus parametrizes wavefields, but can be changed by e.g.:

sn.WaveformSimulationConfiguration(
    spectral_element_order=spectral_element_order,
    ...,
)

The Courant-number in the CFL condition defaults to 0.6 for 2D meshes and 0.47 for 3D meshes.

def estimate_resolved_frequency(
    mesh: UnstructuredMesh,
    min_velocity: npt.NDArray,
    elements_per_wavelength: float,
) -> tuple[float, npt.NDArray]: ...

Estimate the highest resolved frequency in each element.

def estimate_time_step(
    mesh: UnstructuredMesh,
    max_velocity: npt.NDArray | float,
    courant_number: float = 1.0,
    min_gll_point_distance: float = 1.0,
    fast: bool = True,
    return_hmin_elemnodes: bool = False,
    shape_order: int | None = None,
    execution_policy: bindings.ExecutionPolicy = salvus._core.lib.salvus_core_python_bindings.ExecutionPolicy,
) -> tuple[float, npt.NDArray] | tuple[float, npt.NDArray, npt.NDArray]: ...

Compute an estimation of the time step set by each element.

This function is deprecated in favor of compute_time_step, which uses more appropriate defaults and a simplified API.

The time step is estimated by means of the Courant-Friedrichs-Lewy (CFL) condition, which relates the time step to the spatial discretization and the wave propagation speed. This method is an estimation, as it does not fully account for heavily deformed elements.