retention_law.h

Go to the documentation of this file.

// KRATOS___
//     //   ) )
//    //         ___      ___
//   //  ____  //___) ) //   ) )
//  //    / / //       //   / /
// ((____/ / ((____   ((___/ /  MECHANICS
//
//  License:         geo_mechanics_application/license.txt
//
//  Main authors:    Vahid Galavi
//
 
#pragma once
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "geometries/geometry.h"
#include "includes/define.h"
#include "includes/process_info.h"
#include "includes/properties.h"
#include "includes/serializer.h"
#include <optional>
 
namespace Kratos {
 
class KRATOS_API(GEO_MECHANICS_APPLICATION) RetentionLaw {
public:
    using ProcessInfoType = ProcessInfo;
    using SizeType = std::size_t;
    using GeometryType = Geometry<Node>;
 
    KRATOS_CLASS_POINTER_DEFINITION(RetentionLaw);
 
    class Parameters {
        KRATOS_CLASS_POINTER_DEFINITION(Parameters);
 
    public:
        Parameters(const Properties& rMaterialProperties,
                   const ProcessInfo& rCurrentProcessInfo)
            : mrCurrentProcessInfo(rCurrentProcessInfo),
              mrMaterialProperties(rMaterialProperties){};
 
        ~Parameters() = default;
 
        void SetFluidPressure(double FluidPressure)
        {
            mFluidPressure = FluidPressure;
        };
 
        double GetFluidPressure() const
        {
            KRATOS_ERROR_IF_NOT(mFluidPressure.has_value())
                << "Fluid pressure is not yet set in the retention "
                   "law when trying to retrieve it, aborting.\n";
            return mFluidPressure.value();
        }
 
        const ProcessInfo& GetProcessInfo() const
        {
            return mrCurrentProcessInfo;
        }
 
        const Properties& GetMaterialProperties() const
        {
            return mrMaterialProperties;
        }
 
    private:
        std::optional<double> mFluidPressure;
        const ProcessInfo& mrCurrentProcessInfo;
        const Properties& mrMaterialProperties;
 
    }; // class Parameters end
 
    RetentionLaw() = default;
 
    virtual ~RetentionLaw() = default;
 
    virtual RetentionLaw::Pointer Clone() const = 0;
 
    virtual double& CalculateValue(Parameters& rParameters,
                                   const Variable<double>& rThisVariable,
                                   double& rValue) = 0;
 
    virtual double CalculateSaturation(Parameters& rParameters) = 0;
 
    virtual double CalculateEffectiveSaturation(Parameters& rParameters) = 0;
 
    virtual double CalculateDerivativeOfSaturation(Parameters& rParameters) = 0;
 
    virtual double CalculateRelativePermeability(Parameters& rParameters) = 0;
 
    virtual double CalculateBishopCoefficient(Parameters& rParameters) = 0;
 
    virtual void InitializeMaterial(const Properties& rMaterialProperties,
                                    const GeometryType& rElementGeometry,
                                    const Vector& rShapeFunctionsValues);
 
    virtual void Initialize(Parameters& rParameters);
 
    virtual void InitializeSolutionStep(Parameters& rParameters);
 
    virtual void FinalizeSolutionStep(Parameters& rParameters);
 
    virtual void Finalize(Parameters& rParameters);
 
    virtual void ResetMaterial(const Properties& rMaterialProperties,
                               const GeometryType& rElementGeometry,
                               const Vector& rShapeFunctionsValues);
 
    virtual int Check(const Properties& rMaterialProperties,
                      const ProcessInfo& rCurrentProcessInfo) = 0;
 
    inline static bool HasSameType(const RetentionLaw& rLHS, const RetentionLaw& rRHS)
    {
        return (typeid(rLHS) == typeid(rRHS));
    }
 
    inline static bool HasSameType(const RetentionLaw* rLHS, const RetentionLaw* rRHS)
    {
        return RetentionLaw::HasSameType(*rLHS, *rRHS);
    }
 
    virtual std::string Info() const
    {
        return "RetentionLaw";
    }
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        rOStream << "RetentionLaw has no data";
    }
 
private:
    friend class Serializer;
 
    virtual void save(Serializer& rSerializer) const;
 
    virtual void load(Serializer& rSerializer);
 
}; /* Class RetentionLaw */
 
inline std::istream& operator>>(std::istream& rIStream, RetentionLaw& rThis);
 
inline std::ostream& operator<<(std::ostream& rOStream, const RetentionLaw& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << " : " << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
} /* namespace Kratos.*/