quadrature_point_surface_in_volume_geometry.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Manuel Messmer
//
 
#if !defined(KRATOS_QUADRATURE_POINT_SURFACE_IN_VOLUME_GEOMETRY_H_INCLUDED )
#define  KRATOS_QUADRATURE_POINT_SURFACE_IN_VOLUME_GEOMETRY_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/variables.h"
#include "geometries/quadrature_point_geometry.h"
 
namespace Kratos
{
template<class TPointType>
class QuadraturePointSurfaceInVolumeGeometry
    : public QuadraturePointGeometry<TPointType, 3, 3, 2>
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(QuadraturePointSurfaceInVolumeGeometry);
 
    typedef QuadraturePointGeometry<TPointType, 3, 3, 2> BaseType;
    typedef Geometry<TPointType> GeometryType;
 
    typedef typename GeometryType::IndexType IndexType;
    typedef typename GeometryType::SizeType SizeType;
 
    typedef typename GeometryType::PointsArrayType PointsArrayType;
    typedef typename GeometryType::CoordinatesArrayType CoordinatesArrayType;
 
    typedef GeometryShapeFunctionContainer<GeometryData::IntegrationMethod> GeometryShapeFunctionContainerType;
    typedef BoundedMatrix<double,3,2> TangentMatrixType;
 
    using BaseType::Jacobian;
    using BaseType::Calculate;
    using BaseType::DeterminantOfJacobian;
 
 
    QuadraturePointSurfaceInVolumeGeometry(
        const PointsArrayType& ThisPoints,
        GeometryShapeFunctionContainerType& ThisGeometryShapeFunctionContainer,
        const TangentMatrixType& LocalTangents )
        : BaseType(ThisPoints, ThisGeometryShapeFunctionContainer)
    {
        KRATOS_ERROR_IF( mLocalTangents.size1() != LocalTangents.size1() || mLocalTangents.size2() != LocalTangents.size2() )
            << "QuadraturePointSurfaceInVolumeGeometry :: Dimensions of LocalTangents do not match (3,2). "
            << "Given Dimensions are: (" << LocalTangents.size1() << "," << LocalTangents.size2() <<"). " << std::endl;
        mLocalTangents = LocalTangents;
    }
 
    QuadraturePointSurfaceInVolumeGeometry(
        const PointsArrayType& ThisPoints,
        GeometryShapeFunctionContainerType& ThisGeometryShapeFunctionContainer,
        const TangentMatrixType& LocalTangents,
        GeometryType* pGeometryParent)
        : BaseType(ThisPoints, ThisGeometryShapeFunctionContainer, pGeometryParent)
    {
        KRATOS_ERROR_IF( mLocalTangents.size1() != LocalTangents.size1() || mLocalTangents.size2() != LocalTangents.size2() )
            << "QuadraturePointSurfaceInVolumeGeometry :: Dimensions of LocalTangents do not match (3,2). "
            << "Given Dimensions are: (" << LocalTangents.size1() << "," << LocalTangents.size2() <<"). " << std::endl;
        mLocalTangents = LocalTangents;
    }
 
    ~QuadraturePointSurfaceInVolumeGeometry() override = default;
 
    QuadraturePointSurfaceInVolumeGeometry(QuadraturePointSurfaceInVolumeGeometry const& rOther )
        : BaseType( rOther )
        , mLocalTangents(rOther.mLocalTangents)
    {
    }
 
 
    QuadraturePointSurfaceInVolumeGeometry& operator=( const QuadraturePointSurfaceInVolumeGeometry& rOther )
    {
        BaseType::operator=( rOther );
 
        mLocalTangents = rOther.mLocalTangents;
 
        return *this;
    }
 
 
    void Assign(
        const Variable<Matrix >& rVariable,
        const Matrix& rInput) override
    {
        KRATOS_ERROR_IF( rInput.size1() != mLocalTangents.size1() || rInput.size2() != mLocalTangents.size2() )
            << "QuadraturePointSurfaceInVolume :: Input Matrix does not have the same size as LocalTangentMatrix. Size must be (3,2)." << std::endl;
 
        if (rVariable == LOCAL_TANGENT_MATRIX) {
            mLocalTangents = rInput;
        }
    }
 
