Added water boundary for multiline or interpolation

requirements.txt

@@ -1,2 +1,2 @@
 numpy==1.24.2
-gmsh_utils @ git+https://github.com/StemVibrations/gmsh_utils@main
+gmsh_utils @ git+https://github.com/StemVibrations/gmsh_utils@vakantie_branch

requirements_dev.txt

@@ -1,5 +1,5 @@
 numpy==1.24.2
-gmsh_utils @ git+https://github.com/StemVibrations/gmsh_utils@main
+gmsh_utils @ git+https://github.com/StemVibrations/gmsh_utils@vakantie_branch
 pytest==7.2.2
 pytest-cov==4.0.0
 tox==4.4.11

run_stem/demo_create_gmsh_mesh.py

@@ -24,7 +24,6 @@
 mesh_output_dir = "./"
 
 
-
 gmsh_io = GmshIO()
 
 gmsh_io.generate_gmsh_mesh(input_points, extrusion_length, element_size, dims, name_label, mesh_name, mesh_output_dir,

setup.cfg

@@ -17,7 +17,7 @@ packages =
 include_package_data = True
 install_requires =
     numpy>=1.24
-    gmsh_utils @ git+https://github.com/StemVibrations/gmsh_utils@main
+    gmsh_utils @ git+https://github.com/StemVibrations/gmsh_utils@vakantie_branch
 python_requires = >=3.8
 
 [options.extras_require]

stem/IO/kratos_additional_processes_io.py

@@ -42,11 +42,12 @@ def __create_excavation_dict(
             "python_module": "apply_excavation_process",
             "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
             "process_name":  "ApplyExcavationProcess",
-            "Parameters": parameters.__dict__,
+            "Parameters": {},
         }
 
         boundary_dict["Parameters"]["model_part_name"] = f"{self.domain}.{part_name}"
         boundary_dict["Parameters"]["variable_name"] = "EXCAVATION"
+        boundary_dict["Parameters"]["deactivate_soil_part"] = parameters.deactivate_body_model_part
 
         return boundary_dict
 

stem/IO/kratos_output_io.py

@@ -208,6 +208,7 @@ def __create_json_output_dict(
                 "gauss_points_output_variables": [
                     op.name for op in output_parameters.gauss_point_results
                 ],
+                "time_frequency": output_parameters.time_frequency,
             },
         }
         return output_dict

stem/IO/kratos_water_boundaries_io.py

