Davout 0.1.1.dev182__py3-none-any.whl → 0.1.1.dev183__py3-none-any.whl

Davout/CuboidGmsh/aa_tests/solids/notch_mesh.py

@@ -0,0 +1,250 @@
+# Routine to generate an interchangeble mesh both for thrird medium
+# contact and for notch-based crack propagation.
+#
+# Mesh made by Bianca Grahl Reyes
+
+import h5py
+
+import numpy as np
+
+from .....Davout.CuboidGmsh.solids import cuboid_prisms as prisms
+
+from .....Davout.CuboidGmsh.tool_box import meshing_tools as tools
+
+from .....Davout.PythonicUtilities.path_tools import get_parent_path_of_file
+
+# Defines a function to generate the mesh from a set of geometrical pa-
+# rametres. L is the length of the box, W is the width of the box, H is
+# the height of the box, theta is the notch opening angle, and 
+# half_W_notch is the notch width.
+
+def generate_mesh(L, W, H, theta, half_W_notch, L_notch, transfinite_x,
+transfinite_y, transfinite_z, transfinite_radial, mesh_file_name, 
+bias_x, bias_y, bias_z, bias_radial, include_drittes_medium=True,
+verbose=True):
+
+    # Verifies whether the notch opening angle of the notch is between 0
+    # and 90 degrees 
+
+    if theta<0.0 or theta>90.0:
+
+        raise ValueError("The notch opening angle should be between 0 "+
+        "and 90 degrees. Currently, 'theta' is "+str(theta))
+
+    # Converts the theta angle to radians
+
+    theta = theta*(np.pi/180.0)
+
+    # Verifies whether the notch width is confined within the box width  
+
+    if (2*half_W_notch*np.sin(theta))>=W:
+
+        raise ValueError("The notch width, 'half_W_notch', and the not"+
+        "ch opening angle, 'theta', should be such that 2*half_W_notch"+
+        "*sin(theta) < W. So that the notch fits into the width of the"+
+        " box")
+
+    # Verifies whether the notch length is confined within the box length
+
+    # Defines the surfaces and volumes regions names for imposition of
+    # boundary conditions and integration of constitutive models
+
+    surfaces_regions_names = ["top", "front_solid", "front_third", "back", "bottom"]
+
+    volumes_regions_names = ["third medium", "solid"]
+
+    # Initializes the mesh 
+
+    geometric_data = tools.gmsh_initialization(surface_regionsNames= 
+    surfaces_regions_names, volume_regionsNames=volumes_regions_names)
+
+    # Creates the upper half of the notch (filled with third medium)
+
+    # Sets the corner points
+
+    corner_points = np.array([[L-L_notch, 0.5*W, 0.0], [L, 0.5*W, 0.0],
+    [L, (0.5*W)+(half_W_notch*np.sin(theta)), 0.0], [L-L_notch+(
+    half_W_notch*np.cos(theta)), (0.5*W)+(half_W_notch*np.sin(theta)), 
+    0.0],
+    [L-L_notch, 0.5*W, H], [L, 0.5*W, H],
+    [L, (0.5*W)+(half_W_notch*np.sin(theta)), H], [L-L_notch+(
+    half_W_notch*np.cos(theta)), (0.5*W)+(half_W_notch*np.sin(theta)), 
+    H]])
+
+    # Generates this cuboid
+
+    if include_drittes_medium:
+
+        geometric_data = prisms.hexahedron_from_corners(corner_points, 
+        transfinite_directions = [transfinite_y, transfinite_x, 
+        transfinite_z], geometric_data=geometric_data,  
+        explicit_volume_physical_group_name = "third medium", 
+        explicit_surface_physical_group_name = {3: "front_third"},
+        bias_directions = {"x": bias_y, "y": bias_x, "z": bias_z})
+
+    # Creates the upper section of the solid
+
+    # Sets the corner points
+    
+    corner_points = np.array([[L-L_notch+(half_W_notch*np.cos(theta)), 
+    (0.5*W)+(half_W_notch*np.sin(theta)), 0.0],
+    [L, (0.5*W)+(half_W_notch*np.sin(theta)), 0.0],
+    [L, W, 0.0], [0.0, W, 0.0],
+    [L-L_notch+(half_W_notch*np.cos(theta)), 
+    (0.5*W)+(half_W_notch*np.sin(theta)), H],
+    [L, (0.5*W)+(half_W_notch*np.sin(theta)), H],
+    [L, W, H], [0.0, W, H]])
+
+    # Generates this cuboid
+
+    geometric_data = prisms.hexahedron_from_corners(corner_points, 
+    transfinite_directions = [transfinite_radial, transfinite_x, 
+    transfinite_z], geometric_data=geometric_data,  
+    explicit_volume_physical_group_name = "solid", 
+    explicit_surface_physical_group_name = {3: "front_solid", 4: "top"},
+    bias_directions = {"x": bias_radial, "y": bias_x, "z": bias_z})
+
+    # Creates the upper section of the back of the solid
+
+    # Sets the corner points
+        
+    corner_points = np.array([[0.0, 0.5*W, 0.0], [L-L_notch, 0.5*W, 0.0],
+    [L-L_notch+(half_W_notch*np.cos(theta)), (0.5*W)+(half_W_notch*
+    np.sin(theta)), 0.0], [0.0, W, 0.0],
+    [0.0, 0.5*W, H], [L-L_notch, 0.5*W, H],
+    [L-L_notch+(half_W_notch*np.cos(theta)), (0.5*W)+(half_W_notch*
+    np.sin(theta)), H], [0.0, W, H]])
+
+    # Generates this cuboid
+
+    geometric_data = prisms.hexahedron_from_corners(corner_points, 
+    transfinite_directions = [transfinite_y, transfinite_x, 
+    transfinite_z], geometric_data=geometric_data,  
+    explicit_volume_physical_group_name = "solid", 
+    explicit_surface_physical_group_name = {5: "back"},
+    bias_directions = {"x": bias_y, "y": bias_radial, "z": bias_z})
+
+    # Creates the botton section of the back of the solid (6)
+
+    # Sets the corner points
+        
+    corner_points = np.array([[0.0, 0.0, 0.0], [(L-L_notch)+(
+    half_W_notch*np.cos(theta)), 0.5*W-(half_W_notch*np.sin(theta)), 0.0],
+    [L-L_notch, 0.5*W, 0.0], [0.0, 0.5*W, 0.0],
+    [0.0, 0.0, H], [(L-L_notch)+(half_W_notch*np.cos(theta)), 
+    0.5*W-(half_W_notch*np.sin(theta)), H],
+    [L-L_notch, 0.5*W, H], [0.0, 0.5*W, H]])
+
+    # Generates this cuboid
+
+    geometric_data = prisms.hexahedron_from_corners(corner_points, 
+    transfinite_directions = [transfinite_y, transfinite_radial, 
+    transfinite_z], geometric_data=geometric_data,  
+    explicit_volume_physical_group_name = "solid", 
+    explicit_surface_physical_group_name = {5: "back"},
+    bias_directions = {"x": -bias_y, "y": bias_radial, "z": bias_z})
+
+    # Creates the botton part of the third medium (2)
+
+    # Sets the corner points
+        
+    corner_points = np.array([[(L-L_notch)+(half_W_notch*np.cos(theta)), 
+    0.5*W-(half_W_notch*np.sin(theta)), 0.0], [L, 0.5*W-(half_W_notch*
+    np.sin(theta)), 0.0], [L, 0.5*W, 0.0], [L-L_notch, 0.5*W, 0.0], 
+    [(L-L_notch)+(half_W_notch*np.cos(theta)), 0.5*W-(half_W_notch*
+    np.sin(theta)), H], [L, 0.5*W-(half_W_notch*np.sin(theta)), H],
+    [L, 0.5*W, H], [L-L_notch, 0.5*W, H]])
+
+    # Generates this cuboid
+
+    if include_drittes_medium:
+
+        geometric_data = prisms.hexahedron_from_corners(corner_points, 
+        transfinite_directions = [transfinite_y, transfinite_x, 
+        transfinite_z], geometric_data=geometric_data,  
+        explicit_volume_physical_group_name = "third medium", 
+        explicit_surface_physical_group_name = {3: "front_third"},
+        bias_directions = {"x": -bias_y, "y": bias_x, "z": bias_z})
+
+    # Creates the botton part of the solid (4)
+
+    # Sets the corner points
+    
+    corner_points = np.array([[0.0, 0.0, 0.0], [L, 0.0, 0.0], 
+    [L, (0.5*W)-(half_W_notch*np.sin(theta)), 0.0], [L-L_notch+(
+    half_W_notch*np.cos(theta)), (0.5*W)-(half_W_notch*np.sin(theta)), 0.0], 
+    [0.0, 0.0, H], [L, 0.0, H], [L, (0.5*W)-(half_W_notch*np.sin(theta)), 
+    H], [L-L_notch+(half_W_notch*np.cos(theta)), (0.5*W)-(half_W_notch*
+    np.sin(theta)), H]])
+
+    # Generates this cuboid
+
+    geometric_data = prisms.hexahedron_from_corners(corner_points, 
+    transfinite_directions = [transfinite_y, transfinite_x, 
+    transfinite_z], geometric_data=geometric_data,  
+    explicit_volume_physical_group_name = "solid", 
+    explicit_surface_physical_group_name = {3: "front_solid", 2: "bottom"},
+    bias_directions = {"x": -bias_radial, "y": bias_x, "z": bias_z})
+
+    ####################################################################
+    #                          Mesh generation                         #
+    ####################################################################
+    
+    tools.gmsh_finalize(geometric_data=geometric_data, file_name=
+    mesh_file_name, file_directory="", verbose=verbose)
+
+# Testing block
+
+if __name__ == "__main__":
+
+    # Example parameters for the mesh generation
+
+    L = 10.0
+
+    W = 5.0
+    
+    H = 3.0
+    
+    theta = 30.0
+
+    half_W_notch = 1.0
+    
+    L_notch = 8.0
+
+    # Sets the number of elements of each direction
+
+    transfinite_x = 10
+
+    transfinite_y = 4
+    
+    transfinite_z = 5
+    
+    transfinite_radial = 5
+
+    # Sets the bias factors. When the bias is 1.0, nothing happens and
+    # the finite elements are uniformly distributed
+
+    bias_x = 1.1
+
+    bias_y = 1.2
+
+    bias_z = 1.0
+
+    bias_radial = -1.5
+
+    # Defines the name of the mesh and appends the whole path to it.
+    # Uses a function from Davout to automatically retrieve the path to
+    # this file (notch_mesh.py)
+
+    mesh_file_name = get_parent_path_of_file()+"//notch_mesh"
+
+    # Sets a flag to add or not the mesh of the third medium
+
+    include_drittes_medium = True
+
+    # Calls the mesh generation function 
+
+    generate_mesh(L, W, H, theta, half_W_notch, L_notch, transfinite_x,
+    transfinite_y, transfinite_z, transfinite_radial, mesh_file_name,
+    bias_x, bias_y, bias_z, bias_radial, include_drittes_medium=
+    include_drittes_medium)

