geomodel_mesh.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2017, Association Scientifique pour la Geologie et ses
 * Applications (ASGA). All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of ASGA nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ASGA BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *     http://www.ring-team.org
 *
 *     RING Project
 *     Ecole Nationale Superieure de Geologie - GeoRessources
 *     2 Rue du Doyen Marcel Roubault - TSA 70605
 *     54518 VANDOEUVRE-LES-NANCY
 *     FRANCE
 */

#pragma once

#include <ringmesh/basic/common.h>

#include <ringmesh/geomodel/entity_type_manager.h>
#include <ringmesh/geomodel/geomodel_indexing_types.h>

#include <ringmesh/mesh/mesh.h>
#include <ringmesh/mesh/mesh_builder.h>

namespace RINGMesh
{
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshBase );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelEntity );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshEntity );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshEdges );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshWells );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshPolygons );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshPolygonsBase );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshCells );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMesh );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModel );

    ALIAS_3D( GeoModel );
    ALIAS_3D( GeoModelMesh );
} // namespace RINGMesh

namespace RINGMesh
{
    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshCommon
    {
        ringmesh_disable_copy_and_move( GeoModelMeshCommon );
        ringmesh_template_assert_2d_or_3d( DIMENSION );

    protected:
        GeoModelMeshCommon(
            GeoModelMesh< DIMENSION >& gmm, GeoModel< DIMENSION >& geomodel );

        virtual ~GeoModelMeshCommon() = default;

        void set_mesh( MeshBase< DIMENSION >* mesh )
        {
            mesh_base_ = mesh;
        }

        void save_mesh( const std::string& filename ) const
        {
            mesh_base_->save_mesh( filename );
        }

    protected:
        GeoModelMesh< DIMENSION >& gmm_;
        GeoModel< DIMENSION >& geomodel_;
        MeshBase< DIMENSION >* mesh_base_;
    };

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshVerticesBase
        : public GeoModelMeshCommon< DIMENSION >
    {
    public:
        friend class GeoModelMeshWells< DIMENSION >;
        friend class GeoModelMeshEdges< DIMENSION >;
        friend class GeoModelMeshPolygonsBase< DIMENSION >;
        friend class GeoModelMeshCells< DIMENSION >;

        GEO::AttributesManager& attribute_manager() const
        {
            return mesh_->vertex_attribute_manager();
        }

        bool is_initialized() const;
        void test_and_initialize() const;

        index_t nb() const;

        const vecn< DIMENSION >& vertex( index_t v ) const;

        index_t index( const vecn< DIMENSION >& p ) const;

        index_t geomodel_vertex_id(
            const gmme_id& mesh_entity, index_t entity_vertex_index = 0 ) const;

        index_t geomodel_vertex_id( const gmme_id& mesh_entity,
            const ElementLocalVertex& element_local_vertex ) const;

        std::vector< index_t > mesh_entity_vertex_id(
            const gmme_id& mesh_entity, index_t geomodel_vertex_id ) const;

        const std::vector< GMEVertex >& gme_vertices( index_t v ) const;

        std::vector< GMEVertex > gme_type_vertices(
            const MeshEntityType& entity_type, index_t vertex ) const;

        index_t add_vertex( const vecn< DIMENSION >& point );
        index_t add_vertices( const std::vector< vecn< DIMENSION > >& points );

        void update_point( index_t v, const vecn< DIMENSION >& point );

        void update_vertex_mapping( const gmme_id& entity_id,
            index_t entity_vertex_index,
            index_t geomodel_vertex_index );

        virtual void clear();

        void unbind_geomodel_vertex_map( const gmme_id& mesh_entity_id );

        void bind_geomodel_vertex_map( const gmme_id& mesh_entity_id );

        const NNSearch< DIMENSION >& nn_search() const
        {
            test_and_initialize();
            return mesh_->vertex_nn_search();
        }

        void remove_colocated();

        void erase_vertices( std::vector< index_t >& to_delete );

    private:
        void initialize();

    protected:
        GeoModelMeshVerticesBase( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< PointSetMesh< DIMENSION > >& mesh );

        virtual index_t nb_total_vertices() const;
        virtual index_t fill_vertices();
        void fill_vertices_for_entity_type( const GeoModel< DIMENSION >& M,
            const MeshEntityType& entity_type,
            index_t& count );

    private:
        class GeoModelVertexMapper
        {
            ringmesh_disable_copy_and_move( GeoModelVertexMapper );

        public:
            GeoModelVertexMapper( GeoModelMeshVerticesBase& geomodel_vertices,
                const GeoModel< DIMENSION >& geomodel );

            ~GeoModelVertexMapper() = default;

            index_t geomodel_vertex_index( const gmme_id& mesh_entity_id,
                index_t mesh_entity_vertex_index ) const;

            const std::vector< GMEVertex >& mesh_entity_vertex_indices(
                index_t v ) const;

            std::vector< GMEVertex > mesh_entity_vertex_indices(
                index_t v, const MeshEntityType& mesh_entity_type ) const;

            std::vector< index_t > mesh_entity_vertex_indices(
                index_t v, const gmme_id& mesh_entity_id ) const;

            const std::vector< index_t >& vertex_map(
                const gmme_id& mesh_entity_id ) const;

            std::vector< index_t >& vertex_map( const gmme_id& mesh_entity_id );

            void set_vertex_map_value( const gmme_id& mesh_entity_id,
                index_t mesh_entity_vertex_index,
                index_t geomodel_entity_vertex_index );

            void add_to_gme_vertices(
                const GMEVertex& gme_vertex, index_t geomodel_vertex_index );

            void update_mesh_entity_maps_and_gmes(
                const std::vector< index_t >& old2new );

            void resize_geomodel_vertex_gmes( const index_t nb )
            {
                gme_vertices_.resize( nb );
            }

            void clear_and_resize_geomodel_vertex_gmes( const index_t nb )
            {
                gme_vertices_.clear();
                resize_geomodel_vertex_gmes( nb );
            }

            void bind_all_mesh_entity_vertex_maps();

            void clear();

            void clear_geomodel_vertex_gmes( index_t v )
            {
                ringmesh_assert( v < gme_vertices_.size() );
                gme_vertices_[v].clear();
            }

            void clear_vertex_map( const gmme_id& mesh_entity_id );

            std::vector< index_t >& resize_vertex_map(
                const gmme_id& mesh_entity_id );

        private:
            void initialize_mesh_entity_vertex_map(
                const gmme_id& mesh_entity_id );

            bool test_and_initialize_mesh_entity_vertex_map(
                const gmme_id& mesh_entity_id );

            bool is_mesh_entity_vertex_map_initialized(
                const gmme_id& mesh_entity_id ) const;

            void clear_all_mesh_entity_vertex_map();

            void resize_all_mesh_entity_vertex_maps(
                const MeshEntityType& type );

            GEO::AttributesManager& mesh_entity_vertex_attribute_manager(
                const gmme_id& mesh_entity_id ) const;

        private:
            GeoModelMeshVerticesBase< DIMENSION >& geomodel_vertices_;
            const GeoModel< DIMENSION >& geomodel_;

            std::vector< std::vector< index_t > > corner_vertex_maps_;
            std::vector< std::vector< index_t > > line_vertex_maps_;
            std::vector< std::vector< index_t > > surface_vertex_maps_;
            std::vector< std::vector< index_t > > region_vertex_maps_;
            std::map< MeshEntityType, std::vector< std::vector< index_t > >* >
                vertex_maps_;

            std::vector< std::vector< GMEVertex > > gme_vertices_;
        };

    protected:
        std::unique_ptr< PointSetMesh< DIMENSION > >& mesh_;
        GeoModelVertexMapper vertex_mapper_;
    };

