Davout 0.1.1.dev147__tar.gz → 0.1.1.dev148__tar.gz

{davout-0.1.1.dev147/source/Davout.egg-info → davout-0.1.1.dev148}/PKG-INFO

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

{davout-0.1.1.dev147 → davout-0.1.1.dev148}/pyproject.toml

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

{davout-0.1.1.dev147 → davout-0.1.1.dev148}/source/Davout/DeepMech/aa_tests/tests_tool_box/test_SVD_based_NNs.py

@@ -366,6 +366,11 @@ class TestSVDArchitecture:
 
         modulating_function_performance = "identity"
 
+        # Gets the training data as a tensorflow array
+
+        self.training_input_constant = tf.constant(self.training_data, 
+        dtype=tf.as_dtype(self.parameters_dtype))
+
         # Defines a function to get the true values for the performance
         # test
         
@@ -723,8 +728,15 @@ if __name__=="__main__":
     # Creates a list of methods (using their names) that are not to be
     # tested
 
-    reserved_methods = ["test_training_model", "test_monte_carlo_training_model",
-    "test_quotient_space_invariance_model", "test_convexity_in_quotient_space"]
+    #"""
+    reserved_methods = ["test_assembling_model", "test_saving_and_load"+
+    "ing", "test_input_and_parameters", "test_derivative", "test_train"+
+    "ing_model", "test_monte_carlo_training_model", "test_quotient_spa"+
+    "ce_invariance_model", "test_convexity_in_quotient_space"]#"""
+
+    #reserved_methods = ["test_convexity_in_quotient_space"]
+
+    #reserved_methods = ["test_derivative_performance"]
 
     # Calls the function to run all the necessary tests
 

{davout-0.1.1.dev147 → davout-0.1.1.dev148}/source/Davout/DeepMech/custom_architectures/SVD_quotient_space.py

@@ -1041,7 +1041,8 @@ class SVDQuotientSpace:
                 # flector since the multiplication by a vector is from
                 # the right side
 
-                n_dofs_householder_vector = reflector_index+1
+                n_dofs_householder_vector = (reflector_index+
+                self.n_neurons_current_main_layer-self.weights_rank)
 
                 self.householder_first_index_A.append(
                 counter_parameters_A)
@@ -1120,6 +1121,38 @@ class SVDQuotientSpace:
         self.householder_number_of_leading_zeros_B, dtype=
         self.layer_self.code_given_info_class.int_dtype)
 
+    # TEST-TensorArray
+    # Defines a function to get a contiguous flat tensor and split it 
+    # into a set of vectors of different sizes. Each vector comprises
+    # the degrees of freedom of the corresponding Householder reflector
+
+    def split_flat_tensor_into_householder_dofs(self,
+    householder_parameters, householder_lengths):
+
+        # Splits the flat tensor of Householder DOFs of the whole chain
+
+        split_householder_raw_vectors = tf.split(householder_parameters,
+        householder_lengths)
+
+        householder_dofs_tensor_array = tf.TensorArray(dtype=
+        self.layer_self.code_given_info_class.float_dtype,
+        size=len(householder_lengths), infer_shape=False,
+        clear_after_read=False)
+
+        # Iterates over the python list generated by tf.split to write
+        # the individual components into the TensorArray that stores the
+        # raw vector of DOFs of each Householder reflector
+
+        for i, split_householder_raw_vector in enumerate(
+        split_householder_raw_vectors):
+
+            householder_dofs_tensor_array = householder_dofs_tensor_array.write(
+            i, split_householder_raw_vector)
+
+        # Returns the TensorArray only
+
+        return householder_dofs_tensor_array
+
     # Defines a function to multiply the result of the multiplication of
     # the input vector by the B matrix then by the tensor of singular 
     # values. This function is for the case of identity modulation func-
@@ -1194,52 +1227,9 @@ class SVDQuotientSpace:
         # rank, p_i]. The final result must be [n_samples, rank, p_i]
 
         return (singular_values[:,:,None]*B_matrix[None,:,:])
-    
-    # Defines a function to parse a single Householder vector from a
-    # vector of all Householder vectors to construct an orthogonal ma-
-    # trix. The incoming vector is a tensor [0.5*(m_rank*((2*n_rows)-
-    # m_rank-1))], where m_rank is the number of columns of the final 
-    # orthogonal matrix, and n_rows is the number of rows. Receives the
-    # index of the Householder reflector in the Householder chain to
-    # collect the corresponding Householder vector
-
-    def get_householder_vector_from_parameters(self, 
-    householder_first_index, householder_length, 
-    householder_number_of_leading_zeros, householder_parameters, 
-    householder_reflector_index, input_dimensionality):
-        
-        # Gets the first and last indices of the Householder vector, 
-        # then the vector that will become the Householder vector
 
