vasprocar 1.1.19.103__tar.gz → 1.1.19.105__tar.gz

{vasprocar-1.1.19.103/vasprocar.egg-info → vasprocar-1.1.19.105}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vasprocar
-Version: 1.1.19.103
+Version: 1.1.19.105
 Summary: VASProcar is an open-source package written in the Python 3 programming language, which aims to provide an intuitive tool for the post-processing of the output files produced by the DFT VASP/QE codes, through an interactive user interface.
 Home-page: https://doi.org/10.5281/zenodo.6343960
 Download-URL: https://doi.org/10.5281/zenodo.6343960
@@ -9,6 +9,13 @@ Author-email: augusto-lelis@outlook.com, renan.maciel@physics.uu.se
 License: GNU GPLv3
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24.1
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: plotly>=5.13.0
+Requires-Dist: moviepy>=1.0.2
+Requires-Dist: kaleido>=0.2.1
+Requires-Dist: requests>=2.31.0
 
 # VASProcar Copyright (C) 2023   -   GNU GPL-3.0 license
 

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/setup.py

@@ -6,7 +6,7 @@ from typing import Optional
 
 setup(
     name = "vasprocar",
-    version = "1.1.19.103",
+    version = "1.1.19.105",
     entry_points={'console_scripts': ['vasprocar = vasprocar:main']},
     description = "VASProcar is an open-source package written in the Python 3 programming language, which aims to provide an intuitive tool for the post-processing of the output files produced by the DFT VASP/QE codes, through an interactive user interface.",
     author = "Augusto de Lelis Araujo and Renan da Paixao Maciel", 

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/vasprocar/__main__.py

@@ -14,7 +14,7 @@ dir_vasprocar = os.path.dirname(os.path.realpath(__file__))
 print(f'{dir_vasprocar}')
 #------------------------
 
-version = '1.1.19.103'
+version = '1.1.19.105'
 VASProcar_name = 'VASProcar version ' + version
 
 url_1 = 'https://pypi.org/project/vasprocar'

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/vasprocar/src/_VASP/_info.py

@@ -174,7 +174,7 @@ if (ispin == 1):
    
    if ((len(VTemp) >= 3) and (VTemp[0] == 'Fermi')):
       Efermi = float(VTemp[2])
-      VTemp = outcar.readline()
+      VTemp = outcar.readline(); VTemp = outcar.readline(); 
 
    menor_n2 = -1000.0
    maior_n2 = +1000.0
@@ -213,9 +213,77 @@ if (ispin == 1):
       if (kp1 == kp2): inform.write(f'GAP (direct) = {GAP:.4f} eV \n')
       if (kp1 != kp2): inform.write(f'GAP (indirect) = {GAP:.4f} eV \n')
 
-
       inform.write("---------------------------------------------------- \n")
 
+#==========================================================================
+
+if (ispin == 2):
+   for nspin in range(1,(2+1)):
+ 
+      #-----------------------------------------------------------------------
+      # Checking which bands correspond to the valence and conduction bands --
+      # as well as the respective energy gap ---------------------------------
+      # ----------------------------------------------------------------------
+      # This check only makes sense for calculations performed in a single ---
+      # step (n_procar = 1), since the analyzed OUTCAR file may or may not --- 
+      # contain the lowest GAP region of the system --------------------------
+      # ----------------------------------------------------------------------
+      # This check also does not make sense for metallic system --------------
+      #-----------------------------------------------------------------------
+
+      if (nspin == 1):
+         VTemp = outcar.readline(); VTemp = outcar.readline().split()
+         if ((len(VTemp) >= 3) and (VTemp[0] == 'Fermi')): Efermi = float(VTemp[2])
+         #-------------------------------------------------------------------------
+         menor_n2 = -1000.0
+         maior_n2 = +1000.0 
+         #------------------
+
+      if (nspin == 1):
+         number = 0
+         VTemp = outcar.readline(); VTemp = outcar.readline(); VTemp = outcar.readline()
+      if (nspin == 2):
+         number = 0
+         VTemp = outcar.readline(); VTemp = outcar.readline(); VTemp = outcar.readline(); VTemp = outcar.readline()     
+
+      for i in range(nk):
+          number += 1
+
+          VTemp = outcar.readline()
+          VTemp = outcar.readline()
+          for j in range(nb):
+              VTemp = outcar.readline().split()
+              if (nspin == 1): n1 = int(VTemp[0])
+              if (nspin == 2): n1 = int(VTemp[0]) + nb
+              n2 = float(VTemp[1])
+              n3 = float(VTemp[2])
+              if (n3 > 0.0):
+                 if (n2 > menor_n2):
+                    menor_n2 = n2
+                    n1_valencia = n1
+                    kp1 = number
+              if (n3 == 0.0):
+                 if (n2 < maior_n2):
+                    maior_n2 = n2
+                    n1_conducao = n1
+                    kp2 = number
+              GAP = (maior_n2 - menor_n2)
+          VTemp = outcar.readline() 
+
+      if (n_procar == 1):
+         if (n1_valencia <= nb): inform.write(f'Last band occuped = {n1_valencia}up \n')
+         if (n1_valencia > nb):  inform.write(f'Last band occuped = {n1_valencia -nb}dw \n')
+         if (n1_conducao <= nb): inform.write(f'First band empty = {n1_conducao}up \n')
+         if (n1_conducao > nb):  inform.write(f'First band empty = {n1_conducao -nb}dw \n')
+         #---------------------------------------------------
+         inform.write(f'Valence band maximum (VBM)    = {maior_n2} eV  -  k-point {kp2} \n')
+         inform.write(f'Conduction band minimum (CBM) = {menor_n2} eV  -  k-point {kp1} \n')
+         #---------------------------------------------------------------
+         if (kp1 == kp2): inform.write(f'GAP (direct) = {GAP:.4f} eV \n')
+         if (kp1 != kp2): inform.write(f'GAP (indirect) = {GAP:.4f} eV \n')
+
+         inform.write("---------------------------------------------------- \n")
+
 #=======================================================================
 
 inform.write(f'Fermi energy = {Efermi} eV \n')

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/vasprocar/src/_VASP/_info_b.py

@@ -266,6 +266,7 @@ palavra2 = 'reached'
 for line in outcar:
     number += 1
     if (palavra1 or palavra2)  in line:
+       Efermi_check = 1
        break
 #-------------
 outcar.close()

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/vasprocar/src/plot/plot_dos_pdos_ldos_[polarizado].py

@@ -324,7 +324,7 @@ for l in range (1,(loop+1)):     # Loop for analysis of projections
     #====================================================================================================================
 
     plt.xlim((dos_min, dos_max))
-    plt.ylim((energ_min + dE_fermi, energ_max + dE_fermi))
+    plt.ylim((E_min + dE_fermi, E_max + dE_fermi))
 
     plt.xlabel("Density of States")
            
@@ -513,7 +513,7 @@ for l in range (1,(loop+1)):     # Loop for analysis of projections
     #====================================================================================================================
 
     plt.xlim((dos_min, dos_max))
-    plt.ylim((energ_min + dE_fermi , energ_max + dE_fermi))
+    plt.ylim((E_min + dE_fermi, E_max + dE_fermi))
 
     plt.xlabel("Magnetization (DOS_Up - DOS_Down)")
            

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/vasprocar/src/plot/plot_spin_texture_contour.py

@@ -249,107 +249,114 @@ for i in range (1,(6+1)):
                levels[0] = levels_n[j]
                cs = plt.contour(x_grid, y_grid, e_grid, levels, linestyles = '-', cmap = map_gray, linewidths = 0.5, alpha = 1.0, antialiased = True)
                #---------------------------------------------------------------------------------------------------------------------------------------
+               points = []
                paths = cs.collections[0].get_paths()
                verts = [xx.vertices for xx in paths]
-               points = np.concatenate(verts)         
-               #---------------------------------------------------------------------------------------------------------------------------------------
-               new_Sx = griddata((eixo1,eixo2), Spin_Sx, (points[::pulo,0], points[::pulo,1]))
-               new_Sy = griddata((eixo1,eixo2), Spin_Sy, (points[::pulo,0], points[::pulo,1]))
-               new_Sz = griddata((eixo1,eixo2), Spin_Sz, (points[::pulo,0], points[::pulo,1]))
-               #---------------------------------------------------------------------------------------------------------------------------------------
-
-               if (Plano_k == 1):  # Plane (kx,ky) or (k1,k2)       
-                  Spin_S1 = new_Sx
-                  Spin_S2 = new_Sy
-                  Spin_S3 = new_Sz
+               try:
+                   points = np.concatenate(verts) 
+                   ...
+               except Exception as e:
+                   0 == 0
+
+               if (len(points) > 0):    
+                  #---------------------------------------------------------------------------------------------------------------------------------------
+                  new_Sx = griddata((eixo1,eixo2), Spin_Sx, (points[::pulo,0], points[::pulo,1]))
+                  new_Sy = griddata((eixo1,eixo2), Spin_Sy, (points[::pulo,0], points[::pulo,1]))
+                  new_Sz = griddata((eixo1,eixo2), Spin_Sz, (points[::pulo,0], points[::pulo,1]))
+                  #---------------------------------------------------------------------------------------------------------------------------------------
+
+                  if (Plano_k == 1):  # Plane (kx,ky) or (k1,k2)       
+                     Spin_S1 = new_Sx
+                     Spin_S2 = new_Sy
+                     Spin_S3 = new_Sz
          
-               if (Plano_k == 2):  # Plane (kx,kz) or (k1,k3)
-                  Spin_S1 = new_Sx
-                  Spin_S2 = new_Sz
-                  Spin_S3 = new_Sy
+                  if (Plano_k == 2):  # Plane (kx,kz) or (k1,k3)
+                     Spin_S1 = new_Sx
+                     Spin_S2 = new_Sz
+                     Spin_S3 = new_Sy
          
-               if (Plano_k == 3):  # Plane (ky,kz) or (k2,k3)
-                  Spin_S1 = new_Sy
-                  Spin_S2 = new_Sz
-                  Spin_S3 = new_Sx          
+                  if (Plano_k == 3):  # Plane (ky,kz) or (k2,k3)
+                     Spin_S1 = new_Sy
+                     Spin_S2 = new_Sz
+                     Spin_S3 = new_Sx          
          
-               #---------------------------------------------------------------------------------------------------------------------------------------          
+                  #---------------------------------------------------------------------------------------------------------------------------------------          
        
-               passo = len(new_Sx)
-               nulo  = [0.0]*passo
-               angle = [0]*passo
+                  passo = len(new_Sx)
+                  nulo  = [0.0]*passo
+                  angle = [0]*passo
    
-               for k in range(passo):
-                   #----------------------------------------
-                   if (i == 1):
-                      v_spin = [Spin_S1[k], 0.0]
+                  for k in range(passo):
+                      #----------------------------------------
+                      if (i == 1):
+                         v_spin = [Spin_S1[k], 0.0]
                  
-                   if (i == 2):
-                      v_spin = [0.0, Spin_S2[k]]
+                      if (i == 2):
+                         v_spin = [0.0, Spin_S2[k]]
                  
-                   if (i == 3):
-                      v_spin = [Spin_S3[k], 0.0]
+                      if (i == 3):
+                         v_spin = [Spin_S3[k], 0.0]
                 
-                   if (i == 4):
-                      v_spin = [Spin_S1[k], Spin_S2[k]]
-
-                   if (i == 5):
-                      v_spin = [Spin_S1[k], Spin_S3[k]]
-
-                   if (i == 6):
-                      v_spin = [Spin_S3[k], Spin_S2[k]]   
-
-                   #---------------------------------------------------------------------------------------------------
-                   # Obtaining the rotation angle (counter clockwise) of the Spin vector with respect to the x-axis ---
-                   #---------------------------------------------------------------------------------------------------
-                   u = v_spin / np.linalg.norm(v_spin)
-                   v = [1.0, 0.0]   # Reference vector for the angle. Must be kept fixed.
-                   dot_product = np.dot(u, v)
-                   angle[k] = np.arccos(dot_product) / np.pi * 180
-                   if (u[1] < 0.0):
-                      angle[k] = 360 - angle[k]
-
-               #-------------------------------
-               norma = colors.Normalize(0, 360)
-               #-------------------------------
-
-               if (i == 1):
-                  cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, nulo, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                                 alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+                      if (i == 4):
+                         v_spin = [Spin_S1[k], Spin_S2[k]]
+
+                      if (i == 5):
+                         v_spin = [Spin_S1[k], Spin_S3[k]]
+
+                      if (i == 6):
+                         v_spin = [Spin_S3[k], Spin_S2[k]]   
+
+                      #---------------------------------------------------------------------------------------------------
+                      # Obtaining the rotation angle (counter clockwise) of the Spin vector with respect to the x-axis ---
+                      #---------------------------------------------------------------------------------------------------
+                      u = v_spin / np.linalg.norm(v_spin)
+                      v = [1.0, 0.0]   # Reference vector for the angle. Must be kept fixed.
+                      dot_product = np.dot(u, v)
+                      angle[k] = np.arccos(dot_product) / np.pi * 180
+                      if (u[1] < 0.0):
+                         angle[k] = 360 - angle[k]
+
+                  #-------------------------------
+                  norma = colors.Normalize(0, 360)
+                  #-------------------------------
+
+                  if (i == 1):
+                     cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, nulo, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                                    alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
              
-               if (i == 2):
-                  cp = ax.quiver(points[::pulo,0], points[::pulo,1], nulo, Spin_S2, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                                 alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+                  if (i == 2):
+                     cp = ax.quiver(points[::pulo,0], points[::pulo,1], nulo, Spin_S2, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                                    alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
              
-               if (i == 3):
-                  cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, nulo, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                                 alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+                  if (i == 3):
+                     cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, nulo, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                                    alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
              
-               if (i == 4):
-                  cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                                 alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+                  if (i == 4):
+                     cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                                    alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
                
-               # if (i == 4):
-               #    #--------------------------------------
-               #    norma_sz = colors.Normalize(-0.5, +0.5)
-               #    map_sz   = colors.LinearSegmentedColormap.from_list("", ["blue","blue","blue","blue","blue","blue","blue","blue","blue","blue","white",
-               #                                                             "red","red","red","red","red","red","red","red","red","red"])
-               #    #------------------------------------------------------------------------------
-               #    cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, Spin_S3, cmap = map_sz, norm = norma_sz, linewidths = 0.25, edgecolor = 'black',
-               #                   alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
-
-               if (i == 5):
-                  cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S3, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                                 alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
-
-               if (i == 6):
-                  cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, Spin_S2, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                                 alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)   
-
-               #---------------------------------------------------------------------------------------------------------------------------------------       
-               # plt.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle,
-               #            scale_units = "xy", angles = "xy", pivot = 'tail', cmap = map_red_blue, norm = norma, linewidths = 0.5, edgecolor = 'black', alpha = transp)   
-               #---------------------------------------------------------------------------------------------------------------------------------------
+                  # if (i == 4):
+                  #    #--------------------------------------
+                  #    norma_sz = colors.Normalize(-0.5, +0.5)
+                  #    map_sz   = colors.LinearSegmentedColormap.from_list("", ["blue","blue","blue","blue","blue","blue","blue","blue","blue","blue","white",
+                  #                                                             "red","red","red","red","red","red","red","red","red","red"])
+                  #    #------------------------------------------------------------------------------
+                  #    cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, Spin_S3, cmap = map_sz, norm = norma_sz, linewidths = 0.25, edgecolor = 'black',
+                  #                   alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+
+                  if (i == 5):
+                     cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S3, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                                    alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+
+                  if (i == 6):
+                     cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, Spin_S2, angle, cmap = map_color, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                                    alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)   
+
+                  #---------------------------------------------------------------------------------------------------------------------------------------       
+                  # plt.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle,
+                  #            scale_units = "xy", angles = "xy", pivot = 'tail', cmap = map_red_blue, norm = norma, linewidths = 0.5, edgecolor = 'black', alpha = transp)   
+                  #---------------------------------------------------------------------------------------------------------------------------------------
 
                if (j == 1 and b == 1 and i < 4):   
                   cbar = fig.colorbar(cp, orientation = 'vertical', shrink = 1.0, boundaries = [0, 180, 360], ticks = [90, 270])

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105}/vasprocar/src/plot/plot_spin_texture_contour_video.py