Davout/DeepMech/aa_tests/SVD_framework/kinematics_surrogate_model.py

@@ -361,9 +361,13 @@ class RVEKinematicsSurrogateModel:
 
 if __name__=="__main__":
 
-    # Sets the number of transfinite divisions in the RVE mesh
+     # Sets the number of transfinite divisions in the RVE mesh
 
-    n_divisions = 6
+    n_divisions = 10
+
+    # Sets component to be learnt
+
+    component_to_be_learnt = "Y"
 
     # Sets a dictionary for the number of DOFs in the mesh for each num-
     # ber of divisions
@@ -372,8 +376,11 @@ if __name__=="__main__":
 
     # Defines the array with the DOFs to be learnt
 
-    subdofs_to_learn = np.arange(0, dofs_per_number_of_divisions[
-    n_divisions], 3)
+    components_dictionary = {"X": 0, "Y": 1, "Z": 2}
+
+    subdofs_to_learn = np.arange(components_dictionary[
+    component_to_be_learnt], dofs_per_number_of_divisions[n_divisions], 
+    3)
 
     # Defines the number of input neurons of the main network. Remember
     # that the data matrix is a tensor [n_samples, n_input_variables]. 
@@ -399,7 +406,7 @@ if __name__=="__main__":
     1.0}}, 
     {"quadratic":  {"number of neurons": min(n_neurons_per_layer[0], 
     n_neurons_per_layer[1]), "a2": 1.0}}, 
