geomodel_geological_entity.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 <memory>

#include <ringmesh/basic/factory.h>

#include <ringmesh/geomodel/entity_type.h>
#include <ringmesh/geomodel/geomodel_entity.h>

namespace RINGMesh
{
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModel );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelMeshEntity );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilderTopology );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilderGeology );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilderRemovalBase );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilderRemoval );
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModelBuilderInfo );
} // namespace RINGMesh

namespace RINGMesh
{
    template < index_t DIMENSION >
    class RINGMESH_API GeoModelGeologicalEntity
        : public GeoModelEntity< DIMENSION >
    {
    public:
        friend class GeoModelGeologicalEntityAccess< DIMENSION >;

        enum struct GEOL_FEATURE
        {
            ALL_GEOL,
            NO_GEOL,
            STRATI,
            UNCONFORMITY,
            NORMAL_FAULT,
            REVERSE_FAULT,
            FAULT,
            VOI
        };

        static GEOL_FEATURE determine_geological_type( const std::string& in );
        static std::string geol_name( GEOL_FEATURE feature );
        static bool is_fault( GEOL_FEATURE feature );
        static bool is_stratigraphic_limit( GEOL_FEATURE feature )
        {
            return feature == GEOL_FEATURE::STRATI
                   || feature == GEOL_FEATURE::UNCONFORMITY;
        }

        bool has_geological_feature() const
        {
            return geological_feature() != GEOL_FEATURE::NO_GEOL;
        }

        GEOL_FEATURE geological_feature() const
        {
            return geol_feature_;
        }

        static void initialize();

        gmge_id gmge() const
        {
            return gmge_id( type_name(), this->index() );
        }

        GeologicalEntityType entity_type() const
        {
            return gmge().type();
        }

        virtual MeshEntityType child_type_name() const = 0;
        virtual bool is_on_voi() const;
        virtual bool is_connectivity_valid() const;
        virtual bool is_valid() const;
        static GeologicalEntityType type_name_static()
        {
            return ForbiddenGeologicalEntityType::type_name_static();
        }
        virtual GeologicalEntityType type_name() const
        {
            return type_name_static();
        }
        index_t nb_children() const
        {
            return static_cast< index_t >( children_.size() );
        }
        const gmme_id& child_gmme( index_t x ) const;
        const GeoModelMeshEntity< DIMENSION >& child( index_t x ) const;

        virtual bool is_identification_valid() const;

    protected:
        explicit GeoModelGeologicalEntity(
            const GeoModel< DIMENSION >& geomodel )
            : GeoModelEntity< DIMENSION >( geomodel, NO_ID )
        {
        }

        virtual bool is_index_valid() const;

    private:
        void copy_geological_entity(
            const GeoModelGeologicalEntity< DIMENSION >& from )
        {
            this->copy_name( from );
            geol_feature_ = from.geol_feature_;
            children_ = from.children_;
        }

    protected:
        std::vector< index_t > children_{};

        GEOL_FEATURE geol_feature_{ GEOL_FEATURE::NO_GEOL };
    };

    ALIAS_2D_AND_3D( GeoModelGeologicalEntity );

    template < index_t DIMENSION >
    using GeoModelGeologicalEntityFactory = Factory< GeologicalEntityType,
        GeoModelGeologicalEntity< DIMENSION >,
        const GeoModel< DIMENSION >& >;

    ALIAS_2D_AND_3D( GeoModelGeologicalEntityFactory );

    template < index_t DIMENSION >
    class RINGMESH_API Contact : public GeoModelGeologicalEntity< DIMENSION >
    {
    public:
        explicit Contact( const GeoModel< DIMENSION >& geomodel )
            : GeoModelGeologicalEntity< DIMENSION >( geomodel )
        {
        }

        static GeologicalEntityType type_name_static()
        {
            return GeologicalEntityType( "Contact" );
        }
        GeologicalEntityType type_name() const override
        {
            return type_name_static();
        }
        MeshEntityType child_type_name() const override;
    };

    ALIAS_2D_AND_3D( Contact );

    template < index_t DIMENSION >
    class RINGMESH_API Interface : public GeoModelGeologicalEntity< DIMENSION >
    {
    public:
        explicit Interface( const GeoModel< DIMENSION >& geomodel )
            : GeoModelGeologicalEntity< DIMENSION >( geomodel )
        {
        }

        static GeologicalEntityType type_name_static()
        {
            return GeologicalEntityType( "Interface" );
        }
        GeologicalEntityType type_name() const override
        {
            return type_name_static();
        }
        MeshEntityType child_type_name() const override;
    };

    ALIAS_2D_AND_3D( Interface );

    template < index_t DIMENSION >
    class RINGMESH_API Layer : public GeoModelGeologicalEntity< DIMENSION >
    {
    public:
        explicit Layer( const GeoModel< DIMENSION >& geomodel )
            : GeoModelGeologicalEntity< DIMENSION >( geomodel )
        {
        }

        static GeologicalEntityType type_name_static()
        {
            return GeologicalEntityType( "Layer" );
        }
        GeologicalEntityType type_name() const override
        {
            return type_name_static();
        }
        MeshEntityType child_type_name() const override;
    };

    ALIAS_2D_AND_3D( Layer );

    template < index_t DIMENSION >
    class RINGMESH_API GeoModelGeologicalEntityAccess
    {
        ringmesh_disable_copy_and_move( GeoModelGeologicalEntityAccess );
        friend class GeoModelBuilderTopology< DIMENSION >;
        friend class GeoModelBuilderGeology< DIMENSION >;
        friend class GeoModelBuilderInfo< DIMENSION >;
        friend class GeoModelBuilderRemovalBase< DIMENSION >;

    private:
        explicit GeoModelGeologicalEntityAccess(
            GeoModelGeologicalEntity< DIMENSION >& gmge )
            : gmge_( gmge )
        {
        }
        ~GeoModelGeologicalEntityAccess() = default;

        std::string& modifiable_name()
        {
            return gmge_.name_;
        }

        index_t& modifiable_index()
        {
            return gmge_.id_;
        }

        typename GeoModelGeologicalEntity< DIMENSION >::GEOL_FEATURE&
            modifiable_geol_feature()
        {
            return gmge_.geol_feature_;
        }

        std::vector< index_t >& modifiable_children()
        {
            return gmge_.children_;
        }

        static std::unique_ptr< GeoModelGeologicalEntity< DIMENSION > >
            create_geological_entity( const GeologicalEntityType& type,
                const GeoModel< DIMENSION >& geomodel,
                index_t index_in_geomodel );

        void copy( const GeoModelGeologicalEntity< DIMENSION >& from )
        {
            gmge_.copy_geological_entity( from );
        }

    private:
        GeoModelGeologicalEntity< DIMENSION >& gmge_;
    };

} // namespace RINGMesh