line_3d_n.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Klaus B. Sautter
 
 
#if !defined(KRATOS_LINE_3D_N_H_INCLUDED )
#define  KRATOS_LINE_3D_N_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "geometries/geometry.h"
#include "integration/line_gauss_legendre_integration_points.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
template<class TPointType>
 
class Line3DN : public Geometry<TPointType>
{
public:
 
    typedef Geometry<TPointType> BaseType;
 
    KRATOS_CLASS_POINTER_DEFINITION( Line3DN );
 
    typedef GeometryData::IntegrationMethod IntegrationMethod;
 
    typedef typename BaseType::GeometriesArrayType GeometriesArrayType;
 
    typedef TPointType PointType;
 
    typedef typename BaseType::IndexType IndexType;
 
 
    typedef typename BaseType::SizeType SizeType;
 
    typedef  typename BaseType::PointsArrayType PointsArrayType;
 
    typedef typename BaseType::IntegrationPointType IntegrationPointType;
 
    typedef typename BaseType::IntegrationPointsArrayType IntegrationPointsArrayType;
 
    typedef typename BaseType::IntegrationPointsContainerType IntegrationPointsContainerType;
 
    typedef typename BaseType::ShapeFunctionsValuesContainerType ShapeFunctionsValuesContainerType;
 
    typedef typename BaseType::ShapeFunctionsLocalGradientsContainerType ShapeFunctionsLocalGradientsContainerType;
 
    typedef typename BaseType::JacobiansType JacobiansType;
 
    typedef typename BaseType::ShapeFunctionsGradientsType ShapeFunctionsGradientsType;
 
    typedef typename BaseType::NormalType NormalType;
 
    typedef typename BaseType::CoordinatesArrayType CoordinatesArrayType;
 
 
//     Line3DN( const PointType& FirstPoint, const PointType& SecondPoint, const PointType& ThirdPoint )
//         : BaseType( PointsArrayType(), &msGeometryData )
//     {
//         BaseType::Points().push_back( typename PointType::Pointer( new PointType( FirstPoint ) ) );
//         BaseType::Points().push_back( typename PointType::Pointer( new PointType( SecondPoint ) ) );
//         BaseType::Points().push_back( typename PointType::Pointer( new PointType( ThirdPoint ) ) );
//     }
 
    /* Line3DN( typename PointType::Pointer pFirstPoint, typename PointType::Pointer pSecondPoint,
             typename PointType::Pointer pThirdPoint )
        : BaseType( PointsArrayType(), &msGeometryData )
    {
        BaseType::Points().push_back( pFirstPoint );
        BaseType::Points().push_back( pSecondPoint );
        BaseType::Points().push_back( pThirdPoint );
    } */
 
    Line3DN( const PointsArrayType& ThisPoints )
        : BaseType( ThisPoints, &msGeometryData )
    {
        //if ( BaseType::PointsNumber() != 3 )
        //    KRATOS_ERROR << "Invalid points number. Expected 3, given " << BaseType::PointsNumber() << std::endl;
    }
 
    Line3DN( Line3DN const& rOther )
        : BaseType( rOther )
    {
    }
 
    template<class TOtherPointType> Line3DN( Line3DN<TOtherPointType> const& rOther )
        : BaseType( rOther )
    {
    }
 
    ~Line3DN() override {}
 
/*     GeometryData::KratosGeometryFamily GetGeometryFamily() const override
    {
        return GeometryData::Kratos_Linear;
    }
 
    GeometryData::KratosGeometryType GetGeometryType() const override
    {
        return GeometryData::Kratos_Line3DN;
    } */
 
 
    Line3DN& operator=( const Line3DN& rOther )
    {
        BaseType::operator=( rOther );
        return *this;
    }
 
    template<class TOtherPointType>
    Line3DN& operator=( Line3DN<TOtherPointType> const & rOther )
    {
        BaseType::operator=( rOther );
        return *this;
    }
 
 
    typename BaseType::Pointer Create( PointsArrayType const& ThisPoints ) const override
    {
      // line 3 conectivities order 1-3-2
      return typename BaseType::Pointer( new Line3DN( ThisPoints ) );
    }
 
    // Geometry< Point<3> >::Pointer Clone() const override
    // {
    //     Geometry< Point<3> >::PointsArrayType NewPoints;
 
    //     //making a copy of the nodes TO POINTS (not Nodes!!!)
    //     for ( IndexType i = 0 ; i < this->size() ; i++ )
    //     {
    //             NewPoints.push_back(Kratos::make_shared< Point<3> >(( *this )[i]));
    //     }
 
