multiscale_refining_process.h

Go to the documentation of this file.

// KRATOS  __  __ _____ ____  _   _ ___ _   _  ____
//        |  \/  | ____/ ___|| | | |_ _| \ | |/ ___|
//        | |\/| |  _| \___ \| |_| || ||  \| | |  _
//        | |  | | |___ ___) |  _  || || |\  | |_| |
//        |_|  |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Miguel Maso Sotomayor
//
 
#if !defined( KRATOS_MULTISCALE_REFINING_PROCESS_H_INCLUDED )
#define KRATOS_MULTISCALE_REFINING_PROCESS_H_INCLUDED
 
 
// System includes
#include <string>
#include <iostream>
#include <algorithm>
 
// External includes
 
// Project includes
#include "processes/process.h"
#include "includes/model_part.h"
#include "includes/kratos_parameters.h"
#include "includes/global_pointer_variables.h"
#include "utilities/variable_utils.h"
#include "custom_utilities/uniform_refinement_utility.h"
 
 
namespace Kratos {
 
 
 
 
 
 
class KRATOS_API(MESHING_APPLICATION) MultiscaleRefiningProcess : public Process
{
public:
 
 
    typedef Node NodeType;
 
    typedef std::size_t IndexType;
 
    typedef std::vector<IndexType> IndexVectorType;
 
    typedef std::vector<std::string> StringVectorType;
 
    typedef ModelPart::NodesContainerType NodesArrayType;
 
    typedef std::unordered_map<IndexType, IndexType> IndexIndexMapType;
    typedef std::unordered_map<IndexType, std::vector<std::string>> IndexStringMapType;
    typedef std::unordered_map<IndexType, std::vector<IndexType>> IndexVectorMapType;
 
    KRATOS_CLASS_POINTER_DEFINITION(MultiscaleRefiningProcess);
 
 
    MultiscaleRefiningProcess(
        ModelPart& rThisCoarseModelPart,
        ModelPart& rThisRefinedModelPart,
        ModelPart& rThisVisualizationModelPart,
        Parameters ThisParameters = Parameters(R"({})")
        );
 
    ~MultiscaleRefiningProcess() override = default;
 
 
    void operator()()
    {
        Execute();
    }
 
 
    void Execute() override {}
 
    const Parameters GetDefaultParameters() const override;
 
    int Check() override;
 
    void ExecuteRefinement();
 
    void ExecuteCoarsening();
 
    static void InitializeVisualizationModelPart(ModelPart& rReferenceModelPart, ModelPart& rNewModelPart);
 
    static void InitializeRefinedModelPart(ModelPart& rReferenceModelPart, ModelPart& rNewModelPart);
 
    template<class TVarType>
    void TransferLastStepToCoarseModelPart(const TVarType& rVariable)
    {
        ModelPart::NodeIterator refined_begin = mrRefinedModelPart.NodesBegin();
        for (int i = 0; i < static_cast<int>(mrRefinedModelPart.Nodes().size()); i++)
        {
            auto refined_node = refined_begin + i;
            if (refined_node->GetValue(FATHER_NODES).size() == 1)
            {
                auto& value = refined_node->GetValue(FATHER_NODES)[0].FastGetSolutionStepValue(rVariable);
                value = refined_node->FastGetSolutionStepValue(rVariable); // we only copy the current step
            }
        }
    }
 
    template<class TVarType>
    void TransferSubstepToRefinedInterface(const TVarType& rVariable, const double& rSubstepFraction)
    {
        ModelPart::NodeIterator refined_begin = mRefinedInterfaceContainer.begin();
        for (int i = 0; i < static_cast<int>(mRefinedInterfaceContainer.size()); i++)
        {
            auto refined_node = refined_begin + i;
            GlobalPointersVector<NodeType>& father_nodes = refined_node->GetValue(FATHER_NODES);
            IndexType number_of_father_nodes = father_nodes.size();
            std::vector<double> weights = refined_node->GetValue(FATHER_NODES_WEIGHTS);
 
            // Transfer the data
            auto& value = refined_node->FastGetSolutionStepValue(rVariable);
            value = weights[0] * rSubstepFraction * father_nodes[0].FastGetSolutionStepValue(rVariable);
            value += weights[0] * (1-rSubstepFraction) * father_nodes[0].FastGetSolutionStepValue(rVariable, 1);
 
            if (number_of_father_nodes > 1)
            {
                for (IndexType j = 1; j < number_of_father_nodes; j++)
                {
                    value += weights[j] * rSubstepFraction * father_nodes[j].FastGetSolutionStepValue(rVariable);
                    value += weights[j] * (1-rSubstepFraction) * father_nodes[j].FastGetSolutionStepValue(rVariable, 1);
                }
            }
        }
    }
 
