SAMBA-ilum 1.0.0.445__tar.gz → 1.0.0.446__tar.gz

{samba_ilum-1.0.0.445 → samba_ilum-1.0.0.446}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: SAMBA_ilum
-Version: 1.0.0.445
+Version: 1.0.0.446
 Summary: ...
 Author: Augusto de Lelis Araujo
 Author-email: augusto-lelis@outlook.com

{samba_ilum-1.0.0.445 → samba_ilum-1.0.0.446}/SAMBA_ilum.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: SAMBA_ilum
-Version: 1.0.0.445
+Version: 1.0.0.446
 Summary: ...
 Author: Augusto de Lelis Araujo
 Author-email: augusto-lelis@outlook.com

{samba_ilum-1.0.0.445 → samba_ilum-1.0.0.446}/samba_ilum/__main__.py

@@ -16,7 +16,7 @@ dir_samba = os.path.dirname(os.path.realpath(__file__))
 print(f'{dir_samba}')
 #--------------------
 
-version = '1.0.0.445'
+version = '1.0.0.446'
 
 print(" ")
 print("=============================================================")

{samba_ilum-1.0.0.445 → samba_ilum-1.0.0.446}/samba_ilum/src/HeteroStructure_Generator.py

@@ -1338,18 +1338,25 @@ if (n_test == 1):
 
                  #------------------------------------------------------------------------------------------------------------------------
                  # Utilização de vetores temporários (A,B) a fim de auxilizar na criação da célula intermediária -------------------------
-                 # Por simplicidade, os vetores temp_A2 e temp_A3 são alinhados ao vetor A1, com temp_B2 e temp_B3 obtidos por rotação ---
                  #------------------------------------------------------------------------------------------------------------------------
-                 temp_A2 = (A1/mod_A1)*mod_A2
+                 cos = np.cos(angle0); sin = np.sin(angle0)
+                 matriz_rotacao = np.array([[cos, -sin], [sin, cos]])
+                 temp_A2 = matriz_rotacao @ A2                          # Rotacionando o vetor A2 por angle0, para coincidir com a região do vetor A1
+                 #----------------------------
                  cos = np.cos(angle_2); sin = np.sin(angle_2)
                  matriz_rotacao = np.array([[cos, -sin], [sin, cos]])
-                 temp_B2 = matriz_rotacao @ ((A1/mod_A1)*mod_B2)
-                 #----------------------------------------------------
+                 temp_B2 = matriz_rotacao @ ((temp_A2/mod_A2)*mod_B2)   # Usando a direção do vetor A2 rotacionado para criar B2 rotacionado 
+                 #---------------------------------------------------
                  if (n_Lattice == 3):
-                    temp_A3 = (A1/mod_A1)*mod_A3
+                    cos = np.cos(angle2); sin = np.sin(angle2)
+                    matriz_rotacao = np.array([[cos, -sin], [sin, cos]])
+                    temp_A3 = matriz_rotacao @ A3                          # Rotacionando o vetor A3 por angle0, para coincidir com a região do vetor A1
+                    #----------------------------
                     cos = np.cos(angle_3); sin = np.sin(angle_3)
                     matriz_rotacao = np.array([[cos, -sin], [sin, cos]])
-                    temp_B3 = matriz_rotacao @ ((A1/mod_A1)*mod_B3)
+                    temp_B3 = matriz_rotacao @ ((temp_A3/mod_A3)*mod_B3)   # Usando a direção do vetor A3 rotacionado para criar B3 rotacionado 
+                    #---------------------------------------------------
+
                  #-------------------------------------------------------
                  # Vetores que definem a célula intermediária -----------
                  #-------------------------------------------------------
@@ -1364,21 +1371,9 @@ if (n_test == 1):
                  Area_int = np.linalg.norm(np.cross(A_int, B_int))
                  angle_int = np.arccos(np.dot(A_int,B_int)/(mod_A_int*mod_B_int))
 
-                 #------------------------------------------------------------------------------------------------------------------------
-                 # Utilização de vetores temporários (A,B) a fim de estimar a deformação sofrida pelas células originais -----------------
-                 #------------------------------------------------------------------------------------------------------------------------
-                 A4 = (A1/mod_A1)*mod_A_int
-                 A5 = (A2/mod_A2)*mod_A_int
-                 if (n_Lattice == 3): A6 = (A3/mod_A3)*mod_A_int
-                 #-----------------------------------------------
-                 cos = np.cos(angle_int); sin = np.sin(angle_int)
-                 matriz_rotacao = np.array([[cos, -sin], [sin, cos]])
-                 #--------------------------------------------
-                 B4 = matriz_rotacao @ ((A1/mod_A1)*mod_B_int)
-                 B5 = matriz_rotacao @ ((A2/mod_A2)*mod_B_int)
-                 if (n_Lattice == 3):
-                    B6 = matriz_rotacao @ ((A3/mod_A3)*mod_B_int)
-                 #--------------------------------------------------------------------
+                 #------------------------------------------------------------
+                 # Estimando a deformação e mismatch sofrido pelas células ---
+                 #------------------------------------------------------------
                  var_A1 = ((mod_A_int -mod_A1)/mod_A1)*100;  var_A1 = round(var_A1, 4)
                  var_B1 = ((mod_B_int -mod_B1)/mod_B1)*100;  var_B1 = round(var_B1, 4)
                  var_A2 = ((mod_A_int -mod_A2)/mod_A2)*100;  var_A2 = round(var_A2, 4)
@@ -1436,13 +1431,16 @@ if (n_test == 1):
                  # Obtenção das Matrizes de Strain para cada rede =====
                  #=====================================================
                  Lattice_A = [ [A1[0], A1[1]], [B1[0], B1[1]] ]
-                 Lattice_B = [ [A2[0], A2[1]], [B2[0], B2[1]] ]
-                 if (n_Lattice == 3): Lattice_C = [ [A3[0], A3[1]], [B3[0], B3[1]] ]
-                 Lattice_D = [ [A4[0], A4[1]], [B4[0], B4[1]] ]
-                 Lattice_E = [ [A5[0], A5[1]], [B5[0], B5[1]] ]
-                 if (n_Lattice == 3): Lattice_F = [ [A6[0], A6[1]], [B6[0], B6[1]] ]
-                 I = np.eye(2)
+                 Lattice_B = [ [temp_A2[0], temp_A2[1]], [temp_B2[0], temp_B2[1]] ]
+                 if (n_Lattice == 3):
+                    Lattice_C = [ [temp_A3[0], temp_A3[1]], [temp_B3[0], temp_B3[1]] ]
+                 #---------------------------------------------
+                 Lattice_D = [ [A_int[0], A_int[1]], [B_int[0], B_int[1]] ]
+                 Lattice_E = Lattice_D
+                 if (n_Lattice == 3):
+                    Lattice_F = Lattice_D
                  #---------------------------------------
+                 I = np.eye(2)
                  Lattice_A_inv = np.linalg.inv(Lattice_A)
                  F_A = np.dot(Lattice_D, Lattice_A_inv)
                  MStrain_A = 0.5 * (np.dot(F_A.T, F_A) - I)

{samba_ilum-1.0.0.445 → samba_ilum-1.0.0.446}/setup.py

@@ -6,7 +6,7 @@ import json
 
 setup(
     name = "SAMBA_ilum",
-    version = "1.0.0.445",
+    version = "1.0.0.446",
     entry_points={'console_scripts': ['samba_ilum = samba_ilum:main']},
     description = "...",
     author = "Augusto de Lelis Araujo",