State.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 <map>
#include <memory>
 
#include "MeshKernel/Contacts.hpp"
#include "MeshKernel/CurvilinearGrid/CurvilinearGridFromSplines.hpp"
#include "MeshKernel/CurvilinearGrid/CurvilinearGridLineShift.hpp"
#include "MeshKernel/CurvilinearGrid/CurvilinearGridOrthogonalization.hpp"
#include "MeshKernel/CurvilinearGrid/CurvilinearGridSmoothing.hpp"
#include "MeshKernel/Mesh1D.hpp"
#include "MeshKernel/Mesh2D.hpp"
#include "MeshKernel/OrthogonalizationAndSmoothing.hpp"
 
#include "MeshKernelApi/ApiCache/CurvilinearBoundariesAsPolygonCache.hpp"
#include "MeshKernelApi/ApiCache/FacePolygonPropertyCache.hpp"
#include "MeshKernelApi/ApiCache/HangingEdgeCache.hpp"
#include "MeshKernelApi/ApiCache/NodeInPolygonCache.hpp"
#include "MeshKernelApi/ApiCache/ObtuseTriangleCentreCache.hpp"
#include "MeshKernelApi/ApiCache/PolygonRefinementCache.hpp"
#include "MeshKernelApi/ApiCache/SmallFlowEdgeCentreCache.hpp"
#include "MeshKernelApi/PropertyCalculator.hpp"
 
#include "ApiCache/MeshBoundariesAsPolygonCache.hpp"
 
namespace meshkernelapi
{
 
    struct MeshKernelState
    {
 
        MeshKernelState() = default;
 
        explicit MeshKernelState(meshkernel::Projection projection) : m_projection(projection)
        {
            m_mesh1d = std::make_shared<meshkernel::Mesh1D>(projection);
            m_mesh2d = std::make_shared<meshkernel::Mesh2D>(projection);
            m_network1d = std::make_shared<meshkernel::Network1D>(projection);
            m_contacts = std::make_shared<meshkernel::Contacts>(*m_mesh1d, *m_mesh2d);
            m_curvilinearGrid = std::make_shared<meshkernel::CurvilinearGrid>(projection);
            m_frozenLinesCounter = 0;
        }
        explicit MeshKernelState(meshkernel::Projection projection) : m_projection(projection) {…}
 
        // Geometrical entities instances
        std::shared_ptr<meshkernel::Mesh1D> m_mesh1d;                   
        std::shared_ptr<meshkernel::Network1D> m_network1d;             
        std::shared_ptr<meshkernel::Mesh2D> m_mesh2d;                   
        std::shared_ptr<meshkernel::Contacts> m_contacts;               
        std::shared_ptr<meshkernel::CurvilinearGrid> m_curvilinearGrid; 
 
        // Algorithms instances (interactivity)
        std::shared_ptr<meshkernel::OrthogonalizationAndSmoothing> m_meshOrthogonalization;                  
        std::shared_ptr<meshkernel::CurvilinearGridFromSplines> m_curvilinearGridFromSplines;                
        std::shared_ptr<meshkernel::CurvilinearGridLineShift> m_curvilinearGridLineShift;                    
        std::shared_ptr<meshkernel::CurvilinearGridOrthogonalization> m_curvilinearGridOrthogonalization;    
        std::map<int, std::shared_ptr<PropertyCalculator>> m_propertyCalculators;                            
        std::unordered_map<meshkernel::UInt, std::pair<meshkernel::Point, meshkernel::Point>> m_frozenLines; 
        meshkernel::UInt m_frozenLinesCounter = 0;                                                           
 
        // Exclusively owned state
        meshkernel::Projection m_projection{meshkernel::Projection::cartesian}; 
 
        // Cached values, used when dimensions are computed first, followed by values being retrieved in a separate call
        std::shared_ptr<FacePolygonPropertyCache> m_facePropertyCache;                   
        std::shared_ptr<CurvilinearBoundariesAsPolygonCache> m_boundariesAsPolygonCache; 
        std::shared_ptr<MeshBoundariesAsPolygonCache> m_meshBoundariesAsPolygonCache;    
        std::shared_ptr<PolygonRefinementCache> m_polygonRefinementCache;                
        std::shared_ptr<NodeInPolygonCache> m_nodeInPolygonCache;                        
        std::shared_ptr<SmallFlowEdgeCentreCache> m_smallFlowEdgeCentreCache;            
        std::shared_ptr<HangingEdgeCache> m_hangingEdgeCache;                            
        std::shared_ptr<ObtuseTriangleCentreCache> m_obtuseTriangleCentreCache;          
    };
    struct MeshKernelState {…};
 
} // namespace meshkernelapi