KratosMPMApplication 10.4.4__py3-none-any.whl

KratosMultiphysics/MPMApplication/__init__.py

@@ -0,0 +1,6 @@
+from KratosMultiphysics import _ImportApplication
+from KratosMPMApplication import *
+application = KratosMPMApplication()
+application_name = "KratosMPMApplication"
+
+_ImportApplication(application, application_name)

KratosMultiphysics/MPMApplication/apply_mpm_3d_rotating_dirichlet_condition_process.py

@@ -0,0 +1,147 @@
+import KratosMultiphysics
+from KratosMultiphysics.deprecation_management import DeprecationManager
+import KratosMultiphysics.MPMApplication as KratosMPM
+from KratosMultiphysics.MPMApplication.apply_mpm_particle_dirichlet_condition_process import ApplyMPMParticleDirichletConditionProcess
+
+import math
+
+def Factory(settings, Model):
+    if(not isinstance(settings, KratosMultiphysics.Parameters)):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyMPM3DRotatingDirichletConditionProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+class ApplyMPM3DRotatingDirichletConditionProcess(ApplyMPMParticleDirichletConditionProcess):
+    def __init__(self, Model, settings ):
+
+        default_parameters = KratosMultiphysics.Parameters( """
+            {
+                "model_part_name"               : "PLEASE_SPECIFY_MODEL_PART_NAME",
+                "material_points_per_condition" : 0,
+                "imposition_type"               : "penalty",
+                "penalty_coefficient"           : 0,
+                "constrained"                   : "fixed",
+                "option"                        : "",
+                "rotation_center"               : [0.0, 0.0, 0.0],
+                "rotation_velocity"             : [0.0, 0.0, 0.0],
+                "compute_rotation_center"       : false,
+                "rotation_option"               : ""
+            }  """ )
+
+        context_string = type(self).__name__
+        old_name = 'particles_per_condition'
+        new_name = 'material_points_per_condition'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        context_string = type(self).__name__
+        old_name = 'penalty_factor'
+        new_name = 'penalty_coefficient'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        settings.ValidateAndAssignDefaults(default_parameters)
+        self.model = Model
+        self.model_part_name = settings["model_part_name"].GetString()
+
+        # Private process variables
+        self.rotation_center = settings["rotation_center"].GetVector()
+        self.rotation_velocity = settings["rotation_velocity"].GetVector()
+        self.compute_rotation_center = settings["compute_rotation_center"].GetBool()
+        self.rotation_option = settings["rotation_option"].GetString()
+
+        settings.RemoveValue("rotation_center")
+        settings.RemoveValue("rotation_velocity")
+        settings.RemoveValue("compute_rotation_center")
+        settings.RemoveValue("rotation_option")
+
+        # Initiate base class - Dirichlet condition
+        super().__init__(Model, settings)
+
+
+    def ExecuteBeforeSolutionLoop(self):
+        # Get updated model_part
+        if (self.model_part_name.startswith('Background_Grid.')):
+            self.model_part_name = self.model_part_name.replace('Background_Grid.','')
+        mpm_material_model_part_name = "MPM_Material." + self.model_part_name
+        self.model_part = self.model[mpm_material_model_part_name]
+
+        # If compute rotation center automatically is needed
+        if self.compute_rotation_center:
+            self._ComputeCenterRotation()
+
+        # Initial Quaternion, its increment, and rotation_matrix
+        self._InitializeRotationVariables()
+
+    def ExecuteInitializeSolutionStep(self):
+
+        # If compute rotation center automatically is needed and if the center is moved
+        if self.compute_rotation_center and self.rotation_option == "moving_center":
+            self._ComputeCenterRotation()
+
+        # Compute delta quaternion
+        self._ComputeDeltaQuaternion(self.rotation_velocity)
+        
+        self._quaternion = self._quaternion.MultiplyQuaternion(self._delta_quaternion, self._quaternion)
+        
+        # Normalize quaternion
+        self._quaternion.Normalize()
+        
+        # Compute rotation matrix
+        new_rotation_matrix = KratosMultiphysics.Matrix(3,3)
+        self._quaternion.ToRotationMatrix(new_rotation_matrix)
+
+        for mpc in self.model_part.Conditions:
+            # Compute current radius
+            mpc_coord = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_COORD,self.model_part.ProcessInfo)[0]
+            radius = mpc_coord - self.rotation_center
+
+            # Update impose_displacement
+            imposed_disp = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_IMPOSED_DISPLACEMENT,self.model_part.ProcessInfo)[0]
+            
+            imposed_disp += new_rotation_matrix * (self._rotation_matrix.transpose() * radius) - radius
+            mpc.SetValuesOnIntegrationPoints(KratosMPM.MPC_IMPOSED_DISPLACEMENT,[imposed_disp],self.model_part.ProcessInfo)
+
+            # Update normal vector
+            normal = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_NORMAL,self.model_part.ProcessInfo)[0]
+            modified_normal = new_rotation_matrix * (self._rotation_matrix.transpose() * normal)
+            mpc.SetValuesOnIntegrationPoints(KratosMPM.MPC_NORMAL,[modified_normal],self.model_part.ProcessInfo)
+
+
+        # Copy rotation matrix
+        self._rotation_matrix = new_rotation_matrix
+
+    ### Protected functions
+    def _ComputeCenterRotation(self):
+        auto_rc = KratosMultiphysics.Vector(3)
+        for mpc in self.model_part.Conditions:
+            auto_rc += mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_COORD,self.model_part.ProcessInfo)[0]
+
+        auto_rc = auto_rc / self.model_part.NumberOfConditions()
+        self.rotation_center = auto_rc
+
+    def _InitializeRotationVariables(self):
+        self._quaternion = KratosMultiphysics.Quaternion()
+        self._quaternion = self._quaternion.Identity()
+        
+        self._delta_quaternion = KratosMultiphysics.Quaternion()
+        self._delta_quaternion = self._delta_quaternion.Identity()
+
+        self._rotation_matrix = KratosMultiphysics.Matrix(3,3)
+        self._rotation_matrix.fill_identity()
+
+    def _ComputeDeltaQuaternion(self, rot_velocity):
+        if (not isinstance(rot_velocity, KratosMultiphysics.Vector)) and rot_velocity.Size() != 3:
+            raise Exception("expected input shall be a KratosMultiphysics.Vector object with size 3")
+
+        omega = math.sqrt(rot_velocity[0]*rot_velocity[0] + rot_velocity[1]*rot_velocity[1] + rot_velocity[2]*rot_velocity[2])
+        if omega < 1.e-12:
+            omega = 1.e-12
+
+        dt = self.model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME]
+        
+        self._delta_quaternion = KratosMultiphysics.Quaternion()
+        self._delta_quaternion.W = math.cos(omega * dt / 2.0)
+        self._delta_quaternion.X = math.sin(omega * dt / 2.0) * rot_velocity[0] / omega
+        self._delta_quaternion.Y = math.sin(omega * dt / 2.0) * rot_velocity[1] / omega
+        self._delta_quaternion.Z = math.sin(omega * dt / 2.0) * rot_velocity[2] / omega