-    {"quadratic": {"number of neurons": min(n_neurons_per_layer[1], 
+    {"quadratic": {"number of neurons": min(n_neurons_per_layer[1],
     n_neurons_per_layer[2])}}]
 
     # Sets the modulating function for the weights matrices
@@ -416,11 +423,11 @@ if __name__=="__main__":
 
     verbose_delta_iterations = 50
 
-    n_monte_carlo_realizations = 10
+    n_monte_carlo_realizations = 1000
 
-    n_best_models = 5
+    n_best_models = 30
 
-    n_best_samples = 10
+    n_best_samples = 20
 
     loss_metric = "MeanSquaredError"
 
@@ -429,7 +436,7 @@ if __name__=="__main__":
 
     parameters_dtype = "float32"
 
-    saved_model_file = "RVE_kinematics_model.keras"
+    saved_model_file = "RVE_kinematics_model_"+str(component_to_be_learnt)
 
     # Sets the path for the data
 

Davout/MultiMech/aa_tests_and_examples/physics_prototypes/compressible_hyperelasticity.py

@@ -1,4 +1,4 @@
-# Routine to experiment with incompressible hyperelasticity
+# Routine to experiment with compressible hyperelasticity
 
 from dolfin import *
 
@@ -6,7 +6,7 @@ from .....Davout.PythonicUtilities.path_tools import get_parent_path_of_file
 
 from .....Davout.MultiMech.tool_box.mesh_handling_tools import read_mshMesh
 
-from .....Davout.MultiMech.constitutive_models.hyperelasticity.isotropic_hyperelasticity import Neo_Hookean
+from .....Davout.MultiMech.constitutive_models.hyperelasticity.isotropic_hyperelasticity import NeoHookean
 
 from .....Davout.MultiMech.tool_box import functional_tools
 
@@ -31,21 +31,27 @@ E = 1E6
 
 poisson = 0.3
 
-constitutive_models = {"volume 1": Neo_Hookean({"E": E, "nu": poisson})}
+constitutive_models = {"volume 1": NeoHookean({"E": E, "nu": poisson})}
+
+# Checks the constitutive models
+
+for constitutive_model in constitutive_models.values():
+
+    constitutive_model.check_model({})
 
 # Sets the function space
 
 functional_data_class = functional_tools.construct_monolithicFunctionSpace(
 {"Displacement": {"field type": "vector", "interpolation function": "C"+
-"G", "polynomial degree": 2}, "Pressure": {"field type": "scalar", "in"+
-"terpolation function": "CG", "polynomial degree": 1}}, mesh_data_class)
+"G", "polynomial degree": 2}}, mesh_data_class)
 
 # Dirichlet boundary conditions
 
