[Mat] LinearElasticIsotropic model implementation.

Documentation/ProjectFile/process/SMALL_DEFORMATION/constitutive_relation/LinearElasticIsotropic/t_poissons_ratio.md

+Poisson's ratio of a linear elastic material.

Documentation/ProjectFile/process/SMALL_DEFORMATION/constitutive_relation/LinearElasticIsotropic/t_youngs_modulus.md

+Young's modulus of a linear elastic material.

MaterialLib/SolidModels/CreateLinearElasticIsotropic.h

+/**
+ * \copyright
+ * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
+ *            Distributed under a Modified BSD License.
+ *              See accompanying file LICENSE.txt or
+ *              http://www.opengeosys.org/project/license
+ *
+ */
+
+#ifndef MATERIALLIB_SOLIDMODELS_CREATELINEARELASTICISOTROPIC_H_
+#define MATERIALLIB_SOLIDMODELS_CREATELINEARELASTICISOTROPIC_H_
+
+#include "ProcessLib/Utils/ProcessUtils.h"  // required for findParameter
+#include "LinearElasticIsotropic.h"
+
+namespace Solids
+{
+
+template <int DisplacementDim>
+std::unique_ptr<LinearElasticIsotropic<DisplacementDim>>
+createLinearElasticIsotropic(
+    std::vector<std::unique_ptr<ProcessLib::ParameterBase>> const& parameters,
+    BaseLib::ConfigTree const& config)
+{
+    config.checkConfigParameter("type", "LinearElasticIsotropic");
+    DBUG("Create LinearElasticIsotropic material");
+
+    // Youngs modulus
+    auto& youngs_modulus = ProcessLib::findParameter<double>(
+        config, "youngs_modulus", parameters, 1);
+
+    DBUG("Use '%s' as youngs_modulus parameter.", youngs_modulus.name.c_str());
+
+    // Poissons ratio
+    auto& poissons_ratio = ProcessLib::findParameter<double>(
+        config, "poissons_ratio", parameters, 1);
+
+    DBUG("Use '%s' as poissons_ratio parameter.", poissons_ratio.name.c_str());
+
+    typename LinearElasticIsotropic<DisplacementDim>::MaterialProperties mp{
+        youngs_modulus, poissons_ratio};
+
+    return std::unique_ptr<LinearElasticIsotropic<DisplacementDim>>{
+        new LinearElasticIsotropic<DisplacementDim>{mp}};
+}
+
+}  // namespace Solids
+
+#endif  // MATERIALLIB_SOLIDMODELS_CREATELINEARELASTICISOTROPIC_H_

MaterialLib/SolidModels/LinearElasticIsotropic.cpp

+/**
+ * \copyright
+ * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
+ *            Distributed under a Modified BSD License.
+ *              See accompanying file LICENSE.txt or
+ *              http://www.opengeosys.org/project/license
+ *
+ */
+
+#include "LinearElasticIsotropic.h"
+
+namespace Solids
+{
+
+template class LinearElasticIsotropic<2>;
+template class LinearElasticIsotropic<3>;
+
+
+}   // namespace Solids

MaterialLib/SolidModels/LinearElasticIsotropic.h

+/**
+ * \copyright
+ * Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
+ *            Distributed under a Modified BSD License.
+ *              See accompanying file LICENSE.txt or
+ *              http://www.opengeosys.org/project/license
+ *
+ */
+
+#ifndef MATERIALLIB_SOLIDMODELS_LINEARELASTICISOTROPIC_H_
+#define MATERIALLIB_SOLIDMODELS_LINEARELASTICISOTROPIC_H_
+
+#include "MechanicsBase.h"
+
+namespace Solids
+{
+template <int DisplacementDim>
+class LinearElasticIsotropic final : public MechanicsBase<DisplacementDim>
+{
+public:
+    /// Variables specific to the material model
+    class MaterialProperties
+    {
+        using P = ProcessLib::Parameter<double>;
+        using X = ProcessLib::SpatialPosition;
+
+    public:
+        MaterialProperties(P const& youngs_modulus, P const& poissons_ratio)
+            : _youngs_modulus(youngs_modulus), _poissons_ratio(poissons_ratio)
+        {
+        }
+
+        /// Lamé's first parameter.
+        double lambda(double const t, X const& x) const
+        {
+            return _youngs_modulus(t, x)[0] * _poissons_ratio(t, x)[0] /
+                   (1 + _poissons_ratio(t, x)[0]) /
+                   (1 - 2 * _poissons_ratio(t, x)[0]);
+        }
+
+        /// Lamé's second parameter, the shear modulus.
+        double mu(double const t, X const& x) const
+        {
+            return _youngs_modulus(t, x)[0] /
+                   (2 * (1 + _poissons_ratio(t, x)[0]));
+        }
+
+    private:
+        P const& _youngs_modulus;
+        P const& _poissons_ratio;
+    };
+
+    struct MaterialStateVariables
+        : public MechanicsBase<DisplacementDim>::MaterialStateVariables
+    {
+        void pushBackState() {}
+    };
+
+    std::unique_ptr<
+        typename MechanicsBase<DisplacementDim>::MaterialStateVariables>
+    createMaterialStateVariables() override
+    {
+        return std::unique_ptr<
+            typename MechanicsBase<DisplacementDim>::MaterialStateVariables>{
+            new MaterialStateVariables};
+    }
+
+public:
+    static int const KelvinVectorSize =
+        ProcessLib::KelvinVectorDimensions<DisplacementDim>::value;
+    using KelvinVector = ProcessLib::KelvinVectorType<DisplacementDim>;
+    using KelvinMatrix = ProcessLib::KelvinMatrixType<DisplacementDim>;
+
+    explicit LinearElasticIsotropic(
+        MaterialProperties const& material_properties)
+        : _mp(material_properties)
+    {
+    }
+
+    void computeConstitutiveRelation(
+        double const t,
+        ProcessLib::SpatialPosition const& x,
+        double const /*dt*/,
+        KelvinVector const& eps_prev,
+        KelvinVector const& eps,
+        KelvinVector const& sigma_prev,
+        KelvinVector& sigma,
+        KelvinMatrix& C,
+        typename MechanicsBase<DisplacementDim>::MaterialStateVariables&
+        /*material_state_variables*/) override
+    {
+        C.setZero();
+
+        C.template topLeftCorner<3, 3>().setConstant(_mp.lambda(t, x));
+        C.noalias() += 2 * _mp.mu(t, x) * KelvinMatrix::Identity();
+
+        sigma.noalias() = sigma_prev + C * (eps - eps_prev);
+    }
+
+private:
+    MaterialProperties _mp;
+};
+
+}  // namespace Solids
+
+namespace Solids
+{
+extern template class LinearElasticIsotropic<2>;
+extern template class LinearElasticIsotropic<3>;
+}  // namespace Solids
+
+#endif  // MATERIALLIB_SOLIDMODELS_LINEARELASTICISOTROPIC_H_