two_fluid_vms_linearized_darcy.h

Go to the documentation of this file.

//    |  /           | 
//    ' /   __| _` | __|  _ \   __| 
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/ 
//                   Multi-Physics  
//
//  License:         BSD License 
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Daniel Diez
//                   Jordi Cotela
//
 
#if !defined(KRATOS_TWO_FLUID_VMS_LINEARIZED_DARCY_H_INCLUDED )
#define  KRATOS_TWO_FLUID_VMS_LINEARIZED_DARCY_H_INCLUDED
// System includes
#include <string>
#include <iostream>
 
#include "custom_elements/two_fluid_vms.h"
 
namespace Kratos {
 
 
 
 
template< unsigned int TDim,
          unsigned int TNumNodes = TDim + 1 >
class TwoFluidVMSLinearizedDarcy : public TwoFluidVMS<TDim,TNumNodes> {
public:
 
 
    KRATOS_CLASS_INTRUSIVE_POINTER_DEFINITION(TwoFluidVMSLinearizedDarcy);
 
    using ElementBaseType = TwoFluidVMS<TDim,TNumNodes>;
 
    typedef Node NodeType;
    
    typedef Properties PropertiesType;
 
    typedef Geometry<NodeType> GeometryType;
 
    typedef Geometry<NodeType>::PointsArrayType NodesArrayType;
    
    typedef std::size_t IndexType;
 
 
    //Constructors.
 
 
    TwoFluidVMSLinearizedDarcy(IndexType NewId = 0) : ElementBaseType(NewId) {}
 
 
    TwoFluidVMSLinearizedDarcy(IndexType NewId, const NodesArrayType& ThisNodes)
        : ElementBaseType(NewId, ThisNodes) {}
 
 
    TwoFluidVMSLinearizedDarcy(IndexType NewId, GeometryType::Pointer pGeometry)
        : ElementBaseType(NewId, pGeometry) {}
 
 
    TwoFluidVMSLinearizedDarcy(IndexType NewId, GeometryType::Pointer pGeometry,
        PropertiesType::Pointer pProperties)
        : ElementBaseType(NewId, pGeometry, pProperties) {}
 
    ~TwoFluidVMSLinearizedDarcy() override {}
 
 
 
    Element::Pointer Create(IndexType NewId, NodesArrayType const& ThisNodes,
        PropertiesType::Pointer pProperties) const override {
 
        return Kratos::make_intrusive<TwoFluidVMSLinearizedDarcy>(
            NewId, (this->GetGeometry()).Create(ThisNodes), pProperties);
    }
 
 
    Element::Pointer Create(IndexType NewId, GeometryType::Pointer pGeom,
        PropertiesType::Pointer pProperties) const override {
 
        return Kratos::make_intrusive<TwoFluidVMSLinearizedDarcy>(
            NewId, pGeom, pProperties);
    }
 
 
protected:
 
 
    double CalculateDarcyTerm(
        const double Density,
        const double DynamicViscosity,
        const double LinearCoefficient,
        const double NonlinearCoefficient,
        const array_1d<double, TNumNodes>& rShapefunctions) override {
 
        array_1d<double,3> old_velocity;
        this->GetAdvectiveVel(old_velocity, rShapefunctions,1);
        const double old_velocity_norm = MathUtils<double>::Norm3(old_velocity);
 
        return DynamicViscosity * LinearCoefficient + Density * NonlinearCoefficient*old_velocity_norm;
    }
 
private:
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override {
        KRATOS_SERIALIZE_SAVE_BASE_CLASS(rSerializer, ElementBaseType);
    }
 
    void load(Serializer& rSerializer) override {
        KRATOS_SERIALIZE_LOAD_BASE_CLASS(rSerializer, ElementBaseType);
    }
 
};
 
 
template< unsigned int TDim,
          unsigned int TNumNodes >
inline std::istream & operator >>(std::istream& rIStream,
                                  TwoFluidVMSLinearizedDarcy<TDim, TNumNodes>& rThis)
{
    return rIStream;
}
template< unsigned int TDim,
          unsigned int TNumNodes >
inline std::ostream & operator <<(std::ostream& rOStream,
                                  const TwoFluidVMSLinearizedDarcy<TDim, TNumNodes>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
    return rOStream;
}
 
 
 
} // namespace Kratos.
 
#endif //KRATOS_TWO_FLUID_VMS_LINEARIZED_DARCY_H_INCLUDED