[GeoMechanicsApplication] Improve the initialization of the list of sub-modelparts related to processes (#13913)

* added loop over processes in processes section

* added check with processes_sub_model_part_list

* cleaned a bit

* fixed test

* added check for processes

* removed modelpart name

* excluded modelpart name

* added empty parameters

* removed LINE_LOAD in STage 3

* removed debugging statements

* added StringHash to remove a code smell

* introduced collect_ids_from_part

* reduced complexity again

* made a lamda function as a free function

* used std::string_view

* removed const for std::string_view

* passed complete project parameters

* reverted changes, added new processes_sub_model_part_list

* extracted function _AddProcessesSubModelPartList

* removed one-line processes_sub_model_part_list

* removed multi-line problem_domain_sub_model_part_list

* removed processes_sub_model_part_list from unit tests

* used python work flow in C++

* moved AddProcessesSubModelPartList to process_utilities

* used AddProcessesSubModelPartList in python script

* used Kratos style

* used Kratos style 2.0

* added unit tests

* adapted unit test

* changed checking in the test

* removed code smells

* response to the reviews

* removed code smells

* made GenericUtilities::CollectIdsFromEntity

* used static_assert

* response review 2.0

* response to Anne's review

* used iterator for GetIdsFromEntityContents

* removed code smell

Author: markelov208

applications/GeoMechanicsApplication/custom_elements/interface_element.cpp

@@ -17,6 +17,7 @@
 #include "custom_utilities/element_utilities.hpp"
 #include "custom_utilities/equation_of_motion_utilities.h"
 #include "custom_utilities/extrapolation_utilities.h"
+#include "custom_utilities/generic_utilities.h"
 #include "custom_utilities/geometry_utilities.h"
 #include "custom_utilities/math_utilities.h"
 #include "geo_aliases.h"
@@ -194,7 +195,7 @@ void InterfaceElement::Initialize(const ProcessInfo& rCurrentProcessInfo)
         // interface element can at maximum have 2 neighbours
         KRATOS_DEBUG_ERROR_IF(this->GetValue(NEIGHBOUR_ELEMENTS).size() > 2)
             << "Too many neighbour elements for interface element " << this->Id() << std::endl;
-        const auto interface_node_ids = GeometryUtilities::GetNodeIdsFromGeometry(GetGeometry());
+        const auto interface_node_ids = GenericUtilities::GetIdsFromEntityContents(GetGeometry());
         std::vector<std::optional<Vector>> interface_nodal_cauchy_stresses(interface_node_ids.size());
         auto&               r_neighbour_element = this->GetValue(NEIGHBOUR_ELEMENTS).front();
         std::vector<Vector> neighbour_cauchy_stresses;

applications/GeoMechanicsApplication/custom_python/add_custom_utilities_to_python.cpp

@@ -17,6 +17,7 @@
 #include "custom_python/add_custom_utilities_to_python.h"
 
 #include "custom_utilities/node_utilities.h"
+#include "custom_utilities/process_utilities.h"
 #include "custom_workflows/custom_workflow_factory.h"
 #include "custom_workflows/dgeoflow.h"
 #include "custom_workflows/dgeosettlement.h"
@@ -43,6 +44,11 @@ void AddCustomUtilitiesToPython(const pybind11::module& rModule)
     pybind11::class_<KratosExecute::CallBackFunctions>(rModule, "KratosExecuteCallBackFunctions")
         .def(pybind11::init<std::function<void(const char*)>, std::function<void(double)>,
                             std::function<void(const char*)>, std::function<bool()>>());
+
+    pybind11::class_<ProcessUtilities>(rModule, "ProcessUtilities")
+        .def_static("AddProcessesSubModelPartListToSolverSettings",
+                    &ProcessUtilities::AddProcessesSubModelPartListToSolverSettings,
+                    pybind11::arg("project_parameters"), pybind11::arg("solver_settings"));
 }
 
 } // Namespace Kratos::Python.

applications/GeoMechanicsApplication/custom_utilities/extrapolation_utilities.cpp

@@ -13,8 +13,8 @@
 
 #include "custom_utilities/extrapolation_utilities.h"
 
+#include "custom_utilities/generic_utilities.h"
 #include "custom_utilities/linear_nodal_extrapolator.h"
-#include "geometry_utilities.h"
 #include "includes/node.h"
 
 namespace Kratos
@@ -47,7 +47,7 @@ std::vector<std::optional<Vector>> ExtrapolationUtilities::CalculateNodalVectors
     const std::vector<Vector>&      rVectorsAtIntegrationPoints,
     size_t                          ElementId)
 {
-    const auto element_node_ids = GeometryUtilities::GetNodeIdsFromGeometry(rGeometry);
+    const auto element_node_ids = GenericUtilities::GetIdsFromEntityContents(rGeometry);
     const auto extrapolation_matrix = CalculateExtrapolationMatrix(rGeometry, IntegrationMethod, ElementId);
 
     KRATOS_ERROR_IF_NOT(extrapolation_matrix.size2() == rVectorsAtIntegrationPoints.size())

applications/GeoMechanicsApplication/custom_utilities/generic_utilities.h

@@ -8,6 +8,7 @@
 //  License:         geo_mechanics_application/license.txt
 //
 //  Main authors:    Mohamed Nabi
+//                   Gennady Markelov
 //
 
 #pragma once
@@ -48,6 +49,21 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) GenericUtilities
         return result;
     }
 
