uniform_refinement_utility.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Miguel Maso Sotomayor
//
 
 
#if !defined( KRATOS_UNIFORM_REFINEMENT_UTILITY_H_INCLUDED )
#define KRATOS_UNIFORM_REFINEMENT_UTILITY_H_INCLUDED
 
 
// System includes
#include <string>
#include <iostream>
#include <unordered_map>
 
 
// External includes
 
 
// Project includes
#include "includes/key_hash.h"
#include "includes/define.h"
#include "includes/node.h"
#include "includes/element.h"
#include "includes/condition.h"
#include "includes/model_part.h"
#include "geometries/triangle_2d_3.h"
#include "geometries/quadrilateral_3d_4.h"
#include "geometries/tetrahedra_3d_4.h"
#include "geometries/hexahedra_3d_8.h"
#include "meshing_application_variables.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
class UniformRefinementUtility
{
public:
 
    typedef Node NodeType;
 
    typedef Line3D2<NodeType> EdgeType;
 
    typedef Quadrilateral3D4<NodeType> FaceType;
 
    typedef Hexahedra3D8<NodeType> BodyType;
 
    typedef std::size_t IndexType;
 
    typedef ModelPart::NodesContainerType NodesArrayType;
    typedef ModelPart::ElementsContainerType ElementsArrayType;
    typedef ModelPart::ConditionsContainerType ConditionsArrayType;
 
    typedef std::pair<IndexType, IndexType> EdgeKeyType;
    typedef std::array<IndexType, 4> FaceKeyType;
    typedef std::map<EdgeKeyType, IndexType> NodesInEdgeMapType;
    typedef std::unordered_map<FaceKeyType, IndexType, KeyHasherRange<FaceKeyType>, KeyComparorRange<FaceKeyType>> NodesInFaceMapType;
 
    typedef std::vector<IndexType> IndexVectorType;
    typedef std::vector<std::string> StringVectorType;
    typedef std::unordered_map<IndexType, IndexType> IndexIndexMapType;
    typedef std::unordered_map<IndexType, IndexVectorType> IndexIndexVectorMapType;
    typedef std::unordered_map<IndexType, StringVectorType> IndexStringVectorMapType;
 
    KRATOS_CLASS_POINTER_DEFINITION(UniformRefinementUtility);
 
 
    UniformRefinementUtility(ModelPart& rModelPart);
 
    virtual ~UniformRefinementUtility();
 
 
 
 
 
    void Refine(int& rFinalRefinementLevel);
 
    void SetCustomIds(IndexType& rNodeId, IndexType& rElemId, IndexType& rCondId);
 
    void GetLastCreatedIds(IndexType& rNodeId, IndexType& rElemId, IndexType& rCondId);
 
    void RemoveRefinedEntities(Flags ThisFlag);
 
 
 
 
 
 
    virtual std::string Info() const;
 
    virtual void PrintInfo(std::ostream& rOStream) const;
 
    virtual void PrintData(std::ostream& rOStream) const;
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    ModelPart& mrModelPart;             
    IndexType mDimension;
 
    IndexType mLastNodeId;           
    IndexType mLastElemId;           
    IndexType mLastCondId;           
    IndexType mStepDataSize;         
    IndexType mBufferSize;           
 
    NodeType::DofsContainerType mDofs;  
 
    NodesInEdgeMapType mNodesMap;              
    NodesInFaceMapType mNodesInFaceMap;        
 
    IndexIndexMapType mNodesTags;
    IndexIndexMapType mElementsTags;
    IndexIndexMapType mConditionsTags;
    IndexStringVectorMapType mCollections;
 
 
 
 
    void ExecuteDivision(
        const int& rDivision,
        IndexIndexVectorMapType& rTagNodes,
        IndexIndexVectorMapType& rTagElems,
        IndexIndexVectorMapType& rTagConds
        );
 
    typename NodeType::Pointer GetNodeInEdge(
        const EdgeType& rEdge,
        const int& rNumberOfDivisions,
        IndexIndexVectorMapType& rTagNodes,
        const IndexType& rCollectionTag
    );
 
    typename NodeType::Pointer CreateNodeInEdge(
        const EdgeType& rEdge,
        const int& rNumberOfDivisions,
        const EdgeKeyType& rNodeKey
        );
 
    typename NodeType::Pointer GetNodeInFace(
        const FaceType& rFace,
        const int& rNumberOfDivisions,
        IndexIndexVectorMapType& rTagNodes,
        const IndexType& rCollectionTag
        );
 
    typename NodeType::Pointer CreateNodeInFace(
        const FaceType& rFace,
        const int& rNumberOfDivisions,
        const FaceKeyType& rNodeKey
        );
 
    typename NodeType::Pointer GetNodeInBody(
        const BodyType& rBody,
        const int& rNumberOfDivisions,
        IndexIndexVectorMapType& rTagNodes,
        const IndexType& rCollectionTag
        );
 
    void CalculateNodalStepData(
        NodeType::Pointer pNewNode,
        const NodeType::Pointer pNode0,
        const NodeType::Pointer pNode1
        );
 
    void CalculateNodalStepData(
        NodeType::Pointer pNewNode,
        const NodeType::Pointer pNode0,
        const NodeType::Pointer pNode1,
        const NodeType::Pointer pNode2,
        const NodeType::Pointer pNode3
        );
 
    void CalculateNodalStepData(
        NodeType::Pointer pNewNode,
        const BodyType& rBody
        );
 
    void AddOtherFatherNodes(
        GlobalPointersVector<NodeType>& rThisFatherNodes,
        std::vector<double>& rThisFatherWeights,
        GlobalPointersVector<NodeType>& rOtherFatherNodes,
        const std::vector<double>& rOtherFatherWeights,
        const double& rWeight = 0.5
        );
 
    void CreateElement(
        ElementsArrayType::iterator pOriginElement,
        PointerVector<NodeType>& rThisNodes,
        const int& rNumberOfDivisions,
        IndexIndexVectorMapType& rTagElems
        );
 
    void CreateCondition(
        ConditionsArrayType::iterator pOriginCondition,
        PointerVector<NodeType>& rThisNodes,
        const int& rNumberOfDivisions,
        IndexIndexVectorMapType& rTagConds
        );
 
    PointerVector<NodeType> GetSubLineNodes(
        const int Position,
        const Geometry<NodeType>& rGeom,
        NodeType::Pointer& rMiddleNode
        );
 
    PointerVector<NodeType> GetSubTriangleNodes(
        const int Position,
        const Geometry<NodeType>& rGeom,
        std::vector<NodeType::Pointer>& rMiddleNodes
        );
 
    PointerVector<NodeType> GetSubQuadrilateralNodes(
        const int Position,
        const Geometry<NodeType>& rGeom,
        std::vector<NodeType::Pointer>& rMiddleNodes
        );
 
PointerVector<NodeType> GetSubTetrahedraNodes(
    const int Position,
    const Geometry<NodeType>& rGeom,
    std::vector<NodeType::Pointer>& rMiddleNodes
    );
 
PointerVector<NodeType> GetSubHexahedraNodes(
    const int Position,
    const Geometry<NodeType>& rGeom,
    std::vector<NodeType::Pointer>& rMiddleNodes
    );
 
 
 
 
 
 
 
    //UniformRefinementUtility& operator=(UniformRefinementUtility const& rOther);
 
    UniformRefinementUtility(UniformRefinementUtility const& rOther);
 
 
 
}; // Class UniformRefinementUtility
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                UniformRefinementUtility& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                const UniformRefinementUtility& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_UNIFORM_REFINEMENT_UTILITY_H_INCLUDED  defined