OrthogonalizationAndSmoothing.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 <MeshKernel/Definitions.hpp>
#include <MeshKernel/LandBoundaries.hpp>
#include <MeshKernel/Orthogonalizer.hpp>
#include <MeshKernel/Parameters.hpp>
#include <MeshKernel/Smoother.hpp>
#include <MeshKernel/UndoActions/UndoAction.hpp>
 
namespace meshkernel
{
    // Forward declare everything to reduce compile time dependency
    class Point;
    class Mesh2D;
    class Polygons;
    enum class Projection;
 
    class OrthogonalizationAndSmoothing
    {
 
    public:
        OrthogonalizationAndSmoothing(Mesh2D& mesh,
                                      std::unique_ptr<Polygons> polygon,
                                      std::unique_ptr<LandBoundaries> landBoundaries,
                                      LandBoundaries::ProjectToLandBoundaryOption projectToLandBoundaryOption,
                                      const OrthogonalizationParameters& orthogonalizationParameters);
 
        [[nodiscard]] std::unique_ptr<UndoAction> Initialize();
 
        void Compute();
 
        void PrepareOuterIteration();
 
        void Solve();
 
        void FinalizeOuterIteration();
 
    private:
        MeshNodeType GetNodeType(const UInt nodeId) const { return m_nodesTypes[nodeId]; }
 
        void FindNeighbouringBoundaryNodes(const UInt nodeId,
                                           const UInt nearestPointIndex,
                                           UInt& leftNode,
                                           UInt& rightNode) const;
 
        void SnapMeshToOriginalMeshBoundary();
 
        void ComputeLinearSystemTerms();
 
        void ComputeLocalIncrements(UInt nodeIndex,
                                    double& dx0,
                                    double& dy0,
                                    std::array<double, 2>& weightsSum);
 
        void UpdateNodeCoordinates(UInt nodeIndex);
 
        void AllocateLinearSystem();
 
        void ComputeCoordinates() const;
 
        std::vector<std::vector<UInt>> m_nodesNodes; 
        std::vector<MeshNodeType> m_nodesTypes;      
 
        Mesh2D& m_mesh;                                                            
        Smoother m_smoother;                                                       
        Orthogonalizer m_orthogonalizer;                                           
        std::unique_ptr<Polygons> m_polygons;                                      
        std::unique_ptr<LandBoundaries> m_landBoundaries;                          
        LandBoundaries::ProjectToLandBoundaryOption m_projectToLandBoundaryOption; 
        OrthogonalizationParameters m_orthogonalizationParameters;                 
 
        std::vector<UInt> m_localCoordinatesIndices; 
        std::vector<Point> m_localCoordinates;       
        std::vector<Point> m_orthogonalCoordinates;  
        std::vector<Point> m_originalNodes;          
 
        // Linear system terms
        std::vector<UInt> m_compressedEndNodeIndex;   
        std::vector<UInt> m_compressedStartNodeIndex; 
        std::vector<double> m_compressedWeightX;      
        std::vector<double> m_compressedWeightY;      
        std::vector<double> m_compressedRhs;          
        std::vector<UInt> m_compressedNodesNodes;     
 
        // run-time parameters
        double m_mumax = 0.0; 
        double m_mu = 0.0;    
    };
    class OrthogonalizationAndSmoothing {…};
} // namespace meshkernel