Parameters.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/RangeCheck.hpp"
 
namespace meshkernel
{
    struct MakeGridParameters
    {
        int num_columns = 3;
 
        int num_rows = 3;
 
        double angle = 0.0;
 
        double origin_x = 0.0;
 
        double origin_y = 0.0;
 
        double block_size_x = 10.0;
 
        double block_size_y = 10.0;
 
        double upper_right_x = 0.0;
 
        double upper_right_y = 0.0;
 
        double radius_curvature = 0.0;
 
        double uniform_columns_fraction = 0.25;
 
        double uniform_rows_fraction = 0.25;
 
        double maximum_uniform_size_columns = 5.0;
 
        double maximum_uniform_size_rows = 5.0;
    };
    struct MakeGridParameters {…};
 
    inline static void CheckMakeGridParameters(MakeGridParameters const& parameters)
    {
        range_check::CheckGreater(parameters.num_columns, 0, "Number of columns");
        range_check::CheckGreater(parameters.num_rows, 0, "Number of rows");
        range_check::CheckInClosedInterval(parameters.angle, {-90.0, 90.0}, "Grid angle");
        range_check::CheckGreater(parameters.block_size_x, 0.0, "X block size");
        range_check::CheckGreater(parameters.block_size_y, 0.0, "Y block size");
        range_check::CheckGreaterEqual(parameters.radius_curvature, 0.0, "Radius of curvature");
        range_check::CheckGreaterEqual(parameters.uniform_columns_fraction, 0.0, "Uniform m-fraction");
        range_check::CheckGreaterEqual(parameters.uniform_rows_fraction, 0.0, "Uniform n-fraction");
        range_check::CheckGreaterEqual(parameters.maximum_uniform_size_columns, 0.0, "Maximum size / delta-x");
        range_check::CheckGreaterEqual(parameters.maximum_uniform_size_rows, 0.0, "Maximum size / delta-y");
 
        auto isFinite = [](const double value)
        { return std::isfinite(value); };
 
        range_check::CheckPrecondition(parameters.block_size_x, "X block size", "value is finite", isFinite);
        range_check::CheckPrecondition(parameters.block_size_y, "Y block size", "value is finite", isFinite);
        range_check::CheckPrecondition(parameters.radius_curvature, "Radius of curvature", "value is finite", isFinite);
        range_check::CheckPrecondition(parameters.maximum_uniform_size_columns, "Maximum size / delta-x", "value is finite", isFinite);
        range_check::CheckPrecondition(parameters.maximum_uniform_size_rows, "Maximum size / delta-y", "value is finite", isFinite);
        range_check::CheckPrecondition(parameters.uniform_columns_fraction, "Uniform m-fraction", "value is finite", isFinite);
        range_check::CheckPrecondition(parameters.uniform_rows_fraction, "Uniform n-fraction", "value is finite", isFinite);
    }
 
    struct CurvilinearParameters
    {
        int m_refinement = 2000;
 
        int n_refinement = 40;
 
        int smoothing_iterations = 10;
 
        double smoothing_parameter = 0.5;
 
        double attraction_parameter = 0.0;
    };
    struct CurvilinearParameters {…};
 
    inline static void CheckCurvilinearParameters(CurvilinearParameters const& parameters)
    {
        range_check::CheckGreater(parameters.m_refinement, 0, " M-refinement factor");
        range_check::CheckGreater(parameters.n_refinement, 0, "N-refinement factor");
        range_check::CheckGreater(parameters.smoothing_iterations, 0, "Smoothing iterations");
        range_check::CheckInClosedInterval(parameters.smoothing_parameter, {0.0, 1.0}, "Smoothing parameter"); // CHECK ME
        range_check::CheckGreaterEqual(parameters.attraction_parameter, 0.0, "Attraction parameter");          // CHECK ME
    }
 
    struct SplinesToCurvilinearParameters
    {
        double aspect_ratio = 0.1;
 
        double aspect_ratio_grow_factor = 1.1;
 
        double average_width = 500.0;
 
        int curvature_adapted_grid_spacing = 1;
 
        int grow_grid_outside = 0;
 
        int maximum_num_faces_in_uniform_part = 5;
 
        double nodes_on_top_of_each_other_tolerance = 0.0001;
 
        double min_cosine_crossing_angles = 0.95;
 
        int check_front_collisions = 0;
 
        int remove_skinny_triangles = 1;
    };
    struct SplinesToCurvilinearParameters {…};
 
