SAMBA-ilum 1.0.0.450__tar.gz → 1.0.0.452__tar.gz

{samba_ilum-1.0.0.450 → samba_ilum-1.0.0.452}/PKG-INFO

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

{samba_ilum-1.0.0.450 → samba_ilum-1.0.0.452}/SAMBA_ilum.egg-info/PKG-INFO

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

{samba_ilum-1.0.0.450 → samba_ilum-1.0.0.452}/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.450'
+version = '1.0.0.452'
 
 print(" ")
 print("=============================================================")

{samba_ilum-1.0.0.450 → samba_ilum-1.0.0.452}/samba_ilum/src/HeteroStructure_Generator.py

@@ -1228,8 +1228,8 @@ if (n_test == 1):
                  V1 = 0.5*B1; V2 = 0.5*B2
                  if (n_Lattice == 3):  V3 = 0.5*B3
               #-----------------------------------
-              angle = np.arctan2(np.cross(V1, V2), np.dot(V1, V2))  # ângulo de radianos
-              angle0 = np.degrees(angle)
+              angle_V12 = np.arctan2(np.cross(V1, V2), np.dot(V1, V2))  # ângulo em radianos
+              angle0 = np.degrees(angle_V12)
               if (abs(angle0) == 0.0):  angle0 = 0.0
               #-----------------------------------------------------------------
               # if (angle0 < 10):                    angle1 = '00' + str(angle0)
@@ -1241,8 +1241,8 @@ if (n_test == 1):
               angle1 = str(angle0)
               #=================================================================
               if (n_Lattice == 3):
-                 angle = np.arctan2(np.cross(V1, V3), np.dot(V1, V3))  # ângulo de radianos
-                 angle2 = np.degrees(angle)
+                 angle_V13 = np.arctan2(np.cross(V1, V3), np.dot(V1, V3))  # ângulo em radianos
+                 angle2 = np.degrees(angle_V13)
                  if (abs(angle2) == 0.0):  angle2 = 0.0
                  #-----------------------------------------------------------------
                  # if (angle2 < 10):                    angle3 = '00' + str(angle2)
@@ -1308,41 +1308,40 @@ if (n_test == 1):
                  mod_B2 = np.linalg.norm(B2)
                  Area1 = np.linalg.norm(np.cross(A1, B1))
                  Area2 = np.linalg.norm(np.cross(A2, B2))
-                 angle_1 = np.arctan2(np.cross(A1, B1), np.dot(A1, B1))  # ângulo de radianos
-                 angle_2 = np.arctan2(np.cross(A2, B2), np.dot(A2, B2))  # ângulo de radianos
+                 angle_1 = np.arctan2(np.cross(A1, B1), np.dot(A1, B1))  # ângulo em radianos
+                 angle_2 = np.arctan2(np.cross(A2, B2), np.dot(A2, B2))  # ângulo em radianos
                  if (n_Lattice == 3):
                     mod_A3 = np.linalg.norm(A3)
                     mod_B3 = np.linalg.norm(B3)
                     Area3 = np.linalg.norm(np.cross(A3, B3))
-                    angle_3 = np.arctan2(np.cross(A3, B3), np.dot(A3, B3))  # ângulo de radianos
-
-                 #------------------------------------------------------------------------------------------------------------------------
-                 # 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(angle_2); sin = np.sin(angle_2)
-                 matriz_rotacao = np.array([[cos, -sin], [sin, cos]])
-                 temp_B2 = matriz_rotacao @ ((A1/mod_A1)*mod_B2)
-                 #----------------------------------------------------
+                    angle_3 = np.arctan2(np.cross(A3, B3), np.dot(A3, B3))  # ângulo em radianos
+
+                 #----------------------------------------------------------------------------------------------------------------
+                 # Alinhando a célula das redes a fim de criar a célula intermediária --------------------------------------------
+                 #----------------------------------------------------------------------------------------------------------------
+                 theta = angle_V12;  rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+                 A2_rotated = np.dot(rotation_matrix, A2)
+                 theta = angle_2;  rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+                 B2_rotated = np.dot(rotation_matrix, A2_rotated)
+                 #-----------------------------------------------
                  if (n_Lattice == 3):