-bc, dirichlet_loads, functional_data_class, elements_dictionary, variational_form = (
+(bc, dirichlet_loads, functional_data_class, elements_dictionary, 
+variational_form, post_processes, post_processesSubmesh, solution_name) = (
 functional_tools.construct_DirichletBCs({"bottom": 
-{"BC case": "FixedSupportDirichletBC", "sub_fieldsToApplyBC": "Displac"+
-"ement"}}, functional_data_class, mesh_data_class))
+{"BC case": "FixedSupportDirichletBC"}}, functional_data_class, 
+mesh_data_class))
 
 # Variational form of the exterior work using an uniform referential 
 # traction

Davout/MultiMech/aa_tests_and_examples/physics_prototypes/incompressible_hyperelasticity.py

@@ -6,7 +6,7 @@ from .....Davout.PythonicUtilities.path_tools import get_parent_path_of_file
 
 from .....Davout.MultiMech.tool_box.mesh_handling_tools import read_mshMesh
 
-from .....Davout.MultiMech.constitutive_models.hyperelasticity.isotropic_hyperelasticity import Neo_Hookean
+from .....Davout.MultiMech.constitutive_models.hyperelasticity.isotropic_hyperelasticity import NeoHookean
 
 from .....Davout.MultiMech.tool_box import functional_tools
 
@@ -31,7 +31,11 @@ E = 1E6
 
 poisson = 0.3
 
-constitutive_model = Neo_Hookean({"E": E, "nu": poisson})
+constitutive_model = NeoHookean({"E": E, "nu": poisson})
+
+# Checks the constitutive models
+
+constitutive_model.check_model({})
 
 # Sets the function space
 
