MechanicsBase.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <functional>
#include <memory>
#include <optional>
#include <span>
#include <tuple>
#include <vector>
 
#include "BaseLib/Error.h"
#include "MaterialLib/MPL/VariableType.h"
#include "MathLib/KelvinVector.h"
 
namespace ParameterLib
{
class SpatialPosition;
}
 
namespace MeshLib
{
class Element;
}
 
namespace MaterialLib
{
namespace Solids
{
enum class ConstitutiveModel
{
    Ehlers,
    LinearElasticIsotropic,
    Lubby2,
    CreepBGRa,
    Invalid
};

template <int DisplacementDim>
struct MechanicsBase
{
    struct MaterialStateVariables
    {
        virtual ~MaterialStateVariables() = default;
        virtual void pushBackState(){};
        virtual double getEquivalentPlasticStrain() const { return 0.0; }
    };

    virtual std::unique_ptr<MaterialStateVariables>
    createMaterialStateVariables() const
    {
        return std::make_unique<MaterialStateVariables>();
    }
 
    virtual void initializeInternalStateVariables(
        double const /*t*/,
        ParameterLib::SpatialPosition const& /*x*/,
        typename MechanicsBase<DisplacementDim>::MaterialStateVariables&) const
    {
    }
 
    using KelvinVector =
        MathLib::KelvinVector::KelvinVectorType<DisplacementDim>;
    using KelvinMatrix =
        MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>;

    virtual std::optional<std::tuple<
        KelvinVector, std::unique_ptr<MaterialStateVariables>, KelvinMatrix>>
    integrateStress(
        MaterialPropertyLib::VariableArray const& variable_array_prev,
        MaterialPropertyLib::VariableArray const& variable_array,
        double const t,
        ParameterLib::SpatialPosition const& x,
        double const dt,
        MaterialStateVariables const& material_state_variables) const = 0;

    struct InternalVariable
    {
        using Getter = std::function<std::vector<double> const&(
            MaterialStateVariables const&, std::vector<double>& /*cache*/)>;
        using WriteAccess =
            std::function<std::span<double>(MaterialStateVariables&)>;

        std::string const name;

        int const num_components;

        Getter const getter;

        WriteAccess const reference;
    };

    virtual std::vector<InternalVariable> getInternalVariables() const
    {
        return {};
    }

    virtual ConstitutiveModel getConstitutiveModel() const
    {
        return ConstitutiveModel::Invalid;
    }
 
    virtual double getBulkModulus(
        double const /*t*/,
        ParameterLib::SpatialPosition const& /*x*/,
        KelvinMatrix const* const /*C*/ = nullptr) const
    {
        OGS_FATAL(
            "getBulkModulus is not yet implemented for this Solid Material.");
    }

    virtual double getTemperatureRelatedCoefficient(
        double const /*t*/, double const /*dt*/,
        ParameterLib::SpatialPosition const& /*x*/, double const /*T*/,
        double const /*deviatoric_stress_norm*/) const
    {
        return 0.0;
    }
 
    virtual double computeFreeEnergyDensity(
        double const t,
        ParameterLib::SpatialPosition const& x,
        double const dt,
        KelvinVector const& eps,
        KelvinVector const& sigma,
        MaterialStateVariables const& material_state_variables) const = 0;
 
    virtual ~MechanicsBase() = default;
};
 
}  // namespace Solids
}  // namespace MaterialLib