boundaryMesh.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <vector>
 
#include "NeoN/core/primitives/label.hpp"
#include "NeoN/core/vector/vectorTypeDefs.hpp"
 
namespace NeoN
{
 
class BoundaryMesh
{
public:
 
    void validate() const;
 
    BoundaryMesh(
        const Executor& exec,
        labelVector faceOwners,
        vectorVector faceCenters,
        vectorVector ownerCellCenters,
        vectorVector faceNormals,
        scalarVector faceAreas,
        vectorVector faceUnitNormals,
        vectorVector delta,
        scalarVector weights,
        scalarVector deltaCoeffs,
        std::vector<localIdx> offset,
        localIdx procBoundaryPatches,
        std::vector<localIdx> neighbourRank
    );
 
 
    const labelVector& faceOwners() const;
 
    // TODO either dont mix return types, ie dont use view and Vector
    // for functions with same name
    View<const label> faceOwners(const localIdx i) const;
 
    const vectorVector& faceCenters() const;
 
    View<const Vec3> faceCenters(const localIdx i) const;
 
    const vectorVector& ownerCellCenters() const;
 
    View<const Vec3> ownerCellCenters(const localIdx i) const;
 
    const vectorVector& faceNormals() const;
 
    View<const Vec3> faceNormals(const localIdx i) const;
 
    const scalarVector& faceAreas() const;
 
    View<const scalar> faceAreas(const localIdx i) const;
 
    const vectorVector& faceUnitNormals() const;
 
    View<const Vec3> faceUnitNormals(const localIdx i) const;
 
    const vectorVector& delta() const;
 
    View<const Vec3> delta(const localIdx i) const;
 
    const scalarVector& weights() const;
 
    View<const scalar> weights(const localIdx i) const;
 
    const scalarVector& deltaCoeffs() const;
 
    View<const scalar> deltaCoeffs(const localIdx i) const;
 
    localIdx neighbourRank(const localIdx i) const;
 
    // TODO consistent use of Vector on CPU
    const std::vector<localIdx>& offset() const;
 
    localIdx nProcBoundaryPatches() const;
 
    const std::vector<localIdx>& neighbourRank() const;
 
    localIdx neighbourRankForRange(std::pair<localIdx, localIdx> range) const;
 
    localIdx nBoundaries() const { return offset_.size() - 1; }
 
 
    const Vector<localIdx>& getRowOrderWriteIndex() const;
 
    const std::vector<localIdx>& getRowSortPerm() const;
 
    localIdx nBoundaryFaces() const { return faceOwners_.size() - nProcBoundaryFaces(); }
 
    localIdx nProcBoundaryFaces() const;
 
    bool isDistributed() const { return nProcBoundaryFaces() > 0; }
 
private:
 
    const Executor exec_;
 
    labelVector faceOwners_;
 
    vectorVector faceCenters_;
 
    vectorVector ownerCellCenters_;
 
    vectorVector faceNormals_;
 
    scalarVector faceAreas_;
 
    vectorVector faceUnitNormals_;
 
    vectorVector delta_;
 
    scalarVector weights_;
 
    scalarVector deltaCoeffs_;
 
    // TODO consistent use of Vector on CPU
    std::vector<localIdx> offset_;
 
    localIdx procBoundaryPatches_;
 
    std::vector<localIdx> neighbourRank_;
 
    Vector<localIdx> rowOrderWriteIndex_;
 
    std::vector<localIdx> rowSortPerm_;
 
    void computeRowOrderWriteIndex();
};
 
} // namespace NeoN