vasprocar 1.1.19.122__tar.gz → 1.1.19.124__tar.gz

{vasprocar-1.1.19.122/vasprocar.egg-info → vasprocar-1.1.19.124}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vasprocar
-Version: 1.1.19.122
+Version: 1.1.19.124
 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

{vasprocar-1.1.19.122 → vasprocar-1.1.19.124}/setup.py

@@ -6,7 +6,7 @@ from typing import Optional
 
 setup(
     name = "vasprocar",
-    version = "1.1.19.122",
+    version = "1.1.19.124",
     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.122 → vasprocar-1.1.19.124}/vasprocar/__main__.py

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

{vasprocar-1.1.19.122 → vasprocar-1.1.19.124}/vasprocar/src/_VASP/_nscf.py

@@ -167,7 +167,8 @@ for wp in range(1, (n_procar+1)):
             porc = (point_k/nk)*100        
 
             if (porc >= temp):
-               print(f'\rAnalyzed  {porc:>3,.0f}%', end='')                 
+               # print(f'\rAnalyzed  {porc:>3,.0f}%', end='')    # informação imprimida sempre na mesma linha 
+               print(f'Analyzed  {porc:>3,.0f}%')                # informação imprimida em linhas consecutivas 
                number += 1
                if (number == 1):
                   temp = 10.0

{vasprocar-1.1.19.122 → vasprocar-1.1.19.124}/vasprocar/src/plot/plot_fermi_surface.py

@@ -211,7 +211,7 @@ if (video == 1):
       image_output = os.getcwd() + '/figures'
 
    image_files = [os.path.join(image_output,img)
-                  for img in os.listdir(image_output)
+                  for img in sorted(os.listdir(image_output))
                   if img.endswith('.png')]
 
    clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(image_files, fps = n_fig)

{vasprocar-1.1.19.122 → vasprocar-1.1.19.124}/vasprocar/src/plot/plot_spin_texture_contour.py

@@ -138,34 +138,6 @@ map_red_blue = colors.LinearSegmentedColormap.from_list("", ["red","pink","pink"
                                                               "cyan","cyan","cyan","blue","magenta","magenta","magenta","red"])
 map_color = map_red_blue
 
-
-#-------------
-min_energ = []
-max_energ = []
-pulo = (pulo + 1)
-levels = [0]*1
-#-----------------------------------
-for b in range(band_i, (band_f +1)):
-    colum = (3 -1) + (b -1)*4 +2
-    energia = spin[:,colum-1] + dE_fermi + Delta_E
-    #-----------------------------
-    min_energ.append(min(energia))
-    max_energ.append(max(energia))
-#---------------------------------
-# energ_i = min(min_energ)
-# energ_f = max(max_energ)
-#----------------------
-if (tipo_contour == 0):
-   for i in range(n_contour + 2):
-       if (i != 0 and i != (n_contour + 1)):
-          levels_n[i-1] = energ_i + ((energ_f - energ_i)/(n_contour + 1))*(i-1)    
-#----------------------
-if (tipo_contour == 1):
-   for i in range(n_contour):
-       levels_n[i] = energ_i + ((energ_f - energ_i)/(n_contour - 1))*(i)
-#-----------------------------------------------------------------------
-
-
 #=========================================================================
 # 2D Plot of Spin Projection on Level Contours: ==========================
 #=========================================================================
@@ -238,49 +210,36 @@ for i in range (1,(6+1)):
       
     #------------------------------------------
 
-    # for b in range(nb):
-    #     energia = spin[:,(3 + b*4)] + dE_fermi
-    #     Spin_Sx = spin[:,(4 + b*4)]
-    #     Spin_Sy = spin[:,(5 + b*4)]
-    #     Spin_Sz = spin[:,(6 + b*4)]
-
     for b in range(band_i, (band_f +1)):
