SAMBA-ilum 1.1.0.112__tar.gz → 1.1.0.114__tar.gz

{samba_ilum-1.1.0.112 → samba_ilum-1.1.0.114}/PKG-INFO

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

{samba_ilum-1.1.0.112 → samba_ilum-1.1.0.114}/SAMBA_ilum.egg-info/PKG-INFO

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

{samba_ilum-1.1.0.112 → samba_ilum-1.1.0.114}/samba_ilum/__main__.py

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

{samba_ilum-1.1.0.112 → samba_ilum-1.1.0.114}/samba_ilum/src/HeteroStructure_Generator.py

@@ -72,8 +72,8 @@ for k in range(n_Lattice):
     A1x0.append(A1x);  A1y0.append(A1y);  A2x0.append(A2x);  A2y0.append(A2y)   # Storing the vectors A1 and A2 of each lattice
     #--------------------------------------------------------------------------------------------------------------------------
     # Vectors A1 and A2
-    A1 = np.array([A1x, A1y])
-    A2 = np.array([A2x, A2y])
+    A1 = np.array([A1x, A1y, 0.0])
+    A2 = np.array([A2x, A2y, 0.0])
     #-------------------------------------------------------
     # unit cell area
     Area = np.linalg.norm(np.cross(A1, A2))
@@ -409,9 +409,9 @@ for k in range(n_Lattice):
             v2x = float(vx[j]); v2y = float(vy[j]); v2z = float(vz[j]); d2 = float(dist[j])
             #------------------------------------------------------------------------------
 
-            #--------------------------------------------------------------
-            vector1 = np.array([v1x, v1y]);  vector2 = np.array([v2x, v2y])
-            #--------------------------------------------------------------
+            #------------------------------------------------------------------------
+            vector1 = np.array([v1x, v1y, 0.0]);  vector2 = np.array([v2x, v2y, 0.0])
+            #------------------------------------------------------------------------
             Area = np.linalg.norm(np.cross(vector1, vector2))
             if (n_Lattice == 2):  n_ions = Area*(dens_ions[0] + dens_ions[1])
             if (n_Lattice == 3):  n_ions = Area*(dens_ions[0] + dens_ions[1] + dens_ions[2])
@@ -635,8 +635,8 @@ for s in range(len(files)):
                   #--------------------------------------------
                   # Criterion: area mismatch ------------------
                   #--------------------------------------------
-                  A1 = np.array([A1x[i], A1y[i]]);  B1 = np.array([B1x[i], B1y[i]]);  area_cell1 = np.linalg.norm(np.cross(A1, B1))
-                  A2 = np.array([A2x[j], A2y[j]]);  B2 = np.array([B2x[j], B2y[j]]);  area_cell2 = np.linalg.norm(np.cross(A2, B2))
+                  A1 = np.array([A1x[i], A1y[i], 0.0]);  B1 = np.array([B1x[i], B1y[i], 0.0]);  area_cell1 = np.linalg.norm(np.cross(A1, B1))
+                  A2 = np.array([A2x[j], A2y[j], 0.0]);  B2 = np.array([B2x[j], B2y[j], 0.0]);  area_cell2 = np.linalg.norm(np.cross(A2, B2))
                   var_area_cell1 = ((area_cell2 -area_cell1)/area_cell1)*100;  var_area_cell1 = round(var_area_cell1, 4)
                   var_area_cell2 = ((area_cell1 -area_cell2)/area_cell2)*100;  var_area_cell2 = round(var_area_cell2, 4)
                   #-------------------------------------------------------------------------------
@@ -651,8 +651,8 @@ for s in range(len(files)):
                   if (rot_angle_calc == 'A2'):
                      V1 = 0.5*B1
                      V2 = 0.5*B2
-                  #----------------------------------------------------------------------------
-                  angle_V12 = np.arctan2(np.cross(V2, V1), np.dot(V2, V1))   # angle in radians
+                  #-------------------------------------------------------------------------------
+                  angle_V12 = np.arctan2(np.cross(V2, V1)[2], np.dot(V2, V1))   # angle in radians
                   angle0 = np.degrees(angle_V12)
                   if (abs(angle0) == 0.0):  angle0 = 0.0
                   #-------------------------------------