@@ -0,0 +1,171 @@
+from typing import Dict, Any
+
+from stem.water_boundaries import WaterBoundary, PhreaticMultiLineBoundary, InterpolateLineBoundary, \
+    WaterBoundaryParameters, PhreaticLine
+
+
+class KratosWaterBoundariesIO:
+    """
+    Class to create the water boundary process dictionary for the ProjectParameters.json file in Kratos
+
+
+    """
+
+    def __init__(self, domain: str):
+        """
+        Constructor of KratosWaterBoundariesIO class
+
+        Args:
+            domain: Name of the Kratos domain
+
+
+        """
+        self.domain = domain
+
+    def __create_phreatic_line_dict(self, name: str, type: str, water_boundary: PhreaticLine) -> Dict[str, Any]:
+        """
+        Creates a dictionary containing the phreatic line parameters
+
+
+        Args:
+            - name: Name of the boundary
+            - type:  Type of the boundary
+            - water_boundary: Phreatic line boundary object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the phreatic line parameters
+
+        """
+        boundary_dict_phreatic_line: Dict[str, Any] = {
+            "python_module": "apply_scalar_constraint_table_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name": "ApplyScalarConstraintTableProcess",
+            "Parameters": {
+                "model_part_name": f"{self.domain}.{name}",
+                "variable_name": "WATER_PRESSURE",
+                "is_fixed": water_boundary.is_fixed,
+                "table": [0, 0],
+                "fluid_pressure_type": type,
+                "gravity_direction": water_boundary.gravity_direction,
+                "out_of_plane_direction": water_boundary.out_of_plane_direction,
+                "specific_weight": water_boundary.specific_weight,
+                "first_reference_coordinate": water_boundary.first_reference_coordinate,
+                "second_reference_coordinate": water_boundary.second_reference_coordinate,
+                "value": water_boundary.value,
+            }
+        }
+        return boundary_dict_phreatic_line
+
+    def __create_phreatic_multi_line_dict(self, name: str, type: str, water_boundary: PhreaticMultiLineBoundary) -> \
+    Dict[str, Any]:
+        """
+        Creates a dictionary containing the phreatic multi line parameters
+
+        Args:
+            - name: Name of the boundary
+            - type:  Type of the boundary
+            - water_boundary: Multi line phreatic line boundary object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the phreatic line parameters
+
+        """
+        parameters: Dict[str, Any] = {
+            "model_part_name": f"{self.domain}.{name}",
+            "variable_name": "WATER_PRESSURE",
+            "table": [0, 0, 0],
+            "value": water_boundary.water_pressure,
+            "is_fixed": water_boundary.is_fixed,
+            "gravity_direction": water_boundary.gravity_direction,
+            "out_of_plane_direction": water_boundary.out_of_plane_direction,
+            "fluid_pressure_type": type,
+            "specific_weight": water_boundary.specific_weight,
+            "x_coordinates": water_boundary.x_coordinates,
+            "y_coordinates": water_boundary.y_coordinates,
+            "z_coordinates": water_boundary.z_coordinates,
+        }
+        boundary_dict_multi_line: Dict[str, Any] = {
+            "python_module": "apply_scalar_constraint_table_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name": "ApplyScalarConstraintTableProcess",
+            "Parameters": parameters,
+        }
+        return boundary_dict_multi_line
+
+    def __create_interpolation_line_dict(self, name: str, type: str, water_boundary: InterpolateLineBoundary) -> Dict[
+        str, Any]:
+        """
+        Creates a dictionary containing the interpolation line parameters
+
+        Args:
+            - name: Name of the boundary
+            - type: Type of the boundary
+            - water_boundary: Interpolation line boundary object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the phreatic line parameters
+
+        """
+
+        boundary_dict_interpolate: Dict[str, Any] = {
+            "python_module": "apply_scalar_constraint_table_process",
+            "kratos_module": "KratosMultiphysics.GeoMechanicsApplication",
+            "process_name": "ApplyScalarConstraintTableProcess",
+            "Parameters": {
+                "model_part_name": f"{self.domain}.{name}",
+                "variable_name": "WATER_PRESSURE",
+                "is_fixed": water_boundary.is_fixed,
+                "table": 0,
+                "fluid_pressure_type": type,
+                "gravity_direction": water_boundary.gravity_direction,
+                "out_of_plane_direction": water_boundary.out_of_plane_direction,
+            }
+        }
+        return boundary_dict_interpolate
+
+    def __create_water_boundary_dict(self, name: str, type: str, water_boundary: WaterBoundaryParameters) -> Dict[
+        str, Any]:
+        """
+        Creates a dictionary containing the water boundary parameters
+
+        Args:
+            - name: name of the water boundary
+            - type: type of the water boundary
+            - water_boundary: water boundary object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the water boundary parameters
+
+        """
+        if isinstance(water_boundary, PhreaticMultiLineBoundary):
+            temp_phreatic_multi_line: PhreaticMultiLineBoundary = water_boundary
+            boundary_dict_multi_line: Dict[str, Any] = self.__create_phreatic_multi_line_dict(name, type,
+                                                                                              temp_phreatic_multi_line)
+            return boundary_dict_multi_line
+        elif isinstance(water_boundary, InterpolateLineBoundary):
+            temp_interpolate_line: InterpolateLineBoundary = water_boundary
+            boundary_dict_interpolate_line: Dict[str, Any] = self.__create_interpolation_line_dict(name, type,
+                                                                                                   temp_interpolate_line)
+            return boundary_dict_interpolate_line
+        elif isinstance(water_boundary, PhreaticLine):
+            temp_phreatic_line: PhreaticLine = water_boundary
+            boundary_dict_phreatic_line: Dict[str, Any] = self.__create_phreatic_line_dict(name, type,
+                                                                                           temp_phreatic_line)
+            return boundary_dict_phreatic_line
+        else:
+            raise NotImplementedError("This type of boundary is not implemented")
+
+    def create_water_boundary_dict(self, water_boundary: WaterBoundary) -> Dict[str, Any]:
+        """
+        Creates a dictionary containing the water boundary parameters
+
+        Args:
+            - water_boundary: water boundary object
+
+        Returns:
+            - Dict[str, Any]: dictionary containing the water boundary parameters
+
+        """
+        return self.__create_water_boundary_dict(water_boundary.name,
+                                                 water_boundary.water_boundary.type,
+                                                 water_boundary.water_boundary)

stem/additional_processes.py

@@ -20,7 +20,7 @@ class Excavation(AdditionalProcessesParametersABC):
         - :class:`AdditionalProcessesParametersABC`
 
     Attributes:
-        - deactivate_soil_part (bool): Deactivate or not the body model part
+        - deactivate_body_model_part (bool): Deactivate or not the body model part
     """
 
-    deactivate_soil_part: bool
+    deactivate_body_model_part: bool