-                    temp_A3 = (A1/mod_A1)*mod_A3
-                    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)
+                    theta = angle_V13;  rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+                    A3_rotated = np.dot(rotation_matrix, A3)
+                    theta = angle_3;  rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+                    B3_rotated = np.dot(rotation_matrix, A3_rotated)
                  #-------------------------------------------------------
                  # Vetores que definem a célula intermediária -----------
                  #-------------------------------------------------------
                  if (n_Lattice == 2):
-                    A_int = (A1 + temp_A2)/2
-                    B_int = (B1 + temp_B2)/2
+                    A_int = (A1 + A2_rotated)/2
+                    B_int = (B1 + B2_rotated)/2
                  if (n_Lattice == 3):
-                    A_int = (A1 + temp_A2 + temp_A3)/3
-                    B_int = (B1 + temp_B2 + temp_B3)/3
+                    A_int = (A1 + A2_rotated + A3_rotated)/3
+                    B_int = (B1 + B2_rotated + B3_rotated)/3
                  mod_A_int = np.linalg.norm(A_int)
                  mod_B_int = np.linalg.norm(B_int)
                  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))
+                 angle_int = np.arctan2(np.cross(A_int,B_int), np.dot(A_int,B_int))
 
                  #------------------------------------------------------------------------------------------------------------------------
                  # Utilização de vetores temporários (A,B) a fim de estimar a deformação sofrida pelas células originais -----------------
@@ -1416,13 +1415,12 @@ 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]] ]
+                 Lattice_B = [ [A2_rotated[0], A2_rotated[1]], [B2_rotated[0], B2_rotated[1]] ]
+                 if (n_Lattice == 3):
+                    Lattice_C = [ [A3_rotated[0], A3_rotated[1]], [B3_rotated[0], B3_rotated[1]] ]
+                 Lattice_D = [ [A_int[0], A_int[1]], [B_int[0], B_int[1]] ]
+                 #---------------------------------------------------------
                  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)
@@ -1436,7 +1434,7 @@ if (n_test == 1):
                          if (MStrain_A[aa][bb] == -0.0): MStrain_A[aa][bb] = 0.0
                  #--------------------------------------------------------------
                  Lattice_B_inv = np.linalg.inv(Lattice_B)
-                 F_B = np.dot(Lattice_E, Lattice_B_inv)
+                 F_B = np.dot(Lattice_D, Lattice_B_inv)
                  MStrain_B = 0.5 * (np.dot(F_B.T, F_B) - I)
                  for aa in range(2):
                      for bb in range(2):
@@ -1449,7 +1447,7 @@ if (n_test == 1):
                  #--------------------------------------------------------------
                  if (n_Lattice == 3): 
                     Lattice_C_inv = np.linalg.inv(Lattice_C)
-                    F_C = np.dot(Lattice_F, Lattice_C_inv)
+                    F_C = np.dot(Lattice_D, Lattice_C_inv)
                     MStrain_C = 0.5 * (np.dot(F_C.T, F_C) - I)
                     for aa in range(2):
                         for bb in range(2):
@@ -1502,8 +1500,8 @@ if (n_test == 1):
                  poscar_new.write(f' | {ID_Heteroestrutura} \n')
                  #----------------------------------------------
                  poscar_new.write(f'1.0 \n')
-                 poscar_new.write(f'{A4[0]} {A4[1]} 0.0 \n')
-                 poscar_new.write(f'{B4[0]} {B4[1]} 0.0 \n')
+                 poscar_new.write(f'{A_int[0]} {A_int[1]} 0.0 \n')
+                 poscar_new.write(f'{B_int[0]} {B_int[1]} 0.0 \n')
 
                  VTemp1 = poscar1.readline().split()
                  VTemp2 = poscar2.readline()

{samba_ilum-1.0.0.450 → samba_ilum-1.0.0.452}/setup.py

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