vasprocar 1.1.19.142__tar.gz → 1.1.19.144__tar.gz

{vasprocar-1.1.19.142/vasprocar.egg-info → vasprocar-1.1.19.144}/PKG-INFO

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

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

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

{vasprocar-1.1.19.142 → vasprocar-1.1.19.144}/vasprocar/src/_QE/_nscf.py

@@ -630,6 +630,7 @@ for wp in range(1,(n_procar+1)):
               #---------------------------
 
                   VTemp = project.readline().split()
+                  print(VTemp)
                   orb[wp][t_orb][point_k][Band][ion_n] = orb[wp][t_orb][point_k][Band][ion_n] + float(VTemp[2])
                   tot[wp][point_k][Band][ion_n] = tot[wp][point_k][Band][ion_n] + float(VTemp[2])
 

{vasprocar-1.1.19.142 → vasprocar-1.1.19.144}/vasprocar/src/_QE/dos_pdos_ldos.py

@@ -509,7 +509,7 @@ linha += 1; lines.insert(linha, '\n')
 linha += 1; lines.insert(linha, f'n_procar = {n_procar}; nk  = {nk}; x_inicial = {x_inicial}; x_final = {x_final}; energ_min = {y_inicial}; energ_max = {y_final}; lorbit = {lorbit}; esc = {esc} \n')
 linha += 1; lines.insert(linha, f'Efermi = {Efermi}        #  Fermi energy from DFT outpout file \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')
-linha += 1; lines.insert(linha, f'save_png = {save_png}; ; save_pdf = {save_pdf}; save_svg = {save_svg}; save_eps = {save_eps}  #  Plotting output format, onde [0] = NO e [1] = YES \n')                       
+linha += 1; lines.insert(linha, f'save_png = {save_png}; save_pdf = {save_pdf}; save_svg = {save_svg}; save_eps = {save_eps}  #  Plotting output format, onde [0] = NO e [1] = YES \n')                       
 linha += 1; lines.insert(linha, '\n')
 linha += 1; lines.insert(linha, '#===================================================================== \n')
 

{vasprocar-1.1.19.142 → vasprocar-1.1.19.144}/vasprocar/src/_settings.py

@@ -121,6 +121,10 @@ if (len(inputs) == 0 and DFT == '_VASP/'):
       print("## 2D projection of the spatial location of bands (regions) ##")
       print("## [32] Default   --   [-32] Custom                         ##")
       print("## ======================================================== ##")
+      print("##                !!!!!  UNDER TESTS  !!!!!                 ##")
+      print("## 2D projection [ki,kj] of the spatial location of bands   ##")
+      print("## [37] Default   --   [-37] Custom                         ##")
+      print("## ======================================================== ##")
       print("## 2D projection of states Character:                       ##")
       print("## [33] Default   --   [-33] Custom                         ##")
       print("## ======================================================== ##")
@@ -321,7 +325,16 @@ if (opcao == 31 or opcao == -31):
     
 if (opcao == 32 or opcao == -32):
    execute_python_file(filename = 'projecao_localizacao.py')
-    
+
+
+# TESTE ???????????????????????????????????????????????????????
+# ?????????????????????????????????????????????????????????????
+if ((opcao == 37 or opcao == -37) and (DFT == '_VASP/')):
+   execute_python_file(filename = 'projecao_localizacao_contour_video')
+# TESTE ???????????????????????????????????????????????????????
+# ?????????????????????????????????????????????????????????????
+
+
 if (opcao == 33 or opcao == -33):
    execute_python_file(filename = 'projecao_psi.py')
 

vasprocar-1.1.19.144/vasprocar/src/etc/codes_append/Gerador_Slab.py

