stratigraphic_column.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 <string>
#include <vector>

namespace RINGMesh
{
    FORWARD_DECLARATION_DIMENSION_CLASS( Interface );
    FORWARD_DECLARATION_DIMENSION_CLASS( Layer );

    ALIAS_3D( Interface );
    ALIAS_3D( Layer );
} // namespace RINGMesh

namespace RINGMesh
{
    // @todo To develop
    enum struct ROCKTYPE
    {
        NONE,
        MULTIPLE
    };

    class RINGMESH_API RockFeature
    {
    public:
        RockFeature( std::string name, ROCKTYPE type )
            : name_( std::move( name ) ), type_( type )
        {
        }
        explicit RockFeature( std::string name )
            : RockFeature( std::move( name ), ROCKTYPE::NONE )
        {
        }

        const std::string& get_name() const
        {
            return name_;
        }
        void set_name( const std::string& name )
        {
            name_ = name;
        }

        const ROCKTYPE& get_rock_type() const
        {
            return type_;
        }

        void set_rock_type( ROCKTYPE type )
        {
            type_ = type;
        }

    private:
        std::string name_{};
        ROCKTYPE type_{ ROCKTYPE::NONE };
    };

    enum struct RELATION
    {
        CONFORMABLE = 0,
        ERODED = 10,
        TRUNCATION = 11,
        TOPLAP = 12,
        BASELAP = 20,
        ONLAP = 21,
        DOWNLAP = 22
    };

    class RINGMESH_API StratigraphicUnit
    {
        ringmesh_disable_copy_and_move( StratigraphicUnit );

    public:
        StratigraphicUnit( std::string name, RockFeature rock );

        virtual ~StratigraphicUnit() = default;

        virtual const std::string& get_name() const
        {
            return name_;
        }
        void set_rock_feature( const RockFeature& rock_feature )
        {
            rock_ = rock_feature;
        }

        const RockFeature& get_rock_feature() const
        {
            return rock_;
        }

        virtual bool is_conformable_base() const = 0;
        virtual bool is_conformable_top() const = 0;
        virtual RELATION get_relation_base() const = 0;
        virtual RELATION get_relation_top() const = 0;
        virtual const Interface3D& get_interface_base() const = 0;
        virtual const Interface3D& get_interface_top() const = 0;
        virtual double get_min_thick() const = 0;
        virtual double get_max_thick() const = 0;

    protected:
        StratigraphicUnit();

    protected:
        std::string name_{};
        RockFeature rock_;
    };

    class RINGMESH_API UnsubdividedStratigraphicUnit : public StratigraphicUnit
    {
    public:
        UnsubdividedStratigraphicUnit( std::string name,
            const Interface3D& interface_base,
            const Interface3D& interface_top,
            const Layer3D& layer,
            RELATION relation_top,
            RELATION relation_base,
            RockFeature rock,
            double min_thick,
            double max_thick );

        bool is_conformable_base() const final
        {
            return ( relation_base_ == RELATION::CONFORMABLE );
        }

        bool is_conformable_top() const final
        {
            return ( relation_top_ == RELATION::CONFORMABLE );
        }

        RELATION get_relation_base() const final
        {
            return relation_base_;
        }

        RELATION get_relation_top() const final
        {
            return relation_top_;
        }

        const Interface3D& get_interface_base() const final
        {
            return *interface_base_;
        }

        const Interface3D& get_interface_top() const final
        {
            return *interface_top_;
        }

        double get_min_thick() const final
        {
            return min_thick_;
        }

        double get_max_thick() const final
        {
            return max_thick_;
        }

    private:
        const Interface3D* interface_top_;
        const Interface3D* interface_base_;
        const Layer3D* layer_;
        RELATION relation_top_;
        RELATION relation_base_;
        double min_thick_;
        double max_thick_;
    };

    class RINGMESH_API SubdividedStratigraphicUnit : public StratigraphicUnit
    {
    public:
        SubdividedStratigraphicUnit( std::string name,
            RockFeature rock,
            const std::vector< const StratigraphicUnit* >& sub_units )
            : StratigraphicUnit( std::move( name ), std::move( rock ) ),
              units_( sub_units )
        {
        }