    ALIAS_2D_AND_3D( GeoModelMeshVerticesBase );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshVertices final
        : public GeoModelMeshVerticesBase< DIMENSION >
    {
    public:
        GeoModelMeshVertices( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< PointSetMesh< DIMENSION > >& mesh );
    };

    template <>
    class RINGMESH_API GeoModelMeshVertices< 3 > final
        : public GeoModelMeshVerticesBase< 3 >
    {
    public:
        GeoModelMeshVertices( GeoModelMesh3D& gmm,
            GeoModel3D& gm,
            std::unique_ptr< PointSetMesh3D >& mesh );

        void clear() override;
        index_t nb_total_vertices() const override;
        index_t fill_vertices() override;
    };

    ALIAS_2D_AND_3D( GeoModelMeshVertices );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshPolygonsBase
        : public GeoModelMeshCommon< DIMENSION >
    {
        ringmesh_disable_copy_and_move( GeoModelMeshPolygonsBase );
        static const std::string surface_att_name;
        static const std::string polygon_surface_att_name;

    public:
        friend class GeoModelMeshBase< DIMENSION >;
        friend class GeoModelMesh< DIMENSION >;

        virtual ~GeoModelMeshPolygonsBase();

        GEO::AttributesManager& attribute_manager() const
        {
            return mesh_->polygon_attribute_manager();
        }

        bool is_initialized() const;
        void test_and_initialize() const;

        index_t nb() const;

        index_t nb_vertices( index_t polygon ) const;
        index_t vertex( const ElementLocalVertex& polygon_local_vertex ) const;
        index_t adjacent( const PolygonLocalEdge& polygon_local_edge ) const;
        index_t surface( index_t polygon ) const;
        index_t index_in_surface( index_t polygon ) const;
        std::tuple< PolygonType, index_t > type( index_t polygon ) const;

        index_t nb_polygons( PolygonType type = PolygonType::UNDEFINED ) const;
        index_t nb_polygons(
            index_t surface, PolygonType type = PolygonType::UNDEFINED ) const;
        index_t polygon( index_t surface,
            index_t polygon,
            PolygonType type = PolygonType::UNDEFINED ) const;

        index_t nb_triangle() const;
        index_t nb_triangle( index_t surface ) const;
        index_t triangle( index_t surface, index_t triangle ) const;

        index_t nb_quad() const;
        index_t nb_quad( index_t surface ) const;
        index_t quad( index_t surface, index_t quad ) const;

        index_t nb_unclassified_polygon() const;
        index_t nb_unclassified_polygon( index_t surface ) const;
        index_t unclassified_polygon( index_t surface, index_t polygon ) const;

        void clear();

        vecn< DIMENSION > center( index_t polygon ) const;
        double area( index_t polygon ) const;

        const NNSearch< DIMENSION >& nn_search() const
        {
            test_and_initialize();
            return mesh_->polygon_nn_search();
        }

        const SurfaceAABBTree< DIMENSION >& aabb() const;

    private:
        void initialize();
        void resize_polygones_data();
        void clear_polygones_data();

        void disconnect_along_lines();

        void sort_polygons();

    protected:
        GeoModelMeshPolygonsBase( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< SurfaceMesh< DIMENSION > >& mesh );

    protected:
        std::unique_ptr< SurfaceMesh< DIMENSION > >& mesh_;

        std::vector< index_t > surface_id_;
        std::vector< index_t > polygon_id_;

        std::vector< index_t > surface_polygon_ptr_;

        index_t nb_triangles_{ 0 };
        index_t nb_quads_{ 0 };
        index_t nb_unclassified_polygons_{ 0 };
    };

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshPolygons final
        : public GeoModelMeshPolygonsBase< DIMENSION >
    {
    public:
        GeoModelMeshPolygons( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< SurfaceMesh< DIMENSION > >& mesh );
    };