-        initial_index = householder_first_index[
-        householder_reflector_index]
-
-        length = householder_length[householder_reflector_index]
-
-        number_of_leading_zeros = householder_number_of_leading_zeros[
-        householder_reflector_index]
-
-        raw_vector = tf.slice(householder_parameters, [initial_index], [
-        length])
-
-        # Computes the average of the raw vector
-
-        average_raw_vector = tf.reduce_mean(raw_vector)
-
-        # Concatenates the non-free component of the Householder vector
-        # to the first position
-
-        raw_vector = tf.concat([tf.sqrt((average_raw_vector*
-        average_raw_vector)+self.householder_epsilon_squared)[None], 
-        raw_vector], axis=0)
-
-        # Rescales the raw vector to have unit norm, then adds the trai-
-        # ling zeros and returns it
-
-        return tf.pad(tf.math.l2_normalize(raw_vector), [[
-        number_of_leading_zeros, 0]])
-
-    # Defines the same function but XLA-compliant
+    # Defines the same function as get_householder_vector_from_parameters
+    # but XLA-compliant
 
     def get_householder_vector_from_parameters_XLA_compliant(self, 
     householder_first_index, householder_length,
@@ -1332,6 +1322,60 @@ class SVDQuotientSpace:
 
         return householder_vector
     
+    # Defines a function to parse a single Householder vector from a
+    # vector of all Householder vectors to construct an orthogonal ma-
+    # trix. The incoming vector is a tensor [0.5*(m_rank*((2*n_rows)-
+    # m_rank-1))], where m_rank is the number of columns of the final 
+    # orthogonal matrix, and n_rows is the number of rows. Receives the
+    # index of the Householder reflector in the Householder chain to
+    # collect the corresponding Householder vector
+    
+    def get_householder_vector_from_parameters(self, 
+    householder_first_index, householder_length, 
+    householder_number_of_leading_zeros, 
+    #split_householder_DOFs,
+    #householder_parameters, 
+    householder_dofs_tensor_array,
+    householder_reflector_index, input_dimensionality):
+        
+        # Gets the first and last indices of the Householder vector, 
+        # then the vector that will become the Householder vector
+
+        initial_index = householder_first_index[
+        householder_reflector_index]
+
+        length = householder_length[householder_reflector_index]
+
+        number_of_leading_zeros = householder_number_of_leading_zeros[
+        householder_reflector_index]
+
+        """
+        raw_vector = tf.slice(householder_parameters, [initial_index], [
+        length])#"""
+
+        #raw_vector = split_householder_DOFs[householder_reflector_index]
+
+        # TensorArray
+        #"""
+        raw_vector = householder_dofs_tensor_array.read(
+        householder_reflector_index) #"""
+
+        # Computes the average of the raw vector
+
+        average_raw_vector = tf.reduce_mean(raw_vector)
+
+        # Concatenates the non-free component of the Householder vector
+        # to the first position
+
+        raw_vector = tf.math.l2_normalize(tf.concat([tf.sqrt(
+        tf.math.square(average_raw_vector)+
+        self.householder_epsilon_squared)[None], raw_vector], axis=0))
+
+        # Rescales the raw vector to have unit norm, then adds the trai-
+        # ling zeros and returns it
+
+        return raw_vector, number_of_leading_zeros
+    
     # Defines a function to evaluate the multiplication of one Househol-
     # der reflector of the Householder chain of one of the two orthogo-
     # nal matrices of the SVD decomposition (A*diag(sigma)*transpose(B))
@@ -1342,24 +1386,35 @@ class SVDQuotientSpace:
     def multiply_input_vector_by_householder_reflector(self, 
     input_vector, householder_reflector_index, householder_first_index, 
     householder_length, householder_number_of_leading_zeros, 
-    householder_parameters_orthogonal_matrix, input_dimensionality):
+    #split_householder_DOFs,
+    #householder_parameters_orthogonal_matrix, 
+    householder_dofs_tensor_array,
+    input_dimensionality):
         
         # Gets the Householder vector from the Householder parameters of
         # the B matrix. Keep in mind that the order of the Householder 
         # chain of the B matrix is versed with respect to the A matrix,
         # since B is transposed in the SVD
 