KratosMultiphysics/MPMApplication/apply_mpm_coupling_interface_dirichlet_condition_process.py

@@ -0,0 +1,132 @@
+import KratosMultiphysics
+from KratosMultiphysics.deprecation_management import DeprecationManager
+import KratosMultiphysics.MPMApplication as KratosMPM
+from KratosMultiphysics.MPMApplication.apply_mpm_particle_dirichlet_condition_process import ApplyMPMParticleDirichletConditionProcess
+
+from math import sqrt
+
+def Factory(settings, Model):
+    if(not isinstance(settings, KratosMultiphysics.Parameters)):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyMPMCouplingInterfaceDirichletConditionProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+class ApplyMPMCouplingInterfaceDirichletConditionProcess(ApplyMPMParticleDirichletConditionProcess):
+    def __init__(self, Model, settings ):
+
+        default_parameters = KratosMultiphysics.Parameters( """
+            {
+                "model_part_name"               : "PLEASE_SPECIFY_MODEL_PART_NAME",
+                "material_points_per_condition" : 0,
+                "imposition_type"               : "penalty",
+                "penalty_coefficient"           : 0,
+                "constrained"                   : "fixed",
+                "option"                        : "",
+                "is_equal_distributed"          : false
+            }  """ )
+
+        context_string = type(self).__name__
+        old_name = 'particles_per_condition'
+        new_name = 'material_points_per_condition'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        context_string = type(self).__name__
+        old_name = 'penalty_factor'
+        new_name = 'penalty_coefficient'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        settings.ValidateAndAssignDefaults(default_parameters)
+        self.model = Model
+        self.model_part_name = settings["model_part_name"].GetString()
+
+        # Initiate base class - Dirichlet condition
+        super(ApplyMPMCouplingInterfaceDirichletConditionProcess, self).__init__(Model, settings)
+
+        # Set INTERFACE flag active
+        KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.INTERFACE, True, self.model_part.Conditions)
+
+
+    def ExecuteBeforeSolutionLoop(self):
+        # Get updated model_part
+        if (self.model_part_name.startswith('Background_Grid.')):
+            self.model_part_name = self.model_part_name.replace('Background_Grid.','')
+        mpm_material_model_part_name = "MPM_Material." + self.model_part_name
+        self.model_part = self.model[mpm_material_model_part_name]
+
+        # Create additional nodes for Lagrange dofs in case of Lagrange or Perturbed Lagranian method
+        if self.boundary_condition_type==2 or self.boundary_condition_type==3:
+            is_restarted = self.model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]
+            if not is_restarted:
+                grid_model_part=self.model.GetModelPart("Background_Grid")
+                
+                KratosMPM.GenerateLagrangeNodes(grid_model_part)
+
+        ### Translate conditions with INTERFACE flag into a new model part "MPM_Coupling_Dirichlet_Interface" responsible for coupling with structure
+        # Create coupling model part
+        if not self.model.HasModelPart("MPM_Coupling_Dirichlet_Interface"):
+            self.model.CreateModelPart("MPM_Coupling_Dirichlet_Interface")
+        self.coupling_model_part = self.model.GetModelPart("MPM_Coupling_Dirichlet_Interface").CreateSubModelPart(self.model_part_name)
+
+        # Prepare coupling model part
+        self._prepare_coupling_model_part(self.coupling_model_part)
+
+        # Create nodes and fill coupling model part
+        for mpc in self.model_part.Conditions:
+            if (mpc.Is(KratosMultiphysics.INTERFACE)):
+                node_id         = mpc.Id
+                node_coordinate = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_COORD, self.model_part.ProcessInfo)[0]
+                coupling_node   = self.coupling_model_part.CreateNewNode(node_id, node_coordinate[0], node_coordinate[1], node_coordinate[2])
+
+                ## Set Displacement and Normal
+                normal = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_NORMAL, self.model_part.ProcessInfo)[0]
+                coupling_node.SetSolutionStepValue(KratosMultiphysics.NORMAL,0,normal)
+
+
+    def ExecuteInitializeSolutionStep(self):
+        ### Clone delta time
+        self.coupling_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME] = self.model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME]
+
+        ### Send displacement from coupling_mp to mp
+        for coupling_node in self.coupling_model_part.Nodes:
+            coupling_id  = coupling_node.Id
+
+            ## IMPOSED DISPLACEMENT
+            total_displacement = coupling_node.GetSolutionStepValue(KratosMultiphysics.DISPLACEMENT,0)
+            old_displacement = self.model_part.GetCondition(coupling_id).CalculateOnIntegrationPoints(KratosMPM.MPC_DISPLACEMENT, self.model_part.ProcessInfo)[0]
+            incremental_displacement = total_displacement - old_displacement
+            self.model_part.GetCondition(coupling_id).SetValuesOnIntegrationPoints(KratosMPM.MPC_IMPOSED_DISPLACEMENT, [incremental_displacement], self.model_part.ProcessInfo)
+
+            ## ADD VELOCITY
+            current_velocity = coupling_node.GetSolutionStepValue(KratosMultiphysics.VELOCITY,0)
+            self.model_part.GetCondition(coupling_id).SetValuesOnIntegrationPoints(KratosMPM.MPC_VELOCITY, [current_velocity], self.model_part.ProcessInfo)
+
+            ## ADD NORMAL
+            normal = coupling_node.GetSolutionStepValue(KratosMultiphysics.NORMAL,0)
+            # Check and see whether the normal is not zero
+            norm_normal = sqrt(normal[0]*normal[0] + normal[1]*normal[1] + normal[2]*normal[2])
+            if norm_normal > 1.e-10:
+                self.model_part.GetCondition(coupling_id).SetValuesOnIntegrationPoints(KratosMPM.MPC_NORMAL, [normal], self.model_part.ProcessInfo)
+
+
+    def ExecuteFinalizeSolutionStep(self):
+        ### Get contact force from mp to coupling_mp
+        for mpc in self.model_part.Conditions:
+            if (mpc.Is(KratosMultiphysics.INTERFACE)):
+                coupling_id   = mpc.Id
+                contact_force = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_CONTACT_FORCE, self.model_part.ProcessInfo)[0]
+                self.coupling_model_part.GetNode(coupling_id).SetSolutionStepValue(KratosMultiphysics.CONTACT_FORCE,0,contact_force)
+
+
+    # Local functions
+    def _prepare_coupling_model_part(self, coupling_model_part):
+        # Define domain size
+        domain_size = self.model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+        coupling_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] = domain_size
+
+        # Add variables
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.CONTACT_FORCE)
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.NORMAL)

