SAMBA-ilum 1.0.0.472__tar.gz → 1.0.0.473__tar.gz

{samba_ilum-1.0.0.472 → samba_ilum-1.0.0.473}/PKG-INFO

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

{samba_ilum-1.0.0.472 → samba_ilum-1.0.0.473}/SAMBA_ilum.egg-info/PKG-INFO

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

{samba_ilum-1.0.0.472 → samba_ilum-1.0.0.473}/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.472'
+version = '1.0.0.473'
 
 print(" ")
 print("=============================================================")

{samba_ilum-1.0.0.472 → samba_ilum-1.0.0.473}/samba_ilum/src/HeteroStructure_Generator.py

@@ -39,12 +39,10 @@ if (crit_area <= 0.0):             crit_area = 0.01
 #----------------------------------------------------------------------------------------------------------------------------------------------
 # Rotulo temporário para os ions inequivalentes da célula unitária ----------------------------------------------------------------------------
 #----------------------------------------------------------------------------------------------------------------------------------------------
-letters     = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Z', 'Y', 'W' ]
-alphabet    = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Z', 'Y', 'W' ]
-# letters   = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'z', 'y', 'w' ]
-# alphabet += ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'z', 'y', 'w' ]
+letters     = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Z', 'Y', 'W']
+alphabet    = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'Z', 'Y', 'W']
 #------------------------------------------------------
-# Gerando 1040 rótulos temporários para os ions da rede
+# Gerando 1066 rótulos temporários para os ions da rede
 #------------------------------------------------------
 for k in range(40):
     for i in range(len(letters)):

{samba_ilum-1.0.0.472 → samba_ilum-1.0.0.473}/samba_ilum/src/data-base_json.py

@@ -38,7 +38,8 @@ if (l_file == 'null' and l_file_SO == 'null'):  sys.exit(0)
 #==========================================================
 kpoints_file = []
 kpath = []
-#---------
+kpath_label = []
+#---------------
 if os.path.isdir('output/Bandas'):     dir_kpath = 'bands'
 if os.path.isdir('output/Bandas_SO'):  dir_kpath = 'bands.SO'
 #-----------------------------------------------------------------------------
@@ -58,24 +59,27 @@ for i in range(len(kpoints_file)):
            if (j > 3 and len(lines[j]) > 1):
               line = lines[j].split()
               line[3] = line[3].replace('!', '').replace('#1', 'Gamma').replace('#', '')
-              kpath.append([float(line[0]), float(line[1]), float(line[2]), str(line[3])])
-    #-------------------------------------------------------------------------------------
+              kpath.append([round(float(line[0]), 15), round(float(line[1]), 15), round(float(line[2]), 15)])
+              kpath_label.append(line[3])
+    #--------------------------------------
     if (len(kpoints_file) > 1):
        for j in range(len(lines)):
            if (i == 0 and j > 3 and len(lines[j]) > 1):
               line = lines[j].split()
               line[3] = line[3].replace('!', '').replace('#1', 'Gamma').replace('#', '')
-              kpath.append([float(line[0]), float(line[1]), float(line[2]), str(line[3])])
+              kpath.append([round(float(line[0]), 15), round(float(line[1]), 15), round(float(line[2]), 15)])
+              kpath_label.append([line[3]])
            if (i > 0  and j > 4 and len(lines[j]) > 1):
               line = lines[j].split()
               line[3] = line[3].replace('!', '').replace('#1', 'Gamma').replace('#', '')
-              kpath.append([float(line[0]), float(line[1]), float(line[2]), str(line[3])])
+              kpath.append([round(float(line[0]), 15), round(float(line[1]), 15), round(float(line[2]), 15)])
 #----------------------------------------------------------
 # Removendo elementos adjacentes e repetidos da lista kpath
 #----------------------------------------------------------
 i = 0
 while i < (len(kpath) -1):
     if kpath[i] == kpath[i +1]: del kpath[i +1]
+    if kpath_label[i] == kpath_label[i +1]: del kpath_label[i +1]
     else: i += 1  # Avança para o próximo par de elementos
 
 
@@ -125,54 +129,55 @@ if os.path.isfile('output/POSCAR.info'):
          passo = n_materials +1
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         area_perc_mismatch.append([float(temp1[0]), float(temp1[1])])
+         area_perc_mismatch.append([round(float(temp1[0]), 15), round(float(temp1[1]), 15)])
          if (n_materials == 3):
-            area_perc_mismatch.append([float(temp1[2]), float(temp1[3])])
-         #---------------------------------------------------------------
+            area_perc_mismatch.append([round(float(temp1[2]), 15), round(float(temp1[3]), 15)])
+         #-------------------------------------------------
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         for ii in range(len(temp1)): perc_area_change.append(float(temp1[ii]))
-         #---------------------------------------------------------------------
+         for ii in range(len(temp1)): perc_area_change.append(round(float(temp1[ii]), 15))
+         #--------------------------------------------------------------
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         perc_mod_vectors_change.append([float(temp1[0]), float(temp1[1])])
-         perc_mod_vectors_change.append([float(temp1[2]), float(temp1[3])])
+         perc_mod_vectors_change.append([round(float(temp1[0]), 15), round(float(temp1[1]), 15)])
+         perc_mod_vectors_change.append([round(float(temp1[2]), 15), round(float(temp1[3]), 15)])
          if (n_materials == 3):
-            perc_mod_vectors_change.append([float(temp1[4]), float(temp1[5])])
-         #--------------------------------------------------------------------
+            perc_mod_vectors_change.append([round(float(temp1[4]), 15), round(float(temp1[5]), 15)])
+         #------------------------------------------------------
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         angle_perc_mismatch.append([float(temp1[0]), float(temp1[1])])
+         angle_perc_mismatch.append([round(float(temp1[0]), 15), round(float(temp1[1]), 15)])
          if (n_materials == 3):
-            angle_perc_mismatch.append([float(temp1[2]), float(temp1[3])])
-         #----------------------------------------------------------------
+            angle_perc_mismatch.append([round(float(temp1[2]), 15), round(float(temp1[3]), 15)])
+         #--------------------------------------------------
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         for ii in range(len(temp1)): perc_angle_change.append(float(temp1[ii]))
-         #----------------------------------------------------------------------
+         for ii in range(len(temp1)): perc_angle_change.append(round(float(temp1[ii]), 15))
+         #---------------------------------------------------------------
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         for ii in range(len(temp1)): rotation_angle.append(float(temp1[ii]))
-         #-------------------------------------------------------------------
+         for ii in range(len(temp1)): rotation_angle.append(round(float(temp1[ii]), 15))
+         #------------------------------------------------------------
          for i in range(n_materials):
              passo += 4
              temp1 = str(VTemp[passo]).replace('_', ' ').split()
              supercell_matrix.append([[int(temp1[0]), int(temp1[1])], [int(temp1[2]), int(temp1[3])]])
-         #--------------------------------------------------------------------------------------------
+             # supercell_matrix.append([[round(float(temp1[0]), 15), round(float(temp1[1]), 15)], [round(float(temp1[2]), 15), round(float(temp1[3]), 15)]])
+         #------------------------------------------------------------------------
          for i in range(n_materials):
              passo += 4
              temp1 = str(VTemp[passo]).replace('_', ' ').split()
-             deformation_matrix.append([[float(temp1[0]), float(temp1[1])], [float(temp1[2]), float(temp1[3])]])
-         #------------------------------------------------------------------------------------------------------
+             deformation_matrix.append([[round(float(temp1[0]), 15), round(float(temp1[1]), 15)], [round(float(temp1[2]), 15), round(float(temp1[3]), 15)]])
+         #--------------------------------------------------------------------------
          for i in range(n_materials):
              passo += 4
              temp1 = str(VTemp[passo]).replace('_', ' ').split()
-             strain_matrix.append([[float(temp1[0]), float(temp1[1])], [float(temp1[2]), float(temp1[3])]])
-         #-------------------------------------------------------------------------------------------------
+             strain_matrix.append([[round(float(temp1[0]), 15), round(float(temp1[1]), 15)], [round(float(temp1[2]), 15), round(float(temp1[3]), 15)]])
+         #---------------------------------------------------------------------
          passo += 4
          temp1 = str(VTemp[passo]).replace('_', ' ').split()
-         for ii in range(len(temp1)): shift_plane.append(float(temp1[ii]))
-         #----------------------------------------------------------------
+         for ii in range(len(temp1)): shift_plane.append(round(float(temp1[ii]), 15))
+         #---------------------------------------------------------
          passo += 1
          for i in range(n_materials):
              id_materials.append(str(VTemp[-n_materials -1 +i]))
