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

`salvus.mesh.mesh_block.generators.cartesian`

Cartesian mesh grid generators.

Functions

`axisem_tripling_layer_2d()`

def axisem_tripling_layer_2d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cartesian structured grid with tripling such that no element has a single point on the axis (needed for GLJ quadrature in AxiSEM) nelem_lat is the element number on the inner side, number of elements on the outer side is nelem * 3 - 2

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cube_3d()`

def cube_3d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    nelem_y: Union[int, numpy.int32, numpy.int64],
    nelem_z: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    elem_locations_horizontal: Optional[List[numpy.ndarray]] = None,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple rectangular structured grid

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
nelem_y Union[int, numpy.int32, numpy.int64] — nelem_y
nelem_z Union[int, numpy.int32, numpy.int64] — nelem_z
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
min_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_z
max_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_z
elem_locations_horizontal Optional[List[numpy.ndarray]] — Ensure that the horizontal element boundaries exist at these list of coordinate values. Length of this array must equal 2, and the length of the entries must equal nelem_x and nelem_y respectively.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cube_vertical_refine_3d()`

def cube_vertical_refine_3d(
    nelem_x: Union[int, numpy.ndarray],
    nelem_y: Union[int, numpy.ndarray],
    nelem_z: numpy.ndarray,
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    dangling: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.3333333333333333,
    p1: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.5,
    p2: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.64,
    p3: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.1,
    preprocess_nelem_z: bool = True,
    elem_locations_horizontal: Optional[List[numpy.ndarray]] = None,
    fallback: Optional[Callable[[numpy.ndarray], numpy.ndarray]] = None,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple rectangular structured grid

Parameters

nelem_x Union[int, numpy.ndarray] — nelem_x
nelem_y Union[int, numpy.ndarray] — nelem_y
nelem_z numpy.ndarray — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
min_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_z
max_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_z
dangling Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — dangling
p1 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — horizontal location of the refinements boundary
p2 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — vertical location of the nodes in the refinement
p3 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — vertical location in the convex elements
preprocess_nelem_z bool — preprocess_nelem_z
elem_locations_horizontal Optional[List[numpy.ndarray]] — Ensure that the horizontal element boundaries exist at these list of coordinate values. Length of this array must equal 2, and the length of the entries must equal nelem_x and nelem_y respectively.
fallback Optional[Callable[[numpy.ndarray], numpy.ndarray]] — A function that should attempt to modify the number of elements in the vertical direction. This will be called if invalid refinement specifications are detected.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cube_vertical_refine_doubling_3d()`

def cube_vertical_refine_doubling_3d(
    nelem_x: numpy.ndarray,
    nelem_y: numpy.ndarray,
    nelem_z: numpy.ndarray,
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    dangling: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.25,
    p1: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.5,
    p2: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.35714285714285715,
    p3: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.6,
    preprocess_nelem_z: bool = True,
    elem_locations_horizontal: Optional[
        List[
            Union[
                Sequence[Sequence[Sequence[Sequence[Sequence[Any]]]]],
                numpy._array_like._SupportsArray[numpy.dtype],
                Sequence[numpy._array_like._SupportsArray[numpy.dtype]],
                Sequence[
                    Sequence[numpy._array_like._SupportsArray[numpy.dtype]]
                ],
                Sequence[
                    Sequence[
                        Sequence[numpy._array_like._SupportsArray[numpy.dtype]]
                    ]
                ],
                Sequence[
                    Sequence[
                        Sequence[
                            Sequence[
                                numpy._array_like._SupportsArray[numpy.dtype]
                            ]
                        ]
                    ]
                ],
                bool,
                int,
                float,
                complex,
                str,
                bytes,
                Sequence[Union[bool, int, float, complex, str, bytes]],
                Sequence[
                    Sequence[Union[bool, int, float, complex, str, bytes]]
                ],
                Sequence[
                    Sequence[
                        Sequence[Union[bool, int, float, complex, str, bytes]]
                    ]
                ],
                Sequence[
                    Sequence[
                        Sequence[
                            Sequence[
                                Union[bool, int, float, complex, str, bytes]
                            ]
                        ]
                    ]
                ],
            ]
        ]
    ] = None,
    fallback: Optional[Callable[[numpy.ndarray], numpy.ndarray]] = None,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Parameters

nelem_x numpy.ndarray — nelem_x
nelem_y numpy.ndarray — nelem_y
nelem_z numpy.ndarray — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
min_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_z
max_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_z
dangling Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — dangling
p1 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p1
p2 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p2
p3 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p3
preprocess_nelem_z bool — preprocess_nelem_z
elem_locations_horizontal Optional[List[Union[Sequence[Sequence[Sequence[Sequence[Sequence[Any]]]]], numpy._array_like._SupportsArray[numpy.dtype], Sequence[numpy._array_like._SupportsArray[numpy.dtype]], Sequence[Sequence[numpy._array_like._SupportsArray[numpy.dtype]]], Sequence[Sequence[Sequence[numpy._array_like._SupportsArray[numpy.dtype]]]], Sequence[Sequence[Sequence[Sequence[numpy._array_like._SupportsArray[numpy.dtype]]]]], bool, int, float, complex, str, bytes, Sequence[Union[bool, int, float, complex, str, bytes]], Sequence[Sequence[Union[bool, int, float, complex, str, bytes]]], Sequence[Sequence[Sequence[Union[bool, int, float, complex, str, bytes]]]], Sequence[Sequence[Sequence[Sequence[Union[bool, int, float, complex, str, bytes]]]]]]]] — Ensure that the horizontal element boundaries exist at these list of coordinate values. Length of this array must equal 2, and the length of the entries must equal nelem_x and nelem_y respectively.
fallback Optional[Callable[[numpy.ndarray], numpy.ndarray]] — A function that should attempt to modify the number of elements in the vertical direction. This will be called if invalid refinement specifications are detected.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cube_xyz_3d()`

def cube_xyz_3d(
    x: numpy.ndarray, y: numpy.ndarray, z: numpy.ndarray
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Parameters

x numpy.ndarray — x
y numpy.ndarray — y
z numpy.ndarray — z

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cube_z_3d()`

def cube_z_3d(
    z: numpy.ndarray,
    nelem_x: Union[int, numpy.int32, numpy.int64],
    nelem_y: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Parameters

z numpy.ndarray — z
nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
nelem_y Union[int, numpy.int32, numpy.int64] — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`doubling_layer_2d()`

def doubling_layer_2d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    move_nodes: bool = True,
    p1: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.5,
    apply_mask: bool = True,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Generates a cartesian mesh grid with doubling.

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
move_nodes bool — move_nodes
p1 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p1
apply_mask bool — apply_mask
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`doubling_layer_3d()`

def doubling_layer_3d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    nelem_y: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    center_z: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cartesian structured grid with doubling nelem_lat is the element number on the inner side

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
nelem_y Union[int, numpy.int32, numpy.int64] — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
min_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_z
max_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_z
center_z Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — center_z
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`doubling_layer_single_3d()`

def doubling_layer_single_3d(
    nelem_x: numpy.ndarray,
    nelem_y: numpy.ndarray,
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    move_nodes: bool = True,
    apply_mask: bool = True,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cartesian structured grid with doubling nelem_lat is the element number on the inner side

Parameters

nelem_x numpy.ndarray — nelem_x
nelem_y numpy.ndarray — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
min_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_z
max_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_z
move_nodes bool — move_nodes
apply_mask bool — apply_mask
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`mesh_block_collection()`

def mesh_block_collection(
    discontinuities: numpy.ndarray,
    hmax: numpy.ndarray,
    ndim: Union[int, numpy.int32, numpy.int64] = 2,
    horizontal_boundaries: Optional[
        Tuple[numpy.ndarray, numpy.ndarray]
    ] = None,
    hmax_refinement: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.5,
    refinement_style: str = "doubling",
    refinement_top_down: bool = True,
    return_info_dict: bool = False,
    max_nrefine: Optional[int, numpy.int32, numpy.int64] = None,
    hmax_horizontal: Optional[numpy.ndarray] = None,
) -> Union[
    salvus.mesh.mesh_block.mesh_block_collection.MeshBlockCollection,
    Tuple[
        salvus.mesh.mesh_block.mesh_block_collection.MeshBlockCollection, Dict
    ],
]:
    ...

Create a cartesian mesh, quads in 2D or Hex in 3D

Note: using normalized coordinates here

Parameters

discontinuities numpy.ndarray — discontinuities to be respected by the mesh including top and bottom. Z is positive upwards, discontinuities should be sorted from bottom to to top.
hmax numpy.ndarray — maximum elementsize between the discontinuities. Needs to be provided for all layers. array of floats, length = len(discontinuities) - 1
ndim Union[int, numpy.int32, numpy.int64] — number of space dimensions
horizontal_boundaries Optional[Tuple[numpy.ndarray, numpy.ndarray]] — horizontal boundaries of the domain, defaults to [0, 1]. tuple of two numpy float arrays with shape (ndim)
hmax_refinement Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — criterion (radial oversamping factor) for moving doubling_layers inwards to avoid small timestep. Smaller values = more aggressive.
refinement_style str — refinement style to use, choices: “doubling”, “tripling” and for 3D also “doubling_single_layer”
refinement_top_down bool — top down approach means minimizing number of elements at the surface at the cost of more elements at the bottom (default). If False, bottom up approach is used, that is minimizing number of elements at the bottom at the cost of more elements at the surface. Which one is more efficient depends on the velocity model and refinement style.
return_info_dict bool — return_info_dict
max_nrefine Optional[int, numpy.int32, numpy.int64] — maximum number of refinement layers to be used
hmax_horizontal Optional[numpy.ndarray] — hmax_horizontal

Returns Union[salvus.mesh.mesh_block.mesh_block_collection.MeshBlockCollection, Tuple[salvus.mesh.mesh_block.mesh_block_collection.MeshBlockCollection, Dict]]

`rectangle_2d()`

def rectangle_2d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    nelem_y: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    elem_locations_horizontal: Optional[List[numpy.ndarray]] = None,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple rectangular structured grid

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — Points in the x dimension.
nelem_y Union[int, numpy.int32, numpy.int64] — Points in the y dimension.
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — X coordinate of the first point.
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — X coordinate of the last point.
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — Y coordinates of the first point.
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — Y Coordinate of the last point.
elem_locations_horizontal Optional[List[numpy.ndarray]] — Ensure that the horizontal element boundaries exist at these list of coordinate values. Length of this array must equal 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`rectangle_vertical_refine_2d()`

def rectangle_vertical_refine_2d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    nelem_y: numpy.ndarray,
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    p1: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.6,
    p2: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.8,
    elem_locations_horizontal: Optional[List[numpy.ndarray]] = None,
    preprocess_nelem_y: bool = True,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Generate a rectangular mesh grid with localized vertical refinements.

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
nelem_y numpy.ndarray — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
p1 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p1
p2 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p2
elem_locations_horizontal Optional[List[numpy.ndarray]] — Ensure that the horizontal element boundaries exist at these list of coordinate values. Length of this array must equal 1, and the length of the single entry must equal nelem_x.
preprocess_nelem_y bool — Preprocess the number of elements.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`rectangle_vertical_refine_doubling_2d()`

def rectangle_vertical_refine_doubling_2d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    nelem_y: numpy.ndarray,
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    p1: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.65,
    p2: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.8,
    elem_locations_horizontal: Optional[
        List[
            Union[
                Sequence[Sequence[Sequence[Sequence[Sequence[Any]]]]],
                numpy._array_like._SupportsArray[numpy.dtype],
                Sequence[numpy._array_like._SupportsArray[numpy.dtype]],
                Sequence[
                    Sequence[numpy._array_like._SupportsArray[numpy.dtype]]
                ],
                Sequence[
                    Sequence[
                        Sequence[numpy._array_like._SupportsArray[numpy.dtype]]
                    ]
                ],
                Sequence[
                    Sequence[
                        Sequence[
                            Sequence[
                                numpy._array_like._SupportsArray[numpy.dtype]
                            ]
                        ]
                    ]
                ],
                bool,
                int,
                float,
                complex,
                str,
                bytes,
                Sequence[Union[bool, int, float, complex, str, bytes]],
                Sequence[
                    Sequence[Union[bool, int, float, complex, str, bytes]]
                ],
                Sequence[
                    Sequence[
                        Sequence[Union[bool, int, float, complex, str, bytes]]
                    ]
                ],
                Sequence[
                    Sequence[
                        Sequence[
                            Sequence[
                                Union[bool, int, float, complex, str, bytes]
                            ]
                        ]
                    ]
                ],
            ]
        ]
    ] = None,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a rectangular structured grid with localized vertical refinements

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
nelem_y numpy.ndarray — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
p1 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p1
p2 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p2
elem_locations_horizontal Optional[List[Union[Sequence[Sequence[Sequence[Sequence[Sequence[Any]]]]], numpy._array_like._SupportsArray[numpy.dtype], Sequence[numpy._array_like._SupportsArray[numpy.dtype]], Sequence[Sequence[numpy._array_like._SupportsArray[numpy.dtype]]], Sequence[Sequence[Sequence[numpy._array_like._SupportsArray[numpy.dtype]]]], Sequence[Sequence[Sequence[Sequence[numpy._array_like._SupportsArray[numpy.dtype]]]]], bool, int, float, complex, str, bytes, Sequence[Union[bool, int, float, complex, str, bytes]], Sequence[Sequence[Union[bool, int, float, complex, str, bytes]]], Sequence[Sequence[Sequence[Union[bool, int, float, complex, str, bytes]]]], Sequence[Sequence[Sequence[Sequence[Union[bool, int, float, complex, str, bytes]]]]]]]] — Ensure that the horizontal element boundaries exist at these list of coordinate values. Length of this array must equal 2, and the length of the entries must equal nelem_x and nelem_y respectively.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`rectangle_xy_2d()`

def rectangle_xy_2d(
    x: numpy.ndarray, y: numpy.ndarray
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Generate a rectangular mesh by specifying two one dimensional arrays denoting the x and y coordinates along each dimension.

The resulting mesh will have (len(x) - 1) * (len(y) - 1) elements

Parameters

x numpy.ndarray — Array with the x-coordinates.
y numpy.ndarray — Array with the y-coordinates.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`rectangle_y_2d()`

def rectangle_y_2d(
    y: numpy.ndarray,
    nelem_x: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple rectangular structured grid

Parameters

y numpy.ndarray — y
nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`tripling_layer_2d()`

def tripling_layer_2d(
    nelem_x: Union[int, numpy.int32, numpy.int64],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Generate a cartesian mesh grid with tripling.

Parameters

nelem_x Union[int, numpy.int32, numpy.int64] — nelem_x
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`tripling_layer_3d()`

def tripling_layer_3d(
    nelem_x: Union[int, numpy.int32, numpy.int64, numpy.ndarray],
    nelem_y: Union[int, numpy.int32, numpy.int64, numpy.ndarray],
    min_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_x: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_y: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    min_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_z: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cartesian structured grid with tripling nelem_lat is the element number on the inner side

Parameters

nelem_x Union[int, numpy.int32, numpy.int64, numpy.ndarray] — nelem_x
nelem_y Union[int, numpy.int32, numpy.int64, numpy.ndarray] — nelem_y
min_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_x
max_x Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_x
min_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_y
max_y Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_y
min_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_z
max_z Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_z
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock