vasprocar 1.1.19.117__tar.gz → 1.1.19.118__tar.gz

{vasprocar-1.1.19.117/vasprocar.egg-info → vasprocar-1.1.19.118}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vasprocar
-Version: 1.1.19.117
+Version: 1.1.19.118
 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.117 → vasprocar-1.1.19.118}/setup.py

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

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

{vasprocar-1.1.19.117 → vasprocar-1.1.19.118}/vasprocar/src/inputs/input.vasprocar.spin_video

@@ -26,8 +26,8 @@ tipo_spin = 4
 ##############################################################
 # Which band do you want to analyze? =========================
 ############################################################## 
-n_band = 1
-
+band_i = 1
+band_f = 2
 
 
 #######################################################################  

{vasprocar-1.1.19.117 → vasprocar-1.1.19.118}/vasprocar/src/plot/plot_spin_texture_contour.py

@@ -138,6 +138,34 @@ 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: ==========================
 #=========================================================================
@@ -210,34 +238,49 @@ for i in range (1,(6+1)):
       
     #------------------------------------------
 
-    for b in range(n_band_f - n_band_i + 1):
-
-        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)]
-
-        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)
+    # 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)
+        #---------------------------------------------------------------------------
        
-        # 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):
 

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

@@ -0,0 +1,408 @@
+
+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]
+
+
+#-------------
+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)
+#-----------------------------------------------------------------------
+       
+   
+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')
+
+
+# Color Maps -------------------------------------------------------------
+# 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"])
+map_gray = (mpl.colors.ListedColormap(['darkgray', 'darkgray']))
+norma = colors.Normalize(0, 360)
+
+
+#=========================================================================
+# 2D Plot of Spin Projection on Level Contours: ==========================
+#=========================================================================
+
+for i in range (n_contour):
+    #----------------------
+    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}$'      
+
+    for b in range(band_i, (band_f +1)):
+        #-------------------------------
+        cont = 0; points = []
+        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 + Delta_E
+           Spin_Sx = spin[:,colum+0]
+           Spin_Sy = spin[:,colum+1]
+           Spin_Sz = spin[:,colum+2]
+
+           #-----------------------------------------------------------------------------------------------
+           # 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 and cont == 1):
+           #------------------------------------------------------------------------------           
+           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]
+
+           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(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')  
+
+    #----------------
+    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.117 → vasprocar-1.1.19.118}/vasprocar/src/spin_texture_contour.py

@@ -1,4 +1,4 @@
-# VASProcar Copyright (C) 2023
+linha += 1; lines.insert(linha, f'allowed_bands = "all"    # Allowed "all", "even" or "odd" bands \n')# VASProcar Copyright (C) 2023
 # GNU GPL-3.0 license
 
 import numpy as np
@@ -57,8 +57,8 @@ if (escolha == -1):
       print(" ")
 
    if (esc_bands == 0):
-      n_band_i = 1
-      n_band_f = nb
+      band_i = 1
+      band_f = nb
 
    if (esc_bands == 1):
       if (len(inputs) == 0): 
@@ -71,8 +71,8 @@ if (escolha == -1):
          print ("band_i band_f:  1 15                                          ")
          print ("band_i band_f:  7 7                                           ")
          print ("##############################################################")
-         n_band_i, n_band_f = input ("band_i band_f: ").replace(':', ' ').replace('-', ' ').replace('*', ' ').split()
-         n_band_i = int(n_band_i); n_band_f = int(n_band_f)
+         band_i, band_f = input ("band_i band_f: ").replace(':', ' ').replace('-', ' ').replace('*', ' ').split()
+         band_i = int(band_i); band_f = int(band_f)
          print (" ")
 
    print ("#######################################################################")  
@@ -335,8 +335,8 @@ if (escolha == -1):
 #-----------------------------------------------------------------------------
 
 if (escolha == 1):
-   n_band_i = 1
-   n_band_f = nb
+   band_i = 1
+   band_f = nb
    esc_fermi = 1
    rot_energ = 0
    esc_ions = 0
@@ -355,7 +355,6 @@ if (esc_fermi == 0): dE_fermi = 0.0
 if (esc_fermi == 1): dE_fermi = (Efermi)*(-1)     
 #--------------------------------------------
 
-bands_range = '1:' + str(nb)
 
 #======================================================================
 # Obtaining the results from DFT outpout files ========================
@@ -395,17 +394,28 @@ for i in range (n_procar*nk):
     if (Dimensao == 4):
        spin_texture .write(f'{k1} {k2} {k3} ')
 
