entities_utilities.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//                   Philipp Bucher (https://github.com/philbucher)
//
 
#pragma once
 
// System includes
 
// External includes
 
// Project includes
#include "includes/model_part.h"
#include "utilities/parallel_utilities.h"
#include "utilities/string_utilities.h"
 
namespace Kratos
{
namespace EntitiesUtilities
{
    template<class TEntity>
    class KRATOS_API(KRATOS_CORE) EntitityIdentifier
    {
    public:
 
        using GeometryType = typename TEntity::GeometryType;
 
        constexpr static std::size_t LengthArray = static_cast<std::size_t>(GeometryData::KratosGeometryType::NumberOfGeometryTypes);
 
        KRATOS_CLASS_POINTER_DEFINITION(EntitityIdentifier);
 
 
        EntitityIdentifier() = default;
 
        EntitityIdentifier(const std::string& rName);
 
        EntitityIdentifier(const EntitityIdentifier& rOther)
            : mTypes(rOther.mTypes),
              mIsInitialized(rOther.mIsInitialized)
        {
        }
 
 
        EntitityIdentifier& operator=(const EntitityIdentifier& rOther)
        {
            mTypes = rOther.mTypes;
            mIsInitialized = rOther.mIsInitialized;
 
            return *this;
        }
 
 
        bool IsInitialized() const;
 
        bool HasPrototypeEntity(const GeometryType& rGeometry) const;
 
        const TEntity& GetPrototypeEntity(typename GeometryType::Pointer pGeometry) const;
 
        const TEntity& GetPrototypeEntity(const GeometryType& rGeometry) const;
 
 
        std::string Info() const
        {
            return "EntitityIdentifier";
        }
 
        void PrintInfo(std::ostream& rOStream) const
        {
            rOStream << "EntitityIdentifier";
        }
 
        void PrintData(std::ostream& rOStream) const;
 
    private:
 
        std::array<const TEntity*, LengthArray> mTypes;          
        bool mIsInitialized = false;                             
 
 
        std::string GetEntityTypeName() const;
 
        void GenerateSingleType(const std::string& rName);
 
        void GenerateMultipleTypes(const std::string& rName);
 
        void GenerateTemplatedTypes(const std::string& rName);
 
    }; 
 
 
    template<class TEntity>
    inline std::istream& operator >> (std::istream& rIStream,
                                    EntitityIdentifier<TEntity>& rThis);
 
    template<class TEntity>
    inline std::ostream& operator << (std::ostream& rOStream,
                                    const EntitityIdentifier<TEntity>& rThis)
    {
        rThis.PrintInfo(rOStream);
        rOStream << std::endl;
        rThis.PrintData(rOStream);
 
        return rOStream;
    }
 
    void KRATOS_API(KRATOS_CORE) InitializeAllEntities(ModelPart& rModelPart);
 
    void KRATOS_API(KRATOS_CORE) InitializeSolutionStepAllEntities(ModelPart& rModelPart);
 
    void KRATOS_API(KRATOS_CORE) FinalizeSolutionStepAllEntities(ModelPart& rModelPart);
 
    void KRATOS_API(KRATOS_CORE) InitializeNonLinearIterationAllEntities(ModelPart& rModelPart);
 
    void KRATOS_API(KRATOS_CORE) FinalizeNonLinearIterationAllEntities(ModelPart& rModelPart);
 
    template<class TEntityType>
    KRATOS_API(KRATOS_CORE) PointerVectorSet<TEntityType, IndexedObject>& GetEntities(ModelPart& rModelPart);
 
    template<class TEntityType>
    void InitializeEntities(ModelPart& rModelPart)
    {
        KRATOS_TRY
 
        // Array of entities
        auto& r_entities_array = GetEntities<TEntityType>(rModelPart);
 
        // The current process info
        const ProcessInfo& r_current_process_info = rModelPart.GetProcessInfo();
 
        // Initialize
        block_for_each(
            r_entities_array,
            [&r_current_process_info](TEntityType& rEntity) {
                // If the entity is active
                if (rEntity.IsActive()) {
                    rEntity.Initialize(r_current_process_info);
                }
            }
        );
 
        KRATOS_CATCH("")
    }
 
    template<class TEntityType>
    void InitializeSolutionStepEntities(ModelPart& rModelPart)
    {
        KRATOS_TRY
 
        // The current process info
        const ProcessInfo& r_current_process_info = rModelPart.GetProcessInfo();
 
        // Initialize
        block_for_each(
            GetEntities<TEntityType>(rModelPart),
            [&r_current_process_info](TEntityType& rEntity){
                rEntity.InitializeSolutionStep(r_current_process_info);
            }
        );
 
        KRATOS_CATCH("")
    }
 
    template<class TEntityType>
    void FinalizeSolutionStepEntities(ModelPart& rModelPart)
    {
        KRATOS_TRY
 
        // The current process info
        const ProcessInfo& r_current_process_info = rModelPart.GetProcessInfo();
 
        // Initialize
        block_for_each(
            GetEntities<TEntityType>(rModelPart),
            [&r_current_process_info](TEntityType& rEntity){
                rEntity.FinalizeSolutionStep(r_current_process_info);
            }
        );
 
        KRATOS_CATCH("")
    }
 
    template<class TEntityType>
    void InitializeNonLinearIterationEntities(ModelPart& rModelPart)
    {
        KRATOS_TRY
 
        // The current process info
        const ProcessInfo& r_current_process_info = rModelPart.GetProcessInfo();
 
        // Initialize
        block_for_each(
            GetEntities<TEntityType>(rModelPart),
            [&r_current_process_info](TEntityType& rEntity){
                rEntity.InitializeNonLinearIteration(r_current_process_info);
            }
        );
 
        KRATOS_CATCH("")
    }
 
    template<class TEntityType>
    void FinalizeNonLinearIterationEntities(ModelPart& rModelPart)
    {
        KRATOS_TRY
 
        // The current process info
        const ProcessInfo& r_current_process_info = rModelPart.GetProcessInfo();
 
        // Initialize
        block_for_each(
            GetEntities<TEntityType>(rModelPart),
            [&r_current_process_info](TEntityType& rEntity){
                rEntity.FinalizeNonLinearIteration(r_current_process_info);
            }
        );
 
        KRATOS_CATCH("")
    }
 
 
}; // namespace EntitiesUtilities
}  // namespace Kratos