+    template <class ContainerType, class OutputIt>
+    static void GetIdsFromEntityContents(const ContainerType& rContainer, OutputIt Out)
+    {
+        std::ranges::transform(rContainer, Out, [](const auto& rItem) { return rItem.Id(); });
+    }
+
+    template <class ContainerType>
+    static auto GetIdsFromEntityContents(const ContainerType& rContainer)
+    {
+        std::vector<std::size_t> result;
+        result.reserve(rContainer.size());
+        GetIdsFromEntityContents(rContainer, std::back_inserter(result));
+        return result;
+    }
+
 }; // class GenericUtilities
 
 } // namespace Kratos

applications/GeoMechanicsApplication/custom_utilities/geometry_utilities.cpp

@@ -138,15 +138,6 @@ Matrix GeometryUtilities::Calculate3DRotationMatrixForPlaneGeometry(const Geomet
     return result;
 }
 
-std::vector<std::size_t> GeometryUtilities::GetNodeIdsFromGeometry(const Geometry<Node>& rGeometry)
-{
-    std::vector<std::size_t> result;
-    result.reserve(rGeometry.size());
-    std::ranges::transform(rGeometry, std::back_inserter(result),
-                           [](const auto& rNode) { return rNode.Id(); });
-    return result;
-}
-
 void GeometryUtilities::ReverseNodes(PointerVector<Node>&                  rNodes,
                                      GeometryData::KratosGeometryFamily    GeometryFamily,
                                      GeometryData::KratosGeometryOrderType GeometryOrderType)

applications/GeoMechanicsApplication/custom_utilities/geometry_utilities.h

@@ -28,13 +28,12 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) GeometryUtilities
                                                            const array_1d<double, 3>& rLocalCoordinate);
     static Matrix Calculate3DRotationMatrixForPlaneGeometry(const Geometry<Node>& rGeometry,
                                                             const array_1d<double, 3>& rLocalCoordinate);
-    static std::vector<std::size_t> GetNodeIdsFromGeometry(const Geometry<Node>& rGeometry);
-    static void                     ReverseNodes(PointerVector<Node>&                  rNodes,
-                                                 GeometryData::KratosGeometryFamily    GeometryFamily,
-                                                 GeometryData::KratosGeometryOrderType GeometryOrderType);
-    static void                     ReverseNodes(std::vector<std::size_t>&             rNodeIds,
-                                                 GeometryData::KratosGeometryFamily    GeometryFamily,
-                                                 GeometryData::KratosGeometryOrderType GeometryOrderType);
+    static void   ReverseNodes(PointerVector<Node>&                  rNodes,
+                               GeometryData::KratosGeometryFamily    GeometryFamily,
+                               GeometryData::KratosGeometryOrderType GeometryOrderType);
+    static void   ReverseNodes(std::vector<std::size_t>&             rNodeIds,
+                               GeometryData::KratosGeometryFamily    GeometryFamily,
+                               GeometryData::KratosGeometryOrderType GeometryOrderType);
 };
 
 } // namespace Kratos

applications/GeoMechanicsApplication/custom_utilities/neighbouring_element_finder.cpp

@@ -60,7 +60,7 @@ void NeighbouringElementFinder::AddNeighbouringElementsBasedOnBoundaryGeometry(E
                                                                                const Geometry<Node>& rBoundaryGeometry,
                                                                                bool ReverseSearch)
 {
-    auto element_boundary_node_ids = GeometryUtilities::GetNodeIdsFromGeometry(rBoundaryGeometry);
+    auto element_boundary_node_ids = GenericUtilities::GetIdsFromEntityContents(rBoundaryGeometry);
     if (ReverseSearch) {
         GeometryUtilities::ReverseNodes(element_boundary_node_ids, rBoundaryGeometry.GetGeometryFamily(),
                                         rBoundaryGeometry.GetGeometryOrderType());

applications/GeoMechanicsApplication/custom_utilities/neighbouring_element_finder.hpp

@@ -13,7 +13,7 @@
 #pragma once
 
 #include "boundary_generators.h"
-#include "geometry_utilities.h"
+#include "generic_utilities.h"
 #include "includes/geometrical_object.h"
 #include "includes/key_hash.h"
 #include "includes/kratos_export_api.h"
@@ -88,7 +88,7 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) NeighbouringElementFinder
 
                 for (const auto& r_boundary_geometry : r_boundary_generator(r_entity.GetGeometry())) {
                     mGeometryNodeIdsToEntities.insert(
-                        {GeometryUtilities::GetNodeIdsFromGeometry(r_boundary_geometry), {&r_entity}});
+                        {GenericUtilities::GetIdsFromEntityContents(r_boundary_geometry), {&r_entity}});
                 }
             }
 