+    # for j in range (1,(nb+1)):
+    #     VTemp = spin.readline().split()
+    #     if (j >= band_i and j <= band_f):
+    #        #--------------------
+    #        energia = bandas[:,j]
+    #        #--------------------
+    #        Sx = float(VTemp[2]) + float(VTemp[3])
+    #        Sy = float(VTemp[4]) + float(VTemp[5])
+    #        Sz = float(VTemp[6]) + float(VTemp[7])
+    #        spin_texture.write(f'{energia[i]} {Sx} {Sy} {Sz} ')
+    # spin_texture.write(f' \n')
+
     for j in range (1,(nb+1)):
         VTemp = spin.readline().split()
-        if (j >= n_band_i and j <= n_band_f):
-           #--------------------
-           energia = bandas[:,j]
-           #--------------------
-           Sx = float(VTemp[2]) + float(VTemp[3])
-           Sy = float(VTemp[4]) + float(VTemp[5])
-           Sz = float(VTemp[6]) + float(VTemp[7])
-           spin_texture.write(f'{energia[i]} {Sx} {Sy} {Sz} ')
-    spin_texture.write(f' \n')      
+        #--------------------
+        energia = bandas[:,j]
+        #--------------------
+        Sx = float(VTemp[2]) + float(VTemp[3])
+        Sy = float(VTemp[4]) + float(VTemp[5])
+        Sz = float(VTemp[6]) + float(VTemp[7])
+        spin_texture.write(f'{energia[i]} {Sx} {Sy} {Sz} ')
+    spin_texture.write(f' \n')   
 
 #-------------------
 inform.close()
@@ -464,11 +474,12 @@ linha += 1; lines.insert(linha, '#==============================================
 linha += 1; lines.insert(linha, '# These are the parameters that allows the code to run separatedly === \n')
 linha += 1; lines.insert(linha, '#===================================================================== \n')
 linha += 1; lines.insert(linha, '\n')
-linha += 1; lines.insert(linha, f'n_procar = {n_procar}  #  Total Num. of PROCAR files \n')
-linha += 1; lines.insert(linha, f'nk = {nk}              #  Total Num. of k-points \n')
-linha += 1; lines.insert(linha, f'nb = {nb}              #  Total Num. of bands \n')
-linha += 1; lines.insert(linha, f'n_band_i = {n_band_i}  # Initial band to be projected onto the Fermi contour \n')
-linha += 1; lines.insert(linha, f'n_band_f = {n_band_f}  # Final band to be projected onto the Fermi contour \n')
+linha += 1; lines.insert(linha, f'n_procar = {n_procar}    #  Total Num. of PROCAR files \n')
+linha += 1; lines.insert(linha, f'nk = {nk}                #  Total Num. of k-points \n')
+linha += 1; lines.insert(linha, f'nb = {nb}                #  Total Num. of bands \n')
+linha += 1; lines.insert(linha, f'band_i = {band_i}        # Initial band to be projected onto the Fermi contour \n')
+linha += 1; lines.insert(linha, f'band_f = {band_f}        # Final band to be projected onto the Fermi contour \n')
+linha += 1; lines.insert(linha, f'allowed_bands = "all"    # Allowed "all", "even" or "odd" bands \n')
 linha += 1; lines.insert(linha, f'rot_energ = {rot_energ}  #  Choose whether you want to label contour energies, where [0] = NO and [1] = YES \n')
 linha += 1; lines.insert(linha, f'fator = {fator}  #  Factor by which the length of the spin vectors will be increased or decreased \n')
 linha += 1; lines.insert(linha, f'pulo = {pulo}    #  Number of spin vectors to be ignored interleaved along the path of the band contour \n')
@@ -478,7 +489,6 @@ linha += 1; lines.insert(linha, f'Plano_k = {Plano_k}    #  [1] kxky or k1k2; [2
 linha += 1; lines.insert(linha, f'transp = {transp}      #  Transparency applied to the color gradient of the contours 2D plot \n')
 linha += 1; lines.insert(linha, f'tipo_contour = {tipo_contour}  #  How to obtain the energies of the Level Curves: Where [0] is automatic; [1] energy range and [2] entered manually \n')
 linha += 1; lines.insert(linha, f'n_contour = {n_contour}        #  Number of Level Contours to be obtained \n')
-linha += 1; lines.insert(linha, f'bands_range = "{bands_range}" \n')
 linha += 1; lines.insert(linha, f'Efermi = {Efermi}        #  Fermi energy from DFT outpout files \n')
 linha += 1; lines.insert(linha, f'esc_fermi = {esc_fermi}  #  Would you like to shift the Fermi level? [0] No, use the value obtained from VASP [1] Yes, shift the Fermi level to 0.0 eV \n')
 #--------------------------------