@@ -231,145 +231,153 @@ for i in range (n_contour):
     levels[0] = levels_n[i]
     cs = plt.contour(x_grid, y_grid, e_grid, levels, linestyles = '-', cmap = map_gray, linewidths = 0.5, alpha = 1.0, antialiased = True)
     #---------------------------------------------------------------------------------------------------------------------------------------
+    points = []
     paths = cs.collections[0].get_paths()
     verts = [xx.vertices for xx in paths]
-    points = np.concatenate(verts)         
-    #---------------------------------------------------------------------------------------------------------------------------------------
-    new_Sx = griddata((eixo1,eixo2), Spin_Sx, (points[::pulo,0], points[::pulo,1]))
-    new_Sy = griddata((eixo1,eixo2), Spin_Sy, (points[::pulo,0], points[::pulo,1]))
-    new_Sz = griddata((eixo1,eixo2), Spin_Sz, (points[::pulo,0], points[::pulo,1]))
-    #---------------------------------------------------------------------------------------------------------------------------------------
-
-    if (Plano_k == 1):  # Plane (kx,ky) or (k1,k2)       
-       Spin_S1 = new_Sx
-       Spin_S2 = new_Sy
-       Spin_S3 = new_Sz
+    try:
+        points = np.concatenate(verts) 
+        ...
+    except Exception as e:
+        print(f"error detected: {e}")
+
+    #--------------------
+    if (len(points) > 0):        
+       #---------------------------------------------------------------------------------------------------------------------------------------
+       new_Sx = griddata((eixo1,eixo2), Spin_Sx, (points[::pulo,0], points[::pulo,1]))
+       new_Sy = griddata((eixo1,eixo2), Spin_Sy, (points[::pulo,0], points[::pulo,1]))
+       new_Sz = griddata((eixo1,eixo2), Spin_Sz, (points[::pulo,0], points[::pulo,1]))
+       #---------------------------------------------------------------------------------------------------------------------------------------
+
+       if (Plano_k == 1):  # Plane (kx,ky) or (k1,k2)       
+          Spin_S1 = new_Sx
+          Spin_S2 = new_Sy
+          Spin_S3 = new_Sz
          
-    if (Plano_k == 2):  # Plane (kx,kz) or (k1,k3)
-       Spin_S1 = new_Sx
-       Spin_S2 = new_Sz
-       Spin_S3 = new_Sy
+       if (Plano_k == 2):  # Plane (kx,kz) or (k1,k3)
+          Spin_S1 = new_Sx
+          Spin_S2 = new_Sz
+          Spin_S3 = new_Sy
          
-    if (Plano_k == 3):  # Plane (ky,kz) or (k2,k3)
-       Spin_S1 = new_Sy
-       Spin_S2 = new_Sz
-       Spin_S3 = new_Sx          
+       if (Plano_k == 3):  # Plane (ky,kz) or (k2,k3)
+          Spin_S1 = new_Sy
+          Spin_S2 = new_Sz
+          Spin_S3 = new_Sx          
          
-    #---------------------------------------------------------------------------------------------------------------------------------------          
+       #---------------------------------------------------------------------------------------------------------------------------------------          
        
-    passo = len(new_Sx)
-    nulo = [0.0]*passo
-    angle = [0]*passo
+       passo = len(new_Sx)
+       nulo = [0.0]*passo
+       angle = [0]*passo
    
-    for k in range(passo):
-        #----------------------------------------
-        if (tipo_spin == 1):
-            v_spin = [Spin_S1[k], 0.0]
+       for k in range(passo):
+           #----------------------------------------
+           if (tipo_spin == 1):
+               v_spin = [Spin_S1[k], 0.0]
                  
-        if (tipo_spin == 2):
-           v_spin = [0.0, Spin_S2[k]]
+           if (tipo_spin == 2):
+              v_spin = [0.0, Spin_S2[k]]
                 
-        if (tipo_spin == 3):
-           v_spin = [Spin_S3[k], 0.0]
+           if (tipo_spin == 3):
+              v_spin = [Spin_S3[k], 0.0]
                 
-        if (tipo_spin == 4):
-           v_spin = [Spin_S1[k], Spin_S2[k]]
-
-        if (tipo_spin == 5):
-           v_spin = [Spin_S1[k], Spin_S3[k]]
-
-        if (tipo_spin == 6):
-           v_spin = [Spin_S3[k], Spin_S2[k]]   
-
-        #---------------------------------------------------------------------------------------------------
-        # Obtaining the rotation angle (counter clockwise) of the Spin vector with respect to the x-axis ---
-        #---------------------------------------------------------------------------------------------------
-        u = v_spin / np.linalg.norm(v_spin)
-        v = [1.0, 0.0]   # Reference vector for the angle. Must be kept fixed.
-        dot_product = np.dot(u, v)
-        angle[k] = np.arccos(dot_product) / np.pi * 180
-        if (u[1] < 0.0):
-           angle[k] = 360 - angle[k]
-
-    #---------------------------------------------------------------------------------------------------------------------------------------
-    # map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","white","red","white","blue","white","blue","white","red"])
-    # map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","magenta","red","magenta","blue","magenta","blue","magenta","red"])
-    # map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","pink","red","magenta","blue","cyan","blue","magenta","red"])
-    map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","pink","pink","pink","red","magenta","magenta","magenta","blue",
+           if (tipo_spin == 4):
+              v_spin = [Spin_S1[k], Spin_S2[k]]
+
+           if (tipo_spin == 5):
+              v_spin = [Spin_S1[k], Spin_S3[k]]
+
+           if (tipo_spin == 6):
+              v_spin = [Spin_S3[k], Spin_S2[k]]   
+
+           #---------------------------------------------------------------------------------------------------
+           # Obtaining the rotation angle (counter clockwise) of the Spin vector with respect to the x-axis ---
+           #---------------------------------------------------------------------------------------------------
+           u = v_spin / np.linalg.norm(v_spin)
+           v = [1.0, 0.0]   # Reference vector for the angle. Must be kept fixed.
+           dot_product = np.dot(u, v)
+           angle[k] = np.arccos(dot_product) / np.pi * 180
+           if (u[1] < 0.0):
+              angle[k] = 360 - angle[k]
+
+       #---------------------------------------------------------------------------------------------------------------------------------------
+       # map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","white","red","white","blue","white","blue","white","red"])
+       # map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","magenta","red","magenta","blue","magenta","blue","magenta","red"])
+       # map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","pink","red","magenta","blue","cyan","blue","magenta","red"])
+       map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","pink","pink","pink","red","magenta","magenta","magenta","blue",
                                                                        "cyan","cyan","cyan","blue","magenta","magenta","magenta","red"])
-    norma = colors.Normalize(0, 360)
-    #---------------------------------------------------------------------------------------------------------------------------------------
-    if (tipo_spin == 1):
-       cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, nulo, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                      alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+       norma = colors.Normalize(0, 360)
+       #---------------------------------------------------------------------------------------------------------------------------------------
+       if (tipo_spin == 1):
+          cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, nulo, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                         alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
              
-    if (tipo_spin == 2):
-       cp = ax.quiver(points[::pulo,0], points[::pulo,1], nulo, Spin_S2, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                      alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+      if (tipo_spin == 2):
+          cp = ax.quiver(points[::pulo,0], points[::pulo,1], nulo, Spin_S2, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                         alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
              
-    if (tipo_spin == 3):
-       cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, nulo, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                      alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+       if (tipo_spin == 3):
+          cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, nulo, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                         alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
              
-    if (tipo_spin == 4):
-       cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                      alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+       if (tipo_spin == 4):
+          cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                         alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
 
-    if (tipo_spin == 5):
-       cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S3, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                      alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
+       if (tipo_spin == 5):
+          cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S3, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                         alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)
 
-    if (tipo_spin == 6):
-       cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, Spin_S2, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
-                      alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)   
+       if (tipo_spin == 6):
+          cp = ax.quiver(points[::pulo,0], points[::pulo,1], Spin_S3, Spin_S2, angle, cmap = map_red_blue, norm = norma, linewidths = 0.25, edgecolor = 'black',
+                         alpha = transp, width = espessura, scale = comprimento, scale_units = 'inches', pivot = 'tail', minlength = 0.0)   
 
-    #---------------------------------------------------------------------------------------------------------------------------------------       
-    # plt.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle,
-    #            scale_units = "xy", angles = "xy", pivot = 'tail', cmap = map_red_blue, norm = norma, linewidths = 0.5, edgecolor = 'black', alpha = transp)   
-    #---------------------------------------------------------------------------------------------------------------------------------------
+       #---------------------------------------------------------------------------------------------------------------------------------------       
+       # plt.quiver(points[::pulo,0], points[::pulo,1], Spin_S1, Spin_S2, angle,
+       #            scale_units = "xy", angles = "xy", pivot = 'tail', cmap = map_red_blue, norm = norma, linewidths = 0.5, edgecolor = 'black', alpha = transp)   
+       #---------------------------------------------------------------------------------------------------------------------------------------
 
-    if (tipo_spin < 4):   
-       cbar = fig.colorbar(cp, orientation = 'vertical', shrink = 1.0, boundaries = [0, 180, 360], ticks = [90, 270])
-       cbar.ax.set_yticklabels([L1, L2])
+       if (tipo_spin < 4):   
+          cbar = fig.colorbar(cp, orientation = 'vertical', shrink = 1.0, boundaries = [0, 180, 360], ticks = [90, 270])
+          cbar.ax.set_yticklabels([L1, L2])
 