@@ -42,7 +46,8 @@ functional_data_class = functional_tools.construct_monolithicFunctionSpace(
 
 # Dirichlet boundary conditions
 
-bc, dirichlet_loads, functional_data_class, elements_dictionary, variational_form = (
+(bc, dirichlet_loads, functional_data_class, elements_dictionary, 
+variational_form, post_processes, post_processesSubmesh, solution_name) = (
 functional_tools.construct_DirichletBCs({"bottom": 
 {"BC case": "FixedSupportDirichletBC", "sub_fieldsToApplyBC": "Displac"+
 "ement"}}, functional_data_class, mesh_data_class))

Davout/MultiMech/aa_tests_and_examples/physics_prototypes/infinitesimal_plasticity.py

@@ -0,0 +1,239 @@
+# Routine to experiment with quadrature elements to allow for implemen-
+# tations concerned with algorithmic procedures in the quadrature points
+
+from dolfin import *
+
+from .....Davout.PythonicUtilities.path_tools import get_parent_path_of_file
+
+from .....Davout.MultiMech.tool_box.mesh_handling_tools import read_mshMesh
+
+from .....Davout.MultiMech.constitutive_models.plasticity.isotropic_infinitesimal_plasticity import ExponentialHardeningElastoPlasticWithBackStress
+
+from .....Davout.MultiMech.constitutive_models.hyperelasticity.infinitesimal_elasticity import LinearIsotropicElastic
+
+from .....Davout.MultiMech.tool_box import functional_tools
+
+from .....Davout.MultiMech.tool_box import variational_tools
+
+from .....Davout.MultiMech.tool_box.newton_raphson_tools import NewtonRaphson
+
+from .....Davout.MultiMech.tool_box.read_write_tools import write_field_to_xdmf
+
+# Creates a box mesh using gmsh
+
+shape_function_degree = 3
+
+quadrature_degree = int(2*(shape_function_degree-1))
+
+mesh_data_class = read_mshMesh({"length x": 0.3, "length y": 0.2, "len"+
+"gth z": 3.0, "number of divisions in x": 5, "number of divisions in y":
+5, "number of divisions in z": 40, "verbose": False, "mesh file name": 
+"box_mesh", "mesh file directory": get_parent_path_of_file()}, 
+quadrature_degree=quadrature_degree)
+
+# Neumann boundary conditions
+
+maximum_load = 1.5E3
+
+plastic_material = False
+
+# Sets the number of load steps (pseudo-time steps)
+
+n_load_steps = 5
+
+# Sets the constitutive model
+
+E = 1E6
+
+poisson = 0.3
+
+# Sets the coefficients of the plastic behavior
+
+sigma_y = 2E3
+
+H_back_stress = 0.0
+
+K_1 = E*0.02
+
+K_2 = 0.0
+
+theta = 0.0
+
+constitutive_models = None 
+
+if plastic_material:
+
+    constitutive_models = {"volume 1": 
+    ExponentialHardeningElastoPlasticWithBackStress({"E": E, "nu": 
+    poisson, "sigma_y": sigma_y, "H": H_back_stress, "K_1": K_1, "K_2": 
+    K_2, "theta": theta}, newton_raphson_tolerance=1E-4)}
+
+else:
+
+    constitutive_models = {"volume 1": LinearIsotropicElastic({"E": E, 
+    "nu": poisson})}
+
+# Checks the constitutive models and ensures that the supplied param-
+# eters are correct
+
+for constitutive_model in constitutive_models.values():
+
+    constitutive_model.check_model({"mesh_data_class": mesh_data_class})
+
+# Sets the function space
+
+functional_data_class = functional_tools.construct_monolithicFunctionSpace(
+{"Displacement": {"field type": "vector", "interpolation function": "C"+
+"G", "polynomial degree": shape_function_degree}}, mesh_data_class, 
+verbose=True)
+
+# Dirichlet boundary conditions
+
+(bc, dirichlet_loads, functional_data_class, elements_dictionary, 
+variational_form, post_processes, post_processesSubmesh, solution_name) = (
+functional_tools.construct_DirichletBCs({"bottom": {"BC case": "Simple"+
+"SupportDirichletBC", "bc_informationsDict": {"list_of_constrained_dofs": 
+[2]}}, "right": {"BC case": "SimpleSupportDirichletBC", "bc_information"+
+"sDict": {"list_of_constrained_dofs": [1]}}, "back": {"BC case": "Simp"+
+"leSupportDirichletBC", "bc_informationsDict": {"list_of_constrained_d"+
+"ofs": [0]}}}, functional_data_class, mesh_data_class))
+
+# Variational form of the exterior work using an uniform referential 
+# traction
+
+external_work, neumann_loads = variational_tools.traction_work({"top": {
+"load case": "UniformReferentialTraction", "amplitude_tractionX": 
+0.0, "amplitude_tractionY": 0.0, "amplitude_tractionZ": maximum_load, 
+"parametric_load_curve": "linear", "t": 0.0, "t_final": 1.0}}, 
+"Displacement", functional_data_class, mesh_data_class, [])
+
+# Computes the elements necessary to pull-back the Cauchy stress to the
+# first Piola-Kirchhoff stress tensor using Nanson's formula
+
+I = Identity(functional_data_class.solution_fields["Displacement"
+].geometric_dimension())
+
+F = grad(functional_data_class.solution_fields["Displacement"])+I
+
+F_invT = inv(F).T
+
+J = det(F)
+
+# Gets the variational form of the inner work
+
+internal_work = 0.0
+
+for physical_group, constitutive_model in constitutive_models.items():
+
+    print("\nUpdates the constitutive model at '"+str(physical_group)+
+    "'")
+
+    # Updates the internal variables and the tangent modulus. The second
+    # argument is false, because this update is not inside a Newton-
+    # Raphson iteration
+
+    if plastic_material:
+
+        constitutive_model.update_internal_variables(
+        functional_data_class.solution_fields["Displacement"], 
+        flag_newton_raphson_iteration=False)
+
+    # Gets the Cauchy stress tensor from the linear elastic constitutive
+    # relation and pulls it back to the first Piola-Kirchhoff stress 
+    # tensor. This way, a formulation of large displacements and infini-
+    # tesimal strains can be accomplished, since the linearization of 
+    # the first Piola-Kirchhoff stress tensor will carry the geometric
+    # nonlinearities
+
+    sigma = constitutive_model.cauchy_stress(
+    functional_data_class.solution_fields["Displacement"])
+
+    P = J*sigma*F_invT
+
+    internal_work += (inner(P, (grad(
+    functional_data_class.variation_fields["Displacement"])))*
+    mesh_data_class.dx(mesh_data_class.domain_physicalGroupsNameToTag[
+    physical_group]))
+
+# Defines a function to update the variational form
+
+verbose = True
+
+def variational_form_update_function(pseudo_time, 
+flag_newton_raphson_iteration, verbose=verbose):
+
+    # Update the load class
+    
+    neumann_loads[0].update_load(pseudo_time, verbose=verbose)
+
+    if verbose:
+
+        print("\nUpdates the constitutive model at '"+str(physical_group
+        )+"'")
+
+    # Updates the internal variables and the tangent modulus
+
+    if plastic_material:
+
+        constitutive_models["volume 1"].update_internal_variables(
+        functional_data_class.solution_fields["Displacement"],
+        flag_newton_raphson_iteration=flag_newton_raphson_iteration, 
+        verbose=verbose)
+
+# Defines a class to perform post-processes. In this case, simply sa-
+# ving the output field
+
+class PostProcesses:
+
+    def __init__(self, visualization_copy):
+
+        self.xdmf_file = None
+
+        self.visualization_copy_file = None
+
+        self.visualization_copy = visualization_copy
+
+    def __call__(self, pseudo_time, time_step):
+
+        # Saves this pseudo-time step in a xdmf file
+
+        if self.visualization_copy:
+
+            self.xdmf_file, self.visualization_copy_file = write_field_to_xdmf(
+            functional_data_class, explicit_file_name=
+            get_parent_path_of_file()+"//displacement_finite_deformat"+
+            "ion_with_infinitesimal_strain.xdmf", file=self.xdmf_file, 
+            time=pseudo_time, time_step=time_step, visualization_copy=
+            self.visualization_copy, visualization_copy_file=
+            self.visualization_copy_file,
+            flag_read_copy=True, close_file=False)
+
+        else:
+
+            self.xdmf_file = write_field_to_xdmf(functional_data_class, 
+            explicit_file_name=get_parent_path_of_file()+"//displaceme"+
+            "nt_finite_deformation_with_infinitesimal_strain.xdmf", 
+            file=self.xdmf_file, time=pseudo_time, time_step=time_step)
+
+post_processes = PostProcesses(True)
+    
+# Sets the Newton-Raphson solver
+
+newton_raphson_class = NewtonRaphson(n_load_steps, variational_form=(
+internal_work-external_work), functional_data_class=
+functional_data_class, boundary_conditions_list=bc, 
+variational_form_update_function=variational_form_update_function,
+post_processing_function=post_processes, use_custom_newton=True)
+
+# Calls the loading procedure
+
+newton_raphson_class()
+
+if plastic_material:
+
+    print("\nEvaluates the internal variables after the full load hist"+
+    "ory")
+
+    constitutive_models["volume 1"].update_internal_variables(
+    functional_data_class.solution_fields["Displacement"], 
+    flag_newton_raphson_iteration=False, verbose=True)