    template <>
    class GeoModelMeshPolygons< 3 > final : public GeoModelMeshPolygonsBase< 3 >
    {
    public:
        GeoModelMeshPolygons( GeoModelMesh3D& gmm,
            GeoModel3D& gm,
            std::unique_ptr< SurfaceMesh3D >& mesh );

        vec3 normal( index_t p ) const;
    };

    ALIAS_2D_AND_3D( GeoModelMeshPolygons );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshEdges final
        : public GeoModelMeshCommon< DIMENSION >
    {
        ringmesh_disable_copy_and_move( GeoModelMeshEdges );
        static const std::string line_att_name;
        static const std::string edge_line_att_name;

    public:
        friend class GeoModelMeshBase< DIMENSION >;
        friend class GeoModelMesh< DIMENSION >;

        virtual ~GeoModelMeshEdges();

        GEO::AttributesManager& attribute_manager() const
        {
            return mesh_->edge_attribute_manager();
        }

        bool is_initialized() const;
        void test_and_initialize() const;

        index_t nb() const;

        index_t vertex( const ElementLocalVertex& edge_local_vertex ) const;

        index_t line( index_t edge ) const;
        index_t index_in_line( index_t edge ) const;

        index_t nb_edges( index_t line ) const;
        index_t edge( index_t line, index_t edge ) const;
        void clear();

        vecn< DIMENSION > center( index_t edge ) const;
        double length( index_t edge ) const;

        const NNSearch< DIMENSION >& nn_search() const
        {
            test_and_initialize();
            return mesh_->edge_nn_search();
        }

        const LineAABBTree< DIMENSION >& aabb() const;

    private:
        void initialize();
        void resize_edge_data();
        void clear_edge_data();

    protected:
        GeoModelMeshEdges( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< LineMesh< DIMENSION > >& mesh );

    protected:
        std::unique_ptr< LineMesh< DIMENSION > >& mesh_;

        std::vector< index_t > line_id_;
        std::vector< index_t > edge_id_;

        std::vector< index_t > line_edge_ptr_;

        index_t nb_edges_{ 0 };
    };

