divide_geometry.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Ruben Zorrilla
//
 
#if !defined(KRATOS_DIVIDE_GEOMETRY)
#define KRATOS_DIVIDE_GEOMETRY
 
// System includes
 
// External includes
 
// Project includes
#include "includes/node.h"
#include "geometries/point.h"
#include "geometries/geometry.h"
#include "geometries/geometry_data.h"
#include "includes/indexed_object.h"
#include "containers/pointer_vector_set.h"
 
namespace Kratos
{
 
 
 
 
class KRATOS_API(KRATOS_CORE) IndexedPoint : public Point, public IndexedObject
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(IndexedPoint);
 
 
    IndexedPoint();
 
    explicit IndexedPoint(const unsigned int Id);
 
    IndexedPoint(const array_1d<double,3>& rCoords, const unsigned int Id);
 
    ~IndexedPoint();
 
 
 
 
    std::string Info() const override;
 
    void PrintInfo(std::ostream& rOStream) const override;
 
    void PrintData(std::ostream& rOStream) const override;
 
 
 
 
 
private:
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, Point);
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, IndexedObject);
    };
 
    void load(Serializer& rSerializer) override {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, Point);
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, IndexedObject);
    };
 
 
 
 
 
};
 
inline std::istream& operator >> (std::istream& rIStream,
                                  IndexedPoint& rThis) {
    return rIStream;
};
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const IndexedPoint& rThis) {
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
};
 
template<class TPointType>
class KRATOS_API(KRATOS_CORE) DivideGeometry
{
public:
 
 
    KRATOS_CLASS_POINTER_DEFINITION(DivideGeometry);
 
    // General type definitions
    typedef Geometry < TPointType >                                    GeometryType;
    typedef IndexedPoint                                            IndexedPointType;
    typedef IndexedPoint::Pointer                                   IndexedPointPointerType;
    typedef Geometry < IndexedPoint >                               IndexedPointGeometryType;
    typedef Geometry < IndexedPoint >::Pointer                      IndexedPointGeometryPointerType;
    typedef PointerVectorSet<IndexedPointType, IndexedObject>       IndexedPointsContainerType;
 
    bool mIsSplit;          // True if the element is split.
 
    int mSplitEdgesNumber;  // Number of split edges.
    int mDivisionsNumber;   // Number of generated subdivisions.
 
    IndexedPointsContainerType mAuxPointsContainer;                         // Indexed points container to store the original plus the intersection points.
 
 
    DivideGeometry(const GeometryType& rInputGeometry, const Vector& rNodalDistances);
 
    virtual ~DivideGeometry();
 
 
    std::vector<IndexedPointGeometryPointerType> GetPositiveSubdivisions() const;
 
    std::vector<IndexedPointGeometryPointerType> GetNegativeSubdivisions() const;
 
    std::vector<IndexedPointGeometryPointerType> GetPositiveInterfaces() const;
 
    std::vector<IndexedPointGeometryPointerType> GetNegativeInterfaces() const;
 
    std::vector<unsigned int> GetPositiveInterfacesParentIds() const;
 
    std::vector<unsigned int> GetNegativeInterfacesParentIds() const;
 
 
 
    virtual std::string Info() const;
 
    virtual void PrintInfo(std::ostream& rOStream) const;
 
    virtual void PrintData(std::ostream& rOStream) const;
 
 
 
    virtual const std::vector<int>& GetEdgeIdsI() const = 0;
 
    virtual const std::vector<int>& GetEdgeIdsJ() const = 0;
 
    virtual std::vector<int>& GetSplitEdges() = 0;
 
    Vector GetNodalDistances() const;
 
    GeometryType GetInputGeometry() const;
 
    virtual void GenerateDivision() = 0;
 
    virtual void GenerateIntersectionsSkin() = 0;
 
    virtual void GenerateExteriorFaces(
        std::vector < IndexedPointGeometryPointerType > &rExteriorFacesVector,
        std::vector < unsigned int > &rExteriorFacesParentSubdivisionsIdsVector,
        const std::vector < IndexedPointGeometryPointerType > &rSubdivisionsContainer)
    {
        KRATOS_ERROR << "Accessing base class \'GenerateExteriorFaces\' method."<< std::endl;
    };
 
    virtual void GenerateExteriorFaces(
        std::vector < IndexedPointGeometryPointerType > &rExteriorFacesVector,
        std::vector < unsigned int > &rExteriorFacesParentSubdivisionsIdsVector,
        const std::vector < IndexedPointGeometryPointerType > &rSubdivisionsContainer,
        const unsigned int FatherFaceId)
    {
        KRATOS_ERROR << "Accessing base class \'GenerateExteriorFaces\' method."<< std::endl;
    };
 
 
protected:
 
 
    std::vector<IndexedPointGeometryPointerType> mPositiveSubdivisions; // Array to store the generated positive subdivisions geometries.
    std::vector<IndexedPointGeometryPointerType> mNegativeSubdivisions; // Array to store the generated negative subdivisions geometries.
    std::vector<IndexedPointGeometryPointerType> mPositiveInterfaces;   // Array to store the generated positive interfaces geometries.
    std::vector<IndexedPointGeometryPointerType> mNegativeInterfaces;   // Array to store the generated negative interfaces geometries.
    std::vector<unsigned int> mPositiveInterfacesParentIds;             // Array to store the parent subgeometries ids of the generated positive interfaces.
    std::vector<unsigned int> mNegativeInterfacesParentIds;             // Array to store the parent subgeometries ids of the generated negative interfaces.
 
 
 
    void IsSplit();
 
 
 
 
 
private:
 
 
    const GeometryType& mrInputGeometry;
    const Vector& mrNodalDistances;
 
 
 
 
 
 
 
    DivideGeometry& operator=(DivideGeometry const& rOther);
 
    DivideGeometry(DivideGeometry const& rOther)
        : mrInputGeometry(rOther.mrInputGeometry) , mrNodalDistances(rOther.mrNodalDistances) {};
 
 
};// class DivideGeometry
 
}//namespace Kratos
#endif /* KRATOS_DIVIDE_GEOMETRY defined */