integration_point.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_INTEGRATION_POINT_H_INCLUDED )
#define  KRATOS_INTEGRATION_POINT_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "geometries/point.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
template<std::size_t TDimension, class TDataType = double, class TWeightType = double>
class IntegrationPoint : public Point
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(IntegrationPoint);
 
    typedef Point BaseType;
 
    typedef Point PointType;
 
    typedef typename Point::CoordinatesArrayType CoordinatesArrayType;
 
    typedef typename Point::IndexType IndexType;
 
 
    IntegrationPoint() : BaseType(), mWeight()
    {
    }
 
    explicit IntegrationPoint(TDataType const& NewX) : BaseType(NewX), mWeight()
    {
    }
 
    IntegrationPoint(TDataType const& NewX, TDataType const& NewW) : BaseType(NewX), mWeight(NewW)
    {
    }
 
    IntegrationPoint(TDataType const& NewX, TDataType const& NewY, TDataType const& NewW) : BaseType(NewX, NewY), mWeight(NewW)
    {
    }
 
    IntegrationPoint(TDataType const& NewX, TDataType const& NewY, TDataType const& NewZ, TDataType const& NewW) : BaseType(NewX, NewY, NewZ), mWeight(NewW)
    {
    }
 
    IntegrationPoint(IntegrationPoint const& rOtherIntegrationPoint)
        : BaseType(rOtherIntegrationPoint), mWeight(rOtherIntegrationPoint.mWeight) {}
 
    template<std::size_t TOtherDimension>
    IntegrationPoint(IntegrationPoint<TOtherDimension, TDataType, TWeightType> const& rOtherIntegrationPoint)
        : BaseType(rOtherIntegrationPoint), mWeight(rOtherIntegrationPoint.mWeight) {}
 
    explicit IntegrationPoint(PointType const& rOtherPoint)
        : BaseType(rOtherPoint), mWeight() {}
 
    IntegrationPoint(PointType const& rOtherPoint, TWeightType NewWeight)
        : BaseType(rOtherPoint), mWeight(NewWeight) {}
 
    explicit IntegrationPoint(CoordinatesArrayType const& rOtherCoordinates)
        : BaseType(rOtherCoordinates), mWeight() {}
 
    IntegrationPoint(CoordinatesArrayType const& rOtherCoordinates, TWeightType NewWeight)
        : BaseType(rOtherCoordinates), mWeight(NewWeight) {}
 
    template<class TVectorType>
    explicit IntegrationPoint(vector_expression<TVectorType> const&  rOtherCoordinates)
        : BaseType(rOtherCoordinates), mWeight() {}
 
    template<class TVectorType>
    IntegrationPoint(vector_expression<TVectorType> const&  rOtherCoordinates, TWeightType NewWeight)
        : BaseType(rOtherCoordinates), mWeight(NewWeight) {}
 
    explicit IntegrationPoint(std::vector<TDataType> const&  rOtherCoordinates)
        : BaseType(rOtherCoordinates), mWeight() {}
 
    IntegrationPoint(std::vector<TDataType> const&  rOtherCoordinates, TWeightType NewWeight)
        : BaseType(rOtherCoordinates), mWeight(NewWeight) {}
 
    ~IntegrationPoint() override {}
 
 
 
    IntegrationPoint& operator=(const IntegrationPoint& rOther)
    {
        BaseType::operator =(rOther);
        mWeight = rOther.mWeight;
 
        return *this;
    }
 
    IntegrationPoint& operator=(const PointType& OtherPoint)
    {
        BaseType::operator =(OtherPoint);
 
        return *this;
    }
 
    bool operator==(const IntegrationPoint& rOther)
    {
        return (mWeight == rOther.mWeight) && (BaseType::operator ==(rOther));
    }
 
    template<std::size_t TOtherDimension>
    IntegrationPoint& operator=(const IntegrationPoint<TOtherDimension>& rOther)
    {
        BaseType::operator =(rOther);
        mWeight = rOther.Weight();
 
        return *this;
    }
 
 
 
 
    TWeightType Weight() const
    {
        return mWeight;
    }
 
    TWeightType& Weight()
    {
        return mWeight;
    }
 
    void SetWeight(TWeightType NewWeight)
    {
        mWeight = NewWeight;
    }
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << TDimension << " dimensional integration point";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << TDimension << " dimensional integration point";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        if(!TDimension)
            return;
 
        rOStream << "("  << this->operator[](0);
 
        for(IndexType i = 1 ; i < TDimension  ; i++)
            rOStream << " , " << this->operator[](i);
 
        rOStream << "), weight = " << mWeight;
    }
 
 
 
 
    template<std::size_t TOtherDimension, class TOtherDataType, class TOtherWeightType> friend class IntegrationPoint;
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    TWeightType mWeight;
 
 
    friend class Serializer;
 
    void save( Serializer& rSerializer ) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, BaseType );
        rSerializer.save("Weight", mWeight);
 
    }
 
    void load( Serializer& rSerializer ) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, BaseType );
        rSerializer.load("Weight", mWeight);
    }
 
 
 
 
 
 
 
 
 
 
 
 
}; // Class IntegrationPoint
 
 
 
 
 
template<std::size_t TDimension, class TDataType, class TWeightType>
inline std::istream& operator >> (std::istream& rIStream,
                                  IntegrationPoint<TDimension, TDataType, TWeightType>& rThis);
 
template<std::size_t TDimension, class TDataType, class TWeightType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const IntegrationPoint<TDimension, TDataType, TWeightType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_INTEGRATION_POINT_H_INCLUDED  defined