        bool is_conformable_base() const final
        {
            return ( units_.back()->is_conformable_base() );
        }

        bool is_conformable_top() const final
        {
            return ( units_.front()->is_conformable_top() );
        }

        RELATION get_relation_base() const final
        {
            return units_.back()->get_relation_base();
        }

        RELATION get_relation_top() const final
        {
            return units_.front()->get_relation_top();
        }

        const Interface3D& get_interface_base() const final
        {
            return units_.back()->get_interface_base();
        }

        const Interface3D& get_interface_top() const final
        {
            return units_.front()->get_interface_top();
        }

        double get_min_thick() const final
        {
            double sum_min_thick = 0.;
            for( auto unit : units_ )
            {
                sum_min_thick += unit->get_min_thick();
            }
            return sum_min_thick;
        }

        double get_max_thick() const final
        {
            double sum_max_thick = 0.;
            for( auto unit : units_ )
            {
                sum_max_thick += unit->get_max_thick();
            }
            return sum_max_thick;
        }

    private:
        std::vector< const StratigraphicUnit* > units_{};
    };

    enum struct STRATIGRAPHIC_PARADIGM
    {
        CHRONOSTRATIGRAPHIC,
        BIOSTRATIGRAPHIC,
        LITHOSTRATIGRAPHIC,
        UNSPECIFIED
    };

    class RINGMESH_API StratigraphicColumn
    {
    public:
        StratigraphicColumn( std::string name,
            const std::vector< const StratigraphicUnit* >& units,
            STRATIGRAPHIC_PARADIGM type )
            : name_( std::move( name ) ), units_( units ), type_( type )
        {
        }

        StratigraphicColumn(
            std::string name, const STRATIGRAPHIC_PARADIGM type )
            : StratigraphicColumn( std::move( name ), {}, type )
        {
        }

        void insert_unit_below( const StratigraphicUnit& above,
            const StratigraphicUnit& unit_to_add );
        void insert_top_unit( const StratigraphicUnit& to_add );
        void insert_base_unit( const StratigraphicUnit& to_add );

        void remove_unit( const StratigraphicUnit& unit );

        const StratigraphicUnit* get_top_unit() const
        {
            return units_.front();
        }

        const StratigraphicUnit* get_base_unit() const
        {
            return units_.back();
        }

        const StratigraphicUnit* get_unit_above(
            const StratigraphicUnit& unit ) const;
        const StratigraphicUnit* get_unit_below(
            const StratigraphicUnit& unit ) const;

        const StratigraphicUnit* get_unit( const index_t index ) const
        {
            return units_[index];
        }

        const StratigraphicUnit* get_unit( const std::string& name ) const;

        const std::vector< const StratigraphicUnit* >& get_all_units() const
        {
            return units_;
        }

        STRATIGRAPHIC_PARADIGM get_paradigm() const
        {
            return type_;
        }

        bool is_conformable_base() const
        {
            return ( units_.back()->is_conformable_base() );
        }
        bool is_conformable_top() const
        {
            return ( units_.front()->is_conformable_top() );
        }

        RELATION get_relation_base()
        {
            return ( units_.back()->get_relation_base() );
        }
        RELATION get_relation_top()
        {
            return ( units_.front()->get_relation_top() );
        }

        const Interface3D& get_interface_base() const
        {
            return ( units_.back()->get_interface_base() );
        }
        const Interface3D& get_interface_top() const
        {
            return ( units_.front()->get_interface_top() );
        }

        double get_column_min_thick() const;
        double get_column_max_thick() const;

        const std::string& get_name() const
        {
            return name_;
        }

    private:
        index_t get_index( const std::string& unit_name ) const;

    private:
        std::string name_{};
        std::vector< const StratigraphicUnit* > units_{};
        STRATIGRAPHIC_PARADIGM type_{ STRATIGRAPHIC_PARADIGM::UNSPECIFIED };
    };
} // namespace RINGMesh