-        #-------------------------------
-        cont = 0
-        if (allowed_bands == 'all'): cont = 1
-        if (allowed_bands == 'even'):
-           if ((int(b/2) -(b/2)) == 0.0): cont = 1
-        if (allowed_bands == 'odd'):
-           if ((int(b/2) -(b/2)) != 0.0): cont = 1
-        #-----------------------------------------
-        if (cont == 1):
-           #---------------------------
-           colum = (3 -1) + (b -1)*4 +2
-           #---------------------------
-           energia = spin[:,colum-1] + dE_fermi
-           Spin_Sx = spin[:,colum+0]
-           Spin_Sy = spin[:,colum+1]
-           Spin_Sz = spin[:,colum+2]
-
-
-        #------------------------
-        # if (tipo_contour == 0):
-        #    energ_i = min(energia)
-        #    energ_f = max(energia)
-        #    for ii in range(n_contour + 2):
-        #        if (ii != 0 and ii != (n_contour + 1)):
-        #           levels_n[ii-1] = energ_i + ((energ_f - energ_i)/(n_contour + 1))*(ii-1)    
-        #----------------------------------------------------------------------------------
-        # if (tipo_contour == 1):
-        #    for ii in range(n_contour):
-        #        levels_n[ii] = energ_i + ((energ_f - energ_i)/(n_contour - 1))*(ii)
-        #---------------------------------------------------------------------------
+        #---------------------------
+        colum = (3 -1) + (b -1)*4 +2
+        energia = spin[:,colum-1] + dE_fermi
+        #-----------------------------------
+        Spin_Sx = spin[:,(4 + b*4)]
+        Spin_Sy = spin[:,(5 + b*4)]
+        Spin_Sz = spin[:,(6 + b*4)]
+
+        pulo = (pulo + 1)
+        levels = [0]*1
+
+        #------------------------------------------------------------------------------
+
+        if (tipo_contour == 0):
+           energ_i = min(energia)
+           energ_f = max(energia)
+           for ii in range(n_contour + 2):
+               if (ii != 0 and ii != (n_contour + 1)):
+                  levels_n[ii-1] = energ_i + ((energ_f - energ_i)/(n_contour + 1))*(ii-1)    
+
+        if (tipo_contour == 1):
+           for ii in range(n_contour):
+               levels_n[ii] = energ_i + ((energ_f - energ_i)/(n_contour - 1))*(ii)
        
+        # Realizando a interpolação de [Kx, Ky, Energia] -------------------------
 
-        #---------------------------------------------------------------------------
-        # Realizando a interpolação de [Kx, Ky, Energia] ---------------------------
         e_grid = griddata((eixo1,eixo2), energia, (x_grid,y_grid), method = 'cubic')
-        #---------------------------------------------------------------------------
+
+        #------------------------------------------------------------------------------
 
         for j in range(n_contour):
 
@@ -331,23 +290,12 @@ for i in range (1,(6+1)):
    
                   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 == 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]]   
+                      if (i == 1): v_spin = [Spin_S1[k], 0.0]
+                      if (i == 2): v_spin = [0.0, Spin_S2[k]]
+                      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 ---

vasprocar-1.1.19.124/vasprocar/src/plot/plot_spin_texture_contour_video.py

