fluid_element.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Jordi Cotela
//
 
#ifndef KRATOS_FLUID_ELEMENT_H
#define KRATOS_FLUID_ELEMENT_H
 
#include "includes/checks.h"
#include "includes/define.h"
#include "includes/element.h"
#include "includes/serializer.h"
#include "includes/constitutive_law.h"
#include "geometries/geometry.h"
 
#include "includes/cfd_variables.h"
#include "custom_utilities/fluid_element_data.h"
#include "fluid_dynamics_application_variables.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
 
// Forward decalration of auxiliary class
namespace Internals {
template <class TElementData, bool TDataKnowsAboutTimeIntegration>
class FluidElementTimeIntegrationDetail;
}
 
template <class TElementData>
class FluidElement : public Element
{
public:
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(FluidElement);
 
    typedef Node NodeType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef Geometry<NodeType>::PointsArrayType NodesArrayType;
 
    typedef Vector VectorType;
 
    typedef Matrix MatrixType;
 
    typedef std::size_t IndexType;
 
    typedef std::size_t SizeType;
 
    typedef std::vector<std::size_t> EquationIdVectorType;
 
    typedef std::vector< Dof<double>::Pointer > DofsVectorType;
 
    typedef PointerVectorSet<Dof<double>, IndexedObject> DofsArrayType;
 
    typedef MatrixRow< Matrix > ShapeFunctionsType;
 
    typedef Kratos::Matrix ShapeFunctionDerivativesType;
 
    typedef GeometryType::ShapeFunctionsGradientsType ShapeFunctionDerivativesArrayType;
 
    using ElementData = TElementData;
 
    static constexpr unsigned int Dim = TElementData::Dim;
 
    static constexpr unsigned int NumNodes = TElementData::NumNodes;
 
    static constexpr unsigned int BlockSize = Dim + 1;
 
    static constexpr unsigned int LocalSize = NumNodes * BlockSize;
 
    static constexpr unsigned int StrainSize = TElementData::StrainSize;
 
 
    //Constructors.
 
 
    FluidElement(IndexType NewId = 0);
 
 
    FluidElement(IndexType NewId, const NodesArrayType& ThisNodes);
 
 
    FluidElement(IndexType NewId, GeometryType::Pointer pGeometry);
 
 
    FluidElement(IndexType NewId, GeometryType::Pointer pGeometry, Properties::Pointer pProperties);
 
    virtual ~FluidElement();
 
 
 
 
 
 
    Element::Pointer Create(IndexType NewId,
                            NodesArrayType const& ThisNodes,
                            Properties::Pointer pProperties) const override;
 
 
    Element::Pointer Create(IndexType NewId,
                            GeometryType::Pointer pGeom,
                            Properties::Pointer pProperties) const override;
 
 
    void Initialize(const ProcessInfo &rCurrentProcessInfo) override;
 