KratosMultiphysics/MPMApplication/apply_mpm_coupling_interface_neumann_condition_process.py

@@ -0,0 +1,101 @@
+import KratosMultiphysics
+from KratosMultiphysics.deprecation_management import DeprecationManager
+import KratosMultiphysics.MPMApplication as KratosMPM
+from KratosMultiphysics.MPMApplication.apply_mpm_particle_neumann_condition_process import ApplyMPMParticleNeumannConditionProcess
+
+def Factory(settings, Model):
+    if(not isinstance(settings, KratosMultiphysics.Parameters)):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyMPMCouplingInterfaceNeumannConditionProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+class ApplyMPMCouplingInterfaceNeumannConditionProcess(ApplyMPMParticleNeumannConditionProcess):
+    def __init__(self, Model, settings ):
+
+        default_parameters = KratosMultiphysics.Parameters( """
+            {
+                "model_part_name"           : "PLEASE_SPECIFY_MODEL_PART_NAME",
+                "material_points_per_condition"   : 0,
+                "variable_name"             : "POINT_LOAD",
+                "constrained"               : "fixed",
+                "option"                    : ""
+            }  """ )
+
+        context_string = type(self).__name__
+        old_name = 'particles_per_condition'
+        new_name = 'material_points_per_condition'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        settings.ValidateAndAssignDefaults(default_parameters)
+        self.model = Model
+        self.model_part_name = settings["model_part_name"].GetString()
+
+        # Initiate base class - Neumann condition
+        super(ApplyMPMCouplingInterfaceNeumannConditionProcess, self).__init__(Model, settings)
+
+        # Set INTERFACE flag active
+        KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.INTERFACE, True, self.model_part.Conditions)
+
+
+    def ExecuteBeforeSolutionLoop(self):
+        # Get updated model_part
+        if (self.model_part_name.startswith('Background_Grid.')):
+            self.model_part_name = self.model_part_name.replace('Background_Grid.','')
+        mpm_material_model_part_name = "MPM_Material." + self.model_part_name
+        self.model_part = self.model[mpm_material_model_part_name]
+
+        ### Translate conditions with INTERFACE flag into a new model part "MPM_Coupling_Neumann_Interface" responsible for coupling 
+        # Create coupling model part
+        if not self.model.HasModelPart("MPM_Coupling_Neumann_Interface"):
+            self.model.CreateModelPart("MPM_Coupling_Neumann_Interface")
+        self.coupling_model_part = self.model.GetModelPart("MPM_Coupling_Neumann_Interface").CreateSubModelPart(self.model_part_name)
+
+        # Prepare coupling model part
+        self._prepare_coupling_model_part(self.coupling_model_part)
+
+        # Create nodes and fill coupling model part
+        for mpc in self.model_part.Conditions:
+            if (mpc.Is(KratosMultiphysics.INTERFACE)):
+                node_id         = mpc.Id
+                node_coordinate = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_COORD, self.model_part.ProcessInfo)[0]
+                self.coupling_model_part.CreateNewNode(node_id, node_coordinate[0], node_coordinate[1], node_coordinate[2])
+
+
+    def ExecuteInitializeSolutionStep(self):
+        ### Clone delta time
+        self.coupling_model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME] = self.model_part.ProcessInfo[KratosMultiphysics.DELTA_TIME]
+
+        # ### Send Point Load from coupling node to condition
+
+        for coupling_node in self.coupling_model_part.Nodes:
+            coupling_id  = coupling_node.Id
+            point_load = coupling_node.GetSolutionStepValue(KratosMultiphysics.CONTACT_FORCE)
+
+            self.model_part.GetCondition(coupling_id).SetValuesOnIntegrationPoints(KratosMPM.POINT_LOAD, [point_load], self.model_part.ProcessInfo)
+
+
+
+    def ExecuteFinalizeSolutionStep(self):
+        ### Get kinematic variables from mp to coupling_mp
+        for mpc in self.model_part.Conditions:
+            if (mpc.Is(KratosMultiphysics.INTERFACE)):
+                coupling_id   = mpc.Id
+
+                displacement = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_DISPLACEMENT, self.model_part.ProcessInfo)[0]
+                velocity = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_VELOCITY, self.model_part.ProcessInfo)[0]
+                
+                self.coupling_model_part.GetNode(coupling_id).SetSolutionStepValue(KratosMultiphysics.VELOCITY,0,velocity)
+                self.coupling_model_part.GetNode(coupling_id).SetSolutionStepValue(KratosMultiphysics.DISPLACEMENT,0,displacement)
+
+    # Local functions
+    def _prepare_coupling_model_part(self, coupling_model_part):
+        # Define domain size
+        domain_size = self.model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE]
+        coupling_model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE] = domain_size
+
+        # Add variables
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.DISPLACEMENT)
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.VELOCITY)
+        coupling_model_part.AddNodalSolutionStepVariable(KratosMultiphysics.CONTACT_FORCE)
+        