    ALIAS_2D_AND_3D( GeoModelMeshEdges );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshWells final
        : public GeoModelMeshCommon< DIMENSION >
    {
    public:
        explicit GeoModelMeshWells( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< LineMesh< DIMENSION > >& mesh );

        GEO::AttributesManager& attribute_manager() const
        {
            return mesh_->edge_attribute_manager();
        }

        bool is_initialized() const;
        void test_and_initialize() const;

        index_t nb_wells() const;
        index_t nb_edges() const;
        index_t nb_edges( index_t well ) const;
        index_t vertex( index_t well, index_t edge, index_t vertex ) const;
        void clear();

        void initialize();

        const LineAABBTree< DIMENSION >& aabb() const;

    private:
        std::unique_ptr< LineMesh< DIMENSION > >& mesh_;

        std::vector< index_t > well_ptr_;
    };

    ALIAS_2D_AND_3D( GeoModelMeshWells );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshCells final
        : public GeoModelMeshCommon< DIMENSION >
    {
        static const std::string region_att_name;
        static const std::string cell_region_att_name;

    public:
        friend class GeoModelMeshBase< DIMENSION >;
        friend class GeoModelMesh< DIMENSION >;

        enum DuplicateMode
        {
            NONE,
            FAULT,
            HORIZON,
            ALL
        };

        GeoModelMeshCells( GeoModelMesh< DIMENSION >& gmm,
            GeoModel< DIMENSION >& gm,
            std::unique_ptr< VolumeMesh< DIMENSION > >& mesh );

        GEO::AttributesManager& attribute_manager() const
        {
            return mesh_->cell_attribute_manager();
        }
        bool is_initialized() const;
        bool is_duplication_initialized() const;

        void test_and_initialize() const;

        index_t nb() const;
        index_t nb_duplicated_vertices() const;
        index_t nb_total_vertices() const;
        index_t duplicated_corner_index(
            const ElementLocalVertex& cell_local_vertex ) const;
        index_t duplicated_vertex( index_t duplicate_vertex_index ) const;

        index_t nb_vertices( index_t cell ) const;
        index_t vertex( const ElementLocalVertex& cell_local_vertex ) const;
        index_t nb_edges( index_t cell ) const;
        index_t nb_facets( index_t cell ) const;
        index_t nb_facet_vertices(
            const CellLocalFacet& cell_local_facet ) const;
        index_t facet_vertex( const CellLocalFacet& cell_local_facet,
            index_t local_vertex ) const;
        index_t edge_vertex(
            index_t cell, index_t local_edge, index_t local_vertex ) const;
        index_t adjacent( index_t cell, index_t facet ) const;
        index_t region( index_t cell ) const;
        index_t index_in_region( index_t cell ) const;
        CellType type( index_t cell ) const;

        index_t nb_cells( CellType type = CellType::UNDEFINED ) const;
        index_t nb_cells(
            index_t region, CellType type = CellType::UNDEFINED ) const;
        index_t cell( index_t region,
            index_t cell,
            CellType type = CellType::UNDEFINED ) const;

        index_t nb_tet() const;
        index_t nb_tet( index_t region ) const;
        index_t tet( index_t region, index_t tet ) const;

        index_t nb_hex() const;
        index_t nb_hex( index_t region ) const;
        index_t hex( index_t region, index_t hex ) const;

        index_t nb_prism() const;
        index_t nb_prism( index_t region ) const;
        index_t prism( index_t region, index_t prism ) const;

        index_t nb_pyramid() const;
        index_t nb_pyramid( index_t region ) const;
        index_t pyramid( index_t region, index_t pyramid ) const;

        index_t nb_connector() const;
        index_t nb_connector( index_t region ) const;
        index_t connector( index_t region, index_t connector ) const;

        void clear();
        void clear_duplication();

        bool is_cell_facet_on_surface( index_t cell,
            index_t facet_index,
            index_t& colocated_facet_index,
            bool& side ) const;

        vec3 barycenter( index_t cell ) const;
        double volume( index_t cell ) const;

        const NNSearch< DIMENSION >& cell_nn_search() const
        {
            test_and_initialize();
            return mesh_->cell_nn_search();
        }
        const NNSearch< DIMENSION >& cell_facet_nn_search() const
        {
            test_and_initialize();
            return mesh_->cell_facet_nn_search();
        }

        const VolumeAABBTree< DIMENSION >& aabb() const;

    private:
        enum ActionOnSurface
        {
            SKIP = -2,
            TO_PROCESS = -1,
            NEG_SIDE = 0,
            POS_SIDE = 1
        };
        using action_on_surface = std::pair< index_t, ActionOnSurface >;

        void initialize();

        void resize_cell_data();
        void clear_cell_data();

        void test_and_initialize_duplication() const;
        void initialize_duplication();
        bool is_surface_to_duplicate( index_t surface ) const;

        bool are_corners_to_duplicate(
            const std::vector< action_on_surface >& surfaces,
            std::vector< ActionOnSurface >& info );
        void test_and_initialize_cell_facet() const;
        void initialize_cell_facet();

        void sort_cells();

    private:
        std::unique_ptr< VolumeMesh< DIMENSION > >& mesh_;

        std::vector< index_t > region_id_;
        std::vector< index_t > cell_id_;

        std::vector< index_t > region_cell_ptr_;

        index_t nb_tets_{ 0 };
        index_t nb_hexs_{ 0 };
        index_t nb_prisms_{ 0 };
        index_t nb_pyramids_{ 0 };
        index_t nb_connectors_{ 0 };

        DuplicateMode mode_{ NONE };
        std::vector< index_t > duplicated_vertex_indices_;

        std::vector< index_t > polygon_id_;
    };

