Davout 0.1.1.dev181__tar.gz → 0.1.1.dev183__tar.gz

{davout-0.1.1.dev181/source/Davout.egg-info → davout-0.1.1.dev183}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Davout
-Version: 0.1.1.dev181
+Version: 0.1.1.dev183
 Summary: Scientific computing utilities combining FEM, ANN and tooling
 Author: Matheus Janczkowski
 Author-email: Matheus Janczkowski <matheusj2009@hotmail.com>

{davout-0.1.1.dev181 → davout-0.1.1.dev183}/pyproject.toml

@@ -63,7 +63,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Davout"
-version = "0.1.1.dev181"
+version = "0.1.1.dev183"
 description = "Scientific computing utilities combining FEM, ANN and tooling"
 readme = "README.md"
 authors = [

davout-0.1.1.dev183/source/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-0.1.1.dev181 → davout-0.1.1.dev183}/source/Davout/DeepMech/aa_tests/SVD_framework/dataset_generator.py

@@ -14,6 +14,8 @@ from .....Davout.DeepMech.aa_tests.mecsol_2026_quotient_space.box_with_imposed_d
 
 from .....Davout.DeepMech.aa_tests.mecsol_2026_quotient_space.young_modulus_field_generator import generate_field
 
+from input_data_filler import fill_load_steps
+
 import numpy as np
 
 import traceback
@@ -26,7 +28,8 @@ def generate_dataset(n_samples, limits_list, p_norm_list, results_path,
 displacement_file_name, young_modulus_file, mesh_file_name, cube_size,
 influence_radius, damping_factor, radius_power, mesh_data_class, 
 lagrange_multiplier_file_name, strain_energy_file_name,
-save_snapshot_displacement=False):
+displacement_matrix_file_name, strain_energy_matrix_file_name, 
+input_matrix_file_name, save_snapshot_displacement=False):
     
     # Initializes the list of samples
 
@@ -193,14 +196,14 @@ save_snapshot_displacement=False):
 
             # Saves the lists into binary and txt files
 
-            np.save(results_path+"//00_successful_displacement_matrix.n"+
-            "py", np.array(succesful_displacement))
+            np.save(results_path+"//"+displacement_matrix_file_name, 
+            np.array(succesful_displacement))
 
-            np.save(results_path+"//00_successful_strain_energy_matrix"+
-            ".npy", np.array(succesful_strain_energy))
+            np.save(results_path+"//"+strain_energy_matrix_file_name, 
+            np.array(succesful_strain_energy))
 
-            np.save(results_path+"//00_successful_data_matrix.npy", 
-            np.array(succesful_data))
+            np.save(results_path+"//"+input_matrix_file_name, np.array(
+            succesful_data))
 
             list_toTxt(completed_simulations, "00_completed_simulations", 
             parent_path=results_path)
@@ -372,6 +375,31 @@ if __name__=="__main__":
 
     mesh_file_name = "box_mesh_mecsol"
 
+    # Sets the file name of the data matrices
+
+    displacement_matrix_file_name = ("00_successful_displacement_matri"+
+    "x.npy")
+
+    strain_energy_matrix_file_name = ("00_successful_strain_energy_mat"+
+    "rix.npy")
+
+    input_matrix_file_name = "00_successful_data_matrix.npy"
+
+    # Sets the file names of the completed (filled-in with load-steps) 
+    # data matrices and the filtered counterpart
+
+    complete_data_matrix_file_name = ("00_successful_complete_data_mat"+
+    "rix.npy")
+
+    complete_and_filtered_data_matrix_file_name = ("00_successful_comp"+
+    "lete_and_filtered_data_matrix.npy")
+
+    # Sets the initial and final time points for the simulation
+
+    initial_time = 0.2
+
+    final_time = 1.0
+
     # Constructs the mesh
 
     mesh_data_class = read_mshMesh({"length x": cube_size, "length y": 
@@ -382,10 +410,31 @@ if __name__=="__main__":
     "bias x": ["Bump", bias_factor], "bias y": ["Bump", bias_factor], 
     "bias z": ["Bump", bias_factor]})
 
