stationary_stokes.h

Go to the documentation of this file.

#ifndef KRATOS_STATIONARY_STOKES_H
#define KRATOS_STATIONARY_STOKES_H
 
/*
==============================================================================
Kratos
A General Purpose Software for Multi-Physics Finite Element Analysis
Version 1.0 (Released on march 05, 2007).
 
Copyright 2007
Pooyan Dadvand, Riccardo Rossi
pooyan@cimne.upc.edu
rrossi@cimne.upc.edu
CIMNE (International Center for Numerical Methods in Engineering),
Gran Capita' s/n, 08034 Barcelona, Spain
 
Permission is hereby granted, free  of charge, to any person obtaining
a  copy  of this  software  and  associated  documentation files  (the
"Software"), to  deal in  the Software without  restriction, including
without limitation  the rights to  use, copy, modify,  merge, publish,
distribute,  sublicense and/or  sell copies  of the  Software,  and to
permit persons to whom the Software  is furnished to do so, subject to
the following condition:
 
Distribution of this code for  any  commercial purpose  is permissible
ONLY BY DIRECT ARRANGEMENT WITH THE COPYRIGHT OWNER.
 
The  above  copyright  notice  and  this permission  notice  shall  be
included in all copies or substantial portions of the Software.
 
THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT  SHALL THE AUTHORS OR COPYRIGHT HOLDERS  BE LIABLE FOR ANY
CLAIM, DAMAGES OR  OTHER LIABILITY, WHETHER IN AN  ACTION OF CONTRACT,
TORT  OR OTHERWISE, ARISING  FROM, OUT  OF OR  IN CONNECTION  WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
==============================================================================
 */
 
#ifndef KRATOS_FLUID_TAYLOR_HOOD_H
#define KRATOS_FLUID_TAYLOR_HOOD_H
// System includes
#include <string>
#include <iostream>
 
 
// External includes
 
 
// Project includes
#include "includes/define.h"
#include "includes/serializer.h"
#include "includes/element.h"
#include "geometries/geometry_data.h"
#include "geometries/triangle_2d_3.h"
#include "geometries/tetrahedra_3d_4.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
template< unsigned int TDim >
class StationaryStokes : public Element
{
public:
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(StationaryStokes);
 
    typedef Kratos::Vector ShapeFunctionsType;
 
    typedef Kratos::Matrix ShapeDerivativesType;
 
    typedef Kratos::Geometry< Node > GeometryType;
 
 
    StationaryStokes(IndexType NewId = 0) :
        Element(NewId)
    {}
 
    StationaryStokes(IndexType NewId, GeometryType::Pointer pGeometry) :
        Element(NewId, pGeometry)
    {}
 
    StationaryStokes(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties) :
        Element(NewId, pGeometry, pProperties)
    {}
 
