Pre-processing

UNV2D_mesh(meshFile; scale=1, integer_type=Int32, float_type=Float64)

Read and convert 2D UNV mesh file into XCALibre.jl

Input

• meshFile – path to mesh file.

Optional arguments

• scale – used to scale mesh file e.g. scale=0.001 will convert mesh from mm to metres defaults to 1 i.e. no scaling

• integer_type - integer type of the mesh indices; Int64 is needed only when a mesh has more than 2^31 faces, face-node entries or matrix entries, and reading such a mesh as Int32 stops with an error saying so

• float_type - select interger type to use in the mesh (Float32 may be useful on GPU runs)

UNV3D_mesh(unv_mesh::String; scale::Real=1.0, integer_type::Type=Int32, float_type::Type=Float64) -> Mesh3

Constructs a Mesh3 object from a Universal (UNV) file format.

Arguments

• unv_mesh::String: The file path to the UNV mesh file.

Keyword Arguments

• scale::Real=1.0: A scaling factor applied to the nodal coordinates.
• integer_type::Type=Int32: The integer type used for topological indices and connectivity arrays; Int64 is needed only when a mesh has more than 2^31 faces, face-node entries or matrix entries, and reading such a mesh as Int32 stops with an error saying so.
• float_type::Type=Float64: The floating-point type used for coordinates and geometric properties.

Returns

• Mesh3: A fully constructed 3D mesh object containing nodes, cells, faces, boundaries, and populated geometric properties.

FOAM3D_mesh(mesh_file; scale=1, integer_type=Int32, float_type=Float64)

Read and convert 3D OpenFOAM mesh file into XCALibre.jl. Note that, at present, it is not recommended to run 2D cases using meshes imported using this function.

Input

• mesh_file – path to mesh file.

Optional arguments

• scale – used to scale mesh file e.g. scale=0.001 will convert mesh from mm to metres defaults to 1 i.e. no scaling

• integer_type - integer type of the mesh indices; Int64 is needed only when a mesh has more than 2^31 faces, face-node entries or matrix entries, and reading such a mesh as Int32 stops with an error saying so

• float_type - select interger type to use in the mesh (Float32 may be useful on GPU runs)

struct Mesh3{VV, VTF, VR, VO, VI, VS, VB} <: AbstractMesh

3D unstructured mesh. Mesh2 has identical fields. Each cell, face and node property is stored as its own array; mesh.cells, mesh.faces and mesh.nodes return views that index as Cell, Face3D and Node elements. Boundary faces come first in the face arrays.

    cell_centre::VV      # cell centroid coordinates
    cell_volume::VTF     # cell volumes
    cell_nodes_range::VR # range of each cell's nodes in cell_nodes
    cell_faces_range::VR # range of each cell's faces in cell_faces, cell_neighbours, cell_nsign
    cell_nodes::VI       # node IDs of each cell
    cell_faces::VI       # internal face IDs of each cell
    cell_neighbours::VI  # neighbour cell IDs across each cell face
    cell_nsign::VS       # face normal sign per cell face (1 or -1)
    face_nodes_range::VR # range of each face's nodes in face_nodes
    face_ownerCells::VO  # owner cell ID pair of each face (equal on boundary faces)
    face_centre::VV      # face centre coordinates
    face_normal::VV      # face unit normals
    face_e::VV           # unit vectors between owner cell centres
    face_area::VTF       # face areas
    face_delta::VTF      # distance between owner cell centres (boundary: cell centre to nearest face point)
    face_weight::VTF     # linear interpolation weights
    face_nodes::VI       # node IDs of each face
    face_gDiff::VTF      # Laplacian face coefficient (derived, see `_gDiff`)
    boundaries::VB       # boundary patches
    node_coords::VV      # node coordinates
    node_cells_range::VR # range of each node's cells in node_cells
    node_cells::VI       # cell IDs around each node
    get_float::VTF       # one-element array tagging the mesh float type
    get_int::VI          # one-element array tagging the mesh integer type
    boundary_cellsID::VI # owner cell ID of each boundary face
    boundary_cells::VI   # owner cells of boundary faces, each once (derived)
    boundary_cell_faces_range::VR # range of each boundary cell's faces in boundary_cell_faces
    boundary_cell_faces::VI # boundary face IDs grouped by owner cell, ascending within a cell

Kernels that add boundary-face contributions to cells loop over boundary_cells and, for each, over its faces in boundary_cell_faces, so every cell sums its faces in one fixed order: results do not depend on the thread count or the scheduling.

reorder_mesh!(mesh::Union{Mesh2,Mesh3}; method=:rcm) -> mesh

Reorder the cells, faces and nodes of a host mesh in place so that neighbouring cells sit close in memory. Cell loops read the values of each cell's neighbours, so meshes whose generator numbers cells without regard to adjacency (typical of unstructured tetrahedral meshes) run faster once reordered. Geometry, face orientation and boundary patches are unchanged; only the numbering differs. The extra memory is a few index vectors of the mesh's integer type and one buffer the size of the largest connectivity list.

• method=:rcm: reverse Cuthill-McKee ordering of the cell graph (bounded index distance between neighbours).
• method=:morton: Z-order curve of the cell centres (compact groups of consecutive cells).

Internal faces follow their lowest-numbered cell, boundary faces their owner cell within each patch, and nodes the order in which the cells first reach them. The mesh is left unchanged unless the new order shortens the mean index distance between neighbouring cells by at least 10%.

Only the mesh in memory changes; mesh files are not touched. Fields built on the reordered mesh, and results written from them, are in the new order: VTK output carries the mesh in every file, and OpenFOAM output replaces a constant/polyMesh numbered differently before writing any field (in a distributed run, distribute and partition_mesh do this when they partition the mesh). Serial meshes only; call before adapt, and before distribute or partition_mesh to reorder a mesh for a distributed run.

Example

mesh = reorder_mesh!(UNV3D_mesh("mesh.unv", scale=0.001))

hardware = Hardware(backend, workgroup)

Struct used to configure the backend.

Inputs

• backend: used to specify the backend e.g. CPU(), CUDABackend() or other backends supported by KernelAbstraction.jl
• workgroup::Int this is an integer specifying the number of workers that cooperate in a parallel run. For GPUs this could be set to the size of the device's warp e.g. workgroup = 32. On CPUs, the default value in KernelAbstractions.jl is currently workgroup = 1024.

Output

This function returns a Hardware object with the fields backend and workgroup which are accessed by internally in XCALibre.jl to execute a given kernel in the target backend.