-    # Constructs the field
+    # Defines a flag fo generating the dataset and another flag for ge-
+    # nerating the dataset with the intermediate load steps and its fil-
+    # tered version as well
+
+    flag_generate_dataset = False
+
+    flag_fill_in_load_steps = True
+
+    # Generates the dataset from skretch
+
+    if flag_generate_dataset:
+
+        generate_dataset(n_samples, limits_list, p_norm_list, 
+        results_path, displacement_file_name, young_modulus_file, 
+        mesh_file_name, cube_size, influence_radius, damping_factor, 
+        radius_power, mesh_data_class, lagrange_multiplier_file_name, 
+        strain_energy_file_name, displacement_matrix_file_name,
+        strain_energy_matrix_file_name, input_matrix_file_name,
+        save_snapshot_displacement=False)
+
+    # Fills the load-steps and generates the filtered dataset from it
+
+    if flag_fill_in_load_steps:
 
-    generate_dataset(n_samples, limits_list, p_norm_list, results_path,
-    displacement_file_name, young_modulus_file, mesh_file_name, cube_size,
-    influence_radius, damping_factor, radius_power, mesh_data_class,
-    lagrange_multiplier_file_name, strain_energy_file_name, 
-    save_snapshot_displacement=False)
+        fill_load_steps(input_matrix_file_name, 
+        displacement_matrix_file_name, complete_data_matrix_file_name, 
+        complete_and_filtered_data_matrix_file_name, results_path, 
+        initial_time, final_time)

{davout-0.1.1.dev181 → davout-0.1.1.dev183}/source/Davout/DeepMech/aa_tests/SVD_framework/input_data_filler.py

@@ -60,10 +60,10 @@ final_time):
 
             # Recovers the displacement gradient
 
-            displacement_gradient = np.array([[sample_data[2], 
-            sample_data[3], sample_data[4]], [sample_data[5], 
-            sample_data[6], sample_data[7]], [sample_data[8], 
-            sample_data[9], sample_data[10]]])
+            displacement_gradient = np.array([[sample_data[0], 
+            sample_data[1], sample_data[2]], [sample_data[3], 
+            sample_data[4], sample_data[5]], [sample_data[6], 
+            sample_data[7], sample_data[8]]])
 
             # Gets the corresponding deformation gradient
 
@@ -118,7 +118,7 @@ final_time):
                 new_disp_grad[0,1], new_disp_grad[0,2], new_disp_grad[
                 1,0], new_disp_grad[1,1], new_disp_grad[1,2], 
                 new_disp_grad[2,0], new_disp_grad[2,1], new_disp_grad[
-                2,2], sample_data[0], sample_data[1]])
+                2,2], sample_data[9], sample_data[10]])
 
                 # Adds this sample to the filtered input data. Inserts 
                 # the load-based data as the first columns, since this 
@@ -137,18 +137,20 @@ final_time):
         new_input_list = np.array(new_input_list)
 
         print("The new input data matrix has shape "+str(
-        new_input_list.shape)+", whereas it had "+str(input_data.shape[0
-        ])+" rows before.\nThe displacement matrix, on the other hand,"+
-        " has "+str(displacement_matrix.shape[0])+"\n")
+        new_input_list.shape)+", whereas it had the shape "+str(
+        input_data.shape)+" before.\nThe displacement matrix, on the o"+
+        "ther hand, has shape equal to "+str(displacement_matrix.shape)+
+        "\n")
 
         np.save(results_path+"//"+new_input_file, new_input_list)
 
         new_filtered_input_list = np.array(new_filtered_input_list)
 
         print("The new filtered input data matrix has shape "+str(
-        new_filtered_input_list.shape)+", whereas it had "+str(
-        input_data.shape[0])+" rows before.\nThe displacement matrix, "+
-        "on the other hand, has "+str(displacement_matrix.shape[0])+"\n")
+        new_filtered_input_list.shape)+", whereas it had the shape "+str(
+        input_data.shape)+" before.\nThe displacement matrix, on th"+
+        "e other hand, has shape equal to "+str(displacement_matrix.shape
+        )+"\n")
 
         np.save(results_path+"//"+new_filtered_input_file, 
         new_filtered_input_list)