@@ -0,0 +1,417 @@
+
+import os
+import numpy as np
+import matplotlib as mpl
+from matplotlib import cm
+from matplotlib import pyplot as plt
+import matplotlib.ticker as ticker
+from mpl_toolkits.mplot3d.axes3d import Axes3D
+from matplotlib.ticker import LinearLocator, FormatStrFormatter
+import matplotlib.colors as colors
+from scipy.interpolate import griddata
+
+print(" ")
+print("========== 2D Plot of Spin Projection (Level Contours) ==========")
+
+if (tipo_contour < 2):
+   levels_n = [0.0]*n_contour
+
+#--------------------------------------------------------------------------
+# Variables that define the thickness and length of vectors in the plot ---
+#--------------------------------------------------------------------------
+if ((fator > -1.0 and fator < 1.0) or fator == -1.0):
+   fator == 1.0
+   
+if (fator > 0.0):
+   fator = 1/fator
+   
+if (fator < 0.0):
+   fator = (fator**2)**0.5
+
+espessura = 0.005        #  Use espessura = 100 if you only want to plot the triangular head of the arrow and eliminate the tail, 
+comprimento = 2.0*fator  #  which makes it easier to adjust the size/volume of the vectors by adjusting the comprimento variable.
+#----------------------
+
+#------------------------------------------------------------------------
+# Test to know which directories must be correctly informed -------------
+#------------------------------------------------------------------------
+if os.path.isdir('src'):
+   0 == 0
+   dir_output = dir_files + '/output/Spin_Texture/'
+else:
+   dir_files = ''
+   dir_output = ''
+#-----------------
+
+#---------------------------------------------------------------------------------------
+# Checking if the "figures" subfolder exists, if it doesn't exist it will be created ---
+#---------------------------------------------------------------------------------------
+if os.path.isdir(dir_output + 'figures'):
+   0 == 0
+else:
+   os.mkdir(dir_output + 'figures')
+#----------------------------------    
+
+#======================================================================
+#======================================================================
+# File Structure for Plot via Matplotlib ==============================
+#======================================================================
+#====================================================================== 
+
+spin = np.loadtxt(dir_output + 'Spin_Texture.dat') 
+spin.shape
+
+print(" ")
+print(".........................")
+print("..... Wait a moment .....")
+print(".........................")  
+print(". It might take a while .")
+print(".........................")
+
+#----------------------------------------------------------------------
+
+if (esc_fermi == 0): dE_fermi = 0.0
+if (esc_fermi == 1): dE_fermi = (Efermi)*(-1)
+
+#----------------------------------------------------------------------
+
+if (Plano_k == 1):     # Plane (kx,ky) or (k1,k2)     
+   eixo1 = spin[:,0]
+   eixo2 = spin[:,1]
+   
+if (Plano_k == 2):     # Plane (kx,kz) or (k1,k3)     
+   eixo1 = spin[:,0]
+   eixo2 = spin[:,2]
+   
+if (Plano_k == 3):     # Plane (ky,kz) or (k2,k3)    
+   eixo1 = spin[:,1]
+   eixo2 = spin[:,2]
+
+#---------------------------
+b = band_i
+colum = (3 -1) + (b -1)*4 +2
+energia = spin[:,colum-1] + dE_fermi
+#-----------------------------------
+Spin_Sx = spin[:,(4 + b*4)]
+Spin_Sy = spin[:,(5 + b*4)]
+Spin_Sz = spin[:,(6 + b*4)]
+
+pulo = (pulo + 1)
+levels = [0]*1
+
+#----------------------------------------------------------------------
+
+if (tipo_contour == 0):
+   energ_i = min(energia)
+   energ_f = max(energia)
+   for i in range(n_contour + 2):
+       if (i != 0 and i != (n_contour + 1)):
+          levels_n[i-1] = energ_i + ((energ_f - energ_i)/(n_contour + 1))*(i-1)    
+
+if (tipo_contour == 1):
+   for i in range(n_contour):
+       levels_n[i] = energ_i + ((energ_f - energ_i)/(n_contour - 1))*(i)
+       
+#----------------------------------------------------------------------
+   
+if (Plano_k == 1):
+   s1 = 'Sx'; s2 = 'Sy'; s3 = 'Sz'
+   sa = r'${S}_{x}$'; sb = r'${S}_{y}$'; sc = r'${S}_{z}$' 
+if (Plano_k == 2):
+   s1 = 'Sx'; s2 = 'Sz'; s3 = 'Sy'
+   sa = r'${S}_{x}$'; sb = r'${S}_{z}$'; sc = r'${S}_{y}$'
+if (Plano_k == 3):
+   s1 = 'Sy'; s2 = 'Sz'; s3 = 'Sx'
+   sa = r'${S}_{y}$'; sb = r'${S}_{z}$'; sc = r'${S}_{x}$'
+
+#----------------------------------------------------------------------
+   
+if (Dimensao < 4 and Plano_k == 1):
+   ca = r'${k}_{x}$'; cb = r'${k}_{y}$'
+if (Dimensao < 4 and Plano_k == 2):
+   ca = r'${k}_{x}$'; cb = r'${k}_{z}$'
+if (Dimensao < 4 and Plano_k == 3):
+   ca = r'${k}_{y}$'; cb = r'${k}_{z}$'
+   
+#--------------------------------------   
+
+if (Dimensao == 4 and Plano_k == 1):
+   ca = r'${k}_{1}$'; cb = r'${k}_{2}$'
+if (Dimensao == 4 and Plano_k == 2):
+   ca = r'${k}_{1}$'; cb = r'${k}_{3}$'
+if (Dimensao == 4 and Plano_k == 3):
+   ca = r'${k}_{2}$'; cb = r'${k}_{3}$'
+
+#-------------------------------------- 
+
+if (Dimensao == 1): cc = r' $(2{\pi}/{a})$'
+if (Dimensao == 2): cc = r' $({\AA}^{-1})$'
+if (Dimensao == 3): cc = r' $({nm}^{-1})$'
+if (Dimensao == 4): cc = ' '
+
+# Create meshgrid for x,y ------------------------------------------------
+
+xi = np.linspace(min(eixo1), max(eixo1), n_d)
+yi = np.linspace(min(eixo2), max(eixo2), n_d)
+x_grid, y_grid = np.meshgrid(xi,yi)
+
+e_grid = griddata((eixo1,eixo2), energia, (x_grid,y_grid), method = 'cubic')
+
+#=========================================================================
+# 2D Plot of Spin Projection on Level Contours: ==========================
+#=========================================================================
+
+for i in range (n_contour):
+
+    map_gray = (mpl.colors.ListedColormap(['darkgray', 'darkgray']))
+
+    fig = plt.figure()
+    ax = fig.add_subplot(111)
+
+#-----------------------------------------------------------------------
+
+    if (tipo_spin == 1):
+       c1 = sa + '  |  ' + ca + cc
+       c2 = cb + cc
+       L1 = sa + r'${\uparrow}$'
+       L2 = sa + r'${\downarrow}$'
+       rotulo = s1
+      
+    if (tipo_spin == 2):
+       c1 = ca + cc
+       c2 = sb + '  |  ' + cb + cc      
+       L1 = sb + r'${\uparrow}$'
+       L2 = sb + r'${\downarrow}$'
+       rotulo = s2
+      
+    if (tipo_spin == 3):
+       c1 = sc + '  |  ' + ca + cc
+       c2 = cb + cc      
+       L1 = sc + r'${\uparrow}$'
+       L2 = sc + r'${\downarrow}$'
+       rotulo = s3
+      
+    if (tipo_spin == 4):     
+       c1 = sa + '  |  ' + ca + cc
+       c2 = sb + '  |  ' + cb + cc
+       rotulo = s1 + s2
+
+    if (tipo_spin == 5):     
+       rotulo = s1 + s3
+       c1 = sa + '  |  ' + ca + cc
+       c2 = sc + '  |  ' + cb + cc
+
+    if (tipo_spin == 6):     
+       rotulo = s2 + s3
+       c1 = sc + '  |  ' + ca + cc
+       c2 = sb + '  |  ' + cb + cc
+      
+    if ((Plano_k == 1 and tipo_spin == 4) or (Plano_k == 2 and tipo_spin == 5) or (Plano_k == 3 and tipo_spin == 5)):             
+       L1 = r'${S}_{x}{\uparrow} + {S}_{y}{\uparrow}$'
+       L2 = r'${S}_{x|y}{\uparrow}$'
+       L3 = r'${S}_{x|y}{\uparrow} + {S}_{y|x}{\downarrow}$'
+       L4 = r'${S}_{x|y}{\downarrow}$'
+       L5 = r'${S}_{x}{\downarrow} + {S}_{y}{\downarrow}$'
+
+    if ((Plano_k == 1 and tipo_spin == 5) or (Plano_k == 2 and tipo_spin == 4) or (Plano_k == 3 and tipo_spin == 6)): 
+       L1 = r'${S}_{x}{\uparrow} + {S}_{z}{\uparrow}$'
+       L2 = r'${S}_{x|z}{\uparrow}$'
+       L3 = r'${S}_{x|z}{\uparrow} + {S}_{z|x}{\downarrow}$'
+       L4 = r'${S}_{x|z}{\downarrow}$'
+       L5 = r'${S}_{x}{\downarrow} + {S}_{z}{\downarrow}$'
+
+    if ((Plano_k == 1 and tipo_spin == 6) or (Plano_k == 2 and tipo_spin == 6) or (Plano_k == 3 and tipo_spin == 4)):             
+       L1 = r'${S}_{y}{\uparrow} + {S}_{z}{\uparrow}$'
+       L2 = r'${S}_{y|z}{\uparrow}$'
+       L3 = r'${S}_{y|z}{\uparrow} + {S}_{z|y}{\downarrow}$'
+       L4 = r'${S}_{y|z}{\downarrow}$'
+       L5 = r'${S}_{y}{\downarrow} + {S}_{z}{\downarrow}$'      
+      
+#-----------------------------------------------------------------------
+
+    # plt.contourf(x_grid, y_grid, e_grid, levels_n, cmap = "bwr", alpha = 0.05, antialiased = True)
+       
+    #---------------------------------------------------------------------------------------------------------------------------------------
+    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]
+    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 == 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
+   
+       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 == 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",
+                                                                       "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)
+             
+      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 == 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 == 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)   
+       #---------------------------------------------------------------------------------------------------------------------------------------
+
+       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])
+
+       # ax.clabel(cs, inline = False, colors = 'black', fontsize = 8)
+
+       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
+
+       c_band = str(band_i)
+
+       if (esc_fermi == 0): plt.title('Band ' + str(band_i) + ':   $E$ = ' + c_energ + ' eV')
+       if (esc_fermi == 1): plt.title('Band ' + str(band_i) + ':   $E-E_{f}$ = ' + c_energ + ' eV')  
+
+       #----------------------------------------------------------------------
+
+       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) + ']' 
+
+       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()
+    plt.close()
+
+print(" ")
+print("=== Creating a video (.mp4) of the 2D Spin Texture (Level Contours) ===")
+print(" ")
+
+#======================================================================
+# Creating a video with the generated images (moviepy): ===============
+#======================================================================
+   
+import moviepy.video.io.ImageSequenceClip
+
+if (dir_output != ''):
+   image_output = dir_output + 'figures'
+if (dir_output == ''):
+   image_output = os.getcwd() + '/figures'
+
+image_files = [os.path.join(image_output,img)
+               for img in os.listdir(image_output)
+               if img.endswith('.png')]
+
+clip = moviepy.video.io.ImageSequenceClip.ImageSequenceClip(image_files, fps = n_fig)
+
+clip.write_videofile(dir_output + 'STexture_video.mp4')    
+
+#---------------------------------------------------------------------------
+if (dir_output == ''):
+   print(" ")
+   print("========================== Concluded! ==========================")
+#---------------------------------------------------------------------------
+ 
+# VASProcar Copyright (C) 2023
+# GNU GPL-3.0 license