@@ -0,0 +1,22 @@
+import ase
+from ase.build import surface
+from ase.io import read
+
+file_path = 'POSCAR_SiO2_Bulk'
+n_layers = 2
+direction = [-1, 0, -1]
+vacuum = 15
+
+def build_nlayer(poscar_file, n_layers, direction, vacuum):
+    str_dir = ''
+    for i in direction: str_dir += str(i)
+    formula = poscar_file.get_chemical_formula()    
+    ### Generate the surfaces
+
+    surface = ase.build.surface(poscar_file,direction,n_layers,vacuum=vacuum)
+    ase.io.vasp.write_vasp(f'POSCAR_{formula}_{str_dir}_{n_layers}layers.vasp',surface,direct=False,sort=True)
+
+poscar = read(file_path)
+
+build_nlayer(poscar, n_layers, direction, vacuum)
+

vasprocar-1.1.19.144/vasprocar/src/etc/codes_append/Projection_BZs.py

@@ -0,0 +1,161 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.spatial import Voronoi
+
+
+
+
+#---------------------------------------------------------
+# Vetores da rede real (Supercélula S) -------------------
+#---------------------------------------------------------
+S1x = -4.8376251965;  S1y =  0.00000000000;  S1z = 0.000000000000
+S2x =  0.0000000000;  S2y = -17.4125575085;  S2z = 0.000000000000
+S3x =  0.0000000000;  S3y =  0.00000000000;  S3z = 34.87887456188 
+#-----------------------------------------------------------------
+
+
+
+
+#--------------------------------------------------------------------
+# Vetores da rede real (Rede Pristina P) ----------------------------
+#--------------------------------------------------------------------
+P1x = -2.418812598250;  P1y =  0.0000000000000;  P1z = 0.000000000000
+P2x = -1.209406299125;  P2y = -2.1765696885625;  P2z = 0.000000000000
+P3x =  0.000000000000;  P3y =  0.0000000000000;  P3z = 34.87887456188
+#--------------------------------------------------------------------
+# k-points de interesse (Rede Pristina P) ---------------------------
+#--------------------------------------------------------------------
+K1u = [ [+0.5, +0.0], [+0.0, +0.5], [-0.5, +0.0], [+0.0, -0.5], [+0.5, +0.5], [-0.5, -0.5] ]
+K1u += [ [-0.6666666666666666, -0.3333333333333333], [+0.6666666666666666, +0.3333333333333333] ]
+#-----------------------------------------------------------------------------------------------
+
+
+
+
+#------------------------------------------------------
+# Obtendo a rede recíproca da Supercélula S -----------
+#------------------------------------------------------
+ss1 = S1x*((S2y*S3z) - (S2z*S3y))
+ss2 = S1y*((S2z*S3x) - (S2x*S3z))
+ss3 = S1z*((S2x*S3y) - (S2y*S3x))
+ss =  ss1 + ss2 + ss3
+#-------------------------------
+B1x = ((S2y*S3z) - (S2z*S3y))/ss
+B1y = ((S2z*S3x) - (S2x*S3z))/ss 
+B1z = ((S2x*S3y) - (S2y*S3x))/ss
+B2x = ((S3y*S1z) - (S3z*S1y))/ss                             
+B2y = ((S3z*S1x) - (S3x*S1z))/ss
+B2z = ((S3x*S1y) - (S3y*S1x))/ss
+B3x = ((S1y*S2z) - (S1z*S2y))/ss
+B3y = ((S1z*S2x) - (S1x*S2z))/ss
+B3z = ((S1x*S2y) - (S1y*S2x))/ss
+#-------------------------------
+ft = 6.2831853071795860
+S1b = [B1x*ft, B1y*ft]
+S2b = [B2x*ft, B2y*ft]
+#---------------------
+
+
+
+
+#------------------------------------------------------
+# Obtendo a rede recíproca da Rede Pristina P ---------
+# Obtendo as coord. cart. dos k-points de interesse ---
+#------------------------------------------------------
+ss1 = P1x*((P2y*P3z) - (P2z*P3y))
+ss2 = P1y*((P2z*P3x) - (P2x*P3z))
+ss3 = P1z*((P2x*P3y) - (P2y*P3x))
+ss =  ss1 + ss2 + ss3
+#-------------------------------
+B1x = ((P2y*P3z) - (P2z*P3y))/ss
+B1y = ((P2z*P3x) - (P2x*P3z))/ss 
+B1z = ((P2x*P3y) - (P2y*P3x))/ss
+B2x = ((P3y*P1z) - (P3z*P1y))/ss                             
+B2y = ((P3z*P1x) - (P3x*P1z))/ss
+B2z = ((P3x*P1y) - (P3y*P1x))/ss
+B3x = ((P1y*P2z) - (P1z*P2y))/ss
+B3y = ((P1z*P2x) - (P1x*P2z))/ss
+B3z = ((P1x*P2y) - (P1y*P2x))/ss
+#-------------------------------
+ft = 6.2831853071795860
+P1b = [B1x*ft, B1y*ft]
+P2b = [B2x*ft, B2y*ft]
+#---------------------
+
+
+
+
+#-----------------------
+fig, ax = plt.subplots()
+#-----------------------
+
+#-------------------------------------------------------------
+# Construindo a BZ 2D usando Voronoi (Supercélula S) ---------
+#-------------------------------------------------------------
+nx, ny = 12, 12  # Número de pontos na grade
+points = np.dot(np.mgrid[-nx:nx+1, -ny:ny+1].reshape(2, -1).T, np.array([S1b, S2b]))
+vor = Voronoi(points)
+#--------------------------------
+# Plotando a zona de Brillouin 2D
+#--------------------------------
+for simplex in vor.ridge_vertices:
+    simplex = np.asarray(simplex)
+    if np.all(simplex >= 0): ax.plot(vor.vertices[simplex, 0], vor.vertices[simplex, 1], color = 'black', linewidth = 0.25, alpha = 0.5, zorder=3)
+#------------------------------------------------------------------------------------------------
+plt.quiver(0, 0, S1b[0], S1b[1], angles='xy', scale_units='xy', scale=1.0, color='blue', alpha = 0.5, zorder=0)
+plt.quiver(0, 0, S2b[0], S2b[1], angles='xy', scale_units='xy', scale=1.0, color='blue', alpha = 0.5, zorder=0)
+plt.text((S1b[0] +0.005), (S1b[1] +0.005), "B$_1$", fontsize=10, alpha = 0.5, color="black")
+plt.text((S2b[0] +0.010), (S2b[1] +0.010), "B$_2$", fontsize=10, alpha = 0.5, color="black")
+#-------------------------------------------------------------------------------------------
+
+
+
+#-------------------------------------------------------------
+# Construindo a BZ 2D usando Voronoi (Rede Pristina P) -------
+#-------------------------------------------------------------
+nx, ny = 12, 12  # Número de pontos na grade
+points = np.dot(np.mgrid[-nx:nx+1, -ny:ny+1].reshape(2, -1).T, np.array([P1b, P2b]))
+vor = Voronoi(points)
+#--------------------------------
+# Plotando a zona de Brillouin 2D
+#--------------------------------
+for simplex in vor.ridge_vertices:
+    simplex = np.asarray(simplex)
+    if np.all(simplex >= 0): ax.plot(vor.vertices[simplex, 0], vor.vertices[simplex, 1], color = 'black', linewidth = 0.5, zorder=2)
+#------------------------------------------------------------------------------------------------
+plt.quiver(0, 0, P1b[0], P1b[1], angles='xy', scale_units='xy', scale=1.0, color='red', alpha = 0.5, zorder=1)
+plt.quiver(0, 0, P2b[0], P2b[1], angles='xy', scale_units='xy', scale=1.0, color='red', alpha = 0.5, zorder=1)
+plt.text((P1b[0] +0.005), (P1b[1] +0.005), "B$_1$", fontsize=10, alpha = 0.5, color="black")
+plt.text((P2b[0] +0.010), (P2b[1] +0.010), "B$_2$", fontsize=10, alpha = 0.5, color="black")
+#-------------------------------------------------------------------------------------------
+
+
+
+
+#-----------------------------------------------------------------
+# Ajustar os limites dos eixos para refletir os comprimentos reais
+#-----------------------------------------------------------------
+Sx_min, Sx_max = vor.vertices[:, 0].min(), vor.vertices[:, 0].max()
+Sy_min, Sy_max = vor.vertices[:, 1].min(), vor.vertices[:, 1].max()
+
+# Adicionar configuração do gráfico
+plt.title("1º Brillouin Zone (2D)")
+plt.xlabel("kx")
+plt.ylabel("ky")
+
+x_min = -3.0
+x_max = +2.0
+y_min = -3.2
+y_max = +2.0
+
+plt.xlim((x_min, x_max))
+plt.ylim((y_min, y_max))
+
+#----------------------------------------------------
+# Ajustar aspect ratio para refletir proporções reais
+#----------------------------------------------------
+ax.set_box_aspect(abs((y_max - y_min) / (x_max - x_min)))   # Razão dos comprimentos dos eixos
+
+plt.savefig('Brillouin_Zone_2D_Cr2Br2S2_C2.png', dpi = 600, bbox_inches='tight', pad_inches=0)
+plt.savefig('Brillouin_Zone_2D_Cr2Br2S2_C2.eps', dpi = 600, bbox_inches='tight', pad_inches=0)
+# plt.show()

