[GeoMechanicsApplication] Add process factory to settlement workflow

applications/GeoMechanicsApplication/custom_utilities/json_process_info_parser.cpp

@@ -0,0 +1,51 @@
+// KRATOS___
+//     //   ) )
+//    //         ___      ___
+//   //  ____  //___) ) //   ) )
+//  //    / / //       //   / /
+// ((____/ / ((____   ((___/ /  MECHANICS
+//
+//  License:         geo_mechanics_application/license.txt
+//
+//  Main authors:    Richard Faasse
+//
+#include "json_process_info_parser.h"
+
+namespace Kratos
+{
+
+std::vector<ProcessParameters> JsonProcessInfoParser::GetProcessList(const Parameters& rProcessParameters)
+{
+    mProcessParameters = rProcessParameters;
+    const std::vector<std::string> process_list_names = {"constraints_process_list",
+                                                         "loads_process_list",
+                                                         "auxiliar_process_list"};
+
+    for (const auto& process_list_name : process_list_names)
+    {
+        JsonProcessInfoParser::AddProcessesForList(process_list_name);
+    }
+
+    return mProcessNames;
+}
+
+void JsonProcessInfoParser::AddProcessesForList(const std::string& rProcessListName) {
+    if (!mProcessParameters.Has(rProcessListName))
+    {
+        return;
+    }
+
+    const auto processes_in_list = mProcessParameters[rProcessListName];
+
+    for (Parameters process : processes_in_list)
+    {
+        const std::string process_name_entry = "process_name";
+        if (process.Has(process_name_entry))
+        {
+            mProcessNames.emplace_back(process["Parameters"], process[process_name_entry].GetString());
+        }
+    }
+}
+
+}
+

applications/GeoMechanicsApplication/custom_utilities/json_process_info_parser.h

@@ -0,0 +1,34 @@
+// KRATOS___
+//     //   ) )
+//    //         ___      ___
+//   //  ____  //___) ) //   ) )
+//  //    / / //       //   / /
+// ((____/ / ((____   ((___/ /  MECHANICS
+//
+//  License:         geo_mechanics_application/license.txt
+//
+//  Main authors:    Richard Faasse
+//
+
+#pragma once
+
+#include "process_info_parser.h"
+#include "process_parameters.h"
+
+#include <vector>
+
+namespace Kratos {
+
+class JsonProcessInfoParser : public ProcessInfoParser
+{
+public:
+    std::vector<ProcessParameters> GetProcessList(const Parameters& rProcessParameters) override;
+
+private:
+    std::vector<ProcessParameters> mProcessNames;
+    Parameters mProcessParameters;
+
+    void AddProcessesForList(const std::string& rProcessListName);
+};
+
+}

applications/GeoMechanicsApplication/custom_utilities/process_info_parser.h

@@ -0,0 +1,27 @@
+// KRATOS___
+//     //   ) )
+//    //         ___      ___
+//   //  ____  //___) ) //   ) )
+//  //    / / //       //   / /
+// ((____/ / ((____   ((___/ /  MECHANICS
+//
+//  License:         geo_mechanics_application/license.txt
+//
+//  Main authors:    Richard Faasse
+//
+
+#pragma once
+
+#include "process_parameters.h"
+
+#include <vector>
+
+namespace Kratos {
+
+class ProcessInfoParser {
+public:
+    virtual ~ProcessInfoParser() = default;
+    virtual std::vector<ProcessParameters> GetProcessList(const Parameters& rProcessParameters) = 0;
+};
+
+} // Kratos

applications/GeoMechanicsApplication/custom_utilities/process_parameters.h

@@ -0,0 +1,37 @@
+// KRATOS___
+//     //   ) )
+//    //         ___      ___
+//   //  ____  //___) ) //   ) )
+//  //    / / //       //   / /
+// ((____/ / ((____   ((___/ /  MECHANICS
+//
+//  License:         geo_mechanics_application/license.txt
+//
+//  Main authors:    Richard Faasse
+//
+#pragma once
+
+#include "includes/kratos_parameters.h"
+
+#include <string>
+
+namespace Kratos
+{
+
+struct ProcessParameters
+{
+    Parameters parameters;
+    std::string name;
+
+    ProcessParameters(const Parameters& rParameters, const std::string& rName) :
+            parameters{rParameters},
+            name{rName}
+    {}
+
+    bool operator==(const ProcessParameters& rhs) const
+    {
+        return name == rhs.name && parameters.WriteJsonString() == rhs.parameters.WriteJsonString();
+    }
+};
+
+}