    void CalculateLocalSystem(
        MatrixType& rLeftHandSideMatrix,
        VectorType& rRightHandSideVector,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateLeftHandSide(
        MatrixType& rLeftHandSideMatrix,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(
        VectorType& rRightHandSideVector,
        const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateLocalVelocityContribution(
        MatrixType &rDampMatrix,
        VectorType &rRightHandSideVector,
        const ProcessInfo &rCurrentProcessInfo) override;
 
    void CalculateMassMatrix(
        MatrixType &rMassMatrix,
        const ProcessInfo &rCurrentProcessInfo) override;
 
 
    void EquationIdVector(
        EquationIdVectorType& rResult,
        const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetDofList(
        DofsVectorType& rElementalDofList,
        const ProcessInfo& rCurrentProcessInfo) const override;
 
 
    void GetFirstDerivativesVector(Vector& Values, int Step = 0) const override;
 
 
 
    void GetSecondDerivativesVector(Vector& Values, int Step = 0) const override;
 
 
    GeometryData::IntegrationMethod GetIntegrationMethod() const override;
 
 
 
    void CalculateOnIntegrationPoints(
        Variable<array_1d<double, 3>> const& rVariable,
        std::vector<array_1d<double, 3>>& rValues,
        ProcessInfo const& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        Variable<double> const& rVariable,
        std::vector<double>& rValues,
        ProcessInfo const& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        Variable<array_1d<double, 6>> const& rVariable,
        std::vector<array_1d<double, 6>>& rValues,
        ProcessInfo const& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        Variable<Vector> const& rVariable,
        std::vector<Vector>& rValues,
        ProcessInfo const& rCurrentProcessInfo) override;
 
    void CalculateOnIntegrationPoints(
        Variable<Matrix> const& rVariable,
        std::vector<Matrix>& rValues,
        ProcessInfo const& rCurrentProcessInfo) override;
 
 
    int Check(const ProcessInfo &rCurrentProcessInfo) const override;
 
 
    std::string Info() const override;
 
 
    void PrintInfo(std::ostream& rOStream) const override;
 
 
 
 
 
protected:
 
 
 
 
 
 
 
 
 
    virtual double GetAtCoordinate(
        const typename TElementData::NodalScalarData& rValues,
        const typename TElementData::ShapeFunctionsType& rN) const;
 
 
    virtual array_1d<double, 3> GetAtCoordinate(
        const typename TElementData::NodalVectorData& rValues,
        const typename TElementData::ShapeFunctionsType& rN) const;
 
 
    virtual BoundedMatrix<double, TElementData::Dim, TElementData::Dim> GetAtCoordinate(
        const typename TElementData::NodalTensorData &rValues,
        const typename TElementData::ShapeFunctionsType &rN) const;
 
 
    virtual double GetAtCoordinate(
        const double Value,
        const typename TElementData::ShapeFunctionsType& rN) const;
 
 
    virtual void UpdateIntegrationPointData(
        TElementData& rData,
        unsigned int IntegrationPointIndex,
        double Weight,
        const typename TElementData::MatrixRowType& rN,
        const typename TElementData::ShapeDerivativesType& rDN_DX) const;
 
    virtual void CalculateMaterialResponse(TElementData& rData) const;
 
    virtual void CalculateStrainRate(TElementData& rData) const;
 
    virtual void CalculateGeometryData(Vector& rGaussWeights,
                                       Matrix& rNContainer,
                                       ShapeFunctionDerivativesArrayType& rDN_DX) const;
 
    void ConvectionOperator(Vector& rResult,
                            const array_1d<double,3>& rConvVel,
                            const ShapeFunctionDerivativesType& DN_DX) const;
 
    virtual void AddTimeIntegratedSystem(
        TElementData& rData,
        MatrixType& rLHS,
        VectorType& rRHS);
 
    virtual void AddTimeIntegratedLHS(
        TElementData& rData,
        MatrixType& rLHS);
 
    virtual void AddTimeIntegratedRHS(
        TElementData& rData,
        VectorType& rRHS);
 
    virtual void AddVelocitySystem(
        TElementData& rData,
        MatrixType& rLocalLHS,
        VectorType& rLocalRHS);
 
    virtual void AddMassLHS(
        TElementData& rData,
        MatrixType& rMassMatrix);
 
    virtual void AddBoundaryTraction(
        TElementData& rData,
        const Vector& rUnitNormal,
        MatrixType& rLHS,
        VectorType& rRHS);
 
    void GetCurrentValuesVector(
        const TElementData& rData,
        array_1d<double,LocalSize>& rValues) const;
 
    void Calculate(
        const Variable<double> &rVariable,
        double &rOutput,
        const ProcessInfo &rCurrentProcessInfo) override;
 
    void Calculate(
        const Variable<array_1d<double, 3>> &rVariable,
        array_1d<double, 3> &rOutput,
        const ProcessInfo &rCurrentProcessInfo) override;
 
    void Calculate(
        const Variable<Vector> &rVariable,
        Vector &rOutput,
        const ProcessInfo &rCurrentProcessInfo) override;
 
    void Calculate(
        const Variable<Matrix> &rVariable,
        Matrix &rOutput,
        const ProcessInfo &rCurrentProcessInfo) override;
 
 
    const ConstitutiveLaw::Pointer GetConstitutiveLaw() const;
 
    ConstitutiveLaw::Pointer GetConstitutiveLaw();
 
 
 
 
 
 
private:
 
 
 
    ConstitutiveLaw::Pointer mpConstitutiveLaw = nullptr;
 
 
    friend class Internals::FluidElementTimeIntegrationDetail<TElementData, TElementData::ElementManagesTimeIntegration>;
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override;
 
    void load(Serializer& rSerializer) override;
 
 
 
 
 
 
 
 
 
 
    FluidElement& operator=(FluidElement const& rOther);
 
    FluidElement(FluidElement const& rOther);
 
 
 
}; // Class FluidElement
 
namespace Internals {
 
template< class TElementData, std::size_t TDim >
struct StrainRateSpecialization {
/*  @param[out] rStrainRate The strain rate tensor (symmetric gradient of velocity) in Voigt notation.
 *  @param[in] rVelocities Matrix of nodal velocities, as provided by TElementData.
 *  @param[in] rDNDX Matrix of shape function gradients on the integration point, as provided by TElementData.
 *  @see ConstitutiveLaw.
 */
static void Calculate(
    Vector& rStrainRate,
    const typename TElementData::NodalVectorData& rVelocities,
    const typename TElementData::ShapeDerivativesType& rDNDX);
};
 
template< class TElementData >
struct StrainRateSpecialization<TElementData,2> {
static void Calculate(
    Vector& rStrainRate,
    const typename TElementData::NodalVectorData& rVelocities,
    const typename TElementData::ShapeDerivativesType& rDNDX);
};
 
template< class TElementData >
struct StrainRateSpecialization<TElementData,3> {
static void Calculate(
    Vector& rStrainRate,
    const typename TElementData::NodalVectorData& rVelocities,
    const typename TElementData::ShapeDerivativesType& rDNDX);
};
 
}
 
 
 
 
 
 
template< class TElementData >
inline std::istream& operator >>(std::istream& rIStream,
                                 FluidElement<TElementData>& rThis)
{
    return rIStream;
}
 
template< class TElementData >
inline std::ostream& operator <<(std::ostream& rOStream,
                                 const FluidElement<TElementData>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
} // namespace Kratos.
 
#endif // KRATOS_FLUID_ELEMENT_H