[GeoMechanicsApplycation] Settlement API

applications/GeoMechanicsApplication/CMakeLists.txt

@@ -8,9 +8,11 @@ include(pybind11Tools)
 add_compile_definitions(_USE_MATH_DEFINES)
 
 kratos_add_dependency(${KRATOS_SOURCE_DIR}/applications/StructuralMechanicsApplication)
+kratos_add_dependency(${KRATOS_SOURCE_DIR}/applications/LinearSolversApplication)
 
 include_directories( ${CMAKE_SOURCE_DIR}/kratos )
 include_directories( ${CMAKE_SOURCE_DIR}/applications/StructuralMechanicsApplication )
+include_directories( ${CMAKE_SOURCE_DIR}/applications/LinearSolversApplication )
 include_directories( ${CMAKE_SOURCE_DIR}/applications/GeoMechanicsApplication )
 
 ## GeoMechanics Core sources
@@ -40,7 +42,7 @@ endif(${KRATOS_BUILD_TESTING} MATCHES ON)
 file(GLOB_RECURSE KRATOS_GEO_MECHANICS_APPLICATION_PYTHON_INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/custom_python/*.cpp)
 
 add_library(KratosGeoMechanicsCore SHARED ${KRATOS_GEO_MECHANICS_APPLICATION_CORE} ${KRATOS_GEO_MECHANICS_APPLICATION_TESTING_SOURCES})
-target_link_libraries(KratosGeoMechanicsCore PUBLIC KratosCore KratosStructuralMechanicsCore ${CMAKE_DL_LIBS})
+target_link_libraries(KratosGeoMechanicsCore PUBLIC KratosCore KratosStructuralMechanicsCore KratosLinearSolversCore ${CMAKE_DL_LIBS})
 set_target_properties(KratosGeoMechanicsCore PROPERTIES COMPILE_DEFINITIONS "GEO_MECHANICS_APPLICATION=EXPORT,API")
 
 

applications/GeoMechanicsApplication/custom_elements/U_Pw_small_strain_element.cpp

@@ -541,7 +541,7 @@ void UPwSmallStrainElement<TDim,TNumNodes>::CalculateOnIntegrationPoints(const V
         //Defining the shape functions, the Jacobian and the shape functions local gradients Containers
         const Matrix& NContainer = rGeom.ShapeFunctionsValues( mThisIntegrationMethod );
 
-        const auto NodalHydraulicHead = GeoElementUtilities::CalculateNodalHydraulicHeadFromWaterPressures<TNumNodes>(rGeom, rProp);
+        const auto NodalHydraulicHead = GeoElementUtilities::CalculateNodalHydraulicHeadFromWaterPressures(rGeom, rProp);
 
         //Loop over integration points
         for ( unsigned int GPoint = 0; GPoint < NumGPoints; ++GPoint ) {

applications/GeoMechanicsApplication/custom_elements/steady_state_Pw_piping_element.cpp

@@ -265,7 +265,7 @@ void SteadyStatePwPipingElement<TDim,TNumNodes>::
 template< >
 double SteadyStatePwPipingElement<2, 4>::CalculateHeadGradient(const PropertiesType& Prop, const GeometryType& Geom, double dx)
 {
-    auto nodalHead = GeoElementUtilities::CalculateNodalHydraulicHeadFromWaterPressures<4>(Geom, Prop);
+    const auto nodalHead = GeoElementUtilities::CalculateNodalHydraulicHeadFromWaterPressures(Geom, Prop);
 	return std::abs((nodalHead[3] + nodalHead[0]) / 2 - (nodalHead[2] + nodalHead[1])/2) / dx;
 }
 template< >

applications/GeoMechanicsApplication/custom_processes/apply_k0_procedure_process.hpp

@@ -54,6 +54,11 @@ class ApplyK0ProcedureProcess : public Process
         KRATOS_CATCH("")
     }
 
+    std::string Info() const override
+    {
+        return "ApplyK0ProcedureProcess";
+    }
+
   private:
       ModelPart& mrModelPart;
 

applications/GeoMechanicsApplication/custom_processes/apply_scalar_constraint_table_process.cpp

@@ -216,4 +216,9 @@ void ApplyScalarConstraintTableProcess::ExecuteInitializeSolutionStep()
     mProcess->ExecuteInitializeSolutionStep();
 }
 
+std::string ApplyScalarConstraintTableProcess::Info() const
+{
+    return "ApplyScalarConstraintTableProcess";
+}
+
 }

applications/GeoMechanicsApplication/custom_processes/apply_scalar_constraint_table_process.h

@@ -39,6 +39,8 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) ApplyScalarConstraintTableProcess :
     void ExecuteInitialize() override;
     void ExecuteInitializeSolutionStep() override;
 
+    std::string Info() const override;
+
 private:
     void MakeInternalProcess(const Parameters& rProcessSettings);
     void MakeProcessForFluidPressureType(const Parameters&        rProcessSettings,

applications/GeoMechanicsApplication/custom_processes/apply_vector_constraint_table_process.cpp

@@ -110,4 +110,9 @@ void ApplyVectorConstraintTableProcess::ExecuteInitializeSolutionStep()
     }
 }
 
+std::string ApplyVectorConstraintTableProcess::Info() const
+{
+    return "ApplyVectorConstraintTableProcess";
+}
+
 }

applications/GeoMechanicsApplication/custom_processes/apply_vector_constraint_table_process.h

@@ -39,6 +39,8 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) ApplyVectorConstraintTableProcess :
     void ExecuteInitialize() override;
     void ExecuteInitializeSolutionStep() override;
 
+    std::string Info() const override;
+
 private:
     static std::vector<Parameters> CreateParametersForActiveComponents(const Parameters& rSettings);
     static std::vector<char> ActiveComponents(const Parameters& rSettings);

applications/GeoMechanicsApplication/custom_strategies/schemes/backward_euler_quasistatic_U_Pw_scheme.hpp

@@ -69,6 +69,11 @@ class BackwardEulerQuasistaticUPwScheme : public NewmarkQuasistaticUPwScheme<TSp
 
         KRATOS_CATCH( "" )
     }
+
+    std::string Info() const override
+    {
+        return "BackwardEulerQuasistaticUPwScheme";
+    }
 }; // Class BackwardEulerQuasistaticUPwScheme
 
 }

applications/GeoMechanicsApplication/custom_utilities/element_utilities.hpp

@@ -668,13 +668,13 @@ typedef std::size_t IndexType;
 
     //----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-    template< unsigned int TNumNodes >
-    static array_1d<double, TNumNodes> CalculateNodalHydraulicHeadFromWaterPressures(const GeometryType& rGeom, const Properties& rProp)
+    static Vector CalculateNodalHydraulicHeadFromWaterPressures(const GeometryType& rGeom, const Properties& rProp)
     {
         const auto NumericalLimit = std::numeric_limits<double>::epsilon();
     	//Defining necessary variables
-        array_1d<double, TNumNodes> nodal_hydraulic_heads;
-        for (unsigned int node = 0; node < TNumNodes; ++node) {
+
+        Vector nodal_hydraulic_heads(rGeom.PointsNumber());
+        for (unsigned int node = 0; node < rGeom.PointsNumber(); ++node) {
             array_1d<double, 3> node_volume_acceleration;
             noalias(node_volume_acceleration) = rGeom[node].FastGetSolutionStepValue(VOLUME_ACCELERATION, 0);
             const double g = norm_2(node_volume_acceleration);

applications/GeoMechanicsApplication/custom_utilities/solving_strategy_factory.hpp

@@ -36,21 +36,31 @@ class SolvingStrategyFactory
         KRATOS_ERROR_IF_NOT(rSolverSettings.Has(strategy_type))
         << "The parameter strategy_type is undefined, aborting.";
 
+        const auto echo_level = rSolverSettings["echo_level"].GetInt();
+
         auto solver = LinearSolverFactory<TSparseSpace, TDenseSpace>().Create(rSolverSettings["linear_solver_settings"]);
+        KRATOS_ERROR_IF_NOT(solver) << "Failed to create a linear solver" << std::endl;
+
         auto scheme = SchemeFactory<TSparseSpace, TDenseSpace>::Create(rSolverSettings);
+        KRATOS_ERROR_IF_NOT(scheme) << "Failed to create a scheme" << std::endl;
+
         auto builder_and_solver = BuilderAndSolverFactory<TSparseSpace, TDenseSpace, TLinearSolver>::Create(rSolverSettings, solver);
+        KRATOS_ERROR_IF_NOT(builder_and_solver) << "Failed to create a builder-and-solver" << std::endl;
+        builder_and_solver->SetEchoLevel(echo_level);
+
         auto criteria = ConvergenceCriteriaFactory<TSparseSpace, TDenseSpace>::Create(rSolverSettings);
+        KRATOS_ERROR_IF_NOT(criteria) << "Failed to create convergence criteria" << std::endl;
+        criteria->SetEchoLevel(echo_level);
 
-        if (rSolverSettings[strategy_type].GetString() ==
-            GeoMechanicsNewtonRaphsonStrategy<TSparseSpace, TDenseSpace, TLinearSolver>::Name())
+        if (rSolverSettings[strategy_type].GetString() == "newton_raphson")
         {
             const auto max_iterations = rSolverSettings["max_iterations"].GetInt();
             const auto calculate_reactions = rSolverSettings["calculate_reactions"].GetBool();
             const auto reform_dof_set_at_each_step = rSolverSettings["reform_dofs_at_each_step"].GetBool();
             const auto move_mesh_flag = rSolverSettings["move_mesh_flag"].GetBool();
 
             auto strategy_parameters = ExtractStrategyParameters(rSolverSettings);
-            return std::make_unique<GeoMechanicsNewtonRaphsonStrategy<TSparseSpace,
+            auto result = std::make_unique<GeoMechanicsNewtonRaphsonStrategy<TSparseSpace,
                     TDenseSpace,
                     TLinearSolver>>(rModelPart,
                     scheme,
@@ -62,6 +72,8 @@ class SolvingStrategyFactory
                     calculate_reactions,
                     reform_dof_set_at_each_step,
                     move_mesh_flag);
+            result->SetEchoLevel(echo_level);
+            return result;
         }
 
         return nullptr;

applications/GeoMechanicsApplication/custom_workflows/custom_workflow_factory.cpp

@@ -24,7 +24,9 @@ namespace Kratos
 
 KratosGeoSettlement* CustomWorkflowFactory::CreateKratosGeoSettlement()
 {
-    return new KratosGeoSettlement{std::make_unique<FileInputUtility>(), std::make_unique<JsonProcessInfoParser>(), {}};
+    return new KratosGeoSettlement{std::make_unique<FileInputUtility>(),
+                                   std::make_unique<JsonProcessInfoParser>(),
+                                   std::make_unique<TimeLoopExecutor>()};
 }
 
 }