-        householder_vector = self.method_for_householder_vector_from_parameters(
+        (householder_vector_core, number_of_leading_zeros
+        ) = self.method_for_householder_vector_from_parameters(
         householder_first_index, householder_length, 
         householder_number_of_leading_zeros, 
-        householder_parameters_orthogonal_matrix, 
+        #split_householder_DOFs,
+        #householder_parameters_orthogonal_matrix, 
+        householder_dofs_tensor_array,
         householder_reflector_index, input_dimensionality)
 
         # Multiplies the input vector by the Householder reflector (the
-        # operation is already broken down into the rank-1 calculation)
-
-        return input_vector-(self.two*tf.reduce_sum(input_vector*
-        householder_vector, axis=-1, keepdims=True)*householder_vector)
+        # operation is already broken down into the rank-1 calculation).
+        # Note that the multiplication by the Householder vector is done
+        # only for the non-zero components and that the result is padded
+        # to be added to the original input vector
+
+        return input_vector+tf.pad(-(self.two*tf.einsum('bi,i->b', 
+        input_vector[:,number_of_leading_zeros:], 
+        householder_vector_core)[:,None]*householder_vector_core[None,:]
+        ), [[0,0], [number_of_leading_zeros,0]])
     
     # Defines a function to create a wrapper for the method that multi-
     # plies the input vector by an orthogonal matrix and, then, calls
@@ -1370,24 +1425,40 @@ class SVDQuotientSpace:
     householder_reflector_indices, householder_first_index, 
     householder_length, householder_number_of_leading_zeros, 
     householder_parameters_orthogonal_matrix, input_dimensionality):
-        
-        # Iterates through the indices of Householder reflectors
 
-        for householder_reflector_index in householder_reflector_indices:
+        # Splits the Householder DOFs of each Householder vector from 
+        # the flat tensor of DOFs of the chain
+
+        #split_householder_DOFs = tf.split(
+        #householder_parameters_orthogonal_matrix, householder_length)
+
+        """
+        split_householder_DOFs = tf.RaggedTensor.from_row_lengths(
+        householder_parameters_orthogonal_matrix,
+        householder_length)#"""
 
-            # Updates the input vector by recursive multiplication of
-            # reflectors of the Householder chain
+        #"""
+        householder_dofs_tensor_array = self.split_flat_tensor_into_householder_dofs(
+        householder_parameters_orthogonal_matrix, householder_length)#"""
 
