local_refine_geometry_mesh.hpp

Go to the documentation of this file.

// KRATOS  __  __ _____ ____  _   _ ___ _   _  ____
//        |  \/  | ____/ ___|| | | |_ _| \ | |/ ___|
//        | |\/| |  _| \___ \| |_| || ||  \| | |  _
//        | |  | | |___ ___) |  _  || || |\  | |_| |
//        |_|  |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
//  License:             BSD License
//                       Kratos default license: kratos/license.txt
//
//  Main authors:        Nelson Lafontaine
//                       Jordi Cotela Dalmau
//                       Riccardo Rossi
//  Co-authors:          Vicente Mataix Ferrandiz
//
 
#pragma once
 
 
// NOTE: Before compute the remeshing it is necessary to compute the neighbours
 
// System includes
 
// Extrenal includes
 
// Project includes
#include "includes/variables.h"
#include "includes/deprecated_variables.h"
#include "includes/model_part.h"
#include "includes/global_pointer_variables.h"
#include "geometries/geometry.h"
 
namespace Kratos
{
class KRATOS_API(MESHING_APPLICATION) LocalRefineGeometryMesh
{
public:
 
    typedef ModelPart::NodesContainerType NodesArrayType;
    typedef ModelPart::ElementsContainerType ElementsArrayType;
    typedef ModelPart::ConditionsContainerType ConditionsArrayType;
    typedef std::vector<Matrix> Matrix_Order_Tensor;
    typedef std::vector<Vector> Vector_Order_Tensor;
    typedef std::vector<Vector_Order_Tensor> Node_Vector_Order_Tensor;
    typedef Node PointType;
    typedef Node ::Pointer PointPointerType;
    typedef std::vector<PointType::Pointer> PointVector;
    typedef PointVector::iterator PointIterator;
 
 
    LocalRefineGeometryMesh(ModelPart& model_part) : mModelPart(model_part)
    {
 
    }
 
    virtual ~LocalRefineGeometryMesh()
    = default;
 
 
 
    virtual void LocalRefineMesh(
        bool refine_on_reference,
        bool interpolate_internal_variables
        );
 
    virtual void CSRRowMatrix(
        ModelPart& this_model_part,
        compressed_matrix<int>& Coord
        );
 
    virtual void SearchEdgeToBeRefined(
        ModelPart& this_model_part,
        compressed_matrix<int>& Coord
        );
 
    virtual void CreateListOfNewNodes(
        ModelPart& this_model_part,
        compressed_matrix<int>& Coord,
        std::vector<int> &List_New_Nodes,
        std::vector<array_1d<int, 2 > >& Position_Node
        );
 
    virtual void CalculateCoordinateAndInsertNewNodes(
        ModelPart& this_model_part,
        const std::vector<array_1d<int, 2 > >& Position_Node,
        const std::vector<int> &List_New_Nodes
        );
 
    virtual void EraseOldElementAndCreateNewElement(
        ModelPart& this_model_part,
        const compressed_matrix<int>& Coord,
        PointerVector< Element >& New_Elements,
        bool interpolate_internal_variables
        );
 
    virtual void EraseOldConditionsAndCreateNew(
        ModelPart& this_model_part,
        const compressed_matrix<int>& Coord
        );
 
    virtual void CalculateEdges(
        Element::GeometryType& geom,
        const compressed_matrix<int>& Coord,
        int* edge_ids,
        std::vector<int> & aux
        );
 
    inline void CreatePartition(
      unsigned int number_of_threads,
      const int number_of_rows,
      vector<unsigned int>& partitions
      );
 
    template<typename TGeometricalObjectPointerType>
    void InterpolateInteralVariables(
            const int& number_elem,
            const TGeometricalObjectPointerType father_elem,
            TGeometricalObjectPointerType child_elem,
            const ProcessInfo& rCurrentProcessInfo
            )
    {
        // NOTE: Right now there is not an interpolation at all, it just copying the values
        std::vector<Vector> values;
        father_elem->CalculateOnIntegrationPoints(INTERNAL_VARIABLES, values, rCurrentProcessInfo);
        child_elem->SetValuesOnIntegrationPoints(INTERNAL_VARIABLES, values, rCurrentProcessInfo);
    }
 
    virtual void UpdateSubModelPartNodes(ModelPart &rModelPart);
 
    virtual void ResetFatherNodes(ModelPart &rModelPart);
 
protected:
 
 
        ModelPart& mModelPart;       
        int mCurrentRefinementLevel; 
        std::unordered_map<std::size_t, unsigned int> mMapNodeIdToPos;
        std::vector<std::size_t> mMapPosToNodeId;
 
    template<typename TIteratorType>
    void SearchEdgeToBeRefinedGeneric(
            TIteratorType GeometricalObjectsBegin,
            TIteratorType GeometricalObjectsEnd,
            compressed_matrix<int>& rCoord
                      )
    {
        KRATOS_TRY;
 
        for (TIteratorType it = GeometricalObjectsBegin; it != GeometricalObjectsEnd; ++it) {
            if (it->GetValue(SPLIT_ELEMENT)) {
                auto& r_geom = it->GetGeometry(); // Nodes of the element
                for (unsigned int i = 0; i < r_geom.size(); i++) {
                    int index_i = mMapNodeIdToPos[r_geom[i].Id()];
                    for (unsigned int j = 0; j < r_geom.size(); j++) {
                        int index_j = mMapNodeIdToPos[r_geom[j].Id()];
                        if (index_j > index_i)
                        {
                            rCoord(index_i, index_j) = -2;
                        }
                    }
                }
            }
        }
 
        KRATOS_CATCH("");
    }
 
 
 
 
 
private:
 
 
 
 
 
 
        
};
 
} // namespace Kratos.