applications/GeoMechanicsApplication/custom_utilities/process_utilities.cpp

@@ -16,10 +16,11 @@
 #include "containers/model.h"
 #include "includes/kratos_parameters.h"
 
-namespace Kratos
+namespace
 {
-std::vector<std::reference_wrapper<ModelPart>> ProcessUtilities::GetModelPartsFromSettings(
-    Model& rModel, const Parameters& rProcessSettings, const std::string& rProcessInfo)
+
+std::vector<std::string> GetProcessModelPartNames(const Kratos::Parameters& rProcessSettings,
+                                                  const std::string&        rProcessInfo)
 {
     KRATOS_ERROR_IF_NOT(rProcessSettings.Has("model_part_name") ||
                         rProcessSettings.Has("model_part_name_list"))
@@ -30,9 +31,35 @@ std::vector<std::reference_wrapper<ModelPart>> ProcessUtilities::GetModelPartsFr
         << "The parameters 'model_part_name' and 'model_part_name_list' are mutually exclusive for "
         << rProcessInfo;
 
-    const auto model_part_names = rProcessSettings.Has("model_part_name_list")
-                                      ? rProcessSettings["model_part_name_list"].GetStringArray()
-                                      : std::vector{rProcessSettings["model_part_name"].GetString()};
+    return rProcessSettings.Has("model_part_name_list")
+               ? rProcessSettings["model_part_name_list"].GetStringArray()
+               : std::vector{rProcessSettings["model_part_name"].GetString()};
+}
+
+std::set<std::string, std::less<>> ExtractModelPartNames(const auto&      rProcessList,
+                                                         std::string_view RootName,
+                                                         std::string_view Prefix)
+{
+    std::set<std::string, std::less<>> result;
+    for (const auto& r_process : rProcessList) {
+        if (!r_process.Has("Parameters")) continue;
+        const auto model_part_names = GetProcessModelPartNames(r_process["Parameters"], {});
+        for (auto model_part_name : model_part_names) {
+            if (model_part_name == RootName) continue;
+            if (model_part_name.starts_with(Prefix)) model_part_name.erase(0, Prefix.size());
+            result.insert(model_part_name);
+        }
+    }
+    return result;
+};
+} // namespace
+
+namespace Kratos
+{
+std::vector<std::reference_wrapper<ModelPart>> ProcessUtilities::GetModelPartsFromSettings(
+    Model& rModel, const Parameters& rProcessSettings, const std::string& rProcessInfo)
+{
+    const auto model_part_names = GetProcessModelPartNames(rProcessSettings, rProcessInfo);
     KRATOS_ERROR_IF(model_part_names.empty()) << "The parameters 'model_part_name_list' needs "
                                                  "to contain at least one model part name for "
                                               << rProcessInfo;
@@ -45,4 +72,31 @@ std::vector<std::reference_wrapper<ModelPart>> ProcessUtilities::GetModelPartsFr
     return result;
 }
 
+void ProcessUtilities::AddProcessesSubModelPartListToSolverSettings(const Parameters& rProjectParameters,
+                                                                    Parameters& rSolverSettings)
+{
+    std::set<std::string, std::less<>> domain_condition_names;
+    const auto                         root_name = rSolverSettings["model_part_name"].GetString();
+    const auto                         prefix    = root_name + ".";
+
+    if (rProjectParameters.Has("processes")) {
+        for (const auto& r_process : rProjectParameters["processes"]) {
+            const auto modelpart_names = ExtractModelPartNames(r_process, root_name, prefix);
+            domain_condition_names.insert(modelpart_names.begin(), modelpart_names.end());
+        }
+    }
+    if (rSolverSettings.Has("processes_sub_model_part_list")) {
+        KRATOS_WARNING("ProcessUtilities")
+            << "'processes_sub_model_part_list' is deprecated. This list is built automatically "
+               "from the model parts used in all processes."
+            << std::endl;
+        rSolverSettings.RemoveValue("processes_sub_model_part_list");
+    }
+    rSolverSettings.AddEmptyArray("processes_sub_model_part_list");
+
+    for (const auto& r_name : domain_condition_names) {
+        rSolverSettings["processes_sub_model_part_list"].Append(r_name);
+    }
+}
+
 }; // namespace Kratos

applications/GeoMechanicsApplication/custom_utilities/process_utilities.h

@@ -29,5 +29,8 @@ class KRATOS_API(GEO_MECHANICS_APPLICATION) ProcessUtilities
 public:
     static std::vector<std::reference_wrapper<ModelPart>> GetModelPartsFromSettings(
         Model& rModel, const Parameters& rProcessSettings, const std::string& rProcessInfo);
+
+    static void AddProcessesSubModelPartListToSolverSettings(const Parameters& rProjectParameters,
+                                                             Parameters&       rSolverSettings);
 };
 }; // namespace Kratos