-    if (tipo_spin > 3):   
-       cbar = fig.colorbar(cp, orientation = 'vertical', shrink = 1.0, values = [45, 90, 135, 180, 225], ticks = [45, 90, 135, 180, 225])
-       cbar.ax.set_yticklabels([L1, L2, L3, L4, L5])
+       if (tipo_spin > 3):   
+          cbar = fig.colorbar(cp, orientation = 'vertical', shrink = 1.0, values = [45, 90, 135, 180, 225], ticks = [45, 90, 135, 180, 225])
+          cbar.ax.set_yticklabels([L1, L2, L3, L4, L5])
 
-    # ax.clabel(cs, inline = False, colors = 'black', fontsize = 8)
+       # ax.clabel(cs, inline = False, colors = 'black', fontsize = 8)
 
-    temp_level = f'{levels_n[i]:_.4f}'
+       temp_level = f'{levels_n[i]:_.4f}'
 
-    if (levels_n[i] <= 0.0): c_energ = temp_level
-    if (levels_n[i] > 0.0):  c_energ = '+' + temp_level
+       if (levels_n[i] <= 0.0): c_energ = temp_level
+       if (levels_n[i] > 0.0):  c_energ = '+' + temp_level
 
-    c_band = str(Banda)
+       c_band = str(Banda)
 
-    if (esc_fermi == 0): plt.title('Band ' + str(Banda) + ':   $E$ = ' + c_energ + ' eV')
-    if (esc_fermi == 1): plt.title('Band ' + str(Banda) + ':   $E-E_{f}$ = ' + c_energ + ' eV')  
+       if (esc_fermi == 0): plt.title('Band ' + str(Banda) + ':   $E$ = ' + c_energ + ' eV')
+       if (esc_fermi == 1): plt.title('Band ' + str(Banda) + ':   $E-E_{f}$ = ' + c_energ + ' eV')  
 
