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

`salvus.mesh.mesh_block.generators.spherical`

Spherical mesh grid generators.

Functions

`axisem_tripling_layer_2d()`

def axisem_tripling_layer_2d(
    r_inner: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.0,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple spherical 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

r_inner Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_inner
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — element number on the inner side
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_colat
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_colat
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`central_sphere_2d()`

def central_sphere_2d(
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    full: bool = False,
    left: bool = False,
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

generate a central mesh of a quarter or half circle nelem_lat is the element number along the latitude for the half circle returns two structured grids

Parameters

r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — nelem_lat
full bool — full
left bool — left

Returns Tuple[salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock]

`central_sphere_3d()`

def central_sphere_3d(
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.0,
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

generate a hex mesh of a full sphere

nelem_lat is the element number along one side of the cubed sphere chunks

Parameters

nelem_lat Union[int, numpy.int32, numpy.int64] — nelem_lat
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer

Returns Tuple[salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock, salvus.mesh.mesh_block.mesh_block.MeshBlock]

`central_sphere_full_2d()`

def central_sphere_full_2d(
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
) -> Tuple[salvus.mesh.mesh_block.mesh_block.MeshBlock, ...]:
    ...

Parameters

r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — nelem_lat

Returns Tuple[salvus.mesh.mesh_block.mesh_block.MeshBlock, ...]

`cubed_sphere_3d_range()`

def cubed_sphere_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: int,
    nelem_rad: int,
    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,
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

Generate a layer of a cubed sphere from its radial bounds.

Parameters

r_inner float — The inner radius.
r_outer float — The outer radius.
nelem int — Number of elements along each side of the each constituent chunk.
nelem_rad int — nelem_rad.
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 1, and the length of the single entry must equal nelem_x.

`cubed_sphere_chunk_3d_range()`

def cubed_sphere_chunk_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: int,
    nelem_rad: int,
    nelem2: Optional[int] = None,
    max_angle: float = 45.0,
    max_angle2: Optional[float] = None,
    min_angle: Optional[float] = None,
    min_angle2: Optional[float] = None,
    chunk: Optional[int] = None,
    euler_angles: Optional[numpy.ndarray] = None,
    projection: str = "equiangular",
    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 chunk of the cubed sphere, using the radial bounds of the chunk.

Parameters

r_inner float — The inner radius.
r_outer float — The outer radius.
nelem int — nelem
nelem_rad int — nelem_rad.
nelem2 Optional[int] — nelem2
max_angle float — max_angle
max_angle2 Optional[float] — max_angle2
min_angle Optional[float] — min_angle
min_angle2 Optional[float] — min_angle2
chunk Optional[int] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
projection str — projection
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 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_doubling_layer_3d()`

def cubed_sphere_chunk_doubling_layer_3d(
    r: numpy.ndarray,
    nelem: Union[int, numpy.int32, numpy.int64],
    nelem2: Optional[int, numpy.int32, numpy.int64] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    chunk: Optional[int, numpy.int32, numpy.int64] = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    projection: str = "equiangular",
    full_globe: bool = False,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cubed sphere chunk structured grid with doubling nelem is the element number on the inner side

Parameters

r numpy.ndarray — r
nelem Union[int, numpy.int32, numpy.int64] — nelem
nelem2 Optional[int, numpy.int32, numpy.int64] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
chunk Optional[int, numpy.int32, numpy.int64] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
projection str — projection
full_globe bool — full_globe
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_doubling_layer_3d_range()`

def cubed_sphere_chunk_doubling_layer_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: int,
    nelem2: Optional[int] = None,
    max_angle: float = 45.0,
    max_angle2: Optional[float] = None,
    min_angle: Optional[float] = None,
    min_angle2: Optional[float] = None,
    chunk: int = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    projection: str = "equiangular",
    full_globe: bool = False,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cubed sphere chunk structured grid with doubling nelem is the element number on the inner side

Parameters

r_inner float — The inner radius.
r_outer float — The outer radius.
nelem int — nelem
nelem2 Optional[int] — nelem2
max_angle float — max_angle
max_angle2 Optional[float] — max_angle2
min_angle Optional[float] — min_angle
min_angle2 Optional[float] — min_angle2
chunk int — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
projection str — projection
full_globe bool — full_globe
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_doubling_layer_single_3d()`

def cubed_sphere_chunk_doubling_layer_single_3d(
    r: numpy.ndarray,
    nelem: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    chunk: Optional[int, numpy.int32, numpy.int64] = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    projection: str = "equiangular",
    full_globe: bool = False,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cubed sphere chunk structured grid with doubling in a single layer nelem is the element number on the inner side

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
nelem2 Optional[numpy.ndarray] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
chunk Optional[int, numpy.int32, numpy.int64] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
projection str — projection
full_globe bool — full_globe
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_r_3d()`

def cubed_sphere_chunk_r_3d(
    r: numpy.ndarray,
    nelem: Union[int, numpy.int32, numpy.int64],
    nelem2: Optional[int, numpy.int32, numpy.int64] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    chunk: Optional[int, numpy.int32, numpy.int64] = None,
    euler_angles: Optional[numpy.ndarray] = None,
    projection: str = "equiangular",
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a chunk of the cubed sphere

Parameters

r numpy.ndarray — r
nelem Union[int, numpy.int32, numpy.int64] — nelem
nelem2 Optional[int, numpy.int32, numpy.int64] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
chunk Optional[int, numpy.int32, numpy.int64] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
projection str — projection

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_tripling_layer_3d()`

def cubed_sphere_chunk_tripling_layer_3d(
    r: numpy.ndarray,
    nelem: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    chunk: Optional[int, numpy.int32, numpy.int64] = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    full_globe: bool = False,
    projection: str = "equiangular",
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a cubed sphere chunk structured grid with tripling in a single layer nelem is the element number on the inner side

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
nelem2 Optional[numpy.ndarray] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
chunk Optional[int, numpy.int32, numpy.int64] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
full_globe bool — full_globe
projection str — projection
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_vertical_refine_3d()`

def cubed_sphere_chunk_vertical_refine_3d(
    r: numpy.ndarray,
    nelem: numpy.ndarray,
    nelem_r: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    chunk: Union[int, numpy.int32, numpy.int64] = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    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,
    projection: str = "equiangular",
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
nelem_r numpy.ndarray — nelem_r
nelem2 Optional[numpy.ndarray] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
chunk Union[int, numpy.int32, numpy.int64] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
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
projection str — projection

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_vertical_refine_3d_range()`

def cubed_sphere_chunk_vertical_refine_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: numpy.ndarray,
    nelem_rad: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: float = 45.0,
    max_angle2: Optional[float] = None,
    min_angle: Optional[float] = None,
    min_angle2: Optional[float] = None,
    chunk: int = 5,
    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,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Parameters

r_inner float — r_inner
r_outer float — r_outer
nelem numpy.ndarray — nelem
nelem_rad numpy.ndarray — nelem_r
nelem2 Optional[numpy.ndarray] — nelem2
max_angle float — max_angle
max_angle2 Optional[float] — max_angle2
min_angle Optional[float] — min_angle
min_angle2 Optional[float] — min_angle2
chunk int — chunk
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 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_vertical_refine_doubling_3d()`

def cubed_sphere_chunk_vertical_refine_doubling_3d(
    r: numpy.ndarray,
    nelem: numpy.ndarray,
    nelem_r: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    chunk: Union[int, numpy.int32, numpy.int64] = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    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,
    projection: str = "equiangular",
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
nelem_r numpy.ndarray — nelem_r
nelem2 Optional[numpy.ndarray] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
chunk Union[int, numpy.int32, numpy.int64] — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
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
projection str — projection

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_chunk_vertical_refine_doubling_3d_range()`

def cubed_sphere_chunk_vertical_refine_doubling_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: numpy.ndarray,
    nelem_rad: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: float = 45.0,
    max_angle2: Optional[float] = None,
    min_angle: Optional[float] = None,
    min_angle2: Optional[float] = None,
    chunk: int = 5,
    euler_angles: Optional[numpy.ndarray] = None,
    dangling: float = 0.25,
    p1: float = 0.5,
    p2: float = 0.35714285714285715,
    p3: float = 0.6,
    preprocess_nelem_z: bool = True,
    projection: str = "equiangular",
    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:
    ...

Parameters

r_inner float — Inner radius.
r_outer float — Outer radius.
nelem numpy.ndarray — nelem
nelem_rad numpy.ndarray — nelem_r
nelem2 Optional[numpy.ndarray] — nelem2
max_angle float — max_angle
max_angle2 Optional[float] — max_angle2
min_angle Optional[float] — min_angle
min_angle2 Optional[float] — min_angle2
chunk int — chunk
euler_angles Optional[numpy.ndarray] — euler_angles
dangling float — dangling
p1 float — p1
p2 float — p2
p3 float — p3
preprocess_nelem_z bool — preprocess_nelem_z
projection str — projection
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 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`cubed_sphere_doubling_layer_3d()`

def cubed_sphere_doubling_layer_3d(
    r: numpy.ndarray,
    nelem: Union[int, numpy.int32, numpy.int64],
    flip_vertical: bool = False,
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

generate a cubed sphere structured grid with doubling nelem is the element number on the inner side

Parameters

r numpy.ndarray — r
nelem Union[int, numpy.int32, numpy.int64] — nelem
flip_vertical bool — flip_vertical

`cubed_sphere_doubling_layer_3d_range()`

def cubed_sphere_doubling_layer_3d_range(
    r_inner: float, r_outer: float, nelem: int, flip_vertical: bool = False
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

A cubed sphere chunk with doubling using the chunk’s radial bounds.

Parameters

r_inner float — The inner radius.
r_outer float — The outer radius.
nelem int — Number of elements on the coarse side of the doubling layer.
flip_vertical bool — flip_vertical

`cubed_sphere_r_3d()`

def cubed_sphere_r_3d(
    r: numpy.ndarray, nelem: Union[int, numpy.int32, numpy.int64]
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

generate a layer of the cubed sphere

Parameters

r numpy.ndarray — r
nelem Union[int, numpy.int32, numpy.int64] — nelem

`cubed_sphere_tripling_layer_3d()`

def cubed_sphere_tripling_layer_3d(
    r: numpy.ndarray, nelem: numpy.ndarray, flip_vertical: bool = False
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

generate a cubed sphere structured grid with tripling in a single layer nelem is the element number on the inner side

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
flip_vertical bool — flip_vertical

`cubed_sphere_vertical_refine_3d()`

def cubed_sphere_vertical_refine_3d(
    r: numpy.ndarray,
    nelem: numpy.ndarray,
    nelem_r: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    euler_angles: Optional[numpy.ndarray] = None,
    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,
    projection: str = "equiangular",
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
nelem_r numpy.ndarray — nelem_r
nelem2 Optional[numpy.ndarray] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
euler_angles Optional[numpy.ndarray] — euler_angles
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
projection str — projection

`cubed_sphere_vertical_refine_3d_range()`

def cubed_sphere_vertical_refine_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: numpy.ndarray,
    nelem_rad: numpy.ndarray,
    dangling: float = 0.25,
    p1: float = 0.5,
    p2: float = 0.35714285714285715,
    projection: str = "equiangular",
    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,
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

Parameters

r_inner float — r_inner
r_outer float — r_outer
nelem numpy.ndarray — nelem
nelem_rad numpy.ndarray — nelem_rad
dangling float — dangling
p1 float — p1
p2 float — p2
projection str — projection
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 1, and the length of the single entry must equal nelem_x.

`cubed_sphere_vertical_refine_doubling_3d()`

def cubed_sphere_vertical_refine_doubling_3d(
    r: numpy.ndarray,
    nelem: numpy.ndarray,
    nelem_r: numpy.ndarray,
    nelem2: Optional[numpy.ndarray] = None,
    max_angle: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 45.0,
    max_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    min_angle2: Optional[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = None,
    euler_angles: Optional[numpy.ndarray] = None,
    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,
    projection: str = "equiangular",
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

Parameters

r numpy.ndarray — r
nelem numpy.ndarray — nelem
nelem_r numpy.ndarray — nelem_r
nelem2 Optional[numpy.ndarray] — nelem2
max_angle Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle
max_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_angle2
min_angle Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle
min_angle2 Optional[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_angle2
euler_angles Optional[numpy.ndarray] — euler_angles
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
projection str — projection

`cubed_sphere_vertical_refine_doubling_3d_range()`

def cubed_sphere_vertical_refine_doubling_3d_range(
    r_inner: float,
    r_outer: float,
    nelem: numpy.ndarray,
    nelem_rad: numpy.ndarray,
    dangling: float = 0.25,
    p1: float = 0.5,
    p2: float = 0.35714285714285715,
    projection: str = "equiangular",
    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,
) -> Tuple[
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
    salvus.mesh.mesh_block.mesh_block.MeshBlock,
]:
    ...

Parameters

r_inner float — r_inner
r_outer float — r_outer
nelem numpy.ndarray — nelem
nelem_rad numpy.ndarray — nelem_rad
dangling float — dangling
p1 float — p1
p2 float — p2
projection str — projection
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 1, and the length of the single entry must equal nelem_x.

`doubling_layer_2d()`

def doubling_layer_2d(
    r_inner: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.0,
    p1: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.5,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple spherical structured grid

Parameters

r_inner Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_inner
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — element number on the inner side
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_colat
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_colat
p1 Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — p1
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,
    max_colat: Optional[numpy.ndarray] = None,
    min_colat: Optional[numpy.ndarray] = None,
    full_sphere: bool = False,
    inner_core: bool = False,
    axisem: bool = False,
    hmax_refinement: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 1.5,
    refinement_style: str = "doubling",
    refinement_top_down: bool = True,
    exclude_top_n_regions: Union[int, numpy.int32, numpy.int64] = 0,
    return_info_dict: bool = False,
    nelem_bottom_integer_multiple: Optional[
        int, numpy.int32, numpy.int64
    ] = None,
    nelem_vertical: Optional[numpy.ndarray] = None,
    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 or spherical 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 the surface (1.) and the center (0.)
hmax numpy.ndarray — maximum elementsize between the discontinuities. Needs to be provided for all layers (including the center, even if it is not meshed .length = len(discontinuities) - 1
ndim Union[int, numpy.int32, numpy.int64] — number of space dimensions
max_colat Optional[numpy.ndarray] — max_colat
min_colat Optional[numpy.ndarray] — min_colat
full_sphere bool — make a full sphere (overwrites max_colat)
inner_core bool — include the inner core (only for full_sphere true)
axisem bool — axisem
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”, and “tripling” foe 2D, “doubling” only for 3D
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. Bottom up likely won’t work without inner core.
exclude_top_n_regions Union[int, numpy.int32, numpy.int64] — design the mesh as usual but do not leave out the first n regions from the top. Meant to enable vertical refinements in the shallow layers
return_info_dict bool — return_info_dict
nelem_bottom_integer_multiple Optional[int, numpy.int32, numpy.int64] — nelem_bottom_integer_multiple
nelem_vertical Optional[numpy.ndarray] — optionally provide the number of elements in vertical direction for all layers and override hmax for the vertical. length = len(discontinuities) - 1.
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]]

`shell_2d()`

def shell_2d(
    r_inner: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    nelem_rad: Union[int, numpy.int32, numpy.int64],
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.0,
    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 2-D spherical shell mesh grid.

Parameters

r_inner Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — Minimum radius.
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — Maximum radius.
nelem_lat Union[int, numpy.int32, numpy.int64] — Number of points in the angular direction.
nelem_rad Union[int, numpy.int32, numpy.int64] — Number of points in the radial direction.
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — Minimum angle/co-latitude.
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — Maximum angle/co-latitude.
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 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`shell_radii_2d()`

def shell_radii_2d(
    radius: numpy.ndarray,
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.0,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple spherical structured grid with uneven radial spacing

Parameters

radius numpy.ndarray — radius
nelem_lat Union[int, numpy.int32, numpy.int64] — nelem_lat
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_colat
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_colat

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`shell_vertical_refine_2d()`

def shell_vertical_refine_2d(
    r_inner: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    nelem_rad: numpy.ndarray,
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.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[
            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:
    ...

Parameters

r_inner Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_inner
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — nelem_lat
nelem_rad numpy.ndarray — nelem_rad
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_colat
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_colat
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 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`shell_vertical_refine_doubling_2d()`

def shell_vertical_refine_doubling_2d(
    r_inner: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    nelem_rad: numpy.ndarray,
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.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:
    ...

Parameters

r_inner Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_inner
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — nelem_lat
nelem_rad numpy.ndarray — nelem_rad
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_colat
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_colat
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 1, and the length of the single entry must equal nelem_x.

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock

`tripling_layer_2d()`

def tripling_layer_2d(
    r_inner: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    r_outer: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ],
    nelem_lat: Union[int, numpy.int32, numpy.int64],
    min_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 0.0,
    max_colat: Union[
        int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64
    ] = 180.0,
    flip_vertical: bool = False,
) -> salvus.mesh.mesh_block.mesh_block.MeshBlock:
    ...

generate a simple spherical structured grid

Parameters

r_inner Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_inner
r_outer Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — r_outer
nelem_lat Union[int, numpy.int32, numpy.int64] — element number on the inner side
min_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — min_colat
max_colat Union[int, numpy.int32, numpy.int64, float, numpy.float32, numpy.float64] — max_colat
flip_vertical bool — flip_vertical

Returns salvus.mesh.mesh_block.mesh_block.MeshBlock