mapping_variables.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_MAPPING_VARIABLES_H_INCLUDED)
#define KRATOS_MAPPING_VARIABLES_H_INCLUDED
 
// System includes
#include <unordered_set>
#include <unordered_map>
 
// External includes
 
// Project includes
#include "includes/condition.h"
#include "includes/define.h"
#include "includes/key_hash.h"
#include "containers/variable.h"
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_API
 
namespace Kratos
{
 
 
    typedef std::size_t IndexType;
 
 
 
 
    class IndexDatabase
    {
    public:
        KRATOS_CLASS_POINTER_DEFINITION( IndexDatabase );
 
 
        IndexDatabase(){}
 
        virtual ~IndexDatabase(){}
 
 
 
        virtual bool Has(const IndexType IndexOrigin) {return false;}
 
        virtual void AddId(
            const IndexType IndexOrigin,
            const IndexType IndexNewEntity = 0
            ) {}
 
        virtual void RemoveId(const IndexType IndexOrigin) {}
 
        virtual IndexType GetNewEntityId(const IndexType IndexOrigin) {return 0;}
 
        virtual void SetNewEntityId(
            const IndexType IndexOrigin,
            const IndexType IndexNewEntity = 0
            ) {}
 
        virtual std::string Info() const {return "IndexDatabase";}
 
        virtual void save( Serializer& rSerializer ) const {}
 
        virtual void load( Serializer& rSerializer ) {}
    }; // Class IndexDatabase
 
    class IndexSet
        : public std::unordered_set<IndexType>, public IndexDatabase
    {
    public:
        KRATOS_CLASS_POINTER_DEFINITION( IndexSet );
 
        typedef std::unordered_set<IndexType> BaseType;
        typedef iterator IteratorType;
 
 
        IndexSet(){}
 
        virtual ~IndexSet(){}
 
 
 
        IndexType GetId(IteratorType ThisIterator)
        {
            return *ThisIterator;
        }
 
        IndexType GetOtherId(IteratorType ThisIterator)
        {
            return 0;
        }
 
        bool Has(const IndexType IndexOrigin) override
        {
            BaseType::iterator set = find(IndexOrigin);
            if(set != end())
                return true;
 
            return false;
        }
 
        void AddId(
            const IndexType IndexOrigin,
            const IndexType IndexNewEntity = 0
            ) override
        {
            insert({IndexOrigin});
        }
 
        void RemoveId(const IndexType IndexOrigin) override
        {
            BaseType::iterator set = find(IndexOrigin);
            if(set != end())
                erase(set);
        }
 
        std::string Info() const override
        {
            std::stringstream buffer;
            for ( auto it = begin(); it != end(); ++it )
                buffer << "The condition " << *it << std::endl;
            return buffer.str();
        }
 
        void save( Serializer& rSerializer ) const override
        {
//             KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, BaseType );
        }
 
        void load( Serializer& rSerializer ) override
        {
//             KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType );
        }
    }; // Class IndexSet
 
    class IndexMap
        : public std::unordered_map<IndexType, IndexType>, public IndexDatabase
    {
    public:
        KRATOS_CLASS_POINTER_DEFINITION( IndexMap );
 
        typedef std::unordered_map<IndexType, IndexType> BaseType;
        typedef iterator IteratorType;
 
 
        IndexMap(){}
 
        virtual ~IndexMap(){}
 
 
 
        IndexType GetId(IteratorType ThisIterator)
        {
            return ThisIterator->first;
        }
 
        IndexType GetOtherId(IteratorType ThisIterator)
        {
            return ThisIterator->second;
        }
 
        bool Has(const IndexType IndexOrigin) override
        {
            BaseType::iterator map = find(IndexOrigin);
            if(map != end())
                return true;
 
            return false;
        }
 
        void AddId(
            const IndexType IndexOrigin,
            const IndexType IndexNewEntity = 0
            ) override
        {
            insert({IndexOrigin, IndexNewEntity});
        }
 
        void RemoveId(const IndexType IndexOrigin) override
        {
            BaseType::iterator map = find(IndexOrigin);
            if(map != end())
                erase(map);
        }
 
        IndexType GetNewEntityId(const IndexType IndexOrigin) override
        {
            BaseType::iterator map = find(IndexOrigin);
            if(map != end())
                return map->second;
 
            return 0;
        }
 
        void SetNewEntityId(
            const IndexType IndexOrigin,
            const IndexType IndexNewEntity
            ) override
        {
            BaseType::iterator map = find(IndexOrigin);
            if(map != end())
                map->second = IndexNewEntity;
        }
 
        std::string Info() const override
        {
            std::stringstream buffer;
            for ( auto it = begin(); it != end(); ++it )
                buffer << "The condition " << it->first << " related with the new condition " << it->second << std::endl;
            return buffer.str();
        }
 
        void save( Serializer& rSerializer ) const override
        {
//             KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, BaseType );
        }
 
        void load( Serializer& rSerializer ) override
        {
//             KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType );
        }
    }; // Class IndexMap
 
    KRATOS_DEFINE_VARIABLE( IndexSet::Pointer, INDEX_SET )         // An unordened set of which contains the indexes with the paired
    KRATOS_DEFINE_VARIABLE( IndexMap::Pointer, INDEX_MAP )         // An unordened map of which contains the indexes with the paired
    KRATOS_DEFINE_VARIABLE( double, TANGENT_FACTOR )               // The factor between the tangent and normal behaviour
 
} // namespace Kratos
 
#undef  KRATOS_EXPORT_MACRO
#define KRATOS_EXPORT_MACRO KRATOS_NO_EXPORT
 
#endif // KRATOS_MAPPING_VARIABLES_H_INCLUDED defined