{vasprocar-1.1.19.122 → vasprocar-1.1.19.124}/vasprocar/src/spin_texture_contour_video.py

@@ -37,10 +37,6 @@ execute_python_file(filename = DFT + '_var_kpoints.py')
 soma_1 = dk[0] + dk[1] + dk[2]
 soma_2 = dk[3] + dk[4] + dk[5]
 
-print(f'soma_1 = {soma_1}')
-print(f'soma_2 = {soma_2}')
-print(f'dk = {dk}')
-
 if (soma_1 != 2 and soma_2 != 2):
    print ("============================================================")
    print ("!!! ERROR !!!                                               ")
@@ -300,15 +296,14 @@ if ((soma_1 == 2 or soma_2 == 2) and len(inputs) == 0):
    #----------------------------------   
    if (soma_1 == 2 and soma_2 == 2 and escolha == 1):
       Dimensao = 4
-   #----------------------------------   
-    
-if ((soma_1 == 2 or soma_2 == 2) and len(inputs) != 0):
-   #-----------------
+
+if (soma_1 == 2 or soma_2 == 2):
+   #----------------------------------  
    if (Dimensao < 4):
       if (dk[3] == 1 and dk[4] == 1): Plano_k = 1  #  kxky-plan
       if (dk[3] == 1 and dk[5] == 1): Plano_k = 2  #  kxkz-plan
       if (dk[4] == 1 and dk[5] == 1): Plano_k = 3  #  kykz-plan
-   #-----------------
+   #----------------------------------   
    if (Dimensao == 4):
       if (dk[0] == 1 and dk[1] == 1): Plano_k = 1  #  k1k2-plan
       if (dk[0] == 1 and dk[2] == 1): Plano_k = 2  #  k1k3-plan

{vasprocar-1.1.19.122 → vasprocar-1.1.19.124/vasprocar.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vasprocar
-Version: 1.1.19.122
+Version: 1.1.19.124
 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