qfluid_2d.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Author Julio Marti
//
 
 
//#define FIRST
 
// System includes
 
// External includes
 
 
#if !defined(KRATOS_FLUID_2Dp_GLS_H_INCLUDED )
#define  KRATOS_FLUID_2Dp_GLS_H_INCLUDED
 
 
 
// System includes
 
 
// External includes
#include "boost/smart_ptr.hpp"
 
 
// Project includes
#include "includes/define.h"
#include "includes/element.h"
#include "includes/ublas_interface.h"
#include "includes/serializer.h"
 
 
namespace Kratos
{
 
 
 
 
 
 
 
  class QFluid2D
    : public Element
  {
  public:
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(QFluid2D);
 
 
    QFluid2D(IndexType NewId, GeometryType::Pointer pGeometry);
    QFluid2D(IndexType NewId, GeometryType::Pointer pGeometry, PropertiesType::Pointer pProperties);
 
    virtual ~QFluid2D() override;
 
 
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes, PropertiesType::Pointer pProperties) const override;
 
    void CalculateLocalSystem(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void CalculateRightHandSide(VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo) override;
 
    void EquationIdVector(EquationIdVectorType& rResult, const ProcessInfo& rCurrentProcessInfo) const override;
 
    void GetDofList(DofsVectorType& ElementalDofList, const ProcessInfo& CurrentProcessInfo) const override;
 
    void InitializeSolutionStep(const ProcessInfo& CurrentProcessInfo) override;
 
    //void Calculate(const Variable<double>& rVariable, double& Output, const ProcessInfo& rCurrentProcessInfo);
    //void CalculateViscousMatrix(MatrixType& K, const BoundedMatrix<double,3,2>& DN_DX, const double& nu);
    void CalculateViscousMatrix(MatrixType& K  , const BoundedMatrix<double,3,2>& DN_DX, const double& nu, const double& deltat, const double& bulk); //, const double& k);
 
    int Check(const ProcessInfo& rCurrentProcessInfo) const override;
 
 
 
 
 
 
 
    virtual std::string Info() const override
    {
      return "QFluid2D #";
    }
 
 
    virtual void PrintInfo(std::ostream& rOStream) const override
    {
      rOStream << Info() << Id();
    }
 
    //      virtual void PrintData(std::ostream& rOStream) const;
 
 
 
 
 
  protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  private:
 
    IntegrationMethod mThisIntegrationMethod;
    std::vector< Matrix > mInvJ0;
    Vector mDetJ0;
 
 
    void Stage1(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo);//, unsigned int ComponentIndex);
    void Stage2(MatrixType& rLeftHandSideMatrix, VectorType& rRightHandSideVector, const ProcessInfo& rCurrentProcessInfo);
    // inline double CalculateTau(BoundedMatrix<double, 3,2 > & DN_DX, array_1d<double, 2 > & vel_gauss, const double h, const double nu, const double norm_u, const ProcessInfo& CurrentProcessInfo);
    double ComputeSmagorinskyViscosity(const BoundedMatrix<double, 3, 2 > & DN_DX,
                                       const double& h,
                                       const double& C,
                                       const double nu
                       );
 
 
 
 
 
 
 
    friend class Serializer;
 
    // A private default constructor necessary for serialization
 
    QFluid2D() : Element()
    {
    }
 
    virtual void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, Element);
    }
 
    virtual void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, Element);
    }
 
 
    //QFluid2D& operator=(const QFluid2D& rOther);
 
    //QFluid2D(const QFluid2D& rOther);
 
 
 
  }; // Class QFluid2D
 
 
 
 
 
 
  /*  inline std::istream& operator >> (std::istream& rIStream,
      QFluid2D& rThis);
  */
  /*  inline std::ostream& operator << (std::ostream& rOStream,
      const QFluid2D& rThis)
      {
      rThis.PrintInfo(rOStream);
      rOStream << std::endl;
      rThis.PrintData(rOStream);
 
      return rOStream;
      }*/
 
} // namespace Kratos.
 
#endif // KRATOS_FLUID_2D_H_INCLUDED  defined