-    #----------------------------------------------------------------------
+       #----------------------------------------------------------------------
 
-    ax.set_xlabel(c1)
-    ax.set_ylabel(c2)
-    ax.set_box_aspect(1.0/1)   
+       ax.set_xlabel(c1)
+       ax.set_ylabel(c2)
+       ax.set_box_aspect(1.0/1)   
 
-    #----------------------------------------------------------------------
+       #----------------------------------------------------------------------
 
-    m = (i + 1)   
-    if (m < 10):                number = '[000' + str(m) + ']'
-    if (m >= 10 and m < 100):   number = '[00' + str(m) + ']'
-    if (m >= 100 and m < 1000): number = '[0' + str(m) + ']'
-    if (m >= 1000):             number = '[' + str(m) + ']' 
+       m = (i + 1)   
+       if (m < 10):                number = '[000' + str(m) + ']'
+       if (m >= 10 and m < 100):   number = '[00' + str(m) + ']'
+       if (m >= 100 and m < 1000): number = '[0' + str(m) + ']'
+       if (m >= 1000):             number = '[' + str(m) + ']' 
 
-    if (save_png == 1): plt.savefig(dir_output + 'figures/Spin_Texture_video_' + number + '_[' + c_energ + '].png', dpi = 300, bbox_inches='tight', pad_inches=0)
-    if (save_pdf == 1): plt.savefig(dir_output + 'Spin_Texture_video_' + number + '_[' + c_energ + '].pdf', dpi = 600, bbox_inches='tight', pad_inches=0)
-    if (save_svg == 1): plt.savefig(dir_output + 'Spin_Texture_video_' + number + '_[' + c_energ + '].svg', dpi = 600, bbox_inches='tight', pad_inches=0)
-    if (save_eps == 1): plt.savefig(dir_output + 'Spin_Texture_video_' + number + '_[' + c_energ + '].eps', dpi = 600, bbox_inches='tight', pad_inches=0)
+       if (save_png == 1): plt.savefig(dir_output + 'figures/Spin_Texture_video_' + number + '_[' + c_energ + '].png', dpi = 300, bbox_inches='tight', pad_inches=0)
+       if (save_pdf == 1): plt.savefig(dir_output + 'Spin_Texture_video_' + number + '_[' + c_energ + '].pdf', dpi = 600, bbox_inches='tight', pad_inches=0)
+       if (save_svg == 1): plt.savefig(dir_output + 'Spin_Texture_video_' + number + '_[' + c_energ + '].svg', dpi = 600, bbox_inches='tight', pad_inches=0)
+       if (save_eps == 1): plt.savefig(dir_output + 'Spin_Texture_video_' + number + '_[' + c_energ + '].eps', dpi = 600, bbox_inches='tight', pad_inches=0)
 
-    fig = plt.gcf()
-    fig.set_size_inches(8,6)
-    # plt.show()
+       fig = plt.gcf()
+       fig.set_size_inches(8,6)
+       # plt.show()
     plt.close()
 
 print(" ")

{vasprocar-1.1.19.103 → vasprocar-1.1.19.105/vasprocar.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vasprocar
-Version: 1.1.19.103
+Version: 1.1.19.105
 Summary: VASProcar is an open-source package written in the Python 3 programming language, which aims to provide an intuitive tool for the post-processing of the output files produced by the DFT VASP/QE codes, through an interactive user interface.
 Home-page: https://doi.org/10.5281/zenodo.6343960
 Download-URL: https://doi.org/10.5281/zenodo.6343960
@@ -9,6 +9,13 @@ Author-email: augusto-lelis@outlook.com, renan.maciel@physics.uu.se
 License: GNU GPLv3
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: numpy>=1.24.1
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: matplotlib>=3.7.0
+Requires-Dist: plotly>=5.13.0
+Requires-Dist: moviepy>=1.0.2
+Requires-Dist: kaleido>=0.2.1
+Requires-Dist: requests>=2.31.0
 
 # VASProcar Copyright (C) 2023   -   GNU GPL-3.0 license