[GeoMechanicsApplication] implement the "Undrained" behaviour, for the constitutive tensor (#14372)

markelov208 · web-flow · commit abdbdecb35df · 2026-04-22T10:17:01.000+02:00
* corrected error message

* taken GetSkemptonB, GetUndrainedPoissonsRatio, GetUndrainedYoungsModulus with unit tests

* added MakeContinuumConstitutiveTensor and unit test

* added checks for denominators

* changed variable names

* renamed CalculateElasticMatrix as CalculateElasticConstitutiveTensor

* added GEO_POISSON_UNDRAINED and GEO_SKEMPTON_B

* renamed MakeInterfaceConstitutiveMatrix as MakeInterfaceConstitutiveTensor

* used MakeContinuumConstitutiveTensor

* added unit tests for MakeInterfaceConstitutiveTensor

* added ConstitutiveLawUtitlities_CalculateK0NCFromFrictionAngleGivesK0NC

* added unit tests that throw errors

* minor for future

* minor changes in variable names

* more tests for GetUndrainedPoissonsRatio

* added check and tests for GetSkemptonB

* add warning in GetUndrainedPoissonsRatio

* added comments and minor changes

* fixed a code smell

* renamed GetUndrainedYoungsModulus to CalculateUndrainedYoungsModulus

* response to the review comments

* fixed unused variables

* used hard-coded expected values
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/constitutive_law_dimension.h b/applications/GeoMechanicsApplication/custom_constitutive/constitutive_law_dimension.h
@@ -28,12 +28,12 @@ class ConstitutiveLawDimension
 public:
     virtual ~ConstitutiveLawDimension() = default;
 
-    [[nodiscard]] virtual Matrix CalculateElasticMatrix(const Properties& rProperties) const = 0;
-    [[nodiscard]] virtual std::unique_ptr<ConstitutiveLawDimension> Clone() const            = 0;
-    [[nodiscard]] virtual std::size_t                               GetStrainSize() const    = 0;
-    [[nodiscard]] virtual std::size_t                               GetDimension() const     = 0;
-    [[nodiscard]] virtual std::size_t GetNumberOfNormalComponents() const                    = 0;
-    [[nodiscard]] virtual Flags       GetSpatialType() const                                 = 0;
+    [[nodiscard]] virtual Matrix CalculateElasticConstitutiveTensor(const Properties& rProperties) const = 0;
+    [[nodiscard]] virtual std::unique_ptr<ConstitutiveLawDimension> Clone() const         = 0;
+    [[nodiscard]] virtual std::size_t                               GetStrainSize() const = 0;
+    [[nodiscard]] virtual std::size_t                               GetDimension() const  = 0;
+    [[nodiscard]] virtual std::size_t GetNumberOfNormalComponents() const                 = 0;
+    [[nodiscard]] virtual Flags       GetSpatialType() const                              = 0;
 
 private:
     friend class Serializer;
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/incremental_linear_elastic_interface_law.cpp b/applications/GeoMechanicsApplication/custom_constitutive/incremental_linear_elastic_interface_law.cpp
@@ -59,7 +59,8 @@ Matrix& GeoIncrementalLinearElasticInterfaceLaw::CalculateValue(ConstitutiveLaw:
                                                                 Matrix& rValue)
 {
     if (rThisVariable == CONSTITUTIVE_MATRIX) {
-        rValue = mpConstitutiveLawDimension->CalculateElasticMatrix(rParameterValues.GetMaterialProperties());
+        rValue = mpConstitutiveLawDimension->CalculateElasticConstitutiveTensor(
+            rParameterValues.GetMaterialProperties());
     } else {
         KRATOS_ERROR << "Can't calculate value of " << rThisVariable.Name() << ": unsupported variable\n";
     }
@@ -88,7 +89,7 @@ void GeoIncrementalLinearElasticInterfaceLaw::CalculateMaterialResponseCauchy(Co
 {
     rValues.GetStressVector() =
         mPreviousTraction +
-        prod(mpConstitutiveLawDimension->CalculateElasticMatrix(rValues.GetMaterialProperties()),
+        prod(mpConstitutiveLawDimension->CalculateElasticConstitutiveTensor(rValues.GetMaterialProperties()),
              rValues.GetStrainVector() - mPreviousRelativeDisplacement);
 }
 
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/incremental_linear_elastic_law.cpp b/applications/GeoMechanicsApplication/custom_constitutive/incremental_linear_elastic_law.cpp
@@ -125,7 +125,7 @@ void GeoIncrementalLinearElasticLaw::CalculateElasticMatrix(Matrix& C, Constitut
 {
     KRATOS_TRY
 
-    C = mpConstitutiveDimension->CalculateElasticMatrix(rValues.GetMaterialProperties());
+    C = mpConstitutiveDimension->CalculateElasticConstitutiveTensor(rValues.GetMaterialProperties());
 
     if (this->GetConsiderDiagonalEntriesOnlyAndNoShear()) {
         SetEntriesAboveDiagonalToZero(C);
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/interface_coulomb_with_tension_cut_off.cpp b/applications/GeoMechanicsApplication/custom_constitutive/interface_coulomb_with_tension_cut_off.cpp
@@ -161,7 +161,7 @@ void InterfaceCoulombWithTensionCutOff::CalculateMaterialResponseCauchy(Paramete
 
     if (!mCoulombWithTensionCutOffImpl.IsAdmissibleStressState(trial_sigma_tau)) {
         mapped_sigma_tau = mCoulombWithTensionCutOffImpl.DoReturnMapping(
-            trial_sigma_tau, mpConstitutiveDimension->CalculateElasticMatrix(r_properties),
+            trial_sigma_tau, mpConstitutiveDimension->CalculateElasticConstitutiveTensor(r_properties),
             Geo::PrincipalStresses::AveragingType::NO_AVERAGING);
         if (negative) mapped_sigma_tau.Tau() *= -1.0;
     }
@@ -176,7 +176,7 @@ Geo::SigmaTau InterfaceCoulombWithTensionCutOff::CalculateTrialTractionVector(co
 {
     constexpr auto number_of_normal_components = std::size_t{1};
     return Geo::SigmaTau{mTractionVectorFinalized +
-                         prod(ConstitutiveLawUtilities::MakeInterfaceConstitutiveMatrix(
+                         prod(ConstitutiveLawUtilities::MakeInterfaceElasticConstitutiveTensor(
                                   NormalStiffness, ShearStiffness, GetStrainSize(), number_of_normal_components),
                               rRelativeDisplacementVector - mRelativeDisplacementVectorFinalized)};
 }
@@ -194,7 +194,7 @@ Matrix& InterfaceCoulombWithTensionCutOff::CalculateValue(Parameters& rConstitut
     if (rVariable == CONSTITUTIVE_MATRIX) {
         const auto&    r_properties = rConstitutiveLawParameters.GetMaterialProperties();
         constexpr auto number_of_normal_components = std::size_t{1};
-        rValue = ConstitutiveLawUtilities::MakeInterfaceConstitutiveMatrix(
+        rValue = ConstitutiveLawUtilities::MakeInterfaceElasticConstitutiveTensor(
             r_properties[INTERFACE_NORMAL_STIFFNESS], r_properties[INTERFACE_SHEAR_STIFFNESS],
             GetStrainSize(), number_of_normal_components);
     } else {
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/interface_plane_strain.cpp b/applications/GeoMechanicsApplication/custom_constitutive/interface_plane_strain.cpp
@@ -20,9 +20,9 @@
 namespace Kratos
 {
 
-Matrix InterfacePlaneStrain::CalculateElasticMatrix(const Properties& rProperties) const
+Matrix InterfacePlaneStrain::CalculateElasticConstitutiveTensor(const Properties& rProperties) const
 {
-    return ConstitutiveLawUtilities::MakeInterfaceConstitutiveMatrix(
+    return ConstitutiveLawUtilities::MakeInterfaceElasticConstitutiveTensor(
         rProperties[INTERFACE_NORMAL_STIFFNESS], rProperties[INTERFACE_SHEAR_STIFFNESS],
         GetStrainSize(), GetNumberOfNormalComponents());
 }
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/interface_plane_strain.h b/applications/GeoMechanicsApplication/custom_constitutive/interface_plane_strain.h
@@ -21,7 +21,7 @@ namespace Kratos
 class KRATOS_API(GEO_MECHANICS_APPLICATION) InterfacePlaneStrain : public ConstitutiveLawDimension
 {
 public:
-    [[nodiscard]] Matrix CalculateElasticMatrix(const Properties& rProperties) const override;
+    [[nodiscard]] Matrix CalculateElasticConstitutiveTensor(const Properties& rProperties) const override;
     [[nodiscard]] std::unique_ptr<ConstitutiveLawDimension> Clone() const override;
     [[nodiscard]] std::size_t                               GetStrainSize() const override;
     [[nodiscard]] std::size_t                               GetDimension() const override;
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/interface_three_dimensional_surface.cpp b/applications/GeoMechanicsApplication/custom_constitutive/interface_three_dimensional_surface.cpp
@@ -20,9 +20,9 @@
 namespace Kratos
 {
 
-Matrix InterfaceThreeDimensionalSurface::CalculateElasticMatrix(const Properties& rProperties) const
+Matrix InterfaceThreeDimensionalSurface::CalculateElasticConstitutiveTensor(const Properties& rProperties) const
 {
-    auto result = ConstitutiveLawUtilities::MakeInterfaceConstitutiveMatrix(
+    auto result = ConstitutiveLawUtilities::MakeInterfaceElasticConstitutiveTensor(
         rProperties[INTERFACE_NORMAL_STIFFNESS], rProperties[INTERFACE_SHEAR_STIFFNESS],
         GetStrainSize(), GetNumberOfNormalComponents());
 
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/interface_three_dimensional_surface.h b/applications/GeoMechanicsApplication/custom_constitutive/interface_three_dimensional_surface.h
@@ -21,7 +21,7 @@ namespace Kratos
 class KRATOS_API(GEO_MECHANICS_APPLICATION) InterfaceThreeDimensionalSurface : public ConstitutiveLawDimension
 {
 public:
-    [[nodiscard]] Matrix CalculateElasticMatrix(const Properties& rProperties) const override;
+    [[nodiscard]] Matrix CalculateElasticConstitutiveTensor(const Properties& rProperties) const override;
     [[nodiscard]] std::unique_ptr<ConstitutiveLawDimension> Clone() const override;
     [[nodiscard]] std::size_t                               GetStrainSize() const override;
     [[nodiscard]] std::size_t                               GetDimension() const override;
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/linear_elastic_law.cpp b/applications/GeoMechanicsApplication/custom_constitutive/linear_elastic_law.cpp
@@ -158,8 +158,7 @@ int GeoLinearElasticLaw::Check(const Properties&   rMaterialProperties,
     check_properties.Check(YOUNG_MODULUS);
     constexpr auto min_value_poisson_ratio = -1.0;
     constexpr auto max_value_poisson_ratio = 0.5;
-    check_properties.SingleUseBounds(CheckProperties::Bounds::InclusiveLowerAndExclusiveUpper)
-        .Check(POISSON_RATIO, min_value_poisson_ratio, max_value_poisson_ratio);
+    check_properties.Check(POISSON_RATIO, min_value_poisson_ratio, max_value_poisson_ratio);
 
     return 0;
 }
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/mohr_coulomb_with_tension_cutoff.cpp b/applications/GeoMechanicsApplication/custom_constitutive/mohr_coulomb_with_tension_cutoff.cpp
@@ -200,7 +200,8 @@ void MohrCoulombWithTensionCutOff::CalculateMaterialResponseCauchy(ConstitutiveL
     const auto& r_properties = rParameters.GetMaterialProperties();
 
     if (rParameters.GetOptions().Is(ConstitutiveLaw::COMPUTE_CONSTITUTIVE_TENSOR)) {
-        rParameters.GetConstitutiveMatrix() = mpConstitutiveDimension->CalculateElasticMatrix(r_properties);
+        rParameters.GetConstitutiveMatrix() =
+            mpConstitutiveDimension->CalculateElasticConstitutiveTensor(r_properties);
     }
     if (!rParameters.GetOptions().Is(ConstitutiveLaw::COMPUTE_STRESS)) {
         return;
@@ -215,7 +216,7 @@ void MohrCoulombWithTensionCutOff::CalculateMaterialResponseCauchy(ConstitutiveL
     } else {
         mCoulombWithTensionCutOffImpl.SaveKappaOfCoulombYieldSurface();
         auto mapped_principal_stresses = mCoulombWithTensionCutOffImpl.DoReturnMapping(
-            trial_principal_stresses, mpConstitutiveDimension->CalculateElasticMatrix(r_properties),
+            trial_principal_stresses, mpConstitutiveDimension->CalculateElasticConstitutiveTensor(r_properties),
             Geo::PrincipalStresses::AveragingType::NO_AVERAGING);
 
         // For interchanging principal stresses, retry mapping with averaged principal stresses.
@@ -226,7 +227,7 @@ void MohrCoulombWithTensionCutOff::CalculateMaterialResponseCauchy(ConstitutiveL
             mCoulombWithTensionCutOffImpl.RestoreKappaOfCoulombYieldSurface();
             mapped_principal_stresses = mCoulombWithTensionCutOffImpl.DoReturnMapping(
                 averaged_principal_trial_stress_vector,
-                mpConstitutiveDimension->CalculateElasticMatrix(r_properties), averaging_type);
+                mpConstitutiveDimension->CalculateElasticConstitutiveTensor(r_properties), averaging_type);
             mapped_principal_stresses.Values()[1] =
                 mapped_principal_stresses.Values()[AveragingTypeToArrayIndex(averaging_type)];
         }
@@ -240,7 +241,7 @@ void MohrCoulombWithTensionCutOff::CalculateMaterialResponseCauchy(ConstitutiveL
 Vector MohrCoulombWithTensionCutOff::CalculateTrialStressVector(const Vector&     rStrainVector,
                                                                 const Properties& rProperties) const
 {
-    return mStressVectorFinalized + prod(mpConstitutiveDimension->CalculateElasticMatrix(rProperties),
+    return mStressVectorFinalized + prod(mpConstitutiveDimension->CalculateElasticConstitutiveTensor(rProperties),
                                          rStrainVector - mStrainVectorFinalized);
 }
 
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/plane_strain.cpp b/applications/GeoMechanicsApplication/custom_constitutive/plane_strain.cpp
@@ -11,39 +11,18 @@
 //
 
 #include "plane_strain.h"
-
+#include "custom_utilities/constitutive_law_utilities.h"
 #include "geo_mechanics_application_constants.h"
 #include "includes/constitutive_law.h"
 
 namespace Kratos
 {
 
-Matrix PlaneStrain::CalculateElasticMatrix(const Properties& rProperties) const
+Matrix PlaneStrain::CalculateElasticConstitutiveTensor(const Properties& rProperties) const
 {
-    const auto youngs_modulus = rProperties[YOUNG_MODULUS];
-    const auto poissons_ratio = rProperties[POISSON_RATIO];
-    const auto c0 = youngs_modulus / ((1.0 + poissons_ratio) * (1.0 - 2.0 * poissons_ratio));
-    const auto c1 = (1.0 - poissons_ratio) * c0;
-    const auto c2 = poissons_ratio * c0;
-    const auto c3 = (0.5 - poissons_ratio) * c0;
-
-    Matrix result = ZeroMatrix(4, 4);
-
-    result(INDEX_2D_PLANE_STRAIN_XX, INDEX_2D_PLANE_STRAIN_XX) = c1;
-    result(INDEX_2D_PLANE_STRAIN_XX, INDEX_2D_PLANE_STRAIN_YY) = c2;
-    result(INDEX_2D_PLANE_STRAIN_XX, INDEX_2D_PLANE_STRAIN_ZZ) = c2;
-
-    result(INDEX_2D_PLANE_STRAIN_YY, INDEX_2D_PLANE_STRAIN_XX) = c2;
-    result(INDEX_2D_PLANE_STRAIN_YY, INDEX_2D_PLANE_STRAIN_YY) = c1;
-    result(INDEX_2D_PLANE_STRAIN_YY, INDEX_2D_PLANE_STRAIN_ZZ) = c2;
-
-    result(INDEX_2D_PLANE_STRAIN_ZZ, INDEX_2D_PLANE_STRAIN_XX) = c2;
-    result(INDEX_2D_PLANE_STRAIN_ZZ, INDEX_2D_PLANE_STRAIN_YY) = c2;
-    result(INDEX_2D_PLANE_STRAIN_ZZ, INDEX_2D_PLANE_STRAIN_ZZ) = c1;
-
-    result(INDEX_2D_PLANE_STRAIN_XY, INDEX_2D_PLANE_STRAIN_XY) = c3;
-
-    return result;
+    const auto [E, nu] = ConstitutiveLawUtilities::GetOrCalculateElasticProperties(rProperties);
+    return ConstitutiveLawUtilities::MakeContinuumElasticConstitutiveTensor(
+        E, nu, PlaneStrain::GetStrainSize(), PlaneStrain::GetNumberOfNormalComponents());
 }
 
 std::unique_ptr<ConstitutiveLawDimension> PlaneStrain::Clone() const
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/plane_strain.h b/applications/GeoMechanicsApplication/custom_constitutive/plane_strain.h
@@ -20,7 +20,7 @@ namespace Kratos
 class KRATOS_API(GEO_MECHANICS_APPLICATION) PlaneStrain : public ConstitutiveLawDimension
 {
 public:
-    [[nodiscard]] Matrix CalculateElasticMatrix(const Properties& rProperties) const override;
+    [[nodiscard]] Matrix CalculateElasticConstitutiveTensor(const Properties& rProperties) const override;
     [[nodiscard]] std::unique_ptr<ConstitutiveLawDimension> Clone() const override;
     [[nodiscard]] std::size_t                               GetStrainSize() const override;
     [[nodiscard]] std::size_t                               GetDimension() const override;
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/three_dimensional.cpp b/applications/GeoMechanicsApplication/custom_constitutive/three_dimensional.cpp
@@ -12,41 +12,18 @@
 //
 
 #include "three_dimensional.h"
-
+#include "custom_utilities/constitutive_law_utilities.h"
 #include "geo_mechanics_application_constants.h"
 #include "includes/constitutive_law.h"
 
 namespace Kratos
 {
 
-Matrix ThreeDimensional::CalculateElasticMatrix(const Properties& rProperties) const
+Matrix ThreeDimensional::CalculateElasticConstitutiveTensor(const Properties& rProperties) const
 {
-    const auto youngs_modulus = rProperties[YOUNG_MODULUS];
-    const auto poissons_ratio = rProperties[POISSON_RATIO];
-    const auto c0 = youngs_modulus / ((1.0 + poissons_ratio) * (1.0 - 2.0 * poissons_ratio));
-    const auto c1 = (1.0 - poissons_ratio) * c0;
-    const auto c2 = poissons_ratio * c0;
-    const auto c3 = (0.5 - poissons_ratio) * c0;
-
-    Matrix result = ZeroMatrix(GetStrainSize(), GetStrainSize());
-
-    result(INDEX_3D_XX, INDEX_3D_XX) = c1;
-    result(INDEX_3D_XX, INDEX_3D_YY) = c2;
-    result(INDEX_3D_XX, INDEX_3D_ZZ) = c2;
-
-    result(INDEX_3D_YY, INDEX_3D_XX) = c2;
-    result(INDEX_3D_YY, INDEX_3D_YY) = c1;
-    result(INDEX_3D_YY, INDEX_3D_ZZ) = c2;
-
-    result(INDEX_3D_ZZ, INDEX_3D_XX) = c2;
-    result(INDEX_3D_ZZ, INDEX_3D_YY) = c2;
-    result(INDEX_3D_ZZ, INDEX_3D_ZZ) = c1;
-
-    result(INDEX_3D_XY, INDEX_3D_XY) = c3;
-    result(INDEX_3D_YZ, INDEX_3D_YZ) = c3;
-    result(INDEX_3D_XZ, INDEX_3D_XZ) = c3;
-
-    return result;
+    const auto [E, nu] = ConstitutiveLawUtilities::GetOrCalculateElasticProperties(rProperties);
+    return ConstitutiveLawUtilities::MakeContinuumElasticConstitutiveTensor(
+        E, nu, ThreeDimensional::GetStrainSize(), ThreeDimensional::GetNumberOfNormalComponents());
 }
 
 std::unique_ptr<ConstitutiveLawDimension> ThreeDimensional::Clone() const
diff --git a/applications/GeoMechanicsApplication/custom_constitutive/three_dimensional.h b/applications/GeoMechanicsApplication/custom_constitutive/three_dimensional.h
@@ -22,7 +22,7 @@ namespace Kratos
 class KRATOS_API(GEO_MECHANICS_APPLICATION) ThreeDimensional : public ConstitutiveLawDimension
 {
 public:
-    [[nodiscard]] Matrix CalculateElasticMatrix(const Properties& rProperties) const override;
+    [[nodiscard]] Matrix CalculateElasticConstitutiveTensor(const Properties& rProperties) const override;
     [[nodiscard]] std::unique_ptr<ConstitutiveLawDimension> Clone() const override;
     [[nodiscard]] std::size_t                               GetStrainSize() const override;
     [[nodiscard]] std::size_t                               GetDimension() const override;
diff --git a/applications/GeoMechanicsApplication/custom_processes/apply_k0_procedure_process.cpp b/applications/GeoMechanicsApplication/custom_processes/apply_k0_procedure_process.cpp
@@ -142,7 +142,7 @@ void ApplyK0ProcedureProcess::CheckOCRorPOP(const Properties& rProperties, Index
             const auto pop = rProperties[POP];
             KRATOS_ERROR_IF(pop < 0.0)
                 << "POP (" << pop << ") should be in the range [0.0,-> for property Id of "
-                << rProperties.Id() << " element " << ElementId << "." << std::endl;
+                << rProperties.Id() << " for element " << ElementId << "." << std::endl;
         }
     }
 }
diff --git a/applications/GeoMechanicsApplication/custom_python/geo_mechanics_python_application.cpp b/applications/GeoMechanicsApplication/custom_python/geo_mechanics_python_application.cpp
@@ -119,6 +119,8 @@ PYBIND11_MODULE(KratosGeoMechanicsApplication, m)
     KRATOS_REGISTER_IN_PYTHON_VARIABLE(m, OCR)
     KRATOS_REGISTER_IN_PYTHON_VARIABLE(m, POISSON_UNLOADING_RELOADING)
     KRATOS_REGISTER_IN_PYTHON_VARIABLE(m, POP)
+    KRATOS_REGISTER_IN_PYTHON_VARIABLE(m, GEO_POISSON_UNDRAINED)
+    KRATOS_REGISTER_IN_PYTHON_VARIABLE(m, GEO_SKEMPTON_B)
 
     KRATOS_REGISTER_IN_PYTHON_VARIABLE(m, GEO_DRAINAGE_TYPE)
 
diff --git a/applications/GeoMechanicsApplication/custom_utilities/constitutive_law_utilities.cpp b/applications/GeoMechanicsApplication/custom_utilities/constitutive_law_utilities.cpp
diff --git a/applications/GeoMechanicsApplication/custom_utilities/constitutive_law_utilities.h b/applications/GeoMechanicsApplication/custom_utilities/constitutive_law_utilities.h
diff --git a/applications/GeoMechanicsApplication/geo_mechanics_application.cpp b/applications/GeoMechanicsApplication/geo_mechanics_application.cpp
diff --git a/applications/GeoMechanicsApplication/geo_mechanics_application_variables.cpp b/applications/GeoMechanicsApplication/geo_mechanics_application_variables.cpp
diff --git a/applications/GeoMechanicsApplication/geo_mechanics_application_variables.h b/applications/GeoMechanicsApplication/geo_mechanics_application_variables.h
diff --git a/applications/GeoMechanicsApplication/tests/cpp_tests/custom_constitutive/test_incremental_linear_elastic_plane_strain_2D_law.cpp b/applications/GeoMechanicsApplication/tests/cpp_tests/custom_constitutive/test_incremental_linear_elastic_plane_strain_2D_law.cpp
diff --git a/applications/GeoMechanicsApplication/tests/cpp_tests/custom_processes/test_apply_k0_procedure_process.cpp b/applications/GeoMechanicsApplication/tests/cpp_tests/custom_processes/test_apply_k0_procedure_process.cpp
diff --git a/applications/GeoMechanicsApplication/tests/cpp_tests/custom_utilities/test_constitutive_law_utilities.cpp b/applications/GeoMechanicsApplication/tests/cpp_tests/custom_utilities/test_constitutive_law_utilities.cpp

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,8 @@ Matrix& GeoIncrementalLinearElasticInterfaceLaw::CalculateValue(ConstitutiveLaw:`
`59`	`59`	`Matrix& rValue)`
`60`	`60`	`{`
`61`	`61`	`if (rThisVariable == CONSTITUTIVE_MATRIX) {`
`62`		`- rValue = mpConstitutiveLawDimension->CalculateElasticMatrix(rParameterValues.GetMaterialProperties());`
	`62`	`+ rValue = mpConstitutiveLawDimension->CalculateElasticConstitutiveTensor(`
	`63`	`+ rParameterValues.GetMaterialProperties());`
`63`	`64`	`} else {`
`64`	`65`	`KRATOS_ERROR << "Can't calculate value of " << rThisVariable.Name() << ": unsupported variable\n";`
`65`	`66`	`}`
`@@ -88,7 +89,7 @@ void GeoIncrementalLinearElasticInterfaceLaw::CalculateMaterialResponseCauchy(Co`
`88`	`89`	`{`
`89`	`90`	`rValues.GetStressVector() =`
`90`	`91`	`mPreviousTraction +`
`91`		`- prod(mpConstitutiveLawDimension->CalculateElasticMatrix(rValues.GetMaterialProperties()),`
	`92`	`+ prod(mpConstitutiveLawDimension->CalculateElasticConstitutiveTensor(rValues.GetMaterialProperties()),`
`92`	`93`	`rValues.GetStrainVector() - mPreviousRelativeDisplacement);`
`93`	`94`	`}`
`94`	`95`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ void GeoIncrementalLinearElasticLaw::CalculateElasticMatrix(Matrix& C, Constitut`
`125`	`125`	`{`
`126`	`126`	`KRATOS_TRY`
`127`	`127`
`128`		`- C = mpConstitutiveDimension->CalculateElasticMatrix(rValues.GetMaterialProperties());`
	`128`	`+ C = mpConstitutiveDimension->CalculateElasticConstitutiveTensor(rValues.GetMaterialProperties());`
`129`	`129`
`130`	`130`	`if (this->GetConsiderDiagonalEntriesOnlyAndNoShear()) {`
`131`	`131`	`SetEntriesAboveDiagonalToZero(C);`
Original file line number	Diff line number	Diff line change
`@@ -20,9 +20,9 @@`
`20`	`20`	`namespace Kratos`
`21`	`21`	`{`
`22`	`22`
`23`		`-Matrix InterfacePlaneStrain::CalculateElasticMatrix(const Properties& rProperties) const`
	`23`	`+Matrix InterfacePlaneStrain::CalculateElasticConstitutiveTensor(const Properties& rProperties) const`
`24`	`24`	`{`
`25`		`- return ConstitutiveLawUtilities::MakeInterfaceConstitutiveMatrix(`
	`25`	`+ return ConstitutiveLawUtilities::MakeInterfaceElasticConstitutiveTensor(`
`26`	`26`	`rProperties[INTERFACE_NORMAL_STIFFNESS], rProperties[INTERFACE_SHEAR_STIFFNESS],`
`27`	`27`	`GetStrainSize(), GetNumberOfNormalComponents());`
`28`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ namespace Kratos`
`21`	`21`	`class KRATOS_API(GEO_MECHANICS_APPLICATION) InterfacePlaneStrain : public ConstitutiveLawDimension`
`22`	`22`	`{`
`23`	`23`	`public:`
`24`		`- [[nodiscard]] Matrix CalculateElasticMatrix(const Properties& rProperties) const override;`
	`24`	`+ [[nodiscard]] Matrix CalculateElasticConstitutiveTensor(const Properties& rProperties) const override;`
`25`	`25`	`[[nodiscard]] std::unique_ptr<ConstitutiveLawDimension> Clone() const override;`
`26`	`26`	`[[nodiscard]] std::size_t GetStrainSize() const override;`
`27`	`27`	`[[nodiscard]] std::size_t GetDimension() const override;`
Original file line number	Diff line number	Diff line change
`@@ -158,8 +158,7 @@ int GeoLinearElasticLaw::Check(const Properties& rMaterialProperties,`
`158`	`158`	`check_properties.Check(YOUNG_MODULUS);`
`159`	`159`	`constexpr auto min_value_poisson_ratio = -1.0;`
`160`	`160`	`constexpr auto max_value_poisson_ratio = 0.5;`
`161`		`- check_properties.SingleUseBounds(CheckProperties::Bounds::InclusiveLowerAndExclusiveUpper)`
`162`		`- .Check(POISSON_RATIO, min_value_poisson_ratio, max_value_poisson_ratio);`
	`161`	`+ check_properties.Check(POISSON_RATIO, min_value_poisson_ratio, max_value_poisson_ratio);`
`163`	`162`
`164`	`163`	`return 0;`
`165`	`164`	`}`