geometry_data.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
//
 
#if !defined(KRATOS_GEOMETRY_DATA_H_INCLUDED )
#define  KRATOS_GEOMETRY_DATA_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/ublas_interface.h"
#include "integration/integration_point.h"
#include "geometries/geometry_dimension.h"
#include "geometries/geometry_shape_function_container.h"
 
namespace Kratos
{
 
 
 
 
 
 
class GeometryData
{
public:
 
    enum class IntegrationMethod {
        GI_GAUSS_1,
        GI_GAUSS_2,
        GI_GAUSS_3,
        GI_GAUSS_4,
        GI_GAUSS_5,
        GI_EXTENDED_GAUSS_1,
        GI_EXTENDED_GAUSS_2,
        GI_EXTENDED_GAUSS_3,
        GI_EXTENDED_GAUSS_4,
        GI_EXTENDED_GAUSS_5,
        NumberOfIntegrationMethods // Note that this entry needs to be always the last to be used as integration methods counter
    };
 
    enum class KratosGeometryFamily
    {
        Kratos_NoElement,
        Kratos_Point,
        Kratos_Linear,
        Kratos_Triangle,
        Kratos_Quadrilateral,
        Kratos_Tetrahedra,
        Kratos_Hexahedra,
        Kratos_Prism,
        Kratos_Pyramid,
        Kratos_Nurbs,
        Kratos_Brep,
        Kratos_Quadrature_Geometry,
        Kratos_Composite,
        Kratos_generic_family,
        NumberOfGeometryFamilies // Note that this entry needs to be always the last to be used as geometry families counter
    };
 
    enum class KratosGeometryType
    {
        Kratos_generic_type,
        Kratos_Hexahedra3D20,
        Kratos_Hexahedra3D27,
        Kratos_Hexahedra3D8,
        Kratos_Prism3D15,
        Kratos_Prism3D6,
        Kratos_Pyramid3D13,
        Kratos_Pyramid3D5,
        Kratos_Quadrilateral2D4,
        Kratos_Quadrilateral2D8,
        Kratos_Quadrilateral2D9,
        Kratos_Quadrilateral3D4,
        Kratos_Quadrilateral3D8,
        Kratos_Quadrilateral3D9,
        Kratos_Tetrahedra3D10,
        Kratos_Tetrahedra3D4,
        Kratos_Triangle2D3,
        Kratos_Triangle2D6,
        Kratos_Triangle2D10,
        Kratos_Triangle2D15,
        Kratos_Triangle3D3,
        Kratos_Triangle3D6,
        Kratos_Line2D2,
        Kratos_Line2D3,
        Kratos_Line2D4,
        Kratos_Line2D5,
        Kratos_Line3D2,
        Kratos_Line3D3,
        Kratos_Point2D,
        Kratos_Point3D,
        Kratos_Sphere3D1,
        Kratos_Nurbs_Curve,
        Kratos_Nurbs_Surface,
        Kratos_Nurbs_Volume,
        Kratos_Nurbs_Curve_On_Surface,
        Kratos_Surface_In_Nurbs_Volume,
        Kratos_Brep_Curve,
        Kratos_Brep_Surface,
        Kratos_Brep_Curve_On_Surface,
        Kratos_Quadrature_Point_Geometry,
        Kratos_Coupling_Geometry,
        Kratos_Quadrature_Point_Curve_On_Surface_Geometry,
        Kratos_Quadrature_Point_Surface_In_Volume_Geometry,
        NumberOfGeometryTypes // Note that this entry needs to be always the last to be used as geometry types counter
    };
 
    KRATOS_CLASS_POINTER_DEFINITION( GeometryData );
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
    typedef IntegrationPoint<3> IntegrationPointType;
 
    typedef GeometryShapeFunctionContainer<IntegrationMethod>::IntegrationPointsArrayType IntegrationPointsArrayType;
 
    typedef GeometryShapeFunctionContainer<IntegrationMethod>::IntegrationPointsContainerType IntegrationPointsContainerType;
 
