ManifoldMeshes

AbstractManifoldMesh{M <: AbstractManifold}

Abstract supertype for all mesh types on a manifold M.

Every concrete subtype must implement the full mesh interface: grid properties (manifold, num_cells, num_nodes, num_edges), geometry queries (node_coordinates, cell_volume, cell_centroid), topology queries (cell_nodes, cell_cells, node_cells, cell_edges), edge information (edge_length, edge_midpoint, edge_outward_normal), and boundary markers (boundary_nodes, boundary_edges).

Cell, node, and edge IDs are 1-indexed integers.

_build_edge_endpoint_map(g::AbstractManifoldMesh) -> Dict{Int, Tuple{Int,Int}}

Reconstruct edge-to-endpoint-node mapping from the public cell interface. For each cell, edges are ordered (south, north, west, east) and nodes are ordered (SW, SE, NE, NW), giving:

• south edge: SW -> SE (nodes 1-2)
• north edge: NW -> NE (nodes 4-3)
• west edge: SW -> NW (nodes 1-4)
• east edge: SE -> NE (nodes 2-3)

boundary_edges(g, marker) -> Vector{Int}

Edge IDs on the boundary with the given marker. Returns empty for closed manifolds (e.g., full sphere).

boundary_nodes(g, marker) -> Vector{Int}

Node IDs on the boundary with the given marker. Returns empty for closed manifolds (e.g., full sphere).

cell_cells(g, cell_id) -> NTuple{K, Int}

Cell IDs of cells sharing a face with cell_id. Uses 0 as sentinel for missing neighbors (e.g., at domain boundaries). For quadrilateral cells, returns (south, north, west, east).

cell_centroid(g, cell_id) -> SVector{D, Float64}

Centroid of cell cell_id on the manifold, pre-computed at construction.

cell_edges(g, cell_id) -> NTuple{K, Int}

Edge IDs of the edges bounding cell cell_id. For quadrilateral cells, returns (south, north, west, east).

cell_nodes(g, cell_id) -> NTuple{K, Int}

Node IDs at the corners of cell cell_id. Tuple length depends on cell type. For quadrilateral cells, returns (SW, SE, NE, NW).

cell_polygons(g::AbstractManifoldMesh; n_arc_points::Int=20) -> Vector{Vector{Point3f}}

Return closed cell boundaries as discretized great-circle polygons. Each polygon is a vector of Point3f where the first point equals the last. Edges are ordered: south, east, north (reversed), west (reversed).

cell_volume(g, cell_id) -> Float64

Volume (area on 2D manifolds) of cell cell_id, pre-computed at construction.

edge_length(g, edge_id) -> Float64

Geodesic arc length of edge edge_id on the manifold.

edge_midpoint(g, edge_id) -> SVector{D, Float64}

Geodesic midpoint of edge edge_id on the manifold. For degenerate (zero-length) edges, returns one of the endpoints.

edge_outward_normal(g, edge_id, cell_id) -> NamedTuple{(:base_point, :normal)}

Outward-pointing unit normal at the midpoint of edge_id, relative to cell_id.

Returns (base_point, normal) where:

• base_point is the midpoint on the manifold (tangent space origin)
• normal is the unit normal vector in the tangent space at base_point

For degenerate edges (zero length), returns a zero normal.

edge_segments(g::AbstractManifoldMesh; n_arc_points::Int=20) -> Vector{Vector{Point3f}}

Return discretized great-circle arcs for each edge, as a vector of Point3f arrays. Degenerate edges (coincident endpoints) return a single-point segment.

manifold(g) -> AbstractManifold

Returns the underlying manifold on which the mesh is defined.

node_cells(g, node_id) -> Vector{Int}

Cell IDs of all cells adjacent to node_id.

Note: Allocates a Vector{Int} per call. Not recommended for tight FVM loops. Future unstructured meshes should consider a CSR layout for allocation-free access.

node_coordinates(g, node_id) -> SVector{D, Float64}

Cartesian coordinates of node node_id in the embedding space.

node_points(g::AbstractManifoldMesh) -> Vector{Point3f}

Return all node positions as Point3f values, indexed by node ID.

num_cells(g) -> Int

Total number of cells in the mesh.

num_edges(g) -> Int

Total number of edges in the mesh.

num_nodes(g) -> Int

Total number of nodes (vertices) in the mesh.

slerp(p1::SVector{3,Float64}, p2::SVector{3,Float64}, n::Int) -> Vector{Point3f}

Spherical linear interpolation between p1 and p2, producing n evenly spaced points on the great circle arc. For coincident endpoints (θ < 1e-10), returns a single-point vector. For antipodal endpoints (θ ≈ π), falls back to a stable intermediate great circle plane.