KratosMultiphysics/MPMApplication/apply_mpm_particle_dirichlet_condition_process.py

@@ -0,0 +1,207 @@
+import KratosMultiphysics
+from KratosMultiphysics.deprecation_management import DeprecationManager
+import KratosMultiphysics.MPMApplication as KratosMPM
+
+def Factory(settings, Model):
+    if(not isinstance(settings, KratosMultiphysics.Parameters)):
+        raise Exception("expected input shall be a Parameters object, encapsulating a json string")
+    return ApplyMPMParticleDirichletConditionProcess(Model, settings["Parameters"])
+
+## All the processes python should be derived from "Process"
+class ApplyMPMParticleDirichletConditionProcess(KratosMultiphysics.Process):
+    def __init__(self, Model, settings ):
+        KratosMultiphysics.Process.__init__(self)
+
+        default_parameters = KratosMultiphysics.Parameters( """
+            {
+                "model_part_name"               : "PLEASE_SPECIFY_MODEL_PART_NAME",
+                "material_points_per_condition" : 0,
+                "imposition_type"               : "penalty",
+                "penalty_coefficient"           : 0,
+                "variable_name"                 : "DISPLACEMENT",
+                "constrained"                   : "fixed",
+                "value"                         : [0.0, "0*t", 0.0],
+                "interval"                      : [0.0, 1e30],
+                "option"                        : "",
+                "is_equal_distributed"          : false,
+                "local_axes"                    : {}
+            }  """ )
+
+         # Assign this here since it will change the "interval" prior to validation
+        self.interval = KratosMultiphysics.IntervalUtility(settings)
+
+        context_string = type(self).__name__
+        old_name = 'particles_per_condition'
+        new_name = 'material_points_per_condition'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        context_string = type(self).__name__
+        old_name = 'penalty_factor'
+        new_name = 'penalty_coefficient'
+        if DeprecationManager.HasDeprecatedVariable(context_string, settings, old_name, new_name):
+            DeprecationManager.ReplaceDeprecatedVariableName(settings, old_name, new_name)
+
+        settings.ValidateAndAssignDefaults(default_parameters)
+
+        self.model_part = Model[settings["model_part_name"].GetString()]
+        self.model_part_name = settings["model_part_name"].GetString()
+        self.model = Model
+        self.material_points_per_condition = settings["material_points_per_condition"].GetInt()
+        self.imposition_type = settings["imposition_type"].GetString()
+        self.is_neumann_boundary = False
+        self.option = settings["option"].GetString()
+
+        #is_equal_distributed = false (material point conditions at Gauss Point Positions)
+        #is_equal_distributed = true (material point conditions equally distributed; also at nodes; only 2D)
+        self.is_equal_distributed = settings["is_equal_distributed"].GetBool()
+
+        """
+        Set boundary_condition_type:
+        1. penalty
+        2. Lagrange multiplier
+        3. perturbed Lagrangian (Lagrange with Penalty coefficient >0 )
+        """
+
+        # set type of boundary
+        if (self.imposition_type == "penalty" or self.imposition_type == "Penalty"):
+            self.boundary_condition_type = 1
+            self.penalty_coefficient = settings["penalty_coefficient"].GetDouble()
+        elif (self.imposition_type == "lagrange"):
+            self.boundary_condition_type = 2
+            self.penalty_coefficient = 0.0
+        elif (self.imposition_type == "perturbed_lagrange"):
+            self.boundary_condition_type = 3
+            self.penalty_coefficient = settings["penalty_coefficient"].GetDouble()
+        else:
+            err_msg =  "The requested type of Dirichlet boundary imposition: \"" + self.imposition_type + "\" is not available!\n"
+            err_msg += "Available option is: \"penalty\", \"perturbed_lagrange\" or \"lagrange\"."
+            raise Exception(err_msg)
+
+        # check for positive Penalty coefficient
+        if self.penalty_coefficient < 0.0:
+            err_msg = '\n::[ApplyMPMParticleDirichletConditionProcess]:: W-A-R-N-I-N-G: You have specified invalid "penalty_coefficient", '
+            err_msg += 'and assigned negative values. \nPlease assign: "penalty_coefficient" > 0 or = 0!\n'
+            raise Exception(err_msg)
+
+
+        # check constraint
+        self.constrained = settings["constrained"].GetString()
+        self.is_slip_boundary = False
+        self.is_contact_boundary = False
+        if (self.constrained == "fixed"):
+            pass
+        elif (self.constrained == "contact"):
+            self.is_contact_boundary = True
+        elif (self.constrained == "slip"):
+            self.is_slip_boundary = True
+        elif (self.constrained == "contact_slip"):
+            self.is_contact_boundary = True
+            self.is_slip_boundary = True
+        else:
+            err_msg =  "The requested type of constrain: \"" + self.constrained + "\" is not available!\n"
+            err_msg += "Available options are: \"fixed\", \"contact\" and \"slip\"."
+            raise Exception(err_msg)
+
+        # get variable imposed and check
+        variable_name = settings["variable_name"].GetString()
+        variable_name_list = ["DISPLACEMENT","VELOCITY","ACCELERATION"]
+        if(variable_name in variable_name_list):
+            self.variable = KratosMultiphysics.KratosGlobals.GetVariable(variable_name)
+        else:
+            err_msg =  "The given variable \"" + variable_name + "\" is not available to be imposed with this process.\n"
+            err_msg += "Available options are: " + ", ".join(variable_name_list)
+            raise Exception(err_msg)
+
+        self.value_is_numeric = [False, False, False]
+        self.value = KratosMultiphysics.Vector(3)
+        self.aux_function = ["0.0","0.0","0.0"]
+        self.name = ["0.0","0.0","0.0"]
+        # Loop over components X, Y and Z
+        for i, variable in enumerate(["_X", "_Y", "_Z"]):
+            self.name[i] = settings["variable_name"].GetString() + variable
+            if settings["value"][i].IsNumber():
+                self.value_is_numeric[i] = True
+                self.value[i] = settings["value"][i].GetDouble()
+            else:
+                self.function_string = settings["value"][i].GetString()
+                self.aux_function[i] = KratosMultiphysics.GenericFunctionUtility(self.function_string, settings["local_axes"])
+
+
+        # Compute the normal on the nodes of interest
+        KratosMultiphysics.NormalCalculationUtils().CalculateOnSimplex(self.model_part, self.model_part.ProcessInfo[KratosMultiphysics.DOMAIN_SIZE])
+        self.modified_normal = False
+        if self.option == "flip_normal":
+            self.modified_normal = True
+
+        # Set Flag BOUNDARY and variables MATERIAL_POINTS_PER_CONDITION
+        if self.material_points_per_condition >= 0:
+            KratosMultiphysics.VariableUtils().SetFlag(KratosMultiphysics.BOUNDARY, True, self.model_part.Nodes)
+
+            for condition in self.model_part.Conditions:
+                condition.Set(KratosMultiphysics.BOUNDARY, True)
+                condition.Set(KratosMultiphysics.SLIP, self.is_slip_boundary)
+                condition.Set(KratosMultiphysics.CONTACT, self.is_contact_boundary)
+                condition.Set(KratosMultiphysics.MODIFIED, self.modified_normal)
+                condition.SetValue(KratosMPM.MATERIAL_POINTS_PER_CONDITION, self.material_points_per_condition)
+                condition.SetValue(KratosMPM.IS_EQUAL_DISTRIBUTED, self.is_equal_distributed)
+                condition.SetValue(KratosMPM.MPC_IS_NEUMANN, self.is_neumann_boundary)
+                condition.SetValue(KratosMPM.MPC_BOUNDARY_CONDITION_TYPE, self.boundary_condition_type)
+
+                ### Set necessary essential BC variables
+                if self.boundary_condition_type==1 or self.boundary_condition_type==2 or self.boundary_condition_type==3:
+                    condition.SetValue(KratosMultiphysics.PENALTY_COEFFICIENT, self.penalty_coefficient)
+        else:
+            err_msg = '\n::[ApplyMPMParticleDirichletConditionProcess]:: W-A-R-N-I-N-G: You have specified invalid "material_points_per_condition", '
+            err_msg += 'or assigned negative values. \nPlease assign: "material_points_per_condition" > 0 or = 0 (for automatic value)!\n'
+            raise Exception(err_msg)
+
+    def ExecuteBeforeSolutionLoop(self):
+        """ This method is executed in before initialize the solution step
+
+        Keyword arguments:
+        self -- It signifies an instance of a class.
+        """
+
+        # Get updated model_part
+        if (self.model_part_name.startswith('Background_Grid.')):
+            self.model_part_name = self.model_part_name.replace('Background_Grid.','')
+        mpm_material_model_part_name = "MPM_Material." + self.model_part_name
+        self.model_part = self.model[mpm_material_model_part_name]
+
+        # Create additional nodes for Lagrange dofs in case of Lagrange or Perturbed Lagranian method
+        if self.boundary_condition_type==2 or self.boundary_condition_type==3:
+            is_restarted = self.model_part.ProcessInfo[KratosMultiphysics.IS_RESTARTED]
+            if not is_restarted:
+                grid_model_part=self.model.GetModelPart("Background_Grid")
+
+                KratosMPM.GenerateLagrangeNodes(grid_model_part)
+
+        self.ExecuteInitializeSolutionStep()
+
+    def ExecuteInitializeSolutionStep(self):
+        """ This method is executed in order to initialize the current step
+
+        Keyword arguments:
+        self -- It signifies an instance of a class.
+        """
+
+        for mpc in self.model_part.Conditions:
+            current_time = self.model_part.ProcessInfo[KratosMultiphysics.TIME]
+            mpc_coord = mpc.CalculateOnIntegrationPoints(KratosMPM.MPC_COORD,self.model_part.ProcessInfo)[0]
+
+            if self.interval.IsInInterval(current_time):
+
+                self.step_is_active = True
+
+                # Loop over components X, Y and Z
+                for i in range(3):
+                    self.variable = self.name[i]
+                    if  not self.value_is_numeric[i]:
+                        if self.aux_function[i].DependsOnSpace() == False: #depends on time only
+                            self.value[i] = self.aux_function[i].CallFunction(0.0,0.0,0.0,current_time,0.0,0.0,0.0)
+                        else: #most general case - space varying function (possibly also time varying)
+                            self.value[i] = self.aux_function[i].CallFunction(mpc_coord[0],mpc_coord[1],mpc_coord[2],current_time,0.0,0.0,0.0)
+
+
+                mpc.SetValuesOnIntegrationPoints(KratosMPM.MPC_IMPOSED_DISPLACEMENT,[self.value],self.model_part.ProcessInfo)