    typedef GeometryShapeFunctionContainer<IntegrationMethod>::ShapeFunctionsValuesContainerType ShapeFunctionsValuesContainerType;
 
    typedef GeometryShapeFunctionContainer<IntegrationMethod>::ShapeFunctionsLocalGradientsContainerType ShapeFunctionsLocalGradientsContainerType;
 
    typedef DenseVector<Matrix> ShapeFunctionsGradientsType;
 
    typedef DenseVector<Matrix> ShapeFunctionsSecondDerivativesType;
 
    typedef DenseVector<DenseVector<Matrix> > ShapeFunctionsThirdDerivativesType;
 
 
    GeometryData(GeometryDimension const *pThisGeometryDimension,
        IntegrationMethod ThisDefaultMethod,
        const IntegrationPointsContainerType& ThisIntegrationPoints,
        const ShapeFunctionsValuesContainerType& ThisShapeFunctionsValues,
        const ShapeFunctionsLocalGradientsContainerType& ThisShapeFunctionsLocalGradients)
        : mpGeometryDimension(pThisGeometryDimension)
        , mGeometryShapeFunctionContainer(
                ThisDefaultMethod,
                ThisIntegrationPoints,
                ThisShapeFunctionsValues,
                ThisShapeFunctionsLocalGradients)
    {
    }
 
    /*
    * Constructor which has a precomputed shape function container.
    * @param pThisGeometryDimension pointer to the dimensional data
    * @param ThisGeometryShapeFunctionContainer including the evaluated
    *        values for the shape functions, it's derivatives and the
    *        integration points.
    */
    GeometryData(GeometryDimension const *pThisGeometryDimension,
        const GeometryShapeFunctionContainer<IntegrationMethod>& ThisGeometryShapeFunctionContainer)
        : mpGeometryDimension(pThisGeometryDimension)
        , mGeometryShapeFunctionContainer(
                ThisGeometryShapeFunctionContainer)
    {
    }
 
    GeometryData( const GeometryData& rOther )
        : mpGeometryDimension( rOther.mpGeometryDimension)
        , mGeometryShapeFunctionContainer( rOther.mGeometryShapeFunctionContainer)
    {
    }
 
    virtual ~GeometryData() {}
 
 
    GeometryData& operator=( const GeometryData& rOther )
    {
        mpGeometryDimension = rOther.mpGeometryDimension;
        mGeometryShapeFunctionContainer = rOther.mGeometryShapeFunctionContainer;
 
        return *this;
    }
 
 
    void SetGeometryDimension(GeometryDimension const* pGeometryDimension)
    {
        mpGeometryDimension = pGeometryDimension;
    }
 
 
    void SetGeometryShapeFunctionContainer(
        const GeometryShapeFunctionContainer<IntegrationMethod>& rGeometryShapeFunctionContainer)
    {
        mGeometryShapeFunctionContainer = rGeometryShapeFunctionContainer;
    }
 
    const GeometryShapeFunctionContainer<IntegrationMethod>& GetGeometryShapeFunctionContainer() const
    {
        return mGeometryShapeFunctionContainer;
    }
 
 
    SizeType WorkingSpaceDimension() const
    {
        return mpGeometryDimension->WorkingSpaceDimension();
    }
 
    SizeType LocalSpaceDimension() const
    {
        return mpGeometryDimension->LocalSpaceDimension();
    }
 
 
 
    bool HasIntegrationMethod( IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.HasIntegrationMethod(ThisMethod);
    }
 
 
    IntegrationMethod DefaultIntegrationMethod() const
    {
        return mGeometryShapeFunctionContainer.DefaultIntegrationMethod();
    }
 
    SizeType IntegrationPointsNumber() const
    {
        return mGeometryShapeFunctionContainer.IntegrationPointsNumber();
    }
 
    SizeType IntegrationPointsNumber( IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.IntegrationPointsNumber(ThisMethod);
    }
 
 
    const IntegrationPointsArrayType& IntegrationPoints() const
    {
        return mGeometryShapeFunctionContainer.IntegrationPoints();
    }
 