vasprocar-1.1.19.144/vasprocar/src/etc/codes_append/Projection_kpoints.py

@@ -0,0 +1,208 @@
+import os
+import numpy as np
+from scipy.spatial import Voronoi
+#--------------------------------
+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 mcolors
+
+
+
+
+#---------------------------------------------------------
+# Vetores da rede real (Supercélula S) -------------------
+#---------------------------------------------------------
+S1x = -4.8376251965;  S1y =  0.00000000000;  S1z = 0.000000000000
+S2x =  0.0000000000;  S2y = -17.4125575085;  S2z = 0.000000000000
+S3x =  0.0000000000;  S3y =  0.00000000000;  S3z = 34.87887456188 
+#-----------------------------------------------------------------
+
+
+
+
+#----------------------------------------------------------------
+# Vetores da rede real (Rede Pristina P) ------------------------
+#----------------------------------------------------------------
+P1x = -2.418812598250;  P1y =  0.0000000000000;  P1z = 0.000000000000
+P2x = -1.209406299125;  P2y = -2.1765696885625;  P2z = 0.000000000000
+P3x =  0.000000000000;  P3y =  0.0000000000000;  P3z = 34.87887456188
+#-------------------------------------------------------------------
+# k-points de interesse (Rede Pristina P) --------------------------
+#-------------------------------------------------------------------
+K1 = [ [+0.5, +0.0], [+0.0, +0.5], [-0.5, +0.0], [+0.0, -0.5], [+0.5, +0.5], [-0.5, -0.5] ]
+K1 += [ [-0.6666666666666666, -0.3333333333333333], [+0.6666666666666666, +0.3333333333333333] ]
+#-----------------------------------------------------------------------------------------------
+
+
+
+
+#------------------------------------------------------
+# Obtendo a rede recíproca da Supercélula S -----------
+#------------------------------------------------------
+ss1 = S1x*((S2y*S3z) - (S2z*S3y))
+ss2 = S1y*((S2z*S3x) - (S2x*S3z))
+ss3 = S1z*((S2x*S3y) - (S2y*S3x))
+ss =  ss1 + ss2 + ss3
+#-------------------------------
+B1x = ((S2y*S3z) - (S2z*S3y))/ss
+B1y = ((S2z*S3x) - (S2x*S3z))/ss 
+B1z = ((S2x*S3y) - (S2y*S3x))/ss
+B2x = ((S3y*S1z) - (S3z*S1y))/ss                             
+B2y = ((S3z*S1x) - (S3x*S1z))/ss
+B2z = ((S3x*S1y) - (S3y*S1x))/ss
+B3x = ((S1y*S2z) - (S1z*S2y))/ss
+B3y = ((S1z*S2x) - (S1x*S2z))/ss
+B3z = ((S1x*S2y) - (S1y*S2x))/ss
+#-------------------------------
+ft = 6.2831853071795860
+S1b = [B1x*ft, B1y*ft]
+S2b = [B2x*ft, B2y*ft]
+#---------------------
+
+
+
+
+#------------------------------------------------------
+# Obtendo a rede recíproca da Rede Pristina P ---------
+# Obtendo as coord. cart. dos k-points de interesse ---
+#------------------------------------------------------
+ss1 = P1x*((P2y*P3z) - (P2z*P3y))
+ss2 = P1y*((P2z*P3x) - (P2x*P3z))
+ss3 = P1z*((P2x*P3y) - (P2y*P3x))
+ss =  ss1 + ss2 + ss3
+#-------------------------------
+B1x = ((P2y*P3z) - (P2z*P3y))/ss
+B1y = ((P2z*P3x) - (P2x*P3z))/ss 
+B1z = ((P2x*P3y) - (P2y*P3x))/ss
+B2x = ((P3y*P1z) - (P3z*P1y))/ss                             
+B2y = ((P3z*P1x) - (P3x*P1z))/ss
+B2z = ((P3x*P1y) - (P3y*P1x))/ss
+B3x = ((P1y*P2z) - (P1z*P2y))/ss
+B3y = ((P1z*P2x) - (P1x*P2z))/ss
+B3z = ((P1x*P2y) - (P1y*P2x))/ss
+#-------------------------------
+ft = 6.2831853071795860
+P1b = [B1x*ft, B1y*ft]
+P2b = [B2x*ft, B2y*ft]
+#---------------------------------------
+# KPOINTS de interesse (Rede Pristina P)
+#---------------------------------------
+K1_new = []
+for i in range(len(K1)):
+    #-------------------
+    coord_x = (K1[i][0]*P1b[0]) + (K1[i][1]*P2b[0])
+    coord_y = (K1[i][0]*P1b[1]) + (K1[i][1]*P2b[1])
+    temp_xy = []
+    temp_xy.append(coord_x);  temp_xy.append(coord_y)
+    #------------------------------------------------
+    K1_new.append(temp_xy)
+#-------------------------
+
+
+
+
+#-----------------------------------
+# Definirndo matriz de transformação 
+#-----------------------------------
+a = np.array([S1b[0], S1b[1]])
+b = np.array([S2b[0], S2b[1]])
+T = np.linalg.inv(np.array([a, b]).T)
+#------------------------------------
+
+
+
+
+#-------------------------------------------------------------
+# Construindo a BZ 2D usando Voronoi (Supercélula S) ---------
+#-------------------------------------------------------------
+nx, ny = 12, 12  # Número de pontos na grade
+points = np.dot(np.mgrid[-nx:nx+1, -ny:ny+1].reshape(2, -1).T, np.array([S1b, S2b]))
+vor = Voronoi(points)
+#--------------------------------
+# Plotando a zona de Brillouin 2D
+#--------------------------------
+fig, ax = plt.subplots()
+#-----------------------
+for simplex in vor.ridge_vertices:
+    simplex = np.asarray(simplex)
+    if np.all(simplex >= 0): ax.plot(vor.vertices[simplex, 0], vor.vertices[simplex, 1], color = 'black', linewidth = 0.25, alpha = 0.5, zorder=3)
+#------------------------------------------------------------------------------------------------
+plt.quiver(0, 0, S1b[0], S1b[1], angles='xy', scale_units='xy', scale=1.0, color='blue', alpha = 0.5, zorder=0)
+plt.quiver(0, 0, S2b[0], S2b[1], angles='xy', scale_units='xy', scale=1.0, color='blue', alpha = 0.5, zorder=0)
+plt.text((S1b[0] +0.005), (S1b[1] +0.005), "B$_1$", fontsize=10, alpha = 0.5, color="black")
+plt.text((S2b[0] +0.010), (S2b[1] +0.010), "B$_2$", fontsize=10, alpha = 0.5, color="black")
+#-------------------------------------------------------------------------------------------
+
+
+
+
+#--------------------------------------------------------
+# Convertendo as posições cartesianas para a forma direta
+#--------------------------------------------------------
+Kpoints = K1_new
+Kpoints_f = []
+#----------------------------
+for i in range(len(Kpoints)):
+    #-----------------------
+    kx = float(Kpoints[i][0])
+    ky = float(Kpoints[i][1])
+    r = np.array([kx, ky])
+    #----------------------------------------------------------------
+    # Calculandos as posições fracionárias com relação a supercélula:
+    #----------------------------------------------------------------
+    f = np.dot(T, r)
+    for n in range(9):
+        for m in range(2):
+            f[m] = np.where(f[m] < -0.5, f[m] +1, f[m])
+            f[m] = np.where(f[m] > +0.5, f[m] -1, f[m])
+            if (f[m] > -0.00001 and f[m] < 0.00001):  f[m] =  0.0
+            if (f[m] >  0.49999 and f[m] <  0.50001): f[m] =  0.5
+            if (f[m] > -0.50001 and f[m] < -0.49999): f[m] = -0.5
+    #------------------------------------------------------------
+    temp_k = [];  temp_k.append(f[0]);  temp_k.append(f[1])
+    Kpoints_f.append(temp_k)
+    print(temp_k)
+#---------------------------
+Kpoints_f_cart = []
+#------------------
+for i in range(len(Kpoints_f)):
+    #--------------------
+    coord_x = (Kpoints_f[i][0]*S1b[0]) + (Kpoints_f[i][1]*S2b[0])
+    coord_y = (Kpoints_f[i][0]*S1b[1]) + (Kpoints_f[i][1]*S2b[1])
+    temp_k = [];  temp_k.append(coord_x);  temp_k.append(coord_y)
+    #------------------------------------------------------------
+    Kpoints_f_cart.append(temp_k)
+#--------------------------------
+
+
+
+
+#=======================================================
+# Plot (k-points projected) ============================
+#=======================================================
+#----------------------------------------------------------------------------------------------------------------------------------
+for i in range(len(Kpoints_f_cart)): plt.scatter(Kpoints_f_cart[i][0], Kpoints_f_cart[i][1], c='black', marker='o', s=60, zorder=1)
+#----------------------------------------------------------------------------------------------------------------------------------
+plt.title('k-points projection')
+plt.xlabel('$k_x$')
+plt.ylabel('$k_y$')
+#----------------------
+x_min = -1.5
+x_max = +0.75
+y_min = -0.4
+y_max = +0.25
+plt.xlim((x_min, x_max))
+plt.ylim((y_min, y_max))
+#----------------------------------------------------
+# Ajustar aspect ratio para refletir proporções reais
+#----------------------------------------------------
+ax.set_box_aspect(abs((y_max - y_min) / (x_max - x_min)))   # Razão dos comprimentos dos eixos
+#------------------------------------------------------------------------------------
+plt.savefig('k-points_projected.png', dpi = 600, bbox_inches='tight', pad_inches = 0)
+plt.savefig('k-points_projected.eps', dpi = 600, bbox_inches='tight', pad_inches = 0)
+#------------------------------------------------------------------------------------
+