applications/GeoMechanicsApplication/custom_workflows/custom_workflow_factory.cpp

@@ -12,14 +12,19 @@
 
 #include "custom_workflow_factory.h"
 #include "dgeosettlement.h"
+#include "time_loop_executor.h"
+
 #include "custom_utilities/file_input_utility.h"
+#include "custom_utilities/json_process_info_parser.h"
+
 #include <memory>
 
 namespace Kratos
 {
 
 KratosGeoSettlement* CustomWorkflowFactory::CreateKratosGeoSettlement()
 {
-    return new KratosGeoSettlement{std::make_unique<FileInputUtility>()};
+    return new KratosGeoSettlement{std::make_unique<FileInputUtility>(), std::make_unique<JsonProcessInfoParser>(), {}};
 }
+
 }

applications/GeoMechanicsApplication/custom_workflows/dgeosettlement.cpp

@@ -11,14 +11,28 @@
 //
 #include "dgeosettlement.h"
 #include "input_output/logger.h"
+#include "time_loop_executor.h"
+
 #include "utilities/variable_utils.h"
+
+#include "custom_processes/apply_vector_constraints_table_process.hpp"
+#include "custom_processes/set_parameter_field_process.hpp"
+#include "custom_processes/apply_k0_procedure_process.hpp"
+#include "custom_processes/apply_excavation_process.hpp"
+
 #include "custom_utilities/input_utility.h"
