well.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 <array>
#include <memory>

#include <geogram/basic/attributes.h>

#include <ringmesh/basic/geometry.h>

namespace RINGMesh
{
    FORWARD_DECLARATION_DIMENSION_CLASS( GeoModel );
    FORWARD_DECLARATION_DIMENSION_CLASS( Well );
    FORWARD_DECLARATION_DIMENSION_CLASS( NNSearch );
    FORWARD_DECLARATION_DIMENSION_CLASS( PointSetMesh );
    FORWARD_DECLARATION_DIMENSION_CLASS( LineMesh );
    struct ElementLocalVertex;
} // namespace RINGMesh

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

    protected:
        explicit WellEntity( const Well< DIMENSION >* well );
        virtual ~WellEntity() = default;

    public:
        const Well< DIMENSION >& well() const
        {
            return *well_;
        }

    protected:
        const Well< DIMENSION >* well_;
    };

    ALIAS_2D_AND_3D( WellEntity );

    // --------------------------------------------------------------------------

    template < index_t DIMENSION >
    class WellCorner : public WellEntity< DIMENSION >
    {
    public:
        WellCorner( const Well< DIMENSION >* well,
            const vecn< DIMENSION >& point,
            bool is_on_surface,
            index_t id );

        const vecn< DIMENSION >& point() const;

        bool is_on_surface() const
        {
            return is_on_surface_;
        }

        bool id() const
        {
            return id_;
        }

        GEO::AttributesManager& vertex_attribute_manager() const;

    private:
        bool is_on_surface_;
        index_t id_;
        std::unique_ptr< PointSetMesh< DIMENSION > > mesh_;
    };

    ALIAS_2D_AND_3D( WellCorner );

    // --------------------------------------------------------------------------

    template < index_t DIMENSION >
    class WellPart : public WellEntity< DIMENSION >
    {
    public:
        WellPart( const Well< DIMENSION >* well, index_t id );

        void set_corner( index_t c, index_t id )
        {
            corners_[c] = id;
        }
        index_t corner( index_t c ) const
        {
            ringmesh_assert( c < 2 );
            return corners_[c];
        }

        void set_points( const std::vector< vecn< DIMENSION > >& points );

        index_t nb_edges() const;
        index_t nb_vertices() const;

        double length() const;

        void set_id( index_t id )
        {
            id_ = id;
        }
        index_t id() const
        {
            return id_;
        }
        const vecn< DIMENSION >& vertex( index_t v ) const;
        const vecn< DIMENSION >& edge_vertex(
            const ElementLocalVertex& well_edge_local_vertex ) const;

        GEO::AttributesManager& vertex_attribute_manager() const;
        GEO::AttributesManager& edge_attribute_manager() const;

        const NNSearch< DIMENSION >& vertices_nn_search() const;

    private:
        index_t id_;
        std::array< index_t, 2 > corners_;
        std::unique_ptr< LineMesh< DIMENSION > > mesh_;
    };

    ALIAS_2D_AND_3D( WellPart );

    // --------------------------------------------------------------------------

    template < index_t DIMENSION >
    class Edge
    {
    public:
        Edge( const vecn< DIMENSION >& v0, const vecn< DIMENSION >& v1 )
        {
            vertices_[0] = v0;
            vertices_[1] = v1;
        }

        const vecn< DIMENSION >& vertex( index_t i ) const
        {
            return vertices_[i];
        }

        vecn< DIMENSION > barycenter() const
        {
            return ( vertices_[0] + vertices_[1] ) * 0.5;
        }

    private:
        std::array< vecn< DIMENSION >, 2 > vertices_;
    };

    ALIAS_2D_AND_3D( Edge );

    // --------------------------------------------------------------------------

    template < index_t DIMENSION >
    class Well
    {
        ringmesh_disable_copy_and_move( Well );

    public:
        Well();
        ~Well() = default;

        void copy_corners_and_informations( Well< DIMENSION >& well ) const;

        void get_part_edges(
            index_t part_id, std::vector< Edge< DIMENSION > >& edges ) const;
        void get_region_edges(
            index_t part_id, std::vector< Edge< DIMENSION > >& edges ) const;

        index_t create_corner(
            const vecn< DIMENSION >& vertex, bool is_on_surface, index_t id )
        {
            index_t corner_id = static_cast< index_t >( corners_.size() );
            corners_.emplace_back( new WellCorner< DIMENSION >(
                this, vertex, is_on_surface, id ) );
            return corner_id;
        }
        index_t find_corner(
            const vecn< DIMENSION >& vertex, double epsilon ) const;
        const WellCorner< DIMENSION >& corner( index_t c ) const
        {
            ringmesh_assert( c < corners_.size() );
            return *corners_[c];
        }

        index_t create_part( index_t region )
        {
            index_t part_id = static_cast< index_t >( parts_.size() );
            parts_.emplace_back( new WellPart< DIMENSION >( this, part_id ) );
            part_region_id_.push_back( region );
            return part_id;
        }
        const WellPart< DIMENSION >& part( index_t part_id ) const
        {
            ringmesh_assert( part_id < parts_.size() );
            return *parts_[part_id];
        }
        WellPart< DIMENSION >& part( index_t part_id )
        {
            ringmesh_assert( part_id < parts_.size() );
            return *parts_[part_id];
        }
        index_t part_region_id( index_t part_id ) const
        {
            ringmesh_assert( part_id < nb_parts() );
            return part_region_id_[part_id];
        }

        index_t nb_corners() const
        {
            return static_cast< index_t >( corners_.size() );
        }
        index_t nb_parts() const
        {
            return static_cast< index_t >( parts_.size() );
        }
        index_t nb_edges() const;
        void set_name( const std::string& name )
        {
            name_ = name;
        }
        const std::string& name() const
        {
            return name_;
        }

    private:
        std::vector< std::unique_ptr< WellCorner< DIMENSION > > > corners_;
        std::vector< std::unique_ptr< WellPart< DIMENSION > > > parts_;
        std::vector< index_t > part_region_id_;
        std::string name_;
        index_t nb_edges_;
    };

    ALIAS_2D_AND_3D( Well );

    // --------------------------------------------------------------------------

    template < index_t DIMENSION >
    class WellGroup
    {
        ringmesh_disable_copy_and_move( WellGroup );

    public:
        WellGroup();
        virtual ~WellGroup() = default;

        void get_region_edges(
            index_t region, std::vector< Edge< DIMENSION > >& edges ) const;

        void get_region_edges( index_t region,
            std::vector< std::vector< Edge< DIMENSION > > >& edges ) const;

        const GeoModel< DIMENSION >* geomodel() const
        {
            return geomodel_;
        }
        void set_geomodel( GeoModel< DIMENSION >* geomodel )
        {
            geomodel_ = geomodel;
        }

        index_t find_well( const std::string& name ) const;

        void create_wells( index_t nb_wells );

        void add_well(
            const LineMesh< DIMENSION >& mesh, const std::string& name );

        index_t nb_wells() const
        {
            return static_cast< index_t >( wells_.size() );
        }
        const Well< DIMENSION >& well( index_t w ) const
        {
            return *wells_[w];
        }

    private:
        void compute_conformal_mesh(
            const LineMesh< DIMENSION >& in, LineMesh< DIMENSION >& out );

    protected:
        std::vector< Well< DIMENSION >* > wells_;
        GeoModel< DIMENSION >* geomodel_;
    };

    ALIAS_2D_AND_3D( WellGroup );
} // namespace RINGMesh