@@ -777,8 +777,8 @@ if (n_Lattice == 3):
                      #--------------------------------------------
                      # Criterion: area mismatch ------------------
                      #--------------------------------------------
-                     A1 = np.array([A1x[i], A1y[i]]);  B1 = np.array([B1x[i], B1y[i]]);  area_cell1 = np.linalg.norm(np.cross(A1, B1))
-                     A3 = np.array([A3x[j], A3y[j]]);  B3 = np.array([B3x[j], B3y[j]]);  area_cell3 = np.linalg.norm(np.cross(A3, B3))
+                     A1 = np.array([A1x[i], A1y[i], 0.0]);  B1 = np.array([B1x[i], B1y[i], 0.0]);  area_cell1 = np.linalg.norm(np.cross(A1, B1))
+                     A3 = np.array([A3x[j], A3y[j], 0.0]);  B3 = np.array([B3x[j], B3y[j]]);  area_cell3 = np.linalg.norm(np.cross(A3, B3))
                      var_area_cell1 = ((area_cell3 -area_cell1)/area_cell1)*100;  var_area_cell1 = round(var_area_cell1, 4)
                      var_area_cell3 = ((area_cell1 -area_cell3)/area_cell3)*100;  var_area_cell3 = round(var_area_cell3, 4)
                      #-------------------------------------------------------------------------------
@@ -793,7 +793,7 @@ if (n_Lattice == 3):
                      if (rot_angle_calc == 'A2'):
                         V1 = 0.5*B1
                         V3 = 0.5*B3
-                     angle_V13 = np.arctan2(np.cross(V3, V1), np.dot(V3, V1))   # angle in radians
+                     angle_V13 = np.arctan2(np.cross(V3, V1)[2], np.dot(V3, V1))   # angle in radians
                      angle2 = np.degrees(angle_V13)
                      if (abs(angle2) == 0.0):  angle2 = 0.0
                      #-----------------------------------------------------------------
@@ -1105,23 +1105,23 @@ if (n_test == 1):
               poscar1 = open(diret + 'Lattice1' + '/' + dir_temp_m + '/' + '/POSCAR_' + str(i+1) + '.vasp', "r")
               poscar2 = open(diret + 'Lattice2' + '/' + dir_temp_m + '/' + '/POSCAR_' + str(i+1) + '.vasp', "r")
               if (n_Lattice == 3):  poscar3 = open(diret + 'Lattice3' + '/' + dir_temp_m + '/' + '/POSCAR_' + str(i+1) + '.vasp', "r")
-              #----------------------------------------------------------------------------------------------
+              #-----------------------------------------------------------------------------------------------------------------------
               VTemp = poscar1.readline()
               VTemp = poscar1.readline(); param = float(VTemp)
-              A = poscar1.readline().split(); A1 = np.array([ float(A[0])*param, float(A[1])*param ])
-              B = poscar1.readline().split(); B1 = np.array([ float(B[0])*param, float(B[1])*param ])
-              #--------------------------------------------------------------------------------------
+              A = poscar1.readline().split(); A1 = np.array([float(A[0])*param, float(A[1])*param, 0.0])
+              B = poscar1.readline().split(); B1 = np.array([float(B[0])*param, float(B[1])*param, 0.0])
+              #-----------------------------------------------------------------------------------------
               VTemp = poscar2.readline()
               VTemp = poscar2.readline(); param = float(VTemp)
-              A = poscar2.readline().split(); A2 = np.array([ float(A[0])*param, float(A[1])*param ])
-              B = poscar2.readline().split(); B2 = np.array([ float(B[0])*param, float(B[1])*param ])
-              #--------------------------------------------------------------------------------------
+              A = poscar2.readline().split(); A2 = np.array([float(A[0])*param, float(A[1])*param, 0.0])
+              B = poscar2.readline().split(); B2 = np.array([float(B[0])*param, float(B[1])*param, 0.0])
+              #-----------------------------------------------------------------------------------------
               if (n_Lattice == 3):
                  VTemp = poscar3.readline()
                  VTemp = poscar3.readline(); param = float(VTemp)
