point_2d.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Riccardo Rossi
//                   Janosch Stascheit
//                   Felix Nagel
//  contributors:    Hoang Giang Bui
//                   Josep Maria Carbonell
//
 
#if !defined(KRATOS_POINT_2D_H_INCLUDED )
#define  KRATOS_POINT_2D_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "geometries/geometry.h"
 
namespace Kratos
{
 
 
 
 
 
 
template<class TPointType>
class Point2D : public Geometry<TPointType>
{
public:
 
    typedef Geometry<TPointType> BaseType;
 
    KRATOS_CLASS_POINTER_DEFINITION(Point2D);
 
    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;
 
/*
    Point2D(const PointType& FirstPoint)
        : BaseType(PointsArrayType(), &msGeometryData)
    {
        BaseType::Points().push_back(typename PointType::Pointer(new PointType(FirstPoint)));
    }*/
 
    Point2D(typename PointType::Pointer pFirstPoint)
        : BaseType(PointsArrayType(), &msGeometryData)
    {
        BaseType::Points().push_back(pFirstPoint);
    }
 
    Point2D(const PointsArrayType& ThisPoints)
        : BaseType(ThisPoints, &msGeometryData)
    {
        if( BaseType::PointsNumber() != 1)
            KRATOS_ERROR << "Invalid points number. Expected 2, given " << BaseType::PointsNumber() << std::endl;
    }
 
    explicit Point2D(
        const IndexType GeometryId,
        const PointsArrayType& rThisPoints
    ) : BaseType(GeometryId, rThisPoints, &msGeometryData)
    {
        KRATOS_ERROR_IF( this->PointsNumber() != 1 ) << "Invalid points number. Expected 1, given " << this->PointsNumber() << std::endl;
    }
 
    explicit Point2D(
        const std::string& rGeometryName,
        const PointsArrayType& rThisPoints
    ) : BaseType(rGeometryName, rThisPoints, &msGeometryData)
    {
        KRATOS_ERROR_IF(this->PointsNumber() != 1) << "Invalid points number. Expected 1, given " << this->PointsNumber() << std::endl;
    }
 
    Point2D(Point2D const& rOther)
        : BaseType(rOther)
    {
    }
 
 
    template<class TOtherPointType> Point2D(Point2D<TOtherPointType> const& rOther)
        : BaseType(rOther)
    {
    }
 
    ~Point2D() override {}
 
    GeometryData::KratosGeometryFamily GetGeometryFamily() const override
    {
        return GeometryData::KratosGeometryFamily::Kratos_Point;
    }
    GeometryData::KratosGeometryType GetGeometryType() const override
    {
        return GeometryData::KratosGeometryType::Kratos_Point2D;
    }
 
 
    Point2D& operator=(const Point2D& rOther)
    {
        BaseType::operator=(rOther);
 
        return *this;
    }
 
    template<class TOtherPointType>
    Point2D& operator=(Point2D<TOtherPointType> const & rOther)
    {
        BaseType::operator=(rOther);
 
        return *this;
    }
 
 
    typename BaseType::Pointer Create(
        const IndexType NewGeometryId,
        PointsArrayType const& rThisPoints
        ) const override
    {
        return typename BaseType::Pointer( new Point2D( NewGeometryId, rThisPoints ) );
    }
 
    typename BaseType::Pointer Create(
        const IndexType NewGeometryId,
        const BaseType& rGeometry
    ) const override
    {
        auto p_geometry = typename BaseType::Pointer( new Point2D( NewGeometryId, rGeometry.Points() ) );
        p_geometry->SetData(rGeometry.GetData());
        return p_geometry;
    }
 
//     /**
//      * @brief Lumping factors for the calculation of the lumped mass matrix
//      * @param rResult Vector containing the lumping factors
//      * @param LumpingMethod The lumping method considered. The three methods available are:
//      *      - The row sum method
//      *      - Diagonal scaling
//      *      - Evaluation of M using a quadrature involving only the nodal points and thus automatically yielding a diagonal matrix for standard element shape function
//      */
//     Vector& LumpingFactors(
//         Vector& rResult,
//         const typename BaseType::LumpingMethods LumpingMethod = BaseType::LumpingMethods::ROW_SUM
//         )  const override
//  {
//  }
 
 
    double Length() const override
    {
        return 0.00;
    }
 