vasprocar-1.1.19.144/vasprocar/src/etc/codes_append/VASProcar_Direto_Cartesiano.py

@@ -0,0 +1,108 @@
+# VASProcar Copyright (C) 2023
+# GNU GPL-3.0 license
+
+
+#=============================================================================
+# Conversão do arquivo POSCAR/CONTCAR para coordenadas cartesianas/Diretas ===
+#=============================================================================
+
+
+#================
+name_i = 'POSCAR_124atoms_-0.1246_0.1986_1.133_C4+Cr2S2Br2Cr2S2Br2_f84c69e814a8448c+0046.vasp'
+#---------------------------
+poscar_i = open(name_i, "r")
+for i in range(8): VTemp = poscar_i.readline()
+poscar_i.close()
+#------------------
+string = str(VTemp)
+if (string[0] == 'c' or string[0] == 'C'):  name_o = name_i.replace('.vasp','') + '_Direct.vasp'
+if (string[0] == 'd' or string[0] == 'D'):  name_o = name_i.replace('.vasp','') + '_Cartesian.vasp'
+#------------------------------------------------------------------------
+poscar_i  = open(name_i, "r")
+poscar_o  = open(name_o, "w")
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}')
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}');  param = float(VTemp)
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}');  VTemp = VTemp.split();  A = [float(VTemp[0]), float(VTemp[1]), float(VTemp[2])]  
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}');  VTemp = VTemp.split();  B = [float(VTemp[0]), float(VTemp[1]), float(VTemp[2])]
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}');  VTemp = VTemp.split();  C = [float(VTemp[0]), float(VTemp[1]), float(VTemp[2])]
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}')
+VTemp = poscar_i.readline();  poscar_o.write(f'{VTemp}')
+#-----------------------------------------------------
+nions = 0;  VTemp = VTemp.split()
+for k in range(len(VTemp)): nions += int(VTemp[k])
+#-------------------------------------------------
+VTemp = poscar_i.readline()
+#--------------------------
+
+
+#=========================================
+if (string[0] == 'd' or string[0] == 'D'):
+   #---------------------------
+   poscar_o.write(f'Cartesian \n')
+   #-----------------------------------------------------------
+   # Escrita das coordenadas cartesianas ----------------------
+   #-----------------------------------------------------------
+   for k in range(nions):
+       VTemp = poscar_i.readline().split()
+       k1 = float(VTemp[0]); k2 = float(VTemp[1]); k3 = float(VTemp[2])
+       coord_x = ((k1*A[0]) + (k2*B[0]) + (k3*C[0]))
+       coord_y = ((k1*A[1]) + (k2*B[1]) + (k3*C[1]))
+       coord_z = ((k1*A[2]) + (k2*B[2]) + (k3*C[2]))
+       poscar_o.write(f'{coord_x} {coord_y} {coord_z} \n')
+       #--------------------------------------------------
+
+
+#=========================================
+if (string[0] == 'c' or string[0] == 'C'):
+   #---------------------------
+   poscar_o.write(f'Direct \n')
+   #--------------------------------------------------
+   A1 = np.array([A[0]*param, A[1]*param, A[2]*param])
+   A2 = np.array([B[0]*param, B[1]*param, B[2]*param])
+   A3 = np.array([C[0]*param, C[1]*param, C[2]*param])
+   #----------------------------------
+   # Definir a matriz de transformação 
+   T = np.linalg.inv(np.array([A1, A2, A3]).T)
+   #---------------------------------------
+   for k in range(nions):
+       VTemp = poscar_i.readline().split()
+       x = float(VTemp[0])
+       y = float(VTemp[1])
+       z = float(VTemp[2])      
+       r = np.array([x, y, z]) # posição cartesiana dos átomos  
+       #-----------------------------------------------------------
+       # Escrita das coordenadas Diretas --------------------------
+       #-----------------------------------------------------------
+       f = np.dot(T, r)
+       f = np.where(f < 0, f + 1, f)
+       #------------------------------------
+       if ((f[0] >= 0.0) and (f[0] <= 1.0)):
+          if ((f[1] >= 0.0) and (f[1] <= 1.0)):
+             if ((f[2] >= 0.0) and (f[2] <= 1.0)):
+                for m in range(3):
+                    f[m] = round(f[m], 6)
+                    if (f[m] > 0.99999 or f[m] < 0.00001):
+                       f[m] = 0.0
+                poscar_o.write(f'{f[0]} {f[1]} {f[2]} {l} \n')
+
+
+#---------------
+poscar_i.close()   
+poscar_o.close()
+#---------------
+
+"""
+#=======================================================================
+
+#-----------------------------------------------------------------
+print(" ")
+print("======================= Completed =======================")
+print(" ")
+#-----------------------------------------------------------------
+
+#=======================================================================
+# User option to perform another calculation or finished the code ======
+#=======================================================================
+if (len(inputs) == 0):
+   execute_python_file(filename = '_loop.py')
+"""