    ~StationaryStokes() override
    {}
 
 
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, PropertiesType::Pointer pProperties)  const override;
 
 
 
    Element::Pointer Create(IndexType NewId, GeometryType::Pointer pGeom, PropertiesType::Pointer pProperties) const override;
 
 
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
    void Initialize(const ProcessInfo &rCurrentProcessInfo) override;
 
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override
    {
        MatrixType TmpLHS;
        this->CalculateLocalSystem(TmpLHS,rRightHandSideVector,rCurrentProcessInfo);
    }
 
    void GetDofList(DofsVectorType& rElementalDofList, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void EquationIdVector(Element::EquationIdVectorType& rResult, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetFirstDerivativesVector(Vector &rValues, int Step = 0) const override;
 
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "StationaryStokes" << this->GetGeometry().WorkingSpaceDimension() << "D #" << Id();
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "StationaryStokes" << this->GetGeometry().WorkingSpaceDimension() << "D #" << Id() << std::endl;
        rOStream << "Number of Nodes: " << this->GetGeometry().PointsNumber() << std::endl;
        rOStream << "Integration method: " << static_cast<int>(this->mIntegrationMethod);
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        this->PrintInfo(rOStream);
        rOStream << "Geometry Data: " << std::endl;
        this->GetGeometry().PrintData(rOStream);
    }
 
 
 
 
 
protected:
 
 
 
 
 
 
 
    void AddMomentumTerms(MatrixType &rLHS,
                          VectorType &rRHS,
                          const double Density,
                          const double Viscosity,
                          const array_1d<double,3>& BodyForce,
                          const double TauTwo,
                          const ShapeFunctionsType &N,
                          const ShapeDerivativesType &DN_DX,
                          const double Weigth);
 
    void AddContinuityTerms(MatrixType &rLHS,
                            VectorType &rRHS,
                            const double Density,
                            const array_1d<double,3>& BodyForce,
                            const double TauOne,
                            const ShapeFunctionsType &N,
                            const ShapeDerivativesType &DN_DX,
                            const double Weight);
 
    template< class TVariableType >
    void EvaluateInPoint(TVariableType& rResult,
                         const Kratos::Variable<TVariableType>& Var,
                         const ShapeFunctionsType& rShapeFunc,
                         GeometryType& rGeom)
    {
        rResult = rShapeFunc[0] * rGeom[0].FastGetSolutionStepValue(Var);
 
        for(SizeType i = 1; i < rShapeFunc.size(); i++)
        {
            rResult += rShapeFunc[i] * rGeom[i].FastGetSolutionStepValue(Var);
        }
    }
 
    virtual void CalculateTau(double& TauOne,
                              double& TauTwo,
                              const double DynViscosity);
 
    double ElementSize();
 
 
 
 
 
 
 
 
private:
 
 
 
    Element::IntegrationMethod mIntegrationMethod;
 
    std::vector< ShapeDerivativesType > mDN_DX;
 
    std::vector< double > mGaussWeight;
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
        KRATOS_TRY;
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, Element );
 
        unsigned int IntMethod = 0;
        switch(mIntegrationMethod)
        {
        case GeometryData::IntegrationMethod::GI_GAUSS_1:
            IntMethod = 1;
            break;
        case GeometryData::IntegrationMethod::GI_GAUSS_2:
            IntMethod = 2;
            break;
        case GeometryData::IntegrationMethod::GI_GAUSS_3:
            IntMethod = 3;
            break;
        case GeometryData::IntegrationMethod::GI_GAUSS_4:
            IntMethod = 4;
            break;
        case GeometryData::IntegrationMethod::GI_GAUSS_5:
            IntMethod = 5;
            break;
        default:
            KRATOS_ERROR << "Unknown integration method encountered on serializer save for StationaryStokes element: " << static_cast<int>(mIntegrationMethod) << std::endl;
            break;
        }
        rSerializer.save("IntMethod",IntMethod);
        rSerializer.save("mDN_DX",mDN_DX);
        rSerializer.save("mGaussWeight",mGaussWeight);
        KRATOS_CATCH("");
    }
 
    void load(Serializer& rSerializer) override
    {
        KRATOS_TRY;
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer,Element);
 
        unsigned int IntMethod = 0;
        rSerializer.load("IntMethod",IntMethod);
        switch(static_cast<int>(mIntegrationMethod))
        {
        case 1:
            mIntegrationMethod = GeometryData::IntegrationMethod::GI_GAUSS_1;
            break;
        case 2:
            mIntegrationMethod = GeometryData::IntegrationMethod::GI_GAUSS_2;
            break;
        case 3:
            mIntegrationMethod = GeometryData::IntegrationMethod::GI_GAUSS_3;
            break;
        case 4:
            mIntegrationMethod = GeometryData::IntegrationMethod::GI_GAUSS_4;
            break;
        case 5:
            mIntegrationMethod = GeometryData::IntegrationMethod::GI_GAUSS_5;
            break;
        default:
            KRATOS_ERROR << "Unknown integration method encountered on serializer load for StationaryStokes element: " << static_cast<int>(IntMethod);
            break;
        }
        rSerializer.load("mDN_DX",mDN_DX);
        rSerializer.load("mGaussWeight",mGaussWeight);
        KRATOS_CATCH("");
    }
 
 
 
 
 
 
 
 
 
 
    StationaryStokes& operator=(StationaryStokes const& rOther);
 
    StationaryStokes(StationaryStokes const& rOther);
 
 
 
}; // Class StationaryStokes
 
 
 
 
 
 
template< unsigned int TDim >
inline std::istream& operator >> (std::istream& rIStream,
                                  StationaryStokes<TDim>& rThis)
{
    return rIStream;
}
 
template< unsigned int TDim >
inline std::ostream& operator << (std::ostream& rOStream,
                                  const StationaryStokes<TDim>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_FLUID_TAYLOR_HOOD_H
 
 
#endif // KRATOS_STATIONARY_STOKES_H