    void Calculate(
        const Variable<Matrix >& rVariable,
        Matrix& rOutput) const override
    {
        if (rVariable == LOCAL_TANGENT_MATRIX) {
            if( rOutput.size1() != mLocalTangents.size1() || rOutput.size2() != mLocalTangents.size2() ){
                rOutput.resize(mLocalTangents.size1(),mLocalTangents.size2());
            }
            rOutput = mLocalTangents;
        }
    }
 
 
    CoordinatesArrayType Normal(
        IndexType IntegrationPointIndex,
        GeometryData::IntegrationMethod ThisMethod) const override
    {
        KRATOS_DEBUG_ERROR_IF(IntegrationPointIndex != 0)
            << "Trying to access Normal of QuadraturePointCurveOnSurface "
            << "with an integration point index != 0." << std::endl;
 
        Matrix J;
        this->Jacobian(J, IntegrationPointIndex, ThisMethod);
 
        // Map tangents into global space
        TangentMatrixType global_tangents = prod(J, mLocalTangents);
 
        Vector g1 = column(global_tangents,0);
        Vector g2 = column(global_tangents,1);
 
        // Compute normal
        CoordinatesArrayType normal = MathUtils<double>::CrossProduct( g1, g2 );
 
        return normal;
    }
 
 
    double DeterminantOfJacobian(
        IndexType IntegrationPointIndex,
        GeometryData::IntegrationMethod ThisMethod) const override
    {
        KRATOS_DEBUG_ERROR_IF(IntegrationPointIndex != 0)
            << "Trying to access DeterminantOfJacobian of QuadraturePointSurfaceInVolume "
            << "with an integration point index != 0." << std::endl;
 
        Matrix J;
        this->Jacobian(J, IntegrationPointIndex, ThisMethod);
        TangentMatrixType global_tangents = prod(J, mLocalTangents);
 
        return MathUtils<double>::GeneralizedDet( global_tangents );
    }
 
    Vector& DeterminantOfJacobian(
        Vector& rResult,
        GeometryData::IntegrationMethod ThisMethod) const override
    {
        if (rResult.size() != 1)
            rResult.resize(1, false);
 
        rResult[0] = this->DeterminantOfJacobian(0, ThisMethod);
 
        return rResult;
    }
 
 
    GeometryData::KratosGeometryFamily GetGeometryFamily() const override
    {
        return GeometryData::KratosGeometryFamily::Kratos_Quadrature_Geometry;
    }
 
    GeometryData::KratosGeometryType GetGeometryType() const override
    {
        return GeometryData::KratosGeometryType::Kratos_Quadrature_Point_Surface_In_Volume_Geometry;
    }
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Quadrature point geometry for a surface in a nurbs volume with Id: "
            << std::to_string(this->Id()) << ", containing: " << std::to_string(this->size()) << " points." << std::endl;
 
        return buffer.str();
    }
 
    void PrintInfo( std::ostream& rOStream ) const override
    {
        rOStream << "Quadrature point geometry for a surface in a nurbs volume with Id: "
            << this->Id() << ", containing: " << this->size() << " points." << std::endl;
    }
 
    void PrintData( std::ostream& rOStream ) const override
    {
    }
 
private:
 
    TangentMatrixType mLocalTangents;
 
 
    QuadraturePointSurfaceInVolumeGeometry()
        : BaseType()
    {
    }
 
    friend class Serializer;
 
    void save( Serializer& rSerializer ) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, BaseType);
        rSerializer.save("LocalTangents", mLocalTangents);
    }
 
    void load( Serializer& rSerializer ) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType );
        rSerializer.load("LocalTangents", mLocalTangents);
    }
 
}; // Class Geometry
 
}  // namespace Kratos.
 
#endif // KRATOS_QUADRATURE_POINT_SURFACE_IN_VOLUME_GEOMETRY_H_INCLUDED  defined