@@ -225,10 +230,12 @@ type_ions = poscar.readline().split()
 type_ions_n = poscar.readline().split()
 poscar.readline()
 coord_ions = []
+rotulo_ions = []
 for i in range(len(type_ions)):
     for j in range(int(type_ions_n[i])):
         VTemp = poscar.readline().split()
-        coord_ions.append([ float(VTemp[0]), float(VTemp[1]), float(VTemp[2]), str(type_ions[i]) ])
+        coord_ions.append([ round(float(VTemp[0]), 15), round(float(VTemp[1]), 15), round(float(VTemp[2]), 15) ])
+        rotulo_ions.append(type_ions[i])
 poscar.close()
 
 
@@ -243,6 +250,7 @@ for i in range(nion):
     VTemp = poscar.readline().split()
     temp_z.append(float(VTemp[2]))
 total_thickness = (max(temp_z) -min(temp_z))*param
+total_thickness = round(total_thickness, 15)
 poscar.close()
 #---------------------------------------------------------
 if (n_materials == 1): thickness.append( total_thickness )
@@ -255,9 +263,12 @@ if (n_materials > 1):
        for j in range(int(nions_materials[i])):
            VTemp = poscar.readline().split()
            temp_z.append(float(VTemp[2]))
-       thickness.append( (max(temp_z) -min(temp_z))*param )
-       #---------------------------------------------------------------
-       if (i > 0): z_separation.append( (min(temp_z) -temp_max)*param )
+       temp_t = (max(temp_z) -min(temp_z))*param
+       thickness.append(round(temp_t, 15))
+       #---------------------------------------
+       if (i > 0):
+          temp_sep = (min(temp_z) -temp_max)*param
+          z_separation.append(round(temp_sep, 15))
        temp_max = max(temp_z)
        #---------------------
    poscar.close()   
@@ -308,7 +319,7 @@ if os.path.isfile('output/xy-scan/info_xy-scan.dat'):
    xyscan = open('output/xy-scan/info_xy-scan.dat', "r")
    #----------------------------------------------------
    for i in range(6): VTemp = xyscan.readline().split()
-   e_slide = float(VTemp[2])
+   e_slide = round(float(VTemp[2]), 15)
    #-------------
    xyscan.close()
 
@@ -422,7 +433,7 @@ for n in range(2):
        param_a = '--';  a1 = '--';  a2 = '--';  a3 = '--';  param_b = '--';  b1 = '--';  b2 = '--';  b3 = '--'
        module_a1_a2_a3 = '--'; module_b1_b2_b3 = '--';  angle_a1a2_a1a3_a2a3 = '--'; angle_b1b2_b1b3_b2b3 = '--'
        cell_area = '--';  cell_vol = '--';  zb_area = '--';  zb_volume = '--'
-       direct_coord_ions = '--';  k_path = '--'
+       direct_coord_ions = '--';  label_ions = '--';  k_path = '--'
 
 
        #----------------------------------------------------------------------------------------------------------
@@ -477,8 +488,8 @@ for n in range(2):
                  if (VTemp[1] == 'k-points'):  nk = int(VTemp[3])
                  if (VTemp[5] == 'bands'):  nb = int(VTemp[7])
                  if (VTemp[1] == 'ions'):  ni = int(VTemp[3])
-                 if (VTemp[5] == 'electrons'):  ne = float(VTemp[7])
-              #----------------------------------------
+                 if (VTemp[5] == 'electrons'):  ne = round(float(VTemp[7]), 15)
+              #--------------------------------------------------------------------
               elif (VTemp[0] == 'LORBIT'):
                  lorbit = int(VTemp[2])
                  if (VTemp[3] == 'ISPIN'):  ispin = int(VTemp[5])
@@ -488,60 +499,60 @@ for n in range(2):
               elif (VTemp[0] == 'First'):  cbm = vbm +1
               #----------------------------------------
               elif (VTemp[0] == 'Valence'):
-                   e_vbm = float(VTemp[7])
+                   e_vbm = round(float(VTemp[7]), 15)
                    tk_vbm = int(VTemp[11])
               #----------------------------------------
               elif (VTemp[0] == 'Conduction'):
-                   e_cbm = float(VTemp[7])
+                   e_cbm = round(float(VTemp[7]), 15)
                    tk_cbm = int(VTemp[11])
               #----------------------------------------
               elif (VTemp[0] == 'GAP'):
                 type_gap = str(VTemp[2])
-                gap = float(VTemp[5])
+                gap = round(float(VTemp[5]), 15)
               #----------------------------------------
-              elif (VTemp[0] == 'Fermi'): e_fermi = float(VTemp[3])
+              elif (VTemp[0] == 'Fermi'): e_fermi = round(float(VTemp[3]), 15)
               #----------------------------------------
               elif (VTemp[0] == 'free'):
-                   total_energy = float(VTemp[4])
-                   # e_per_ion = total_energy/ni
-              #----------------------------------------
-              elif (VTemp[0] == 'Volume_cell'):  Volume_cell = float(VTemp[2])   
+                   total_energy = round(float(VTemp[4]), 15)
+                   # e_per_ion = round(float(total_energy)/ni, 15)
+              #--------------------------------------------------------
+              elif (VTemp[0] == 'Volume_cell'):  Volume_cell = round(float(VTemp[2]), 15)
               #----------------------------------------
               elif (VTemp[0] == 'Param.'):  param = float(VTemp[2])   
               #----------------------------------------
               elif (VTemp[0] == 'A1'):
-                   a1 = [float(VTemp[4])*param, float(VTemp[5])*param, float(VTemp[6])*param]                  
-                   A1 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*param;  module_a1_a2_a3 = []; module_a1_a2_a3.append(np.linalg.norm(A1))
+                   a1 = [round(float(VTemp[4])*param, 15), round(float(VTemp[5])*param, 15), round(float(VTemp[6])*param, 15)]                  
+                   A1 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*param;  module_a1_a2_a3 = []; module_a1_a2_a3.append(round(np.linalg.norm(A1), 15))
               elif (VTemp[0] == 'A2'):
-                   a2 = [float(VTemp[4])*param, float(VTemp[5])*param, float(VTemp[6])*param]
-                   A2 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*param;  module_a1_a2_a3.append(np.linalg.norm(A2))
+                   a2 = [round(float(VTemp[4])*param, 15), round(float(VTemp[5])*param, 15), round(float(VTemp[6])*param, 15)]
+                   A2 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*param;  module_a1_a2_a3.append(round(np.linalg.norm(A2), 15))
               elif (VTemp[0] == 'A3'):
-                   a3 = [float(VTemp[4])*param, float(VTemp[5])*param, float(VTemp[6])*param]
-                   A3 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*param;  module_a1_a2_a3.append(np.linalg.norm(A3))
+                   a3 = [round(float(VTemp[4])*param, 15), round(float(VTemp[5])*param, 15), round(float(VTemp[6])*param, 15)]
+                   A3 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*param;  module_a1_a2_a3.append(round(np.linalg.norm(A3), 15))
                    #-------------------------------------------------------
                    angle_a1a2_a1a3_a2a3 = []
-                   angle_a1a2_a1a3_a2a3.append(round(np.degrees(np.arccos(np.dot(A1,A2) / (np.linalg.norm(A1) * np.linalg.norm(A2)))), 3))
-                   angle_a1a2_a1a3_a2a3.append(round(np.degrees(np.arccos(np.dot(A1,A3) / (np.linalg.norm(A1) * np.linalg.norm(A3)))), 3))
-                   angle_a1a2_a1a3_a2a3.append(round(np.degrees(np.arccos(np.dot(A2,A3) / (np.linalg.norm(A2) * np.linalg.norm(A3)))), 3))
+                   angle_a1a2_a1a3_a2a3.append(round(np.degrees(np.arccos(np.dot(A1,A2) / (np.linalg.norm(A1) * np.linalg.norm(A2)))), 15))
+                   angle_a1a2_a1a3_a2a3.append(round(np.degrees(np.arccos(np.dot(A1,A3) / (np.linalg.norm(A1) * np.linalg.norm(A3)))), 15))
+                   angle_a1a2_a1a3_a2a3.append(round(np.degrees(np.arccos(np.dot(A2,A3) / (np.linalg.norm(A2) * np.linalg.norm(A3)))), 15))
               #----------------------------------------
               elif (VTemp[0] == '2pi/Param.'):  fator_rec = float(VTemp[2])   
               #----------------------------------------
               elif (VTemp[0] == 'B1'):