    template<class TVarType>
    void FixRefinedInterface(const TVarType& rVariable, bool IsFixed)
    {
        VariableUtils().ApplyFixity(rVariable, IsFixed, mRefinedInterfaceContainer);
    }
 
 
 
    ModelPart& GetCoarseModelPart()
    {
        return mrCoarseModelPart;
    }
 
    ModelPart& GetRefinedModelPart()
    {
        return mrRefinedModelPart;
    }
 
    ModelPart& GetVisualizationModelPart()
    {
        return mrVisualizationModelPart;
    }
 
 
    std::string Info() const override
    {
        return "MultiscaleRefiningProcess";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
 
 
    protected:
 
 
 
 
 
 
 
 
 
    private:
 
 
 
    ModelPart& mrCoarseModelPart;  
    ModelPart& mrRefinedModelPart; 
    ModelPart& mrVisualizationModelPart;
    Parameters mParameters;
 
    unsigned int mEchoLevel;
    int mDivisionsAtSubscale;
    IndexType mStepDataSize;
 
    UniformRefinementUtility mUniformRefinement; 
 
    NodesArrayType mRefinedInterfaceContainer;
 
    std::string mRefinedInterfaceName;
    std::string mInterfaceConditionName;
 
    IndexStringMapType mCollections;  
 
 
    void InterpolateLevelBoundaryValuesAtSubStep(const int& rSubStep, const int& rSubSteps);
 
    void UpdateSubLevel();
 
    void TransferDataToCoarseLevel();
 
    void InitializeCoarseModelPartInterface();
 
    void InitializeRefinedModelPartInterface();
 
    static void InitializeNewModelPart(ModelPart& rReferenceModelPart, ModelPart& rNewModelPart);
 
    static void AddAllPropertiesToModelPart(ModelPart& rOriginModelPart, ModelPart& rDestinationModelPart);
 
    static void AddAllTablesToModelPart(ModelPart& rOriginModelPart, ModelPart& rDestinationModelPart);
 
    void MarkElementsFromNodalFlag();
 
    void MarkConditionsFromNodalFlag();
 
    void CloneNodesToRefine(IndexType& rNodeId);
 
    void CreateElementsToRefine(IndexType& rElemId, IndexIndexMapType& rElemTag);
 
    void CreateConditionsToRefine(IndexType& rCondId, IndexIndexMapType& rCondTag);
 
    void UpdateVisualizationAfterRefinement();
 
    void UpdateVisualizationAfterCoarsening();
 
    void IdentifyParentNodesToCoarsen();
 
    void IdentifyElementsToErase();
 
    void IdentifyConditionsToErase();
 
    void IdentifyRefinedNodesToErase();
 
    void FinalizeRefinement();
 
    void FinalizeCoarsening();
 
    void IdentifyCurrentInterface();
 
    void UpdateRefinedInterface();
 
    void GetLastId(IndexType& rNodesId, IndexType& rElemsId, IndexType& rCondsId);
 
 
 
 
 
    // MultiscaleRefiningProcess& operator=(MultiscaleRefiningProcess const& rOther);
 
    // MultiscaleRefiningProcess(MultiscaleRefiningProcess const& rOther);
 
 
}; // Class MultiscaleRefiningProcess
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  MultiscaleRefiningProcess& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const MultiscaleRefiningProcess& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}  // namespace Kratos.
 
#endif // KRATOS_MULTISCALE_REFINING_PROCESS_H_INCLUDED