{davout-0.1.1.dev181 → davout-0.1.1.dev183}/source/Davout/DeepMech/aa_tests/SVD_framework/kinematics_surrogate_model.py

@@ -5,6 +5,10 @@ import numpy as np
 
 import tensorflow as tf
 
+from .....Davout.DeepMech.tool_box.gpu_tools import give_access_of_gpu_to_tensorflow
+
+give_access_of_gpu_to_tensorflow(True)
+
 from time import time
 
 from .....Davout.DeepMech.tool_box import ANN_tools, training_tools
@@ -28,8 +32,7 @@ class RVEKinematicsSurrogateModel:
     maximum_training_iterations, verbose_delta_iterations,
     mesh_file_name, optimizer, subdofs_to_learn, parameters_dtype="flo"+
     "at32", householder_epsilon=1.0, verbose=True, integer_dtype="int3"+
-    "2", get_all_inputs_to_zeroth_order_of_magnitude=False, 
-    non_orthogonal_matrices=False, device_type="CPU", 
+    "2", non_orthogonal_matrices=False, device_type="CPU", 
     input_data_regularization_method=None):
 
         # Saves the needed information
@@ -38,9 +41,6 @@ class RVEKinematicsSurrogateModel:
 
         self.device_type = device_type
 
-        self.get_all_inputs_to_zeroth_order_of_magnitude = (
-        get_all_inputs_to_zeroth_order_of_magnitude)
-
         self.activations_list_main_network = activations_list_main_network
 
         self.activations_list_auxiliar_network = (
@@ -89,7 +89,7 @@ class RVEKinematicsSurrogateModel:
         # Converts the tensor of DOFs to a tensorflow integer tensor
 
         self.subdofs_to_learn = tf.convert_to_tensor(subdofs_to_learn,
-        dtype=tf.as_dtype(self.parameters_dtype))
+        dtype=tf.as_dtype(self.integer_dtype))
 
         # Gets the number of output neurons from the tensor of the indi-
         # ces of the DOFs that will actually be learnt
@@ -98,13 +98,31 @@ class RVEKinematicsSurrogateModel:
 
         # Reads the output data 
 
-        self.output_data = np.load(self.results_path+"//"+
+        self.whole_output_data = np.load(self.results_path+"//"+
         self.displacement_data_file)
 
         # Gets the numbers of samples and of total of DOFs
 
         self.number_of_samples, self.total_number_of_dofs = (
-        self.output_data.shape)
+        self.whole_output_data.shape)
+
+        # Checks whether subdofs to learn has any DOF index that is lar-
+        # ger than the number of DOFs of the output data
+
+        if tf.reduce_max(self.subdofs_to_learn).numpy(
+        )>=self.total_number_of_dofs:
+
+            raise IndexError("The maximum DOF index requested by 'subd"+
+            "ofs_to_learn' is "+str(tf.reduce_max(self.subdofs_to_learn
+            ).numpy())+". But the output data at\n"+str(
+            self.results_path+"//"+self.displacement_data_file)+"\nhas"+
+            " only "+str(self.total_number_of_dofs)+" columns")
+
+        # Otherwise, uses the subdofs to learn to retrieve the needed 
+        # DOFs for training
+
+        self.output_data = self.whole_output_data[:,
+        self.subdofs_to_learn]
 
         # Gets the input data
 
@@ -343,9 +361,26 @@ class RVEKinematicsSurrogateModel:
 
 if __name__=="__main__":
 
+     # Sets the number of transfinite divisions in the RVE mesh
+
+    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
+
+    dofs_per_number_of_divisions = {6: 3993, 8: 10125, 10: 20577}
+
     # Defines the array with the DOFs to be learnt
 