+#include "custom_utilities/process_factory.hpp"
+#include "custom_utilities/process_info_parser.h"
 
 namespace Kratos
 {
 
-KratosGeoSettlement::KratosGeoSettlement(std::unique_ptr<InputUtility> pInputUtility) :
-        mpInputUtility{std::move(pInputUtility)}
+KratosGeoSettlement::KratosGeoSettlement(std::unique_ptr<InputUtility> pInputUtility,
+                                         std::unique_ptr<ProcessInfoParser> pProcessInfoParser,
+                                         std::unique_ptr<TimeLoopExecutor> pTimeLoopExecutor) :
+    mpInputUtility{std::move(pInputUtility)},
+    mpProcessInfoParser{std::move(pProcessInfoParser)},
+    mpTimeLoopExecutor{std::move(pTimeLoopExecutor)}
 {
     KRATOS_INFO("KratosGeoSettlement") << "Setting up Kratos" << std::endl;
     KRATOS_ERROR_IF_NOT(mpInputUtility) << "Invalid Input Utility";
@@ -29,6 +43,38 @@ KratosGeoSettlement::KratosGeoSettlement(std::unique_ptr<InputUtility> pInputUti
         mpGeoApp = Kratos::make_shared<KratosGeoMechanicsApplication>();
         mKernel.ImportApplication(mpGeoApp);
     }
+
+    InitializeProcessFactory();
+}
+
+void KratosGeoSettlement::InitializeProcessFactory() {
+    mProcessFactory->AddCreator("ApplyVectorConstraintsTableProcess",
+                                [this](const Parameters& rParameters)
+                                {
+                                    return std::make_unique<ApplyVectorConstraintsTableProcess>(mModel.GetModelPart(mModelPartName),
+                                                                                                rParameters);
+                                });
+
+    mProcessFactory->AddCreator("SetParameterFieldProcess",
+                                [this](const Parameters& rParameters)
+                                {
+                                    return std::make_unique<SetParameterFieldProcess>(mModel.GetModelPart(mModelPartName),
+                                                                                      rParameters);
+                                });
+
+    mProcessFactory->AddCreator("ApplyExcavationProcess",
+                                [this](const Parameters& rParameters)
+                                {
+                                    return std::make_unique<ApplyExcavationProcess>(mModel.GetModelPart(mModelPartName),
+                                                                                    rParameters);
+                                });
+
+    mProcessFactory->AddCreator("ApplyK0ProcedureProcess",
+                                [this](const Parameters& rParameters)
+                                {
+                                    return std::make_unique<ApplyK0ProcedureProcess>(mModel.GetModelPart(mModelPartName),
+                                                                                     rParameters);
+                                });
 }
 
 int KratosGeoSettlement::RunStage(const std::filesystem::path&            rWorkingDirectory,
@@ -45,6 +91,7 @@ int KratosGeoSettlement::RunStage(const std::filesystem::path&            rWorki
             project_parameters_file_path.generic_string());
     KRATOS_INFO("KratosGeoSettlement") << "Parsed project parameters file " << project_parameters_file_path << std::endl;
 
+    mModelPartName = project_parameters["solver_settings"]["model_part_name"].GetString();
     if (const auto model_part_name = project_parameters["solver_settings"]["model_part_name"].GetString();
         !mModel.HasModelPart(model_part_name)) {
         auto& model_part = AddNewModelPart(model_part_name);
@@ -59,6 +106,22 @@ int KratosGeoSettlement::RunStage(const std::filesystem::path&            rWorki
         KRATOS_INFO("KratosGeoSettlement") << "Read the materials from " << material_file_path << std::endl;
     }
 
+    std::vector<std::reference_wrapper<Process>> process_references;
+    std::vector<std::unique_ptr<Process>> process_unique_ptrs;
+    if (project_parameters.Has("processes"))
+    {
+        const auto processes = mpProcessInfoParser->GetProcessList(project_parameters["processes"]);
+        for (const auto& process : processes)
+        {
+            process_unique_ptrs.emplace_back(std::move(mProcessFactory->Create(process.name, process.parameters)));
+        }
+        for (const auto& process_unique_ptr : process_unique_ptrs)
+        {
+            process_references.emplace_back(*process_unique_ptr);
+        }
+    }
+    mpTimeLoopExecutor->SetProcessReferences(process_references);
+
     return 0;
 }
 

applications/GeoMechanicsApplication/custom_workflows/dgeosettlement.h

@@ -24,12 +24,17 @@
 namespace Kratos
 {
 
+class ProcessFactory;
 class InputUtility;
+class ProcessInfoParser;
+class TimeLoopExecutor;
 
 class KRATOS_API(GEO_MECHANICS_APPLICATION) KratosGeoSettlement
 {
 public:
-    explicit KratosGeoSettlement(std::unique_ptr<InputUtility> pInputUtility);
+    explicit KratosGeoSettlement(std::unique_ptr<InputUtility> pInputUtility,
+                                 std::unique_ptr<ProcessInfoParser> pProcessInfoParser,
+                                 std::unique_ptr<TimeLoopExecutor> pTimeLoopExecutor);
     ~KratosGeoSettlement();
 
     int RunStage(const std::filesystem::path&            rWorkingDirectory,
@@ -45,11 +50,16 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) KratosGeoSettlement
     ModelPart& AddNewModelPart(const std::string& rModelPartName);
     static void AddNodalSolutionStepVariablesTo(ModelPart& rModelPart);
     static void AddDegreesOfFreedomTo(ModelPart& rModelPart);
+    void InitializeProcessFactory();
 
     Kernel mKernel;
     Model mModel;
+    std::string mModelPartName;
     KratosGeoMechanicsApplication::Pointer mpGeoApp;
+    std::unique_ptr<ProcessFactory> mProcessFactory = std::make_unique<ProcessFactory>();
     std::unique_ptr<InputUtility> mpInputUtility;
+    std::unique_ptr<ProcessInfoParser> mpProcessInfoParser;
+    std::unique_ptr<TimeLoopExecutor> mpTimeLoopExecutor;
 };
 
 }

applications/GeoMechanicsApplication/custom_workflows/time_loop_executor.h

@@ -0,0 +1,28 @@
+// KRATOS___
+//     //   ) )
+//    //         ___      ___
+//   //  ____  //___) ) //   ) )
+//  //    / / //       //   / /
+// ((____/ / ((____   ((___/ /  MECHANICS
+//
+//  License:         geo_mechanics_application/license.txt
+//
+//  Main authors:    Richard Faasse
+//
+
+#pragma once
+
+#include <vector>
+
+namespace Kratos
+{
+
+class Process;
+
+class TimeLoopExecutor {
+public :
+    virtual ~TimeLoopExecutor() = default;
+    virtual void SetProcessReferences(const std::vector<std::reference_wrapper<Process>>& rProcessRefs) = 0;
+};
+
+}