boussinesq_element.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Miguel Maso Sotomayor
//
 
#ifndef KRATOS_BOUSSINESQ_ELEMENT_H_INCLUDED
#define KRATOS_BOUSSINESQ_ELEMENT_H_INCLUDED
 
// System includes
 
 
// External includes
 
 
// Project includes
#include "primitive_element.h"
 
namespace Kratos
{
 
 
 
 
 
 
template<std::size_t TNumNodes>
class BoussinesqElement : public PrimitiveElement<TNumNodes>
{
public:
 
    typedef std::size_t IndexType;
 
    typedef Node NodeType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef PrimitiveElement<TNumNodes> BaseType;
 
    typedef typename BaseType::VectorType VectorType;
 
    typedef typename BaseType::NodesArrayType NodesArrayType;
 
    typedef typename BaseType::PropertiesType PropertiesType;
 
    typedef typename BaseType::ElementData ElementData;
 
    typedef typename BaseType::LocalMatrixType LocalMatrixType;
 
    typedef typename BaseType::LocalVectorType LocalVectorType;
 
    typedef typename BaseType::ShapeFunctionsGradientsType ShapeFunctionsGradientsType;
 
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(BoussinesqElement);
 
 
    BoussinesqElement() : BaseType(){}
 
    BoussinesqElement(IndexType NewId, const NodesArrayType& ThisNodes) : BaseType(NewId, ThisNodes){}
 
    BoussinesqElement(IndexType NewId, GeometryType::Pointer pGeometry) : BaseType(NewId, pGeometry){}
 
    BoussinesqElement(IndexType NewId, GeometryType::Pointer pGeometry, typename PropertiesType::Pointer pProperties) : BaseType(NewId, pGeometry, pProperties){}
 
    ~ BoussinesqElement() override {};
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, typename PropertiesType::Pointer pProperties) const override
    {
        return Kratos::make_intrusive<BoussinesqElement<TNumNodes>>(NewId, this->GetGeometry().Create(ThisNodes), pProperties);
    }
 
    Element::Pointer Create(IndexType NewId, GeometryType::Pointer pGeom, typename PropertiesType::Pointer pProperties) const override
    {
        return Kratos::make_intrusive<BoussinesqElement<TNumNodes>>(NewId, pGeom, pProperties);
    }
 
    Element::Pointer Clone(IndexType NewId, NodesArrayType const& ThisNodes) const override
    {
        Element::Pointer p_new_elem = Create(NewId, this->GetGeometry().Create(ThisNodes), this->pGetProperties());
        p_new_elem->SetData(this->GetData());
        p_new_elem->Set(Flags(*this));
        return p_new_elem;
    }
 
    void InitializeNonLinearIteration(const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void AddExplicitContribution(const ProcessInfo& rCurrentProcessInfo) override;
 
 
    const Parameters GetSpecifications() const override;
 
 
    std::string Info() const override
    {
        return "BoussinesqElement";
    }
 
 
protected:
 
    static constexpr IndexType mLocalSize = BaseType::mLocalSize;
 
 
    void AddRightHandSide(
        LocalVectorType& rRHS,
        ElementData& rData,
        const Matrix& rNContainer,
        const ShapeFunctionsGradientsType& rDN_DXContainer,
        const Vector& rWeights);
 
    void AddDispersionProjection(
        LocalVectorType& rDispersionH,
        LocalVectorType& rDispersionU,
        const ElementData& rData,
        const array_1d<double,TNumNodes>& rN,
        const BoundedMatrix<double,TNumNodes,2>& rDN_DX,
        const double Weight = 1.0);
 
    void GetNodalData(ElementData& rData, const GeometryType& rGeometry, int Step = 0) override;
 
    void CalculateArtificialViscosity(
        BoundedMatrix<double,3,3>& rViscosity,
        BoundedMatrix<double,2,2>& rDiffusion,
        const ElementData& rData,
        const array_1d<double,TNumNodes>& rN,
        const BoundedMatrix<double,TNumNodes,2>& rDN_DX) override;
 
    void AlgebraicResidual(
        double& rMassResidual,
        array_1d<double,2>& rFreeSurfaceGradient,
        const ElementData& rData,
        const array_1d<double,TNumNodes>& rN,
        const BoundedMatrix<double,TNumNodes,2>& rDN_DX) const;
 
    void AddDispersiveTerms(
        LocalVectorType& rVector,
        const ElementData& rData,
        const array_1d<double,TNumNodes>& rN,
        const BoundedMatrix<double,TNumNodes,2>& rDN_DX,
        const double Weight = 1.0) override;
 
    void AddMassTerms(
        LocalMatrixType& rMatrix,
        const ElementData& rData,
        const array_1d<double,TNumNodes>& rN,
        const BoundedMatrix<double,TNumNodes,2>& rDN_DX,
        const double Weight = 1.0) override;
 
 
private:
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, Element);
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, Element);
    }
 
 
 
 
 
 
}; // Class BoussinesqElement
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_BOUSSINESQ_ELEMENT_H_INCLUDED  defined