    const IntegrationPointsArrayType& IntegrationPoints(  IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.IntegrationPoints(ThisMethod);
    }
 
 
    const Matrix& ShapeFunctionsValues() const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionsValues();
    }
 
    const Matrix& ShapeFunctionsValues(  IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionsValues(
            ThisMethod);
    }
 
    double ShapeFunctionValue( IndexType IntegrationPointIndex, IndexType ShapeFunctionIndex ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionValue(
            IntegrationPointIndex,
            ShapeFunctionIndex);
    }
 
    double ShapeFunctionValue(
        IndexType IntegrationPointIndex,
        IndexType ShapeFunctionIndex,
        IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionValue(
            IntegrationPointIndex, ShapeFunctionIndex, ThisMethod );
    }
 
    const ShapeFunctionsGradientsType& ShapeFunctionsLocalGradients() const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionsLocalGradients();
    }
 
    const ShapeFunctionsGradientsType& ShapeFunctionsLocalGradients( IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionsLocalGradients(ThisMethod);
    }
 
    const Matrix& ShapeFunctionLocalGradient( IndexType IntegrationPointIndex ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionLocalGradient(IntegrationPointIndex);
    }
 
    const Matrix& ShapeFunctionLocalGradient( IndexType IntegrationPointIndex,  IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionLocalGradient(IntegrationPointIndex, ThisMethod);
    }
 
    const Matrix& ShapeFunctionLocalGradient( IndexType IntegrationPointIndex, IndexType ShapeFunctionIndex,  IntegrationMethod ThisMethod ) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionLocalGradient(IntegrationPointIndex, ThisMethod);
    }
 
    /*
    * @brief access to the shape function derivatives.
    * @param DerivativeOrderIndex defines the wanted order of the derivative
    * @param IntegrationPointIndex the corresponding contorl point of this geometry
    * @return the shape function or derivative value related to the input parameters
    *         the matrix is structured: (derivative dN_de / dN_du , the corresponding node)
    */
    const Matrix& ShapeFunctionDerivatives(
        IndexType DerivativeOrderIndex,
        IndexType IntegrationPointIndex,
        IntegrationMethod ThisMethod) const
    {
        return mGeometryShapeFunctionContainer.ShapeFunctionDerivatives(
            DerivativeOrderIndex, IntegrationPointIndex, ThisMethod);
    }
 
 
    virtual std::string Info() const
    {
        return "geometry data";
    }
 
    virtual void PrintInfo( std::ostream& rOStream ) const
    {
        rOStream << "geometry data";
    }
 
    virtual void PrintData( std::ostream& rOStream ) const
    {
        rOStream << "    Working space dimension : " << mpGeometryDimension->WorkingSpaceDimension() << std::endl;
        rOStream << "    Local space dimension   : " << mpGeometryDimension->LocalSpaceDimension();
    }
 
 
 
private:
 
    GeometryDimension const* mpGeometryDimension;
 
    GeometryShapeFunctionContainer<IntegrationMethod> mGeometryShapeFunctionContainer;
 
 
    friend class Serializer;
 
    virtual void save( Serializer& rSerializer ) const
    {
        rSerializer.save("GeometryDimension", mpGeometryDimension);
        rSerializer.save("GeometryShapeFunctionContainer", mGeometryShapeFunctionContainer);
    }
 
    virtual void load( Serializer& rSerializer )
    {
        rSerializer.load("GeometryDimension", const_cast<GeometryDimension*>(mpGeometryDimension));
        rSerializer.load("GeometryShapeFunctionContainer", mGeometryShapeFunctionContainer);
    }
 
    // Private default constructor for serialization
    GeometryData()
    {
    }
 
 
}; // Class GeometryData
 
 
 
 
 
 
inline std::istream& operator >> ( std::istream& rIStream,
                                   GeometryData& rThis );
 
inline std::ostream& operator << ( std::ostream& rOStream,
                                   const GeometryData& rThis )
{
    rThis.PrintInfo( rOStream );
    rOStream << std::endl;
    rThis.PrintData( rOStream );
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_GEOMETRY_DATA_H_INCLUDED  defined