gauss_point_item.h

Go to the documentation of this file.

// KRATOS  __  __ _____ ____  _   _ ___ _   _  ____
//        |  \/  | ____/ ___|| | | |_ _| \ | |/ ___|
//        | |\/| |  _| \___ \| |_| || ||  \| | |  _
//        | |  | | |___ ___) |  _  || || |\  | |_| |
//        |_|  |_|_____|____/|_| |_|___|_| \_|\____| APPLICATION
//
//  License:         BSD License
//                       license: MeshingApplication/license.txt
//
//  Main authors:    Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_GAUSS_POINT_ITEM )
#define  KRATOS_GAUSS_POINT_ITEM
 
// System includes
 
// External includes
 
// Project includes
#include "geometries/point.h"
#include "includes/constitutive_law.h"
 
namespace Kratos
{
 
 
 
 
 
class GaussPointItem
    : public Point
{
public:
 
 
    typedef std::size_t IndexType;
 
    KRATOS_CLASS_POINTER_DEFINITION( GaussPointItem );
 
 
    GaussPointItem():
        Point()
    {
    }
 
    GaussPointItem(const array_1d<double, 3>& Coordinates):
        Point(Coordinates)
    {
    }
 
    GaussPointItem(
        const array_1d<double, 3>& Coordinates,
        ConstitutiveLaw::Pointer pConstitutiveLaw,
        const double Weight
        ):Point(Coordinates),
          mpConstitutiveLaw(std::move(pConstitutiveLaw)),
          mWeight(Weight)
    {
    }
 
    GaussPointItem(const GaussPointItem& GP)= default;
 
    ~GaussPointItem() override= default;
 
 
 
    Point GetPoint()
    {
        Point Point(this->Coordinates());
 
        return Point;
    }
 
    void SetPoint(const Point& Point)
    {
        this->Coordinates() = Point.Coordinates();
    }
 
    void SetConstitutiveLaw(ConstitutiveLaw::Pointer pConstitutiveLaw)
    {
        mpConstitutiveLaw = pConstitutiveLaw;
    }
 
    ConstitutiveLaw::Pointer GetConstitutiveLaw()
    {
        return mpConstitutiveLaw;
    }
 
    double GetWeight() const
    {
        return mWeight;
    }
 
    void SetWeight(const double Weight)
    {
        mWeight = Weight;
    }
 
    bool Has(const Variable<double>& rVariable)
    {
        const IndexType variable_key = rVariable.Key();
        auto double_set = mMapDoubleVariables.find(variable_key);
        if(double_set != mMapDoubleVariables.end()) {
            return true;
        }
 
        return false;
    }
 
    bool Has(const Variable<array_1d<double, 3>>& rVariable)
    {
        const IndexType variable_key = rVariable.Key();
        auto array_set = mMapArrayVariables.find(variable_key);
        if(array_set != mMapArrayVariables.end()) {
            return true;
        }
 
        return false;
    }
 
    bool Has(const Variable<Vector>& rVariable)
    {
        const IndexType variable_key = rVariable.Key();
        auto vector_set = mMapVectorVariables.find(variable_key);
        if(vector_set != mMapVectorVariables.end()) {
            return true;
        }
 
        return false;
    }
 
    bool Has(const Variable<Matrix>& rVariable)
    {
        const IndexType variable_key = rVariable.Key();
        auto matrix_set = mMapMatrixVariables.find(variable_key);
        if(matrix_set != mMapMatrixVariables.end()) {
            return true;
        }
 
        return false;
    }
 
    void SetValue(
        const Variable<double>& rVariable,
        const double rValue
        )
    {
        const IndexType variable_key = rVariable.Key();
        auto double_set = mMapDoubleVariables.find(variable_key);
        if(double_set != mMapDoubleVariables.end()) {
            mMapDoubleVariables[variable_key] = rValue;
            return void();
        }
        mMapDoubleVariables.insert({variable_key, rValue});
    }
 
    void SetValue(
        const Variable<array_1d<double, 3>>& rVariable,
        const array_1d<double, 3>& rValue
        )
    {
        const IndexType variable_key = rVariable.Key();
        auto array_set = mMapArrayVariables.find(variable_key);
        if(array_set != mMapArrayVariables.end()) {
            mMapArrayVariables[variable_key] = rValue;
            return void();
        }
        mMapArrayVariables.insert({variable_key, rValue});
    }
 
    void SetValue(
        const Variable<Vector>& rVariable,
        const Vector& rValue
        )
    {
        const IndexType variable_key = rVariable.Key();
        auto vector_set = mMapVectorVariables.find(variable_key);
        if(vector_set != mMapVectorVariables.end()) {
            mMapVectorVariables[variable_key] = rValue;
            return void();
        }
        mMapVectorVariables.insert({variable_key, rValue});
    }
 
    void SetValue(
        const Variable<Matrix>& rVariable,
        const Matrix& rValue
        )
    {
        const IndexType variable_key = rVariable.Key();
        auto matrix_set = mMapMatrixVariables.find(variable_key);
        if(matrix_set != mMapMatrixVariables.end()) {
            mMapMatrixVariables[variable_key] = rValue;
            return void();
        }
        mMapMatrixVariables.insert({variable_key, rValue});
    }
 
    double GetValue(
        const Variable<double>& rVariable,
        double& rValue
        )
    {
        rValue = mMapDoubleVariables[rVariable.Key()];
        return rValue;
    }
 
    array_1d<double, 3> GetValue(
        const Variable<array_1d<double, 3>>& rVariable,
        array_1d<double, 3>& rValue
        )
    {
        rValue = mMapArrayVariables[rVariable.Key()];
        return rValue;
    }
 
    Vector GetValue(
        const Variable<Vector>& rVariable,
        Vector& rValue
        )
    {
        rValue = mMapVectorVariables[rVariable.Key()];
        return rValue;
    }
 
    Matrix GetValue(
        const Variable<Matrix>& rVariable,
        Matrix& rValue
        )
    {
        rValue = mMapMatrixVariables[rVariable.Key()];
        return rValue;
    }
 
    void RemoveId(const IndexType VariableKey)
    {
        auto double_set = mMapDoubleVariables.find(VariableKey);
        if(double_set != mMapDoubleVariables.end()) {
            mMapDoubleVariables.erase(double_set);
            return void();
        }
        auto array_set = mMapArrayVariables.find(VariableKey);
        if(array_set != mMapArrayVariables.end()) {
            mMapArrayVariables.erase(array_set);
            return void();
        }
        auto vector_set = mMapVectorVariables.find(VariableKey);
        if(vector_set != mMapVectorVariables.end()) {
            mMapVectorVariables.erase(vector_set);
            return void();
        }
        auto matrix_set = mMapMatrixVariables.find(VariableKey);
        if(matrix_set != mMapMatrixVariables.end()) {
            mMapMatrixVariables.erase(matrix_set);
            return void();
        }
    }
protected:
 
 
 
 
 
 
 
 
private:
 
    ConstitutiveLaw::Pointer mpConstitutiveLaw; 
    double mWeight;                             
 
    /* For values not available on the constitutive law */                                        
    std::unordered_map<IndexType,double> mMapDoubleVariables;             
    std::unordered_map<IndexType,array_1d<double, 3>> mMapArrayVariables; 
    std::unordered_map<IndexType,Vector> mMapVectorVariables;             
    std::unordered_map<IndexType,Matrix> mMapMatrixVariables;             
 
 
 
 
 
 
}; // Class GaussPointItem
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_GAUSS_POINT_ITEM  defined