-    subdofs_to_learn = np.arange(0, 20577, 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]. 
@@ -358,7 +393,7 @@ if __name__=="__main__":
     # Defines the number of neurons of the different hidden layers and of
     # the output layer
 
-    n_neurons_per_layer = [100, 1000, 20577]
+    n_neurons_per_layer = [100, 1000, subdofs_to_learn.shape[0]]
 
     # Sets a list of layers and the activation functions
 
@@ -366,11 +401,12 @@ if __name__=="__main__":
     n_neurons_per_layer[0]}}, {"elu": {"number of neurons":
     n_neurons_per_layer[1]}}, {"linear": n_neurons_per_layer[2]}]
 
-    activations_list_auxiliar_network = [{"quadratic": {"number"+
-    " of neurons": min(quotient_space_dimension, n_neurons_per_layer[0]),
-    "a2": 1.0}}, {"quadratic":  {"number of neurons": min(
-    n_neurons_per_layer[0], n_neurons_per_layer[1]), "a2": 1.0}}, {"qu"+
-    "adratic": {"number of neurons": min(n_neurons_per_layer[1],
+    activations_list_auxiliar_network = [{"quadratic": {"number of neu"+
+    "rons": min(quotient_space_dimension, n_neurons_per_layer[0]), "a2": 
+    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],
     n_neurons_per_layer[2])}}]
 
     # Sets the modulating function for the weights matrices
@@ -387,21 +423,25 @@ 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"
 
+    loss_metric = {"name": "LpNormError", "p": 12, "use_stable_impleme"+
+    "ntation": True}
+
     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
 
-    results_path = get_parent_path_of_file()+"//results"
+    results_path = (get_parent_path_of_file()+"//results_n_divisions_"+
+    str(n_divisions))
    
     displacement_data_file = "00_successful_displacement_matrix.npy"
 
@@ -411,12 +451,8 @@ if __name__=="__main__":
 
     # Sets the method to regularize the input data matrix
 
-    input_data_regularization_method = None
-
-    # Sets if the input data must be put into the same order of magnitu-
-    # de
-
-    get_all_inputs_to_zeroth_order_of_magnitude = False
+    input_data_regularization_method = ("maximum_absolute_order_normal"+
+    "ization")
 
     # Sets the device type where the training will be performed
 
@@ -425,7 +461,7 @@ if __name__=="__main__":
     # Sets whether the constraint on orthogonality of the SVD matrices
     # will not be enforced
 
-    non_orthogonal_matrices = False
+    non_orthogonal_matrices = True
 
     # Instantiates the class that owns all information about training 
     # and testing models
@@ -438,9 +474,7 @@ if __name__=="__main__":
     n_best_models, n_best_samples, maximum_training_iterations, 
     verbose_delta_iterations, mesh_file_name, optimizer, 
     subdofs_to_learn, parameters_dtype=parameters_dtype, 
-    householder_epsilon=1.0, verbose=True, 
-    get_all_inputs_to_zeroth_order_of_magnitude=
-    get_all_inputs_to_zeroth_order_of_magnitude, device_type=
+    householder_epsilon=1.0, verbose=True, device_type=
     device_type, non_orthogonal_matrices=non_orthogonal_matrices,
     input_data_regularization_method=input_data_regularization_method)
 

davout-0.1.1.dev183/source/Davout/DeepMech/tool_box/gpu_tools.py

@@ -0,0 +1,21 @@
+# Routine to store methods to set the GPU for tensorflow
+
+import tensorflow as tf
+
+# Defines a function to set the access of tensorflow to the GPU
+
+def give_access_of_gpu_to_tensorflow(flag_to_use_gpu):
+
+    # Checks whether the flag for tensorflow to use the GPU is false
+
+    if not flag_to_use_gpu:
+
+        # Disables the GPU if necessary
+
+        tf.config.set_visible_devices([], 'GPU')
+
+    print(tf.config.list_physical_devices('CPU'))
+
+    print(tf.config.list_physical_devices('GPU'))
+
+    print("Visible GPUs:", tf.config.get_visible_devices("GPU"))