unstructuredMesh.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "Kokkos_Sort.hpp"
 
#include "NeoN/core/dictionary.hpp"
#include "NeoN/core/parallelAlgorithms.hpp"
#include "NeoN/core/vector/vectorTypeDefs.hpp"
#include "NeoN/mesh/unstructured/boundaryMesh.hpp"
#include "NeoN/core/primitives/label.hpp"
 
namespace NeoN
{

class UnstructuredMesh
{
public:

    UnstructuredMesh(
        Executor exec,
        vectorVector points,
        scalarVector cellVolumes,
        vectorVector cellCenters,
        vectorVector faceNormals,
        vectorVector faceCenters,
        scalarVector faceAreas,
        labelVector faceOwners,
        labelVector faceNeighbors,
        BoundaryMesh boundaryMesh
    );

    UnstructuredMesh(
        vectorVector points,
        scalarVector cellVolumes,
        vectorVector cellCenters,
        vectorVector faceNormals,
        vectorVector faceCenters,
        scalarVector faceAreas,
        labelVector faceOwners,
        labelVector faceNeighbors,
        BoundaryMesh boundaryMesh
    );

    const vectorVector& points() const { return points_; }
    vectorVector& points() { return points_; }

    const scalarVector& cellVolumes() const { return cellVolumes_; }
    scalarVector& cellVolumes() { return cellVolumes_; }

    const vectorVector& cellCenters() const { return cellCenters_; }
    vectorVector& cellCenters() { return cellCenters_; }

    const vectorVector& faceCenters() const { return faceCenters_; }
    vectorVector& faceCenters() { return faceCenters_; }

    const vectorVector& faceNormals() const { return faceNormals_; }
    vectorVector& faceNormals() { return faceNormals_; }

    const scalarVector& faceAreas() const { return faceAreas_; }
    scalarVector& faceAreas() { return faceAreas_; }

    const labelVector& faceOwners() const { return faceOwners_; }
    labelVector& faceOwners() { return faceOwners_; }

    const labelVector& faceNeighbors() const { return faceNeighbors_; }
    labelVector& faceNeighbors() { return faceNeighbors_; }

    sizeType nCells() const { return nCells_; }

    sizeType nInternalFaces() const { return nInternalFaces_; }

    sizeType nBoundaryFaces() const { return boundaryMesh_.nBoundaryFaces(); }

    sizeType nTotalFaces() const
    {
        return nInternalFaces() + nBoundaryFaces() + nProcBoundaryFaces();
    }

    sizeType nBoundaries() const { return boundaryMesh_.nBoundaries(); }

    sizeType nProcBoundaryFaces() const { return boundaryMesh_.nProcBoundaryFaces(); }

    localIdx globalOffset() const { return globalOffset_; }

    const BoundaryMesh& boundaryMesh() const { return boundaryMesh_; }
    BoundaryMesh& boundaryMesh() { return boundaryMesh_; }

    Dictionary& stencilDB() const { return stencilDataBase_; }

    const Executor& exec() const { return exec_; }
 
private:

    const Executor exec_;

    vectorVector points_;

    scalarVector cellVolumes_;

    vectorVector cellCenters_;

    vectorVector faceNormals_;

    vectorVector faceCenters_;

    scalarVector faceAreas_;

    labelVector faceOwners_;

    labelVector faceNeighbors_;

    sizeType nCells_;

    sizeType nInternalFaces_;

    BoundaryMesh boundaryMesh_;
 
    //
    localIdx globalOffset_;

    mutable Dictionary stencilDataBase_;
};

UnstructuredMesh createSingleCellMesh(const Executor exec);

UnstructuredMesh create1DUniformMesh(const Executor exec, const localIdx nCells, scalar lx = 1.0);

UnstructuredMesh create2DUniformMesh(
    const Executor exec, localIdx nx, localIdx ny, scalar lx = 1.0, scalar ly = 1.0
);

UnstructuredMesh create3DUniformMesh(
    const Executor exec,
    localIdx nx,
    localIdx ny,
    localIdx nz,
    scalar lx = 1.0,
    scalar ly = 1.0,
    scalar lz = 1.0
);
 
 
#ifdef NF_WITH_MPI_SUPPORT
UnstructuredMesh create1DUniformMeshPart(const Executor exec, const localIdx nCells);

UnstructuredMesh create2DUniformMeshPart(
    const Executor exec, const localIdx nCells, const localIdx totalRanks, const localIdx rank
);

UnstructuredMesh create2DUniformMeshPartX(
    const Executor exec, const localIdx nCells, const localIdx totalRanks, const localIdx rank
);
#endif
 
} // namespace NeoN