geometrical_object.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//                   Riccardo Rossi
//
 
#pragma once
 
// System includes
#include <atomic>
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "includes/node.h"
#include "containers/flags.h"
#include "geometries/geometry.h"
#include "includes/indexed_object.h"
 
namespace Kratos
{
 
 
 
 
 
 
class KRATOS_API(KRATOS_CORE) GeometricalObject : public IndexedObject, public Flags
{
public:
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(GeometricalObject);
 
    typedef Node NodeType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef std::size_t IndexType;
 
    typedef std::size_t result_type;
 
 
    explicit GeometricalObject(IndexType NewId = 0)
        : IndexedObject(NewId),
          Flags(),
          mpGeometry()
    {}
 
    GeometricalObject(IndexType NewId, GeometryType::Pointer pGeometry)
        : IndexedObject(NewId),
          Flags(),
          mpGeometry(pGeometry)
    {}
 
    ~GeometricalObject() override {}
 
    GeometricalObject(GeometricalObject const& rOther)
        : IndexedObject(rOther.Id()),
          Flags(rOther),
          mpGeometry(rOther.mpGeometry)
    {}
 
 
 
    GeometricalObject& operator=(GeometricalObject const& rOther)
    {
        IndexedObject::operator=(rOther);
        Flags::operator =(rOther);
        return *this;
    }
 
 
 
    virtual void SetGeometry(GeometryType::Pointer pGeometry)
    {
        mpGeometry = pGeometry;
    }
 
    GeometryType::Pointer pGetGeometry()
    {
        return mpGeometry;
    }
 
    const GeometryType::Pointer pGetGeometry() const
    {
        return mpGeometry;
    }
 
    GeometryType& GetGeometry()
    {
        return *mpGeometry;
    }
 
    GeometryType const& GetGeometry() const
    {
        return *mpGeometry;
    }
 
    Flags& GetFlags()
    {
        return *this;
    }
 
    Flags const& GetFlags() const
    {
        return *this;
    }
 
    void SetFlags(Flags const& rThisFlags)
    {
        Flags::operator=(rThisFlags);
    }
 
 
    KRATOS_DEPRECATED_MESSAGE("This method is deprecated. Use 'GetData()' instead.")
    DataValueContainer& Data()
    {
        return pGetGeometry()->GetData();
    }
 
    DataValueContainer& GetData()
    {
        return pGetGeometry()->GetData();
    }
 
    DataValueContainer const& GetData() const
    {
        return GetGeometry().GetData();
    }
 
    void SetData(DataValueContainer const& rThisData)
    {
        return GetGeometry().SetData(rThisData);
    }
 
    template<class TDataType> bool Has(const Variable<TDataType>& rThisVariable) const
    {
        return GetData().Has(rThisVariable);
    }
 
    template<class TVariableType> void SetValue(
        const TVariableType& rThisVariable,
        typename TVariableType::Type const& rValue)
    {
        GetData().SetValue(rThisVariable, rValue);
    }
 
    template<class TVariableType> typename TVariableType::Type& GetValue(
        const TVariableType& rThisVariable)
    {
        return GetData().GetValue(rThisVariable);
    }
 
    template<class TVariableType> typename TVariableType::Type const& GetValue(
        const TVariableType& rThisVariable) const
    {
        return GetData().GetValue(rThisVariable);
    }
 
 
    bool IsActive() const;
 
    inline static bool HasSameType(const GeometricalObject& rLHS, const GeometricalObject& rRHS) {
        return (typeid(rLHS) == typeid(rRHS));
    }
 
    inline static bool HasSameType(const GeometricalObject * rLHS, const GeometricalObject* rRHS) {
        return GeometricalObject::HasSameType(*rLHS, *rRHS);
    }
 
    inline static bool HasSameGeometryType(const GeometricalObject& rLHS, const GeometricalObject& rRHS) {
        return (rLHS.GetGeometry().GetGeometryType() == rRHS.GetGeometry().GetGeometryType());
    }
 
    inline static bool HasSameGeometryType(const GeometricalObject* rLHS, const GeometricalObject* rRHS) {
        return GeometricalObject::HasSameGeometryType(*rLHS, *rRHS);
    }
 
    inline static bool IsSame(const GeometricalObject& rLHS, const GeometricalObject& rRHS) {
        return GeometricalObject::HasSameType(rLHS, rRHS) && GeometricalObject::HasSameGeometryType(rLHS, rRHS);
    }
 
    inline static bool IsSame(const GeometricalObject* rLHS, const GeometricalObject* rRHS) {
        return GeometricalObject::HasSameType(*rLHS, *rRHS) && GeometricalObject::HasSameGeometryType(*rLHS, *rRHS);
    }
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "Geometrical object # "
               << Id();
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
    }
 
    //*********************************************
    //public API of intrusive_ptr
    unsigned int use_count() const noexcept
    {
        return mReferenceCounter;
    }
    //*********************************************
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    GeometryType::Pointer mpGeometry; 
 
 
    //*********************************************
    //this block is needed for refcounting
    mutable std::atomic<int> mReferenceCounter{0};
 
    friend void intrusive_ptr_add_ref(const GeometricalObject* x)
    {
        x->mReferenceCounter.fetch_add(1, std::memory_order_relaxed);
    }
 
    friend void intrusive_ptr_release(const GeometricalObject* x)
    {
        if (x->mReferenceCounter.fetch_sub(1, std::memory_order_release) == 1) {
        std::atomic_thread_fence(std::memory_order_acquire);
        delete x;
        }
    }
    //*********************************************
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, IndexedObject );
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, Flags );
        rSerializer.save("Geometry",mpGeometry);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, IndexedObject );
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, Flags );
        rSerializer.load("Geometry",mpGeometry);
    }
 
 
 
 
 
 
 
 
 
}; // Class GeometricalObject
 
 
 
 
 
 
inline std::istream& operator >> (std::istream& rIStream,
                                  GeometricalObject& rThis);
 
inline std::ostream& operator << (std::ostream& rOStream,
                                  const GeometricalObject& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.