    double Area() const override
    {
        return 0.00;
    }
 
 
    double DomainSize() const override
    {
        return 0.00;
    }
 
 
    //         virtual JacobiansType& Jacobian(JacobiansType& rResult, IntegrationMethod ThisMethod) const
    //  {
    //  }
 
    //    virtual Matrix& Jacobian(Matrix& rResult, IndexType IntegrationPointIndex, IntegrationMethod ThisMethod) const
    //  {
    //  }
 
//
    //     virtual Vector& DeterminantOfJacobian(Vector& rResult, IntegrationMethod ThisMethod) const
    //  {
    //  }
 
    //     virtual double DeterminantOfJacobian(IndexType IntegrationPointIndex, IntegrationMethod ThisMethod) const
    //  {
    //  }
 
//       virtual double DeterminantOfJacobian(const CoordinatesArrayType& rPoint) const
//  {
//  }
 
 
    //      virtual JacobiansType& InverseOfJacobian(JacobiansType& rResult, IntegrationMethod ThisMethod) const
    //  {
    //  }
 
    //      virtual Matrix& InverseOfJacobian(Matrix& rResult, IndexType IntegrationPointIndex, IntegrationMethod ThisMethod) const
    //  {
    //  }
 
    //    virtual Matrix& InverseOfJacobian(Matrix& rResult, const CoordinatesArrayType& rPoint) const
    //  {
    //  }
 
 
    SizeType EdgesNumber() const override
    {
        return 1;
    }
 
    SizeType FacesNumber() const override
    {
        return 0;
    }
 
 
//      virtual double ShapeFunctionValue(IndexType ShapeFunctionIndex,
//                                            const CoordinatesArrayType& rPoint) const
//     {
//          KRATOS_ERROR << "This method is not implemented yet!" << *this <<  std::endl;
//       return 0;
//          }
 
 
    std::string Info() const override
    {
        return "a point geometry in 2D space";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "a point geometry in 2D space";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << "a point geometry in 2D space";
    }
 
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
    static const GeometryData msGeometryData;
 
    static const GeometryDimension msGeometryDimension;
 
 
 
 
 
 
//      static Matrix CalculateShapeFunctionsIntegrationPointsValues(typename BaseType::IntegrationMethod ThisMethod)
//     {
//      }
 
    //      static ShapeFunctionsGradientsType CalculateShapeFunctionsIntegrationPointsLocalGradients(typename BaseType::IntegrationMethod ThisMethod)
    //  {
    //  }
 
    static const IntegrationPointsContainerType AllIntegrationPoints()
    {
        IntegrationPointsContainerType integration_points;
        return integration_points;
    }
 
    static const ShapeFunctionsValuesContainerType AllShapeFunctionsValues()
    {
        ShapeFunctionsValuesContainerType shape_functions_value;
        return shape_functions_value;
    }
    static const ShapeFunctionsLocalGradientsContainerType AllShapeFunctionsLocalGradients()
    {
        ShapeFunctionsLocalGradientsContainerType shape_functions_local_gradients;
        return shape_functions_local_gradients;
    }
 
 
 
 
 
 
    template<class TOtherPointType> friend class Point2D;
 
 
    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 );
    }
 
    // Default constructor needed for serialization only
    Point2D():BaseType( PointsArrayType(), &msGeometryData ) {}
 
 
 
 
 
 
 
}; // Class Geometry
 
 
 
 
 
 
template<class TPointType>
inline std::istream& operator >> (std::istream& rIStream,
                                  Point2D<TPointType>& rThis);
 
template<class TPointType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const Point2D<TPointType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
template<class TPointType>
const GeometryData Point2D<TPointType>::msGeometryData(
        &msGeometryDimension,
        GeometryData::IntegrationMethod::GI_GAUSS_1,
        Point2D<TPointType>::AllIntegrationPoints(),
        Point2D<TPointType>::AllShapeFunctionsValues(),
        AllShapeFunctionsLocalGradients());
 
template<class TPointType>
const GeometryDimension Point2D<TPointType>::msGeometryDimension(2, 0);
 
}  // namespace Kratos.
 
#endif // KRATOS_LINE_2D_H_INCLUDED  defined