-            input_vector = self.multiply_input_vector_by_householder_reflector(
-            input_vector, householder_reflector_index, 
+        # Defines the step function that will perform each update of the
+        # input tensor by means of the Householder reflector
+
+        def update_step(accumulator_vector, householder_reflector_index):
+
+            return self.multiply_input_vector_by_householder_reflector(
+            accumulator_vector, householder_reflector_index, 
             householder_first_index, householder_length, 
             householder_number_of_leading_zeros, 
-            householder_parameters_orthogonal_matrix, 
+            #split_householder_DOFs,
+            #householder_parameters_orthogonal_matrix,
+            householder_dofs_tensor_array,
             input_dimensionality)
 
-        # Returns the updated input vector
+        # Uses foldl to perform the chain multiplication
 
-        return input_vector
+        return tf.foldl(update_step, householder_reflector_indices,
+        initializer=input_vector)
     
     # Defines a function to evaluate the multiplication of the Househol-
     # der chain of the transposed B matrix of the SVD decomposition (A*
@@ -1410,12 +1481,19 @@ class SVDQuotientSpace:
             # Householder chain of the B matrix is reversed with respect 
             # to the A matrix, since B is transposed in the SVD
 
-            householder_vector = self.method_for_householder_vector_from_parameters(
+            (householder_vector_core, number_of_leading_zeros
+            ) = self.method_for_householder_vector_from_parameters(
             householder_first_index_B, householder_length_B, 
             householder_number_of_leading_zeros_B, 
             householder_parameters_B_matrix, householder_reflector_index,
             input_dimensionality)
 
+            # Gets the Householder vector by padding the core with the
+            # leading zeros
+
+            householder_vector = tf.pad(householder_vector_core, [[
+            number_of_leading_zeros, 0]])
+
             # Multiplies the partially reconstructed B matrix by the 
             # Householder reflector to the left. However, the structure 
             # of the rank-1 projection is taken advantage of
@@ -1446,12 +1524,19 @@ class SVDQuotientSpace:
             # Gets the Householder vector from the Householder parameters 
             # of the A matrix
 
-            householder_vector = self.method_for_householder_vector_from_parameters(
+            (householder_vector_core, number_of_leading_zeros
+            ) = self.method_for_householder_vector_from_parameters(
             householder_first_index_A, householder_length_A, 
             householder_number_of_leading_zeros_A, 
             householder_parameters_A_matrix, householder_reflector_index,
             input_dimensionality)
 
+            # Gets the Householder vector by padding the core with the
+            # leading zeros
+
+            householder_vector = tf.pad(householder_vector_core, [[
+            number_of_leading_zeros, 0]])
+
             # Multiplies the partially reconstructed A matrix by the 
             # Householder reflector to the left. However, the structure 
             # of the rank-1 projection is taken advantage of. The multi-

{davout-0.1.1.dev147 → davout-0.1.1.dev148}/source/Davout/DeepMech/tool_box/differentiation_tools.py

@@ -172,8 +172,8 @@ class ScalarGradientWrtTrainableParamsGivenParameters:
 
         self.parameters_type = parameters_type
 
-        self.model_trainable_parameters = tf.Variable(tf.constant(
-        model_initial_parameters, dtype=self.parameters_type))
+        #self.model_trainable_parameters = tf.Variable(tf.constant(
+        #model_initial_parameters, dtype=self.parameters_type))
 
     # Defines a helper function to enable the true values of y argument
     # even though the original scalar function does not use it
@@ -224,16 +224,11 @@ class ScalarGradientWrtTrainableParamsGivenParameters:
 
     def evaluate_scalar_function(self, trainable_parameters):
 
-        # Sets the trainable variables to the variable tensor for ease 
-        # of differentiation
-
-        self.model_trainable_parameters.assign(tf.cast(
-        trainable_parameters, self.parameters_type))
-
         # Gets the response of the model
         
         y = self.model_output_given_parameters(self.input_tensor, 
-        self.model_trainable_parameters)
+        tf.convert_to_tensor(trainable_parameters, dtype=
+        self.parameters_type))
 
         # Gets the scalar function value and returns it
 
@@ -289,17 +284,12 @@ class ScalarGradientWrtTrainableParamsGivenParameters:
 
     def __call__(self, trainable_parameters):
 
-        # Sets the trainable variables to the variable tensor for ease 
-        # of differentiation
-
-        self.model_trainable_parameters.assign(tf.cast(
-        trainable_parameters, self.parameters_type))
-
         # Calls the loss function and the gradient using the same func-
-        # tion to spare computational effort
+        # tion to spare computational effort. But converts the input to
+        # a tensorflow tensor first
 
-        return self.joint_loss_gradient_method(
-        self.model_trainable_parameters)
+        return self.joint_loss_gradient_method(tf.convert_to_tensor(
+        trainable_parameters, dtype=self.parameters_type))
     
     # Defines a function to update the scalar function if it is parame-
     # terizable by externally-given quantities

davout-0.1.1.dev148/source/Davout/GraphUtilities/aa_tests/strain_tensors.py

@@ -0,0 +1,127 @@
+# Routine to demonstrate the differences between the Green-Lagrange and
+# infinitesimal strain tensors
+
+import matplotlib.pyplot as plt
+
+import numpy as np
+
+# Defines a function to evaluate the rotation tensor as a function of 
+# time
+
+def rotation_tensor(t):
+
+    theta = 0.5*np.pi*t
+
+    c = np.cos(theta)
+
+    s = np.sin(theta)
+
+    return np.array([[c, s, 0.0], [-s, c, 0.0], [0.0, 0.0, 1.0]])
+
+# Defines a function to evaluate the stretch tensor 
+
+def stretch_tensor(t):
+
+    T = min(t, 1.0)
+
+    return np.array([[T, 0.0, 0.0], [0.0, T*T, 0.0], [0.0, 0.0, 1.0]])
+
+# Defines the displacement as a linear mapping
+
+def displacement_field(t, material_position_vector):
+
+    # Evaluates the rotation and stretch tensors
+
+    R = rotation_tensor(t)
+
+    U = stretch_tensor(t)
+
+    # Evaluates the displacement field
+
+    return np.einsum('ik,k->i', np.einsum('ij,jk->ik', R, U)-np.eye(3), 
+    material_position_vector)
+
+# Defines a function to evaluate the deformation gradient
+
+def deformation_gradient(t):
+
+    # Evaluates the rotation and stretch tensors
+
+    R = rotation_tensor(t)
+
+    U = stretch_tensor(t)
+
+    return np.matmul(R, U)+np.eye(3)
+
+# Defines a function to compute the Green-Lagrange strain tensor
+
+def green_lagrange_strain(t):
+
+    # Evaluates the deformation gradient
+
+    F = deformation_gradient(t)
+
+    # Evaluates the Green-Lagrange strain tensor
+
+    return 0.5*(np.einsum('ji,jk->ik', F, F)-np.eye(3))
+
+# Defines a function to compute the infinitesimal strain tensor
+
+def infinitesimal_strain(t):
+
+    # Evaluates the deformation gradient
+
+    F = deformation_gradient(t)
+
+    return 0.5*(F.T+F)-np.eye(3)
+
+# Defines a function to compute the Frobenius norm of the difference of
+# the two tensors
+
+def difference_between_strain_tensors(t):
+
+    # Computes the Green-Lagrange and infinitesimal strain tensors
+
+    E = green_lagrange_strain(t)
+
+    epsilon = infinitesimal_strain(t)
+
+    # Returns the Frobenius norm
+
+    delta = E-epsilon
+
+    return np.linalg.norm(delta, ord="fro")
+
+# Test block
+
+if __name__=="__main__":
+
+    # Gets a set of time points
+
+    t_final = 1.0
+
+    t_initial = 0.0
+
+    t_range = np.linspace(t_initial, t_final, 50)
+
+    # Computes the difference between the two tensor as a function of time
+
+    differences = [difference_between_strain_tensors(t) for t in t_range]
+
+    plt.figure(figsize=(8, 5))
+
+    plt.plot(t_range, differences, color="crimson", linewidth=2)
+
+    plt.xlabel("Time $t$ / Deformation Magnitude", fontsize=11)
+
+    plt.ylabel(r"Frobenius Norm $\|\mathbf{E} - \mathbf{\epsilon}\|_F$",
+    fontsize=11)
+
+    plt.title("Divergence between Green-Lagrange and Infinitesimal Str"+
+    "ain", fontsize=12)
+
+    plt.grid(True, linestyle="--", alpha=0.6)
+
+    plt.tight_layout()
+
+    plt.show()

{davout-0.1.1.dev147 → davout-0.1.1.dev148}/source/Davout/PythonicUtilities/testing_tools.py

@@ -182,8 +182,8 @@ n_evaluations_to_show_memory_data=None, ten_notation=" E"):
 
     print("The "+str(n_warm_up_runs)+" warm-up runs took "+
     terminal_color(warm_up_time, "green")+" seconds. Thus, it is estim"+
-    "ated\nthat the "+terminal_color(n_evaluation_runs, "yellow")+"eva"+
-    "luation runs will took "+terminal_color(estimated_time, "bold red")
+    "ated\nthat the "+terminal_color(n_evaluation_runs, "yellow")+" ev"+
+    "aluation runs will took "+terminal_color(estimated_time, "bold red")
     +" seconds\nNow, the computer strikes its clock at "+terminal_color(
     current_computer_time.strftime('%H:%M:%S'), "bold light blue")+";"+
     "\nthe evaluations are estimated to be completed at "+terminal_color(

{davout-0.1.1.dev147 → davout-0.1.1.dev148/source/Davout.egg-info}/PKG-INFO

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

{davout-0.1.1.dev147 → davout-0.1.1.dev148}/source/Davout.egg-info/SOURCES.txt

@@ -140,6 +140,7 @@ source/Davout/GraphUtilities/aa_tests/cauchy_tetrahedron.py
 source/Davout/GraphUtilities/aa_tests/continuum_mechanics_potato_collage.py
 source/Davout/GraphUtilities/aa_tests/fake_book_spines.py
 source/Davout/GraphUtilities/aa_tests/null_space_architecture.py
+source/Davout/GraphUtilities/aa_tests/strain_tensors.py
 source/Davout/GraphUtilities/aa_tests/tests_collage_tools.py
 source/Davout/GraphUtilities/aa_tests/tests_delaunay.py
 source/Davout/GraphUtilities/aa_tests/tests_paraview_tools.py