KratosDamApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/DamApplication/__init__.py

@@ -0,0 +1,10 @@
+
+# Application dependent names and paths
+from KratosMultiphysics import _ImportApplication
+import KratosMultiphysics.StructuralMechanicsApplication
+import KratosMultiphysics.PoromechanicsApplication
+from KratosDamApplication import *
+application = KratosDamApplication()
+application_name = "KratosDamApplication"
+
+_ImportApplication(application,application_name)

KratosMultiphysics/DamApplication/apply_constraint_vector_dam_table_process.py

@@ -0,0 +1,62 @@
+import KratosMultiphysics
+import KratosMultiphysics.DamApplication as KratosDam
+from KratosMultiphysics.assign_scalar_variable_process import AssignScalarVariableProcess
+
+def Factory(settings, Model):
+    if not isinstance(settings, KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyConstraintVectorDamTableProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+
+class ApplyConstraintVectorDamTableProcess(KratosMultiphysics.Process):
+    def __init__(self, Model, settings ):
+        KratosMultiphysics.Process.__init__(self)
+
+        model_part = Model[settings["model_part_name"].GetString()]
+        variable_name = settings["variable_name"].GetString()
+
+        self.components_process_list = []
+
+        x_params = KratosMultiphysics.Parameters("{}")
+        x_params.AddValue("model_part_name",settings["model_part_name"])
+        x_params.AddValue("constrained",settings["constrained"][0])
+        x_params.AddValue("value",settings["value"][0])
+        x_params.AddEmptyValue("variable_name").SetString(variable_name+"_X")
+        if settings["Value_Table"][0].GetInt() == 0:
+            self.components_process_list.append(AssignScalarVariableProcess(Model, x_params))
+        else:
+            x_params.AddValue("table",settings["Value_Table"][0])
+            self.components_process_list.append(KratosDam.ApplyComponentTableProcessDam(model_part, x_params))
+
+        y_params = KratosMultiphysics.Parameters("{}")
+        y_params.AddValue("model_part_name",settings["model_part_name"])
+        y_params.AddValue("constrained",settings["constrained"][1])
+        y_params.AddValue("value",settings["value"][1])
+        y_params.AddEmptyValue("variable_name").SetString(variable_name+"_Y")
+        if settings["Value_Table"][1].GetInt() == 0:
+            self.components_process_list.append(AssignScalarVariableProcess(Model, y_params))
+        else:
+            y_params.AddValue("table",settings["Value_Table"][1])
+            self.components_process_list.append(KratosDam.ApplyComponentTableProcessDam(model_part, y_params))
+
+        z_params = KratosMultiphysics.Parameters("{}")
+        z_params.AddValue("model_part_name",settings["model_part_name"])
+        z_params.AddValue("constrained",settings["constrained"][2])
+        z_params.AddValue("value",settings["value"][2])
+        z_params.AddEmptyValue("variable_name").SetString(variable_name+"_Z")
+        if settings["Value_Table"][2].GetInt() == 0:
+            self.components_process_list.append(AssignScalarVariableProcess(Model, z_params))
+        else:
+            z_params.AddValue("table",settings["Value_Table"][2])
+            self.components_process_list.append(KratosDam.ApplyComponentTableProcessDam(model_part, z_params))
+
+    def ExecuteBeforeSolutionLoop(self):
+
+        for component in self.components_process_list:
+            component.ExecuteBeforeSolutionLoop()
+
+    def ExecuteInitializeSolutionStep(self):
+
+        for component in self.components_process_list:
+            component.ExecuteInitializeSolutionStep()

KratosMultiphysics/DamApplication/apply_load_vector_dam_process.py

@@ -0,0 +1,76 @@
+import KratosMultiphysics
+from KratosMultiphysics.assign_scalar_variable_process import (
+    AssignScalarVariableProcess,
+)
+
+
+def Factory(settings, Model):
+    if not isinstance(settings, KratosMultiphysics.Parameters):
+        raise Exception(
+            "expected input shall be a Parameters object, encapsulating a json string"
+        )
+    return ApplyLoadVectorDamProcess(Model, settings["Parameters"])
+
+
+## All the processes python should be derived from "Process"
+
+
+class ApplyLoadVectorDamProcess(KratosMultiphysics.Process):
+    def __init__(self, Model, settings):
+        KratosMultiphysics.Process.__init__(self)
+
+        variable_name = settings["variable_name"].GetString()
+
+        self.components_process_list = []
+
+        self.factor = settings["modulus"].GetDouble()
+        self.direction = [
+            settings["direction"][0].GetDouble(),
+            settings["direction"][1].GetDouble(),
+            settings["direction"][2].GetDouble(),
+        ]
+        self.value = [
+            self.direction[0] * self.factor,
+            self.direction[1] * self.factor,
+            self.direction[2] * self.factor,
+        ]
+
+        if abs(self.value[0]) > 1.0e-15:
+            x_params = KratosMultiphysics.Parameters("{}")
+            x_params.AddValue("model_part_name", settings["model_part_name"])
+            x_params.AddEmptyValue("constrained").SetBool(False)
+            x_params.AddEmptyValue("value").SetDouble(self.value[0])
+            x_params.AddEmptyValue("variable_name").SetString(variable_name + "_X")
+            self.components_process_list.append(
+                AssignScalarVariableProcess(Model, x_params)
+            )
+
+        if abs(self.value[1]) > 1.0e-15:
+            y_params = KratosMultiphysics.Parameters("{}")
+            y_params.AddValue("model_part_name", settings["model_part_name"])
+            y_params.AddEmptyValue("constrained").SetBool(False)
+            y_params.AddEmptyValue("value").SetDouble(self.value[1])
+            y_params.AddEmptyValue("variable_name").SetString(variable_name + "_Y")
+            self.components_process_list.append(
+                AssignScalarVariableProcess(Model, y_params)
+            )
+
+        if abs(self.value[2]) > 1.0e-15:
+            z_params = KratosMultiphysics.Parameters("{}")
+            z_params.AddValue("model_part_name", settings["model_part_name"])
+            z_params.AddEmptyValue("constrained").SetBool(False)
+            z_params.AddEmptyValue("value").SetDouble(self.value[2])
+            z_params.AddEmptyValue("variable_name").SetString(variable_name + "_Z")
+            self.components_process_list.append(
+                AssignScalarVariableProcess(Model, z_params)
+            )
+
+    def ExecuteBeforeSolutionLoop(self):
+
+        for component in self.components_process_list:
+            component.ExecuteBeforeSolutionLoop()
+
+    def ExecuteInitializeSolutionStep(self):
+
+        for component in self.components_process_list:
+            component.ExecuteInitializeSolutionStep()

KratosMultiphysics/DamApplication/apply_load_vector_dam_table_process.py

@@ -0,0 +1,69 @@
+import KratosMultiphysics
+import KratosMultiphysics.DamApplication as KratosDam
+from KratosMultiphysics.assign_scalar_variable_process import AssignScalarVariableProcess
+
+def Factory(settings, Model):
+    if not isinstance(settings, KratosMultiphysics.Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyLoadVectorDamTableProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+
+class ApplyLoadVectorDamTableProcess(KratosMultiphysics.Process):
+    def __init__(self, Model, settings ):
+        KratosMultiphysics.Process.__init__(self)
+
+        model_part = Model[settings["model_part_name"].GetString()]
+        variable_name = settings["variable_name"].GetString()
+
+        self.components_process_list = []
+
+        self.factor = settings["modulus"].GetDouble()
+        self.direction = [settings["direction"][0].GetDouble(),settings["direction"][1].GetDouble(),settings["direction"][2].GetDouble()]
+        self.value = [self.direction[0]*self.factor, self.direction[1]*self.factor, self.direction[2]*self.factor]
+
+        if abs(self.value[0])>1.0e-15:
+            x_params = KratosMultiphysics.Parameters("{}")
+            x_params.AddValue("model_part_name",settings["model_part_name"])
+            x_params.AddEmptyValue("constrained").SetBool(False)
+            x_params.AddEmptyValue("value").SetDouble(self.value[0])
+            x_params.AddEmptyValue("variable_name").SetString(variable_name+"_X")
+            if settings["table"].GetInt() == 0:
+                self.components_process_list.append(AssignScalarVariableProcess(Model, x_params))
+            else:
+                x_params.AddValue("table", settings["table"])
+                self.components_process_list.append(KratosDam.ApplyComponentTableProcessDam(model_part, x_params))
+
+        if abs(self.value[1])>1.0e-15:
+            y_params = KratosMultiphysics.Parameters("{}")
+            y_params.AddValue("model_part_name",settings["model_part_name"])
+            y_params.AddEmptyValue("constrained").SetBool(False)
+            y_params.AddEmptyValue("value").SetDouble(self.value[1])
+            y_params.AddEmptyValue("variable_name").SetString(variable_name+"_Y")
+            if settings["table"].GetInt() == 0:
+                self.components_process_list.append(AssignScalarVariableProcess(Model, y_params))
+            else:
+                y_params.AddValue("table",settings["table"])
+                self.components_process_list.append(KratosDam.ApplyComponentTableProcessDam(model_part, y_params))
+
+        if abs(self.value[2])>1.0e-15:
+            z_params = KratosMultiphysics.Parameters("{}")
+            z_params.AddValue("model_part_name",settings["model_part_name"])
+            z_params.AddEmptyValue("constrained").SetBool(False)
+            z_params.AddEmptyValue("value").SetDouble(self.value[2])
+            z_params.AddEmptyValue("variable_name").SetString(variable_name+"_Z")
+            if settings["table"].GetInt() == 0:
+                self.components_process_list.append(AssignScalarVariableProcess(Model, z_params))
+            else:
+                z_params.AddValue("table",settings["table"])
+                self.components_process_list.append(KratosDam.ApplyComponentTableProcessDam(model_part, z_params))
+
+    def ExecuteBeforeSolutionLoop(self):
+
+        for component in self.components_process_list:
+            component.ExecuteBeforeSolutionLoop()
+
+    def ExecuteInitializeSolutionStep(self):
+
+        for component in self.components_process_list:
+            component.ExecuteInitializeSolutionStep()

KratosMultiphysics/DamApplication/check_and_prepare_model_process_dam_mechanical.py

@@ -0,0 +1,83 @@
+import KratosMultiphysics
+
+def Factory(settings, Model):
+    if not isinstance(settings, Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return CheckAndPrepareModelProcessDamMechanical(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+class CheckAndPrepareModelProcessDamMechanical(KratosMultiphysics.Process):
+    """Prepare the computing model part.
+
+    The computing model part is created if it does not exist. Nodes and elements
+    from the domain sub model parts are added to the computing model part.
+    Conditions are added from the processes sub model parts.
+    """
+    def __init__(self, main_model_part, Parameters ):
+        KratosMultiphysics.Process.__init__(self)
+        self.main_model_part = main_model_part
+
+        self.mechanical_model_part_name  = Parameters["mechanical_model_part_name"].GetString()
+        self.mechanical_domain_sub_model_part_list = Parameters["mechanical_domain_sub_model_part_list"]
+        self.mechanical_loads_sub_model_part_list = Parameters["mechanical_loads_sub_model_part_list"]
+        self.body_domain_sub_model_part_list = Parameters["body_domain_sub_model_part_list"]
+        self.body_domain_sub_sub_model_part_list = Parameters["body_domain_sub_sub_model_part_list"]
+        self.loads_sub_model_part_list = Parameters["loads_sub_model_part_list"]
+        self.loads_sub_sub_model_part_list = Parameters["loads_sub_sub_model_part_list"]
+
+    def Execute(self):
+        # Construct the computing model part: a model part which contains the mesh to compute
+        self.main_model_part.CreateSubModelPart(self.mechanical_model_part_name)
+        mechanical_model_part = self.main_model_part.GetSubModelPart(self.mechanical_model_part_name)
+        mechanical_model_part.ProcessInfo = self.main_model_part.ProcessInfo
+        mechanical_model_part.Properties = self.main_model_part.Properties
+        mechanical_model_part.Set(KratosMultiphysics.ACTIVE)
+
+        domain_parts = []
+        for i in range(self.mechanical_domain_sub_model_part_list.size()):
+            domain_parts.append(self.main_model_part.GetSubModelPart(self.mechanical_domain_sub_model_part_list[i].GetString()))
+        # Adding Nodes to Computing Model Part
+        list_of_ids = set()
+        for part in domain_parts:
+            for node in part.Nodes:
+                list_of_ids.add(node.Id)
+        mechanical_model_part.AddNodes(list(list_of_ids))
+        # Adding Elements to Computing Model Part
+        list_of_ids = set()
+        for part in domain_parts:
+            for elem in part.Elements:
+                list_of_ids.add(elem.Id)
+        mechanical_model_part.AddElements(list(list_of_ids))
+        # Adding Conditions to Computing Model Part
+        domain_conditions = []
+        for i in range(self.mechanical_loads_sub_model_part_list.size()):
+            domain_conditions.append(self.main_model_part.GetSubModelPart(self.mechanical_loads_sub_model_part_list[i].GetString()))
+        list_of_ids = set()
+        for part in domain_conditions:
+            for cond in part.Conditions:
+                list_of_ids.add(cond.Id)
+        mechanical_model_part.AddConditions(list(list_of_ids))
+
+        # Adding Computing Sub Sub Model Parts
+        # Body - Joints
+        for i in range(self.body_domain_sub_model_part_list.size()):
+            body_sub_model_part = self.main_model_part.GetSubModelPart(self.body_domain_sub_model_part_list[i].GetString())
+            mechanical_model_part.CreateSubModelPart(self.body_domain_sub_sub_model_part_list[i].GetString())
+            body_sub_sub_model_part = mechanical_model_part.GetSubModelPart(self.body_domain_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in body_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            body_sub_sub_model_part.AddNodes(list(list_of_ids))
+            list_of_ids = set()
+            for elem in body_sub_model_part.Elements:
+                list_of_ids.add(elem.Id)
+            body_sub_sub_model_part.AddElements(list(list_of_ids))
+        # Arc-Length
+        for i in range(self.loads_sub_model_part_list.size()):
+            load_sub_model_part = self.main_model_part.GetSubModelPart(self.loads_sub_model_part_list[i].GetString())
+            mechanical_model_part.CreateSubModelPart(self.loads_sub_sub_model_part_list[i].GetString())
+            load_sub_sub_model_part = mechanical_model_part.GetSubModelPart(self.loads_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in load_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            load_sub_sub_model_part.AddNodes(list(list_of_ids))

KratosMultiphysics/DamApplication/check_and_prepare_model_process_dam_thermal.py

@@ -0,0 +1,155 @@
+import KratosMultiphysics
+
+def Factory(settings, Model):
+    if not isinstance(settings, Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return CheckAndPrepareModelProcessDamThermal(Model, settings["Parameters"])
+
+
+## All the processes python should be derived from "Process"
+class CheckAndPrepareModelProcessDamThermal(KratosMultiphysics.Process):
+    """Prepare the computing model part.
+
+    The computing model part is created if it does not exist. Nodes and elements
+    from the domain sub model parts are added to the computing model part.
+    Conditions are added from the processes sub model parts.
+    """
+    def __init__(self, main_model_part, Parameters ):
+        KratosMultiphysics.Process.__init__(self)
+        self.main_model_part = main_model_part
+
+        self.thermal_model_part_name  = Parameters["thermal_model_part_name"].GetString()
+        self.thermal_domain_sub_model_part_list = Parameters["thermal_domain_sub_model_part_list"]
+        self.thermal_loads_sub_model_part_list = Parameters["thermal_loads_sub_model_part_list"]
+        self.thermal_domain_sub_sub_model_part_list = Parameters["thermal_domain_sub_sub_model_part_list"]
+        self.thermal_loads_sub_sub_model_part_list = Parameters["thermal_loads_sub_sub_model_part_list"]
+
+        self.mechanical_model_part_name  = Parameters["mechanical_model_part_name"].GetString()
+        self.mechanical_domain_sub_model_part_list = Parameters["mechanical_domain_sub_model_part_list"]
+        self.mechanical_loads_sub_model_part_list = Parameters["mechanical_loads_sub_model_part_list"]
+        self.body_domain_sub_model_part_list = Parameters["body_domain_sub_model_part_list"]
+        self.body_domain_sub_sub_model_part_list = Parameters["body_domain_sub_sub_model_part_list"]
+        self.loads_sub_model_part_list = Parameters["loads_sub_model_part_list"]
+        self.loads_sub_sub_model_part_list = Parameters["loads_sub_sub_model_part_list"]
+
+    def Execute(self):
+
+        ## Construct the thermal model part:
+        thermal_parts = []
+        for i in range(self.thermal_domain_sub_model_part_list.size()):
+            thermal_parts.append(self.main_model_part.GetSubModelPart(self.thermal_domain_sub_model_part_list[i].GetString()))
+        self.main_model_part.CreateSubModelPart(self.thermal_model_part_name)
+        thermal_model_part = self.main_model_part.GetSubModelPart(self.thermal_model_part_name)
+        thermal_model_part.ProcessInfo = self.main_model_part.ProcessInfo
+        thermal_model_part.Properties = self.main_model_part.Properties
+        thermal_model_part.Set(KratosMultiphysics.ACTIVE)
+        print("Adding Nodes to Thermal Model Part")
+        list_of_ids = set()
+        for part in thermal_parts:
+            for node in part.Nodes:
+                list_of_ids.add(node.Id)
+        thermal_model_part.AddNodes(list(list_of_ids))
+        print("Adding Elements to Thermal Model Part")
+        list_of_ids = set()
+        for part in thermal_parts:
+            for elem in part.Elements:
+                list_of_ids.add(elem.Id)
+        thermal_model_part.AddElements(list(list_of_ids))
+        # Thermal Conditions
+        print("Adding Thermal Conditions to Thermal Model Part")
+        thermal_conditions = []
+        for i in range(self.thermal_loads_sub_model_part_list.size()):
+            thermal_conditions.append(self.main_model_part.GetSubModelPart(self.thermal_loads_sub_model_part_list[i].GetString()))
+        list_of_ids = set()
+        for part in thermal_conditions:
+            for cond in part.Conditions:
+                list_of_ids.add(cond.Id)
+        thermal_model_part.AddConditions(list(list_of_ids))
+        # Sub sub model parts
+        # Construction process
+        print("Adding Thermal Sub Sub Model Parts")
+        for i in range(self.thermal_domain_sub_model_part_list.size()):
+            thermal_sub_model_part = self.main_model_part.GetSubModelPart(self.thermal_domain_sub_model_part_list[i].GetString())
+            thermal_model_part.CreateSubModelPart(self.thermal_domain_sub_sub_model_part_list[i].GetString())
+            thermal_sub_sub_model_part = thermal_model_part.GetSubModelPart(self.thermal_domain_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for elem in thermal_sub_model_part.Elements:
+                list_of_ids.add(elem.Id)
+            thermal_sub_sub_model_part.AddElements(list(list_of_ids))
+            list_of_ids = set()
+            for node in thermal_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            thermal_sub_sub_model_part.AddNodes(list(list_of_ids))
+        for i in range(self.thermal_loads_sub_model_part_list.size()):
+            thermal_load_sub_model_part = self.main_model_part.GetSubModelPart(self.thermal_loads_sub_model_part_list[i].GetString())
+            thermal_model_part.CreateSubModelPart(self.thermal_loads_sub_sub_model_part_list[i].GetString())
+            thermal_load_sub_sub_model_part = thermal_model_part.GetSubModelPart(self.thermal_loads_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in thermal_load_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            thermal_load_sub_sub_model_part.AddNodes(list(list_of_ids))
+            list_of_ids = set()
+            for cond in thermal_load_sub_model_part.Conditions:
+                list_of_ids.add(cond.Id)
+            thermal_load_sub_sub_model_part.AddConditions(list(list_of_ids))
+        print(thermal_model_part)
+
+        ## Construct the mechanical model part:
+        mechanical_parts = []
+        for i in range(self.mechanical_domain_sub_model_part_list.size()):
+            mechanical_parts.append(self.main_model_part.GetSubModelPart(self.mechanical_domain_sub_model_part_list[i].GetString()))
+        self.main_model_part.CreateSubModelPart(self.mechanical_model_part_name)
+        mechanical_model_part = self.main_model_part.GetSubModelPart(self.mechanical_model_part_name)
+        mechanical_model_part.ProcessInfo = self.main_model_part.ProcessInfo
+        mechanical_model_part.Properties = self.main_model_part.Properties
+        mechanical_model_part.Set(KratosMultiphysics.ACTIVE)
+        print("Adding Nodes to Mechanical Model Part")
+        list_of_ids = set()
+        for part in mechanical_parts:
+            for node in part.Nodes:
+                list_of_ids.add(node.Id)
+        mechanical_model_part.AddNodes(list(list_of_ids))
+        print("Adding Elements to Mechanical Model Part")
+        list_of_ids = set()
+        for part in mechanical_parts:
+            for elem in part.Elements:
+                list_of_ids.add(elem.Id)
+        mechanical_model_part.AddElements(list(list_of_ids))
+        # Mechanical Conditions
+        print("Adding Conditions to Mechanical Model Part")
+        mechanical_conditions = []
+        for i in range(self.mechanical_loads_sub_model_part_list.size()):
+            mechanical_conditions.append(self.main_model_part.GetSubModelPart(self.mechanical_loads_sub_model_part_list[i].GetString()))
+        list_of_ids = set()
+        for part in mechanical_conditions:
+            for cond in part.Conditions:
+                list_of_ids.add(cond.Id)
+        mechanical_model_part.AddConditions(list(list_of_ids))
+        print("Adding Mechanical Sub Sub Model Parts")
+        # Sub sub model parts
+        # Body - Joints
+        for i in range(self.body_domain_sub_model_part_list.size()):
+            body_sub_model_part = self.main_model_part.GetSubModelPart(self.body_domain_sub_model_part_list[i].GetString())
+            mechanical_model_part.CreateSubModelPart(self.body_domain_sub_sub_model_part_list[i].GetString())
+            body_sub_sub_model_part = mechanical_model_part.GetSubModelPart(self.body_domain_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in body_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            body_sub_sub_model_part.AddNodes(list(list_of_ids))
+            list_of_ids = set()
+            for elem in body_sub_model_part.Elements:
+                list_of_ids.add(elem.Id)
+            body_sub_sub_model_part.AddElements(list(list_of_ids))
+        # Arc-length
+        for i in range(self.loads_sub_model_part_list.size()):
+            load_sub_model_part = self.main_model_part.GetSubModelPart(self.loads_sub_model_part_list[i].GetString())
+            mechanical_model_part.CreateSubModelPart(self.loads_sub_sub_model_part_list[i].GetString())
+            load_sub_sub_model_part = mechanical_model_part.GetSubModelPart(self.loads_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in load_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            load_sub_sub_model_part.AddNodes(list(list_of_ids))
+            for cond in load_sub_model_part.Conditions:
+                list_of_ids.add(cond.Id)
+            load_sub_sub_model_part.AddConditions(list(list_of_ids))
+        print(mechanical_model_part)

KratosMultiphysics/DamApplication/check_and_prepare_selfweight_model_process_dam.py

@@ -0,0 +1,85 @@
+import KratosMultiphysics
+
+def Factory(settings, Model):
+    if not isinstance(settings, Parameters):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return CheckAndPrepareSelfweightModelProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+class CheckAndPrepareSelfweightModelProcess(KratosMultiphysics.Process):
+    """Prepare the computing model part.
+
+    The computing model part is created if it does not exist. Nodes and elements
+    from the domain sub model parts are added to the computing model part.
+    Conditions are added from the processes sub model parts.
+    """
+    def __init__(self, main_model_part, Parameters ):
+        KratosMultiphysics.Process.__init__(self)
+        self.main_model_part = main_model_part
+
+        self.mechanical_model_part_name  = Parameters["mechanical_model_part_name"].GetString()
+        self.mechanical_domain_sub_model_part_list = Parameters["mechanical_domain_sub_model_part_list"]
+        self.mechanical_loads_sub_model_part_list = Parameters["mechanical_loads_sub_model_part_list"]
+        self.body_domain_sub_model_part_list = Parameters["body_domain_sub_model_part_list"]
+        self.body_domain_sub_sub_model_part_list = Parameters["body_domain_sub_sub_model_part_list"]
+        self.loads_sub_model_part_list = Parameters["loads_sub_model_part_list"]
+        self.loads_sub_sub_model_part_list = Parameters["loads_sub_sub_model_part_list"]
+
+    def Execute(self):
+
+        ## Construct the mechanical model part:
+        mechanical_parts = []
+        for i in range(self.mechanical_domain_sub_model_part_list.size()):
+            mechanical_parts.append(self.main_model_part.GetSubModelPart(self.mechanical_domain_sub_model_part_list[i].GetString()))
+        self.main_model_part.CreateSubModelPart(self.mechanical_model_part_name)
+        mechanical_model_part = self.main_model_part.GetSubModelPart(self.mechanical_model_part_name)
+        mechanical_model_part.ProcessInfo = self.main_model_part.ProcessInfo
+        mechanical_model_part.Properties = self.main_model_part.Properties
+        mechanical_model_part.Set(KratosMultiphysics.ACTIVE)
+        print("Adding Nodes to Mechanical Model Part")
+        list_of_ids = set()
+        for part in mechanical_parts:
+            for node in part.Nodes:
+                list_of_ids.add(node.Id)
+        mechanical_model_part.AddNodes(list(list_of_ids))
+        print("Adding Elements to Mechanical Model Part")
+        list_of_ids = set()
+        for part in mechanical_parts:
+            for elem in part.Elements:
+                list_of_ids.add(elem.Id)
+        mechanical_model_part.AddElements(list(list_of_ids))
+        # Mechanical Conditions
+        print("Adding Conditions to Mechanical Model Part")
+        mechanical_conditions = []
+        for i in range(self.mechanical_loads_sub_model_part_list.size()):
+            mechanical_conditions.append(self.main_model_part.GetSubModelPart(self.mechanical_loads_sub_model_part_list[i].GetString()))
+        list_of_ids = set()
+        for part in mechanical_conditions:
+            for cond in part.Conditions:
+                list_of_ids.add(cond.Id)
+        mechanical_model_part.AddConditions(list(list_of_ids))
+        print("Adding Mechanical Sub Sub Model Parts")
+        # Sub sub model parts
+        # Body - Joints
+        for i in range(self.body_domain_sub_model_part_list.size()):
+            body_sub_model_part = self.main_model_part.GetSubModelPart(self.body_domain_sub_model_part_list[i].GetString())
+            mechanical_model_part.CreateSubModelPart(self.body_domain_sub_sub_model_part_list[i].GetString())
+            body_sub_sub_model_part = mechanical_model_part.GetSubModelPart(self.body_domain_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in body_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            body_sub_sub_model_part.AddNodes(list(list_of_ids))
+            list_of_ids = set()
+            for elem in body_sub_model_part.Elements:
+                list_of_ids.add(elem.Id)
+            body_sub_sub_model_part.AddElements(list(list_of_ids))
+        # Arc-length
+        for i in range(self.loads_sub_model_part_list.size()):
+            load_sub_model_part = self.main_model_part.GetSubModelPart(self.loads_sub_model_part_list[i].GetString())
+            mechanical_model_part.CreateSubModelPart(self.loads_sub_sub_model_part_list[i].GetString())
+            load_sub_sub_model_part = mechanical_model_part.GetSubModelPart(self.loads_sub_sub_model_part_list[i].GetString())
+            list_of_ids = set()
+            for node in load_sub_model_part.Nodes:
+                list_of_ids.add(node.Id)
+            load_sub_sub_model_part.AddNodes(list(list_of_ids))
+        print(mechanical_model_part)