    inline static void CheckSplinesToCurvilinearParameters(SplinesToCurvilinearParameters const& parameters)
    {
        range_check::CheckGreater(parameters.aspect_ratio, 0.0, "Aspect ratio");
        range_check::CheckGreater(parameters.aspect_ratio_grow_factor, 0.0, "Aspect ratio grow factor");
        range_check::CheckGreater(parameters.average_width, 0.0, "Average width");
        range_check::CheckOneOf(parameters.curvature_adapted_grid_spacing, {0, 1}, "Curvature adapted grid spacing");
        range_check::CheckOneOf(parameters.grow_grid_outside, {0, 1}, "Grow grid outside");
        range_check::CheckGreater(parameters.maximum_num_faces_in_uniform_part, 0, "Max number of faces in uniform part");
        range_check::CheckGreater(parameters.nodes_on_top_of_each_other_tolerance, 0.0, "nodes on top of each other tolerance");
        range_check::CheckGreater(parameters.min_cosine_crossing_angles, 0.0, "Min cosine crossing angles");
        range_check::CheckOneOf(parameters.check_front_collisions, {0, 1}, "Check front collisions");
        range_check::CheckOneOf(parameters.remove_skinny_triangles, {0, 1}, "Remove skinny triangles");
    }
 
    struct MeshRefinementParameters
    {
        int max_num_refinement_iterations = 10;
 
        int refine_intersected = 0;
 
        int use_mass_center_when_refining = 1;
 
        double min_edge_size = 0.5;
 
        int refinement_type = 2;
 
        int connect_hanging_nodes = 1;
 
        int account_for_samples_outside = 0;
 
        int smoothing_iterations = 5;
 
        double max_courant_time = 120.0;
 
        int directional_refinement = 0;
    };
    struct MeshRefinementParameters {…};
 
    inline static void CheckMeshRefinementParameters(MeshRefinementParameters const& parameters)
    {
        range_check::CheckGreater(parameters.max_num_refinement_iterations, 0, "Max num refinement iterations");
        range_check::CheckOneOf(parameters.refine_intersected, {0, 1}, "Refine intersected");
        range_check::CheckOneOf(parameters.use_mass_center_when_refining, {0, 1}, "Use mass center when refining");
        range_check::CheckGreater(parameters.min_edge_size, 0.0, "Min edge size");
        // Move enum meshkernel::MeshRefinement::RefinementType out of meshkernel::MeshRefinement
        // then use the underlying type of the enums to define ValidMeshRefinementTypes
        static std::vector<int> const ValidMeshRefinementTypes{1, 2, 3};
        range_check::CheckOneOf(parameters.refinement_type, ValidMeshRefinementTypes, "Refinement type");
        range_check::CheckOneOf(parameters.connect_hanging_nodes, {0, 1}, "Connect hanging nodes");
        range_check::CheckOneOf(parameters.account_for_samples_outside, {0, 1}, "Account for samples outside");
        range_check::CheckGreaterEqual(parameters.smoothing_iterations, 0, "Smoothing iterations");
        range_check::CheckGreater(parameters.max_courant_time, 0.0, "Max courant time");
        range_check::CheckOneOf(parameters.directional_refinement, {0, 1}, "Directional refinement");
    }
 
    struct OrthogonalizationParameters
    {
        int outer_iterations = 2;
 
        int boundary_iterations = 25;
 
        int inner_iterations = 25;
 
        double orthogonalization_to_smoothing_factor = 0.975;
 
        double orthogonalization_to_smoothing_factor_at_boundary = 1.0;
 
        double areal_to_angle_smoothing_factor = 1.0;
    };
    struct OrthogonalizationParameters {…};
 
    inline static void CheckOrthogonalizationParameters(OrthogonalizationParameters const& parameters)
    {
        range_check::CheckGreater(parameters.outer_iterations, 0, "Outer iterations");
        range_check::CheckGreater(parameters.boundary_iterations, 0, "Boundary iterations");
        range_check::CheckGreater(parameters.inner_iterations, 0, "Inner iterations");
        range_check::CheckInClosedInterval(parameters.orthogonalization_to_smoothing_factor, {0.0, 1.0}, "Orthogonalization-to-smoothing_factor");
        range_check::CheckInClosedInterval(parameters.orthogonalization_to_smoothing_factor_at_boundary, {0.0, 1.0}, "orthogonalization-to-smoothing factor at boundary");
        range_check::CheckInClosedInterval(parameters.areal_to_angle_smoothing_factor, {0.0, 1.0}, "area to angle smoothing factor");
    }
 
} // namespace meshkernel