    //     //creating a geometry with the new points
    //     Geometry< Point<3> >::Pointer p_clone( new Line3DN< Point<3> >( NewPoints ) );
 
    //     return p_clone;
    // }
 
    //lumping factors for the calculation of the lumped mass matrix
    Vector& LumpingFactors( Vector& rResult,
        const typename BaseType::LumpingMethods LumpingMethod) const override
    {
        KRATOS_ERROR << "'LumpingFactors' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
 
    double Length() const override
    {
        const int number_points  = BaseType::PointsNumber();
        const TPointType& point0 = BaseType::GetPoint(0);
        const TPointType& point1 = BaseType::GetPoint(number_points-1);
        const double lx = point0.X() - point1.X();
        const double ly = point0.Y() - point1.Y();
        const double lz = point0.Z() - point1.Z();
 
        const double length = lx * lx + ly * ly + lz * lz;
 
        return sqrt( length );
    }
 
    double Area() const override
    {
      return Length();
    }
 
 
    double DomainSize() const override
    {
        KRATOS_ERROR << "'DomainSize' not available for arbitrarty noded line" << std::endl;
        return 0.0;
    }
 
    bool IsInside(
        const CoordinatesArrayType& rPoint,
        CoordinatesArrayType& rResult,
        const double Tolerance = std::numeric_limits<double>::epsilon()
        ) const override
    {
        KRATOS_ERROR << "'IsInside' not available for arbitrarty noded line" << std::endl;
        return false;
    }
 
 
    JacobiansType& Jacobian( JacobiansType& rResult, IntegrationMethod ThisMethod ) const override
    {
        KRATOS_ERROR << "'Jacobian' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
 
    JacobiansType& Jacobian( JacobiansType& rResult, IntegrationMethod ThisMethod, Matrix & DeltaPosition ) const override
    {
        KRATOS_ERROR << "'Jacobian' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
    Matrix& Jacobian( Matrix& rResult, IndexType IntegrationPointIndex, IntegrationMethod ThisMethod ) const override
    {
        KRATOS_ERROR << "'Jacobian' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
    Matrix& Jacobian( Matrix& rResult, const CoordinatesArrayType& rPoint ) const override
    {
        KRATOS_ERROR << "'Jacobian' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
    Vector& DeterminantOfJacobian( Vector& rResult, IntegrationMethod ThisMethod ) const override
    {
        KRATOS_ERROR << "Jacobian is not square" << std::endl;
        return rResult;
    }
 
    JacobiansType& InverseOfJacobian( JacobiansType& rResult, IntegrationMethod ThisMethod ) const override
    {
        KRATOS_ERROR << "Jacobian is not square" << std::endl;
        return rResult;
    }
 
    Matrix& InverseOfJacobian( Matrix& rResult, IndexType IntegrationPointIndex,
                                       IntegrationMethod ThisMethod ) const override
    {
        KRATOS_ERROR << "Jacobian is not square" << std::endl;
        return rResult;
    }
 
    Matrix& InverseOfJacobian( Matrix& rResult, const CoordinatesArrayType& rPoint ) const override
    {
        KRATOS_ERROR << "Jacobian is not square" << std::endl;
        return rResult;
    }
 
 
    SizeType EdgesNumber() const override
    {
        return 0;
    }
 
    SizeType FacesNumber() const override
    {
        return 0;
    }
 
 
    double ShapeFunctionValue( IndexType ShapeFunctionIndex,
                                       const CoordinatesArrayType& rPoint ) const override
    {
        KRATOS_ERROR << "'ShapeFunctionValue' not available for arbitrarty noded line" << std::endl;
        return 0;
    }
 
 
 
    void ShapeFunctionsIntegrationPointsGradients( ShapeFunctionsGradientsType& rResult, IntegrationMethod ThisMethod ) const override
    {
        KRATOS_ERROR << "Jacobian is not square" << std::endl;
    }
 
 
 
    std::string Info() const override
    {
        return "1 dimensional line with n nodes in 3D space";
    }
 
    void PrintInfo( std::ostream& rOStream ) const override
    {
        rOStream << "1 dimensional line with n nodes in 3D space";
    }
 
    void PrintData( std::ostream& rOStream ) const override
    {
        BaseType::PrintData( rOStream );
    }
 
    virtual ShapeFunctionsGradientsType ShapeFunctionsLocalGradients(
        IntegrationMethod ThisMethod )
    {
        KRATOS_ERROR << "'ShapeFunctionsLocalGradients' not available for arbitrarty noded line" << std::endl;
        ShapeFunctionsGradientsType Result( 0 );
        return Result;
    }
 
    virtual ShapeFunctionsGradientsType ShapeFunctionsLocalGradients()
    {
        KRATOS_ERROR << "'ShapeFunctionsLocalGradients' not available for arbitrarty noded line" << std::endl;
        ShapeFunctionsGradientsType Result( 0 );
        return Result;
    }
 
    Matrix& ShapeFunctionsLocalGradients( Matrix& rResult,
            const CoordinatesArrayType& rPoint ) const override
    {
        KRATOS_ERROR << "'ShapeFunctionsLocalGradients' not available for arbitrarty noded line" << std::endl;
        return( rResult );
    }
 
    Matrix& PointsLocalCoordinates( Matrix& rResult ) const override
    {
        KRATOS_ERROR << "'PointsLocalCoordinates' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
    virtual Matrix& ShapeFunctionsGradients( Matrix& rResult, CoordinatesArrayType& rPoint )
    {
        KRATOS_ERROR << "'ShapeFunctionsGradients' not available for arbitrarty noded line" << std::endl;
        return rResult;
    }
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
    static const GeometryData msGeometryData;
 
    static const GeometryDimension msGeometryDimension;
 
 
 
 
    friend class Serializer;
 
    void save( Serializer& rSerializer ) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, BaseType );
    }
 
    void load( Serializer& rSerializer ) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType );
    }
 
    Line3DN(): BaseType( PointsArrayType(), &msGeometryData ) {}
 
 
 
 
 
    static Matrix CalculateShapeFunctionsIntegrationPointsValues( typename BaseType::IntegrationMethod ThisMethod )
    {
        KRATOS_ERROR << "'CalculateShapeFunctionsIntegrationPointsValues' not available for arbitrarty noded line" << std::endl;
        Matrix N( 0, 3 );
        return N;
    }
 
    static ShapeFunctionsGradientsType CalculateShapeFunctionsIntegrationPointsLocalGradients(
        typename BaseType::IntegrationMethod ThisMethod )
    {
        //KRATOS_ERROR << "'CalculateShapeFunctionsIntegrationPointsLocalGradients' not available for arbitrarty noded line" << std::endl;
        ShapeFunctionsGradientsType DN_De( 0 );
        return DN_De;
    }
 
    static const IntegrationPointsContainerType AllIntegrationPoints()
    {
        //KRATOS_ERROR << "'AllIntegrationPoints' not available for arbitrarty noded line" << std::endl;
        IntegrationPointsContainerType integration_points;
        return integration_points;
    }
 
    static const ShapeFunctionsValuesContainerType AllShapeFunctionsValues()
    {
        //KRATOS_ERROR << "'AllIntegrationPoints' not available for arbitrarty noded line" << std::endl;
        ShapeFunctionsValuesContainerType shape_functions_values;
        return shape_functions_values;
    }
 
    static const ShapeFunctionsLocalGradientsContainerType AllShapeFunctionsLocalGradients()
    {
        //KRATOS_ERROR << "'AllShapeFunctionsLocalGradients' not available for arbitrarty noded line" << std::endl;
        ShapeFunctionsLocalGradientsContainerType shape_functions_local_gradients;
        return shape_functions_local_gradients;
    }
 
 
 
 
 
 
    template<class TOtherPointType> friend class Line3DN;
 
 
 
}; // Class Geometry
 
 
 
 
 
 
template<class TPointType>
inline std::istream& operator >> ( std::istream& rIStream,
                                   Line3DN<TPointType>& rThis );
 
template<class TPointType>
inline std::ostream& operator << ( std::ostream& rOStream,
                                   const Line3DN<TPointType>& rThis )
{
    rThis.PrintInfo( rOStream );
    rOStream << std::endl;
    rThis.PrintData( rOStream );
 
    return rOStream;
}
 
 
 
template<class TPointType>
const GeometryData Line3DN<TPointType>::msGeometryData(
        &msGeometryDimension,
        GeometryData::IntegrationMethod::GI_GAUSS_2,
        Line3DN<TPointType>::AllIntegrationPoints(),
        Line3DN<TPointType>::AllShapeFunctionsValues(),
        AllShapeFunctionsLocalGradients() );
 
 
template<class TPointType>
const GeometryDimension Line3DN<TPointType>::msGeometryDimension(3, 1);
 
}  // namespace Kratos.
 
#endif // KRATOS_LINE_3D_3_H_INCLUDED  defined