-                   b1 = [float(VTemp[4])*fator_rec, float(VTemp[5])*fator_rec, float(VTemp[6])*fator_rec]
-                   B1 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*fator_rec;  module_b1_b2_b3 = []; module_b1_b2_b3.append(np.linalg.norm(B1))
+                   b1 = [round(float(VTemp[4])*fator_rec, 15), round(float(VTemp[5])*fator_rec, 15), round(float(VTemp[6])*fator_rec, 15)]
+                   B1 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*fator_rec;  module_b1_b2_b3 = []; module_b1_b2_b3.append(round(np.linalg.norm(B1), 15))
               elif (VTemp[0] == 'B2'):
-                   b2 = [float(VTemp[4])*fator_rec, float(VTemp[5])*fator_rec, float(VTemp[6])*fator_rec]
-                   B2 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*fator_rec;  module_b1_b2_b3.append(np.linalg.norm(B2))
+                   b2 = [round(float(VTemp[4])*fator_rec, 15), round(float(VTemp[5])*fator_rec, 15), round(float(VTemp[6])*fator_rec, 15)]
+                   B2 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*fator_rec;  module_b1_b2_b3.append(round(np.linalg.norm(B2), 15))
               elif (VTemp[0] == 'B3'):
-                   b3 = [float(VTemp[4])*fator_rec, float(VTemp[5])*fator_rec, float(VTemp[6])*fator_rec]
-                   B3 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*fator_rec;  module_b1_b2_b3.append(np.linalg.norm(B3))
+                   b3 = [round(float(VTemp[4])*fator_rec, 15), round(float(VTemp[5])*fator_rec, 15), round(float(VTemp[6])*fator_rec, 15)]
+                   B3 = np.array([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])*fator_rec;  module_b1_b2_b3.append(round(np.linalg.norm(B3), 15))
                    #-------------------------------------------------------
                    angle_b1b2_b1b3_b2b3 = []
-                   angle_b1b2_b1b3_b2b3.append(round(np.degrees(np.arccos(np.dot(B1,B2) / (np.linalg.norm(B1) * np.linalg.norm(B2)))), 3))
-                   angle_b1b2_b1b3_b2b3.append(round(np.degrees(np.arccos(np.dot(B1,B3) / (np.linalg.norm(B1) * np.linalg.norm(B3)))), 3))
-                   angle_b1b2_b1b3_b2b3.append(round(np.degrees(np.arccos(np.dot(B2,B3) / (np.linalg.norm(B2) * np.linalg.norm(B3)))), 3))
+                   angle_b1b2_b1b3_b2b3.append(round(np.degrees(np.arccos(np.dot(B1,B2) / (np.linalg.norm(B1) * np.linalg.norm(B2)))), 15))
+                   angle_b1b2_b1b3_b2b3.append(round(np.degrees(np.arccos(np.dot(B1,B3) / (np.linalg.norm(B1) * np.linalg.norm(B3)))), 15))
+                   angle_b1b2_b1b3_b2b3.append(round(np.degrees(np.arccos(np.dot(B2,B3) / (np.linalg.norm(B2) * np.linalg.norm(B3)))), 15))
               #----------------------------------------
-              elif (VTemp[0] == 'Volume_ZB'):  vol_zb = float(VTemp[2])   
+              elif (VTemp[0] == 'Volume_ZB'):  vol_zb = VTemp[2]   
               #----------------------------------------
               elif (VTemp[0] == 'k-points'):  loop = i+3
 
@@ -566,8 +577,8 @@ for n in range(2):
              for nn in range(2): VTemp = info.readline()
              for nn in range(1,(nk+1)):
                  VTemp = info.readline().split()
-                 if (nn == int(tk_vbm)): k_vbm = [float(VTemp[1]), float(VTemp[2]), float(VTemp[3])]
-                 if (nn == int(tk_cbm)): k_cbm = [float(VTemp[1]), float(VTemp[2]), float(VTemp[3])]
+                 if (nn == int(tk_vbm)): k_vbm = [round(float(VTemp[1]), 15), round(float(VTemp[2]), 15), round(float(VTemp[3]), 15)]
+                 if (nn == int(tk_cbm)): k_cbm = [round(float(VTemp[1]), 15), round(float(VTemp[2]), 15), round(float(VTemp[3]), 15)]
 
 
        # =================================================================
