CasulliRefinement.hpp

//---- GPL ---------------------------------------------------------------------
//
// Copyright (C)  Stichting Deltares, 2011-2021.
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation version 3.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
// contact: delft3d.support@deltares.nl
// Stichting Deltares
// P.O. Box 177
// 2600 MH Delft, The Netherlands
//
// All indications and logos of, and references to, "Delft3D" and "Deltares"
// are registered trademarks of Stichting Deltares, and remain the property of
// Stichting Deltares. All rights reserved.
//
//------------------------------------------------------------------------------
 
#pragma once
 
#include <array>
#include <memory>
#include <vector>
 
#include "MeshKernel/Mesh2D.hpp"
#include "MeshKernel/Parameters.hpp"
#include "MeshKernel/Polygons.hpp"
#include "MeshKernel/SampleInterpolator.hpp"
#include "MeshKernel/UndoActions/UndoAction.hpp"
 
namespace meshkernel
{
    class CasulliRefinement
    {
    public:
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> Compute(Mesh2D& mesh);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> Compute(Mesh2D& mesh, const Polygons& polygon);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> Compute(Mesh2D& mesh,
                                                                             const Polygons& polygon,
                                                                             const std::vector<double>& depthValues,
                                                                             const MeshRefinementParameters& refinementParameters,
                                                                             const double minimumDepthRefinement);
 
        [[nodiscard]] static std::unique_ptr<meshkernel::UndoAction> Compute(Mesh2D& mesh,
                                                                             const Polygons& polygon,
                                                                             const SampleInterpolator& interpolator,
                                                                             const int propertyId,
                                                                             const MeshRefinementParameters& refinementParameters,
                                                                             const double minimumDepthRefinement);
 
    private:
        enum class NodeMask : char
        {
            NewAssignedNode, //< a new node has been added, current node mask value is any value strictly greater than Unassigned.
            NewGeneralNode,  //< a new node has been added, current node mask value is any assigned value
            Unassigned,      //< Uninitialised state for node mask
            RegisteredNode,  //< Node is to be considered as part of the Casulli refinement
            BoundaryNode,    //< Node lies on the boundary
            CornerNode       //< Node lies at corner of element on the boundary.
        };
 
        static constexpr UInt InitialEdgeArraySize = 100;
 
        static constexpr UInt MaximumNumberOfNodesInNewlyCreatedElements = 4;
 
        using EdgeNodes = std::array<UInt, 4>;
 
        static void InitialiseBoundaryNodes(const Mesh2D& mesh, std::vector<NodeMask>& nodeMask);
 
        static void InitialiseCornerNodes(const Mesh2D& mesh, std::vector<NodeMask>& nodeMask);
 
        static void InitialiseFaceNodes(const Mesh2D& mesh, std::vector<NodeMask>& nodeMask);
 
        static void RegisterNodesInsidePolygon(const Mesh2D& mesh,
                                               const Polygons& polygon,
                                               std::vector<NodeMask>& nodeMask);
 
        static std::vector<NodeMask> InitialiseNodeMask(const Mesh2D& mesh, const Polygons& polygon);
 
        static std::vector<NodeMask> InitialiseDepthBasedNodeMask(const Mesh2D& mesh,
                                                                  const Polygons& polygon,
                                                                  const std::vector<double>& depthValues,
                                                                  const MeshRefinementParameters& refinementParameters,
                                                                  const double minimumDepthRefinement,
                                                                  bool& refinementRequested);
 
        static void RefineNodeMaskBasedOnDepths(const Mesh2D& mesh,
                                                const std::vector<double>& depthValues,
                                                const MeshRefinementParameters& refinementParameters,
                                                const double minimumDepthRefinement,
                                                std::vector<NodeMask>& nodeMask,
                                                bool& refinementRequested);
 
        static void ComputeNewNodes(Mesh2D& mesh, std::vector<EdgeNodes>& newNodes, std::vector<NodeMask>& nodeMask);
 
        static void ConnectNodes(Mesh2D& mesh, const std::vector<EdgeNodes>& newNodes, const UInt numEdges);
 
        static std::vector<UInt> GetNodesToConnect(const Mesh2D& mesh,
                                                   const std::vector<NodeMask>& nodeMask,
                                                   const std::vector<UInt>& newEdges,
                                                   const std::vector<EdgeNodes>& newNodes,
                                                   const UInt edgeCount,
                                                   const UInt nodeIndex);
 
        static void ConnectNodes(Mesh2D& mesh,
                                 const NodeMask nodeMask,
                                 const std::vector<UInt>& nodesToConnect,
                                 const UInt edgeCount,
                                 const UInt nodeIndex);
 
        static void CreateMissingBoundaryEdges(Mesh2D& mesh, const UInt numNodes, const std::vector<EdgeNodes>& newNodes, std::vector<NodeMask>& nodeMask);
 
        static void ComputeNewFaceNodes(Mesh2D& mesh, std::vector<EdgeNodes>& newNodes, std::vector<NodeMask>& nodeMask);
 
        static void ComputeNewEdgeNodes(Mesh2D& mesh, const UInt numEdges, std::vector<EdgeNodes>& newNodes, std::vector<NodeMask>& nodeMask);
 
        static void ConnectEdges(Mesh2D& mesh,
                                 const UInt currentNode,
                                 const std::vector<EdgeNodes>& newNodes,
                                 UInt& edgeCount,
                                 std::vector<UInt>& newEdges);
 
        static void ConnectFaceNodes(Mesh2D& mesh,
                                     const UInt currentFace,
                                     const std::vector<EdgeNodes>& newNodes,
                                     std::vector<NodeMask>& nodeMask);
 
        static void ConnectNewNodes(Mesh2D& mesh, const std::vector<EdgeNodes>& newNodes, const UInt numNodes, const UInt numEdges, const UInt numFaces, std::vector<NodeMask>& nodeMask);
 
        static void StoreNewNode(const Mesh2D& mesh, const UInt nodeId, const UInt edge1Index, const UInt edge2Index, const UInt newNodeId, std::vector<EdgeNodes>& newNodes);
 
        static void FindPatchIds(const Mesh2D& mesh,
                                 const UInt currentNode,
                                 std::vector<UInt>& sharedFaces,
                                 std::vector<UInt>& connectedNodes,
                                 std::vector<std::vector<UInt>>& faceNodeMapping);
 
        static void Administrate(Mesh2D& mesh, const UInt numNodes, const std::vector<NodeMask>& nodeMask);
    };
    class CasulliRefinement {…};
 
} // namespace meshkernel