    ALIAS_2D_AND_3D( GeoModelMeshCells );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMeshBase
    {
        ringmesh_disable_copy_and_move( GeoModelMeshBase );
        ringmesh_template_assert_2d_or_3d( DIMENSION );

    public:
        virtual ~GeoModelMeshBase();

        const GeoModel< DIMENSION >& geomodel() const
        {
            return geomodel_;
        }

        void remove_colocated_vertices();

        void erase_vertices( std::vector< index_t >& to_delete );

        void erase_invalid_vertices();

        void change_point_set_mesh_data_structure( const MeshType& type );
        void change_line_mesh_data_structure( const MeshType& type );
        void change_surface_mesh_data_structure( const MeshType& type );

    protected:
        const GeoModel< DIMENSION >& geomodel_;

        MeshSet< DIMENSION > mesh_set_;

    protected:
        GeoModelMeshBase(
            GeoModelMesh< DIMENSION >& gmm, GeoModel< DIMENSION >& geomodel );

    public:
        GeoModelMeshVertices< DIMENSION > vertices;
        GeoModelMeshEdges< DIMENSION > edges;
        GeoModelMeshWells< DIMENSION > wells;
        GeoModelMeshPolygons< DIMENSION > polygons;
    };

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelMesh final : public GeoModelMeshBase< DIMENSION >
    {
    public:
        explicit GeoModelMesh( GeoModel< DIMENSION >& geomodel );
    };

    template <>
    class RINGMESH_API GeoModelMesh< 3 > final : public GeoModelMeshBase< 3 >
    {
        ringmesh_disable_copy_and_move( GeoModelMesh );

    public:
        explicit GeoModelMesh( GeoModel3D& geomodel );
        virtual ~GeoModelMesh();

        void transfer_attributes_from_gmm_to_gm_regions() const;
        void transfer_attributes_from_gm_regions_to_gmm() const;
        void transfer_cell_attributes_from_gmm_to_gm_regions() const;
        void transfer_cell_attributes_from_gm_regions_to_gmm() const;
        void transfer_vertex_attributes_from_gmm_to_gm_regions() const;
        void transfer_vertex_attributes_from_gm_regions_to_gmm() const;

        GeoModelMeshCells3D::DuplicateMode duplicate_mode() const
        {
            return mode_;
        }
        void set_duplicate_mode(
            const GeoModelMeshCells3D::DuplicateMode& mode ) const
        {
            if( mode_ == mode )
                return;
            mode_ = mode;
            const_cast< GeoModelMesh3D* >( this )->cells.clear_duplication();
        }

        void change_volume_mesh_data_structure( const MeshType& type );

    private:
        mutable GeoModelMeshCells3D::DuplicateMode mode_{
            GeoModelMeshCells3D::NONE
        };

    public:
        GeoModelMeshCells3D cells;
    };

    ALIAS_2D_AND_3D( GeoModelMesh );

} // namespace RINGMesh