@@ -585,10 +596,10 @@ for n in range(2):
                     vector_bader = []
                     VTemp = bader.readline()
                     VTemp = bader.readline().split()
-                    vector_bader.append(float(VTemp[2]))
+                    vector_bader.append(round(float(VTemp[2]), 15))
                     for mm in range(len(t_ions_materials[mn])):
                         VTemp = bader.readline().split()
-                        vector_bader.append(float(VTemp[3]))
+                        vector_bader.append(round(float(VTemp[3]), 15))
                     charge_transfer.append(vector_bader)
           #===========
           if (n == 1):
@@ -601,10 +612,10 @@ for n in range(2):
                     vector_bader = []
                     VTemp = bader.readline()
                     VTemp = bader.readline().split()
-                    vector_bader.append(float(VTemp[2]))
+                    vector_bader.append(round(float(VTemp[2]), 15))
                     for mm in range(len(t_ions_materials[mn])):
                         VTemp = bader.readline().split()
-                        vector_bader.append(float(VTemp[3]))
+                        vector_bader.append(round(float(VTemp[3]), 15))
                     charge_transfer_SO.append(vector_bader)
 
 
@@ -623,9 +634,9 @@ for n in range(2):
              for i in range(loop):  VTemp = info.readline()
              for i in range(nk):
                  VTemp = info.readline().split()
-                 k_points_direct.append([float(VTemp[1]), float(VTemp[2]), float(VTemp[3])])
-                 k_points_cart.append([float(VTemp[4]), float(VTemp[5]), float(VTemp[6])])
-                 k_path.append(float(VTemp[7]))
+                 k_points_direct.append([VTemp[1], VTemp[2], VTemp[3]])
+                 k_points_cart.append([VTemp[4], VTemp[5], VTemp[6]])
+                 k_path.append(VTemp[7])
           print(k_path)
           #-----------
           info.close()
@@ -669,8 +680,8 @@ for n in range(2):
        V2 = np.array([A2[0], A2[1]])
        #----------------------------
        # Área da célula no plano XY
-       Area_cell = np.linalg.norm(np.cross(V1, V2))
-       #-------------------------------------------
+       Area_cell = round(np.linalg.norm(np.cross(V1, V2)), 15)
+       #------------------------------------------------------
 
 
        #=======================================
@@ -680,8 +691,8 @@ for n in range(2):
        V2 = np.array([B2[0], B2[1]])
        #----------------------------
        # Área da zb no plano KxKy
-       Area_ZB = np.linalg.norm(np.cross(V1, V2))
-       #-----------------------------------------
+       Area_ZB = round(np.linalg.norm(np.cross(V1, V2)), 15)
+       #----------------------------------------------------
 
 
        # ===========================================
@@ -742,7 +753,9 @@ for n in range(2):
                 "zb_area": Area_ZB,
                 # "zb_volume": vol_zb,
                 "direct_coord_ions": coord_ions,
+                "label_ions": rotulo_ions,
                 "kpath": kpath,
+                "kpath_label": kpath_label,
                 }
 
 
@@ -766,8 +779,8 @@ for n in range(2):
                    "e_vacuum": e_vacuum,
                    # "work_function": work_function,
                    "total_energy": total_energy,
-                   "e_per_ion":  total_energy/ni,
-                   "e_per_area": total_energy/Area_cell,
+                   "e_per_ion":  round(float(total_energy)/ni, 15),
+                   "e_per_area": round(float(total_energy)/float(Area_cell), 15),
                    "e_binding": e_binding  if n_materials > 1 else None,
                    "e_slide": e_slide  if n_materials > 1 else None,
                    "charge_transfer": charge_transfer  if n_materials > 1 else None,
@@ -794,8 +807,8 @@ for n in range(2):
                    "e_vacuum_SO": e_vacuum,
                    # "work_function_SO": work_function,
                    "total_energy_SO": total_energy,
-                   "e_per_ion_SO":  total_energy/ni,
-                   "e_per_area_SO": total_energy/Area_cell,
+                   "e_per_ion_SO":  round(float(total_energy)/ni, 15),
+                   "e_per_area_SO": round(float(total_energy)/float(Area_cell), 15),
                    "charge_transfer_SO": charge_transfer_SO  if n_materials > 1 else None,
                    }
 

{samba_ilum-1.0.0.472 → samba_ilum-1.0.0.473}/setup.py

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