-                 A = poscar3.readline().split(); A3 = np.array([ float(A[0])*param, float(A[1])*param ])
-                 B = poscar3.readline().split(); B3 = np.array([ float(B[0])*param, float(B[1])*param ])
-              #-----------------------------------------------------------------------------------------
+                 A = poscar3.readline().split(); A3 = np.array([float(A[0])*param, float(A[1])*param, 0.0])
+                 B = poscar3.readline().split(); B3 = np.array([float(B[0])*param, float(B[1])*param, 0.0])
+              #--------------------------------------------------------------------------------------------
               if (rot_angle_calc == 'center_cell'):
                  V1 = 0.5*A1 + 0.5*B1; V2 = 0.5*A2 + 0.5*B2
                  if (n_Lattice == 3):  V3 = 0.5*A3 + 0.5*B3
@@ -1133,8 +1133,8 @@ if (n_test == 1):
               if (rot_angle_calc == 'A2'):
                  V1 = 0.5*B1; V2 = 0.5*B2
                  if (n_Lattice == 3):  V3 = 0.5*B3
-              #-------------------------------------------------------
-              angle_V12 = np.arctan2(np.cross(V2, V1), np.dot(V2, V1))   # angle in radians
+              #-------------------------------------------------------------------------------
+              angle_V12 = np.arctan2(np.cross(V2, V1)[2], np.dot(V2, V1))   # angle in radians
               angle0 = np.degrees(angle_V12)
               if (abs(angle0) == 0.0):  angle0 = 0.0
               #-----------------------------------------------------------------
@@ -1155,7 +1155,7 @@ if (n_test == 1):
               angle1 = round(angle1, 4)
               #=================================================================
               if (n_Lattice == 3):
-                 angle_V13 = np.arctan2(np.cross(V3, V1), np.dot(V3, V1))   # angle in radians
+                 angle_V13 = np.arctan2(np.cross(V3, V1)[2], np.dot(V3, V1))   # angle in radians
                  angle2 = np.degrees(angle_V13)
                  if (abs(angle2) == 0.0):  angle2 = 0.0
                  #-----------------------------------------------------------------
@@ -1241,12 +1241,12 @@ if (n_test == 1):
                     #----------------------------------------------------------------------------------------------------------------
                     # Aligning the cells of the different lattices ------------------------------------------------------------------
                     #----------------------------------------------------------------------------------------------------------------
-                    theta = angle_V12;  rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+                    theta = angle_V12;  rotation_matrix = np.array([ [np.cos(theta), -np.sin(theta), 0], [np.sin(theta), np.cos(theta), 0], [0, 0, 1] ])
                     A2_rotated = np.dot(rotation_matrix, A2)
                     B2_rotated = np.dot(rotation_matrix, B2)
                     #---------------------------------------
                     if (n_Lattice == 3):
-                       theta = angle_V13;  rotation_matrix = np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]])
+                       theta = angle_V13;  rotation_matrix = np.array([ [np.cos(theta), -np.sin(theta), 0], [np.sin(theta), np.cos(theta), 0], [0, 0, 1] ])
                        A3_rotated = np.dot(rotation_matrix, A3)
                        B3_rotated = np.dot(rotation_matrix, B3)
                     #-------------------------------------------------------
@@ -1275,7 +1275,7 @@ if (n_test == 1):
                     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.arctan2(np.cross(A_int,B_int), np.dot(A_int,B_int))
+                    angle_int = np.arctan2(np.cross(A_int,B_int)[2], np.dot(A_int,B_int))
 
                     #-----------------------------------------------------------------------------------------------------------
                     # Use of temporary vectors (A,B) to estimate the deformation applied to the original cells -----------------

{samba_ilum-1.1.0.112 → samba_ilum-1.1.0.114}/setup.py

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