{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Anhramonic lattice Dynamics\n", "\n", "In this exercise we will learn how to calculate temperature-dependent anharmonic phonons of PbTe\n", "using 2×2×2 ZG supercells and the A-SDM. Unlike Zr, seen in an another Notebook, PbTe is a polar material\n", "and a correction to the dynamical matrix arising from long-range dipole-dipole interactions is essential.\n", "Since the A-SDM relies on the computation of IFCs by finite differences, we employ the mixed space\n", "approach described in J. Phys. Condens. Matter 22 202201 (2010), as implemented in ${\\tt matdyn.x}$.\n", "The key flags here to be used are ${\\tt fd = .true.}$, $\\tt{na\\_{ifc} = .true.}$, and ${\\tt incl\\_epsil = .true.}$.\n", "In this example, the harmonic IFCs matrix is positive definite and therefore the computation of the\n", "polymorphous structure is not required to initialize the A-SDM procedure.\n", "\n", "The A-SDM combines the special displacement method with the self-consistent phonon (SCP)\n", "theory; for details of the theory related to this exercise please refer to Refs. [Phys. Rev. B 108, 035155\n", "(2023)] and [D. Hooton, LI. a new treatment of anharmonicity in lattice thermodynamics: I, London\n", "Edinburgh Philos. Mag. J. Sci. 46, 422 (1955)]. The main aim is to find the effective matrix of IFCs\n", "that best describes anharmonicity in the potential energy surface. For this reason we minimize the\n", "trial free energy with respect to the matrix of IFCs which requires, essentially,\n", "to solve self-consistently the following equation:\n", "\n", "$\\tilde{C}_{p \\kappa \\alpha, \\kappa' \\alpha'}(T) = \n", "\\langle \\partial U / \\partial \\tau_{p \\kappa \\alpha} \\partial \\tau_{p' \\kappa' \\alpha'} \\rangle_T$\n", "\n", "Below we define the main input file which defines all constants and the system we will investigate, in this case PbTe." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "k-point parallelization (npools): 14\n", "Number of cores to be used: 224\n", "===========================================\n", "Downloading pseudo from Pseudo-Dojo library\n", "--2024-07-05 08:02:44-- http://www.pseudo-dojo.org/pseudos/nc-sr-04_pbesol_standard/Pb.upf.gz\n", "Resolving www.pseudo-dojo.org (www.pseudo-dojo.org)... 130.104.22.53\n", "Connecting to www.pseudo-dojo.org (www.pseudo-dojo.org)|130.104.22.53|:80... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 82213 (80K) [application/x-gzip]\n", "Saving to: ‘Pb.upf.gz’\n", "\n", "100%[======================================>] 82,213 319KB/s in 0.3s \n", "\n", "2024-07-05 08:02:44 (319 KB/s) - ‘Pb.upf.gz’ saved [82213/82213]\n", "\n", "--2024-07-05 08:02:45-- http://www.pseudo-dojo.org/pseudos/nc-sr-04_pbesol_standard/Te.upf.gz\n", "Resolving www.pseudo-dojo.org (www.pseudo-dojo.org)... 130.104.22.53\n", "Connecting to www.pseudo-dojo.org (www.pseudo-dojo.org)|130.104.22.53|:80... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 65660 (64K) [application/x-gzip]\n", "Saving to: ‘Te.upf.gz’\n", "\n", "100%[======================================>] 65,660 255KB/s in 0.3s \n", "\n", "2024-07-05 08:02:46 (255 KB/s) - ‘Te.upf.gz’ saved [65660/65660]\n", "\n", "\n", " \n", " \n", " -*#*- ...............- \n", " .+*= .+%*-=%%: .=#*- -===============-:.\n", " :*%=*%%- *%* #%* :+%+-%%+ .:. -=. :==-. \n", " -%S -%%*: :#%. -%%-. -##: #%* -=. :==- \n", " .. .%S: +%%%%*. :*%%%#= %%= -=. :==- \n", " :=#%%*- .#S- .. .%%= :*#*: -=. :==- \n", " -%S:.=#%%*==%# *%%=::=##-+%%. . .=-. :==- .= \n", " :%%- .-+++: -+##*=. =%S :-::==: .==- --.\n", " *%# #%+ -=--:. .----:. \n", " :%%- -%S. \n", " .-=*####SS%#########: -###########*+: +#######= =%SS####+::. \n", " =+#**%SSSSSSSSSSSSSSSS= =SSSSSSSSSSSSSSS= #SSSSSSS*. +SSSSSSSS%%%%- \n", " *%% =SSS.. .SSS= SSS=. .:+SSS+ -SSS:. .-::. .SSS+. #%* \n", " #%#. =SSS. *S# *S%: SSS= %SS%. .SSS= #SSS%. :SSS: =%#. \n", " *%%: =SSS#*#SSS- SSS= .+SSS+. %SS*.=SSSSS+ +SS%.:+%+ \n", " +%%:=SSSSSSSSS- SSSSSSSSSSSSS=. +SSS:SSS%SSS:%SS*-#%= \n", " ....#S==SSS:..SSS: =+- SSS%######+=. -SSS%SS%.#SS%SSS==%%=. \n", " .:+##%%#*- =SSS. ::. :SSS. SSS=. SSSSSS:..SSSSSS: :*%%%*=- \n", " #%+. -+#SSS*+++++++*SSS: .=+SSS#++++: %SSSS+. =SSSS%. :-+#%%+ \n", " #%* .SSSSSSSSSSSSSSSSSS: *SSSSSSSSSSS. +SSS%. %SSS*. . .%%= \n", " =%S :::::::::::::::::. .:::::::::. :::. :::. =+=-.#%+ \n", " -%S: =+===#S: \n", " ==*------------------------------=========+++++++++++++++++++++++========++-+## \n", " =+++++++++++*******++++++++++++++++========------------------==========+++++++- \n", "-- -- -- -- -- -- -- -- -- -- -- -- Structure Info -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "2\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "pseudopotential: ['Pb.upf', 'Te.upf']\n", "pseudopotential directory: '/home1/07369/mzach/epwpypseudos'\n", "prefix: PbTe\n" ] }, { "data": { "text/plain": [ "0" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "import math\n", "import os \n", "import shutil\n", "import sys\n", "import subprocess\n", "import EPWpy\n", "from EPWpy import EPWpy\n", "from EPWpy.plotting import plot_bands\n", "\n", "# Constants\n", "cm_1_to_meV = 0.124\n", "Ry_to_meV = 13605.66228\n", "# System\n", "nat=2 # number of atoms in the unit cell\n", "ntyp=2 # number of types of atoms\n", "dim1=2 # dimensions of the supercell\n", "dim2=2\n", "dim3=2\n", "nmodesu=nat*3 # total number of phonon modes in the unit cell\n", "dofsuper=dim1*dim2*dim3*nat*3*2 # total number of nuclear degrees of freedom in supercell, factor of 2 for directions\n", "# k-point grid for unit-cell\n", "nk1=6\n", "nk2=6\n", "nk3=6\n", "#\n", "T=300 # target temperature to obtain the anharmonic phonon dispersion\n", "# Number of CPUs and pools\n", "ncores=56*4\n", "npoolsuper = round((nk1*nk2*nk3) / (dim1*dim2*dim3) / 2)\n", "print(\"k-point parallelization (npools):\", npoolsuper)\n", "ncoresuper = ncores - ncores % npoolsuper # take modulo\n", "print(\"Number of cores to be used:\", ncoresuper)\n", "#\n", "font=16\n", "#\n", "#Define folder locations, prefix and number of cores\n", "folder='./'\n", "cores='224'\n", "#pseudo = os.getcwd() + '/pseudos'\n", "pseudo='/home1/07369/mzach/epwpypseudos'\n", "QE = '/home1/07369/mzach/codes/q-e_dev_2024/bin'\n", "######Define the directory of installation##############\n", "#\n", "prefix='PbTe'\n", "flfrc='\\''+str(prefix)+'.fc\\''\n", "#\n", "##########################################################################\n", "# Download pseudo from Pseudo-Dojo library\n", "print(\"===========================================\")\n", "print(\"Downloading pseudo from Pseudo-Dojo library\")\n", "#\n", "#define elements \n", "elements = ['Pb', 'Te']\n", "masses = [207.2, 127.6]\n", "# Download pseudos for all elements, one could also use pseudo_auto option below\n", "for i in range(0, ntyp):\n", " if os.path.exists(f'./{elements[i]}.upf'): # If upf file exists then \n", " os.remove(f'./{elements[i]}.upf') # remove it from parent directory\n", " !wget http://www.pseudo-dojo.org/pseudos/nc-sr-04_pbesol_standard/{str(elements[i])}.upf.gz\n", "# !wget http://www.pseudo-dojo.org/pseudos/nc-fr-04_pbesol_standard/{str(elements[i])}.upf.gz # for SOC calculations\n", " !gunzip {str(elements[i])}.upf.gz \n", " if os.path.exists(f'/{pseudo}/{elements[i]}.upf'): # If upf file exists in pseudo directory\n", " os.remove(f'/{pseudo}/{elements[i]}.upf') # then remove it\n", " #\n", " shutil.move(f'./{elements[i]}.upf', pseudo) # mv upf file in pseudo directory \n", "#########################################################################\n", "#\n", "# Define the system used for the calculations\n", "pbte=EPWpy.EPWpy({'prefix':f'\\'{prefix}\\'','restart_mode':'\\'from_scratch\\'','calculation':'\\'scf\\'',\n", " 'verbosity':'\\'high\\'',\n", " 'celldm(1)':'12.17740', \n", " #'pseudo_auto':True,\n", " 'pseudo_dir':'\\''+str(pseudo)+'\\'',\n", " 'ibrav':2,\n", " 'nat':nat,\n", " 'ntyp':ntyp,\n", " 'ecutwfc':'50', 'ecutrho':'200',\n", " 'atomic_species':[f'{elements[0]}',f'{elements[1]}'],\n", " 'mass':[masses[0], masses[1]],\n", " 'atoms':[f'{elements[0]}',f'{elements[1]}'],\n", " 'pseudo':[f'{elements[0]}.upf',f'{elements[1]}.upf'], \n", " 'atomic_position_type':'{angstroms}',\n", " 'atomic_pos':np.array([[-3.222, 3.222, 3.222],[0.0, 0.0, 0.0]]),\n", " },code=QE,env='ibrun',system = prefix)\n", "pbte.serial = True\n", "\n", "#######Printing any attribute######\n", "pseudopot=pbte.__dict__['pw_atomic_species']['pseudo'][0]\n", "print('pseudopotential:', pbte.__dict__['pw_atomic_species']['pseudo'][:])\n", "print('pseudopotential directory:', pbte.__dict__['pw_control']['pseudo_dir'])\n", "print('prefix:',prefix)\n", "\n", "os.system('module list')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Self Consistent Field (SCF) Calculations\n", "\n", "We first solve the Kohn-Sham equations to obtain the Kohn-Sham orbitals $\\phi_v(r)$, $r$ is the electronic position (generally a mesh grid), $R$ is the position of ions.\n", "\n", "$E[\\phi_v,R]=-\\frac{\\hbar^2}{2m}\\sum_v{\\int{\\phi_v^\\star(r)\\nabla^2\\phi_v(r)dr}+\\int{V_R(r)n(r)dr}+\\frac{e^2}{2}\\int{\\frac{n(r)n(r')}{|r-r'|}drdr'}+E_{xc}[n(r')]+\\sum_{I\\neq J}{\\frac{e^2}{2}\\frac{Z_IZ_J}{|R_I-R_J|}}}$\n", "\n", "We minimize $E(R)=min(E[\\phi_v,R])$\n", "\n", "Where, $\\Big(-\\frac{\\hbar^2}{2m}\\nabla^2+V_{KS}(r)\\Big)\\phi_v(r)=\\epsilon_v\\phi_v(r)$" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: scf -- -- -- -- -- -- -- -- -- -- -- \n", "Running scf |████████████████████████████████████████| in 0.0s (196.05/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "## Create SCF input file ##\n", "pbte.scf(electrons={'conv_thr':'1E-7',\n", " 'mixing_beta':'0.7'},\n", " kpoints={'kpoints':[[nk1,nk2,nk3]],\n", " 'kpoints_type':'automatic'},\n", " name='scf')\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='scf')\n", "## Run calculation ##\n", "pbte.run(48)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Error in calculation ./PbTe/scf/scf.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.file = './'+str(prefix)+'/scf/scf.out'\n", "pbte.get_QE_status()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Phonon Calculations\n", "\n", "Here we evaluate the harmonic phonon energies and displacement vectors in the unit cell using the density-functional perturbation theory (DFPT)\n", "\n", "https://docs.epw-code.org/_downloads/b3f5899664a87fcdd6dcacc262e6f103/Mon.1.Giannozzi.pdf\n", "\n", "In this example we evaluate phonons in a $3\\times3\\times3$ $q$-grid." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: ph -- -- -- -- -- -- -- -- -- -- -- \n", "Running ph |████████████████████████████████████████| in 0.0s (191.26/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "## Create PH input file ##\n", "pbte.ph(phonons={'nq1':2,\n", " 'nq2':2,\n", " 'nq3':2,\n", " 'fildvscf':'\\' \\''})\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='ph')\n", "## Run calculation ##\n", "pbte.run(48,type_run='ph')" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Error in calculation ./PbTe/ph/ph.out\n", "TACC: Starting up job 6434316 \n", "\n", "TACC: Starting parallel tasks... \n", "\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.file = './'+str(prefix)+'/ph/ph.out'\n", "pbte.get_QE_status()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Interatomic Force Constants (IFCs)\n", "\n", "In order to produce the ZG configurations we first need to evaluate the interatomic forces constants, as they will provide information on how to displace the atoms. These constants correspond to second derivatives of the total potential energy, that is: $C_{\\kappa\\alpha\\rho\\kappa'\\alpha'\\rho'}=\\partial^{2}U/\\partial\\tau_{\\kappa\\alpha\\rho}\\tau_{\\kappa'\\alpha'\\rho'}$, but do not curry any temperature dependence. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: q2r -- -- -- -- -- -- -- -- -- -- -- \n", "Running q2r |████████████████████████████████████████| in 0.0s (200.99/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "## Create q2r input file ##\n", "pbte.q2r(q2r={'fildyn':'\\''+str(prefix)+'.dyn\\'',\n", " 'flfrc':flfrc,\n", " 'zasr':'\\'crystal\\''})\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='q2r')\n", "## Run calculation ##\n", "pbte.run(1,type_run='q2r')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the harmonic phonon dispersion\n", "\n", "Here we perform a ${\\tt matdyn.x}$ calculation to obtain the harmonic phonon frequencies." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: matdyn -- -- -- -- -- -- -- -- -- -- -- \n", "on 1: running phonon bands calculation\n", "Running matdyn |████████████████████████████████████████| in 0.0s (113.82/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.matdyn(name='matdyn',\n", " matdyn={'flfrq':'\\''+str(prefix)+'_harm.freq\\'',\n", " 'flfrc':flfrc},\n", " kpoints={'kpoints':[['0.0', '0.5', '0.5', '100'], #X\n", " ['0.0', '0.0', '0.0', '100'], #Gamma \n", " ['0.0', '0.5', '0.5', '1']]}) # X\n", " \n", "\n", "pbte.prepare(1,type_run='matdyn')\n", "\n", "pbte.run(1,type_run='matdyn')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "No handles with labels found to put in legend.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot the phonon dispersion\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)\n", "\n", "# remember to \"module load python3.7\" from terminal\n", "import matplotlib.pyplot as plt\n", "\n", "data = np.loadtxt(str(os.getcwd())+'/'+str(prefix)+'/ph/'+str(prefix)+'_harm.freq.gp') \n", "\n", "plt.plot([0,2.01], [0, 0], color='orange', linewidth=2)\n", "plt.xlim(0, 2.01)\n", "for i in range(1, nmodesu + 1):\n", " plt.plot(data[:, 0], data[:, i]*cm_1_to_meV,color='green')\n", " \n", "plt.title(f'{prefix}: Harmonic phonon dispersion')\n", "\n", "plt.legend()\n", "\n", "plt.ylabel(r'Phonon energy (meV)')\n", "\n", "from matplotlib import font_manager\n", "#\n", "ticks= [0.0, 1.0, 2.0]\n", "labels=['X', '$\\Gamma$', 'X']\n", "\n", "for ii in ticks:\n", " plt.axvline(ii, linewidth=0.75, color='k', alpha=0.5)\n", "\n", "# text labels\n", "font_prop = font_manager.FontProperties(size=16)\n", "plt.xticks(ticks, labels, fontproperties=font_prop, size =16)\n", "\n", "plt.show()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### ZG displacements to obtain the polymorphous structure\n", "\n", "To create the ${\\tt zg.in}$ file see below. \n", "\n", "The input format of ${{\\tt inputzg}}$ list is the same as in a standard ${\\tt ZG.x}$ calculation. We remark\n", "that here we are using a 2×2×2 supercell and therefore ${\\tt incl\\_qA = .true.}$. The flag\n", "${\\tt ASDM}$ is set to true to enable the A-SDM procedure; it allows the code to read the input variables in the\n", "list ${{\\tt inputazg}}$. The cell paramaters, number of atoms, k-grid, and atomic coordinates are modified automatically based on the supercell dimensions. The code will always generate the lattice information in angstroms." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: zg -- -- -- -- -- -- -- -- -- -- -- \n", "Running zg |████████████████████████████████████████| in 0.0s (192.62/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "## Create ZG input file ##\n", "#\n", "pbte.zg(inputzg={'flfrc':flfrc,\n", " 'T':T,\n", " 'dim1':dim1,\n", " 'dim2':dim2,\n", " 'dim3':dim3,\n", " 'atm_zg(1)':f'\\'{elements[0]}\\'',\n", " 'atm_zg(2)':f'\\'{elements[1]}\\'',\n", " 'error_thresh':'0.4',\n", " 'niters':'4000', 'incl_qA':'.true.',\n", " 'ASDM':'.true.'},\n", " inputazg={'poly':'.false.',\n", " 'poly_fd_forces':'.false.',\n", " 'iter_idx':1, \n", " 'apply_fd':'.true.'}\n", " )\n", "\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='zg')\n", "## Run calculation ##\n", "pbte.run(2,type_run='zg')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/zg.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.file = './'+str(prefix)+'/zg/zg.out'\n", "pbte.get_QE_status()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Run scf calculations for files ${\\tt ZG-scf\\_300.00K\\_iter\\_01\\_XXXX.in}$ and save all scf outputs in the folder\n", "${\\bf fd\\_forces}$. The cell below is as before but with a new name for ${\\tt filein,\\,fileout}$ variables." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks/PbTe/zg\n", "Number of cores: 224\n", "Number of pools: 14\n", "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks\n" ] } ], "source": [ "# Calculate forces for iteration 1\n", "os.chdir('./'+str(prefix)+'/zg/') # go to zg directory where all ZG-scf*in files are located\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)\n", "#\n", "print(\"Number of cores:\", ncoresuper)\n", "print(\"Number of pools:\", npoolsuper)\n", "#\n", "if not os.path.isdir('fd_forces'):\n", " os.mkdir('fd_forces')\n", "#\n", "from EPWpy.EPWpy_run import py_run\n", "# iteration index\n", "itr_idx = 1\n", "# Loop over the range from 0001 to 1000\n", "for i in range(1,dofsuper+1):\n", " pbte.env = f'ibrun -np {ncoresuper}'\n", " pbte.code = '/home1/07369/mzach/codes/q-e_dev_2024/bin'\n", " pbte.run_QE=py_run(1,pbte.env,pbte.code)\n", " if not os.path.isdir(f'{i:04d}'):\n", " os.mkdir(f'{i:04d}') # create directory 0001, 0002 ...\n", " pbte.run_QE.dir = f'./{i:04d}' # Calculations are performed in separate folders 0001, 0002 ...\n", " pbte.run_QE.filein=f'ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.in'\n", " pbte.run_QE.fileout=f'ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out'\n", " pbte.run_QE.util=f'ibrun -np {ncoresuper} pw.x -nk {npoolsuper} < ../ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.in > ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out'\n", " pbte.run_QE.serial=True\n", " pbte.run_QE.runner()\n", " shutil.copy(f'ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out','../fd_forces/.')\n", " os.chdir('../')\n", "\n", "os.chdir('../../') # return to parent directory\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0001.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0002.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0003.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0004.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0005.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0006.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0007.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0008.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0009.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0010.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0011.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0012.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0013.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0014.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0015.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0016.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0017.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0018.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0019.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0020.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0021.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0022.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0023.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0024.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0025.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0026.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0027.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0028.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0029.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0030.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0031.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0032.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0033.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0034.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0035.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0036.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0037.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0038.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0039.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0040.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0041.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0042.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0043.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0044.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0045.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0046.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0047.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0048.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0049.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0050.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0051.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0052.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0053.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0054.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0055.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0056.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0057.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0058.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0059.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0060.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0061.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0062.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0063.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0064.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0065.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0066.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0067.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0068.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0069.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0070.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0071.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0072.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0073.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0074.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0075.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0076.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0077.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0078.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0079.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0080.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0081.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0082.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0083.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0084.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0085.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0086.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0087.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0088.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0089.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0090.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0091.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0092.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0093.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0094.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0095.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_01_0096.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "# iteration index\n", "itr_idx = 1\n", "# check if calculations were succesful\n", "for i in range(1,dofsuper+1):\n", " pbte.file = './'+str(prefix)+f'/zg/fd_forces/ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out'\n", " pbte.get_QE_status()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Self Consistent Phonon Theory:Obtain the IFC file for iteration 1\n", "\n", "If all calculations run successfully, the code evaluates the IFCs using the finite differences formula and\n", "prints the following new files related to the first iteration:\n", "\n", "(i) ${\\tt FORCE\\_CONSTANTS\\_300.00K\\_iter\\_01}$,\n", "\n", "(ii) ${\\tt FORCE\\_CONSTANTS\\_sym\\_300.00K\\_iter\\_01}$,\n", "\n", "and (iii) ${\\tt 300.00K\\_iter\\_01.fc}$ which contains the symmetrized IFCs in the same $\\verb|q2r.x|$ output format to be used for the next A-SDM iteration.\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: zg -- -- -- -- -- -- -- -- -- -- -- \n", "Running zg |████████████████████████████████████████| in 0.0s (159.49/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "## Create zg input file to generate the temperature-dependent IFCs at iteration 1\n", "#\n", "pbte.zg(inputzg={'flfrc':flfrc,\n", " 'T':T,\n", " 'dim1':dim1,\n", " 'dim2':dim2,\n", " 'dim3':dim3,\n", " 'atm_zg(1)':f'\\'{elements[0]}\\'',\n", " 'atm_zg(2)':f'\\'{elements[1]}\\'',\n", " 'error_thresh':'0.4',\n", " 'niters':'4000',\n", " 'ASDM':'.true.'},\n", " inputazg={'poly':'.false.','poly_fd_forces':'.false.',\n", " 'iter_idx':1,\n", " 'apply_fd':'.false.', \n", " 'read_fd_forces':'.true.','mixing':'.false.',\n", " 'incl_epsil':'.true.'}\n", " )\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='zg')\n", "## Run calculation ##\n", "pbte.run(2,type_run='zg')" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Error in calculation ./PbTe/zg/zg.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.file = './'+str(prefix)+'/zg/zg.out'\n", "pbte.get_QE_status()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the anharmonic phonons from iteration 1\n", "\n", "Note here that we add the flags ${\\tt fd = .true.}$, ${\\tt na\\_ifc = .true.}$ to account\n", "for long range effects since the IFCs in ${\\tt 300.00K\\_iter\\_01.fc}$ are obtained by finite differences." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: matdyn -- -- -- -- -- -- -- -- -- -- -- \n", "on 1: running phonon bands calculation\n", "Running matdyn |████████████████████████████████████████| in 0.0s (153.04/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "# perform a matdyn.x calculation using ifc file 'T_iter_01.fc'\n", "pbte.matdyn(name='matdyn',\n", " matdyn={'flfrq':'\\'./'+str(prefix)+'_01.freq\\'',\n", " 'flfrc':f'\\'../zg/{T}.00K_iter_01.fc\\'',\n", " 'fd':'.true.', \n", " 'na_ifc':'.true.'}, \n", " kpoints={'kpoints':[['0.0', '0.5', '0.5', '100'], #X\n", " ['0.0', '0.0', '0.0', '100'], #Gamma \n", " ['0.0', '0.5', '0.5', '1']]}) # X\n", " \n", "\n", "pbte.prepare(1,type_run='matdyn')\n", "\n", "pbte.run(1,type_run='matdyn')" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot the phonon dispersion\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)\n", "\n", "# remember to \"module load python3.7\" from terminal\n", "import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots()\n", "\n", "data = np.loadtxt(str(os.getcwd())+'/'+f'./'+str(prefix)+'/ph/'+str(prefix)+'_harm.freq.gp') \n", "data2 = np.loadtxt(str(os.getcwd())+'/'+f'./'+str(prefix)+'/ph/'+str(prefix)+'_01.freq.gp')\n", "\n", "plt.plot([0, 2.01], [0, 0], color='orange', linewidth=2)\n", "plt.xlim(0, 2.01)\n", "for i in range(1, nmodesu + 1):\n", " plt.plot(data[:, 0], data[:, i]*cm_1_to_meV,color='green')\n", " plt.plot(data2[:, 0], data2[:, i]*cm_1_to_meV,color='red')\n", "\n", "ax.plot([], [], color='green', label='Harmonic') \n", "ax.plot([], [], color='red', label='iter 01 (300 K)')\n", "ax.legend(loc='upper center', bbox_to_anchor=(0.85, 0.22), shadow=True, ncol=1)\n", "\n", "plt.xlabel('Wavevector')\n", "plt.ylabel('Phonon energy (meV)')\n", "\n", "\n", "from matplotlib import font_manager\n", "#\n", "ticks= [0.0, 1.0, 2.0]\n", "labels=['X', '$\\Gamma$', 'X']\n", "\n", "for ii in ticks:\n", " plt.axvline(ii, linewidth=0.75, color='k', alpha=0.5)\n", "\n", "# text labels\n", "font_prop = font_manager.FontProperties(size=16)\n", "plt.xticks(ticks, labels, fontproperties=font_prop, size =16)\n", "\n", "#plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, we compare the phonon dispersion of PbTe at $T =300$ K obtained at the first iteration (red)\n", "with the harmonic phonon dispersion (green). \n", "It is evident that anharmonicity is important to describe lattice dynamics in PbTe at elevated tem-\n", "peratures, particularly for the optical modes. T In the following we proceed to the second iteration and\n", "re-evaluate the phonon dispersion of PbTe at $T = 300$ K starting from the IFCs of the previous iteration. We repeat until we obtain convergence. \n", "\n", "\n", "### Now repeat the procedure until convergence" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: zg -- -- -- -- -- -- -- -- -- -- -- \n", "Running zg |████████████████████████████████████████| in 0.0s (193.13/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "## Create zg input file to start iteration 2 ##\n", "#\n", "pbte.zg(inputzg={'flfrc':f'\\'{T}.00K_iter_01.fc\\'',\n", " 'T':T,\n", " 'dim1':dim1,\n", " 'dim2':dim2,\n", " 'dim3':dim3,\n", " 'error_thresh':'0.4',\n", " 'niters':'4000',\n", " 'fd':'.true.', \n", " 'na_ifc':'.true.',\n", " 'ASDM':'.true.'},\n", " inputazg={'poly':'.false.','poly_fd_forces':'.false.',\n", " 'iter_idx':2,\n", " 'apply_fd':'.true.', \n", " 'read_fd_forces':'.false.','mixing':'.false.'}\n", " )\n", "# Note here that we add the flags 𝚏𝚍 =.𝚝𝚛𝚞𝚎., 𝚗𝚊_𝚒𝚏𝚌 =.𝚝𝚛𝚞𝚎. to account for long range \n", "# effects since the IFCs in 𝟹𝟶𝟶.𝟶𝟶𝙺_𝚒𝚝𝚎𝚛_𝟶𝟷.𝚏𝚌 are obtained by finite differences.\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='zg')\n", "## Run calculation ##\n", "pbte.run(2,type_run='zg')" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/zg.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.file = './'+str(prefix)+'/zg/zg.out'\n", "pbte.get_QE_status()" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks/PbTe/zg\n", "Number of cores: 224\n", "Number of pools: 14\n", "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks\n" ] } ], "source": [ "# Calculate forces for iteration 2\n", "os.chdir('./'+str(prefix)+'/zg/') # go to zg directory where all ZG-scf*in files are located\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)\n", "#\n", "print(\"Number of cores:\", ncoresuper)\n", "print(\"Number of pools:\", npoolsuper)\n", "#\n", "from EPWpy.EPWpy_run import py_run\n", "# iteration index\n", "itr_idx = 2\n", "# Loop over the range from 0001 to dofsuper\n", "for i in range(1,dofsuper+1):\n", " pbte.env = f'ibrun -np {ncoresuper}'\n", " pbte.code = '/home1/07369/mzach/codes/q-e_dev_2024/bin'\n", " pbte.run_QE=py_run(1,pbte.env,pbte.code) \n", " pbte.run_QE.dir = f'./{i:04d}' # Calculations are performed in separate folders 0001, 0002 ...\n", " pbte.run_QE.filein=f'ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.in'\n", " pbte.run_QE.fileout=f'ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out'\n", " pbte.run_QE.util=f'ibrun -np {ncoresuper} pw.x -nk {npoolsuper} < ../ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.in > ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out'\n", " pbte.run_QE.serial=True\n", " pbte.run_QE.runner()\n", " shutil.copy(f'ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out','../fd_forces/.')\n", " os.chdir('../')\n", "\n", "os.chdir('../../')\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0001.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0002.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0003.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0004.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0005.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0006.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0007.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0008.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0009.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0010.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0011.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0012.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0013.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0014.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0015.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0016.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0017.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0018.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0019.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0020.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0021.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0022.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0023.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0024.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0025.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0026.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0027.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0028.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0029.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0030.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0031.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0032.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0033.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0034.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0035.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0036.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0037.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0038.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0039.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0040.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0041.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0042.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0043.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0044.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0045.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0046.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0047.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0048.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0049.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0050.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0051.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0052.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0053.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0054.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0055.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0056.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0057.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0058.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0059.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0060.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0061.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0062.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0063.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0064.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0065.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0066.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0067.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0068.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0069.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0070.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0071.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0072.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0073.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0074.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0075.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0076.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0077.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0078.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0079.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0080.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0081.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0082.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0083.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0084.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0085.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0086.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0087.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0088.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0089.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0090.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0091.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0092.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0093.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0094.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0095.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Calculation finished normally in ./PbTe/zg/fd_forces/ZG-scf_300.00K_iter_02_0096.out\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "# iteration index\n", "itr_idx = 2\n", "# check if calculations were succesful\n", "for i in range(1,dofsuper+1):\n", " pbte.file = './'+str(prefix)+f'/zg/fd_forces/ZG-scf_{T}.00K_iter_{itr_idx:02d}_{i:04d}.out'\n", " pbte.get_QE_status()" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: zg -- -- -- -- -- -- -- -- -- -- -- \n", "Running zg |████████████████████████████████████████| in 0.0s (164.51/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "# Create the zg input file to generate the temperature-dependent IFCs at iteration 2 (mixing is applied)\n", "#\n", "pbte.zg(inputzg={'flfrc':f'\\'{T}.00K_iter_01.fc\\'',\n", " 'T':T,\n", " 'dim1':dim1,\n", " 'dim2':dim2,\n", " 'dim3':dim3,\n", " 'error_thresh':'0.4',\n", " 'niters':'4000',\n", " 'fd':'.true.', \n", " 'na_ifc':'.true.',\n", " 'ASDM':'.true.'},\n", " inputazg={'poly':'.false.','poly_fd_forces':'.false.',\n", " 'iter_idx0':1, 'iter_idx':2,\n", " 'apply_fd':'.false.',\n", " 'incl_epsil':'.true.',\n", " 'read_fd_forces':'.true.','mixing':'.true.'}\n", " )\n", "# NOTE: Mixing is performed between the current and all previous IFCs matrices as \n", "# specified by the input variables iter_idx0 and iter_idx. We found that for the current system\n", "# convergence is achieved faster. Instead, one can perform mixing between consecutive iterations \n", "# (current and previous iteration) by choosing appropriately iter_idx0 and iter_idx. In any case the\n", "# converged result should be similar.\n", "#\n", "## Prepare folders and copy necessary files ##\n", "pbte.prepare(1,type_run='zg')\n", "## Run calculation ##\n", "pbte.run(2,type_run='zg')" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n", "Error in calculation ./PbTe/zg/zg.out\n", "TACC: Starting up job 6434316 \n", "\n", "TACC: Starting parallel tasks... \n", "\n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "pbte.file = './'+str(prefix)+'/zg/zg.out'\n", "pbte.get_QE_status()" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-- -- -- -- -- -- -- -- -- -- -- Calculation: matdyn -- -- -- -- -- -- -- -- -- -- -- \n", "on 1: running phonon bands calculation\n", "Running matdyn |████████████████████████████████████████| in 0.0s (151.11/s) \n", "\n", "-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- \n" ] } ], "source": [ "# perform a matdyn.x calculation using ifc file 'T_iter_02.fc'\n", "pbte.matdyn(name='matdyn',\n", " matdyn={'flfrq':'\\'./'+str(prefix)+'_02.freq\\'',\n", " 'flfrc':f'\\'../zg/{T}.00K_iter_02.fc\\'',\n", " 'fd':'.true.', \n", " 'na_ifc':'.true.'}, \n", " kpoints={'kpoints':[['0.0', '0.5', '0.5', '100'], #X\n", " ['0.0', '0.0', '0.0', '100'], #Gamma \n", " ['0.0', '0.5', '0.5', '1']]}) # X\n", " \n", "\n", "pbte.prepare(1,type_run='matdyn')\n", "\n", "pbte.run(1,type_run='matdyn')" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Current Directory: /work2/07369/mzach/frontera/QE/Notebooks\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot the phonon dispersion\n", "current_directory = os.getcwd()\n", "print(\"Current Directory:\", current_directory)\n", "\n", "# remember to \"module load python3.7\" from terminal\n", "import matplotlib.pyplot as plt\n", "fig, ax = plt.subplots()\n", "\n", "data = np.loadtxt(str(os.getcwd())+'/'+f'./'+str(prefix)+'/ph/'+str(prefix)+'_harm.freq.gp') \n", "data2 = np.loadtxt(str(os.getcwd())+'/'+f'./'+str(prefix)+'/ph/'+str(prefix)+'_01.freq.gp')\n", "data3 = np.loadtxt(str(os.getcwd())+'/'+f'./'+str(prefix)+'/ph/'+str(prefix)+'_02.freq.gp')\n", "\n", "plt.plot([0, 2.1], [0, 0], color='orange', linewidth=2)\n", "plt.xlim(0, 2.1)\n", "for i in range(1, nmodesu + 1):\n", " plt.plot(data[:, 0], data[:, i]*cm_1_to_meV,color='green')\n", " plt.plot(data2[:, 0], data2[:, i]*cm_1_to_meV,color='red')\n", " plt.plot(data3[:, 0], data3[:, i]*cm_1_to_meV,color='blue')\n", " \n", "ax.plot([], [], color='green', label='Harmonic') \n", "ax.plot([], [], color='red', label='iter 01 (300 K)')\n", "ax.plot([], [], color='blue', label='iter 02 (300 K)')\n", "ax.legend(loc='upper center', bbox_to_anchor=(0.85, 0.22), shadow=True, ncol=1)\n", "\n", "plt.title('PbTe Phonon Dispersion at 300 K')\n", "plt.xlabel('Wavevector')\n", "plt.ylabel('Phonon energy (meV)')\n", "#\n", "from matplotlib import font_manager\n", "#\n", "ticks= [0.0, 1.0, 2.0]\n", "labels=['X', '$\\Gamma$', 'X']\n", "\n", "for ii in ticks:\n", " plt.axvline(ii, linewidth=0.75, color='k', alpha=0.5)\n", "\n", "# text labels\n", "font_prop = font_manager.FontProperties(size=16)\n", "plt.xticks(ticks, labels, fontproperties=font_prop, size =16)\n", "\n", "#plt.legend()\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, we compare the phonon dispersion of PbTe at $T =300$ K obtained at the second iteration (blue)\n", "with the one at first iteration (red), and the harmonic phonon dispersion (green). \n", "As we can see the result at the second iteration is almost converged. One can repeat further iterative steps to check convergence. \n", "\n", "### Homework\n", "\n", "As a homework repeat the previous steps for the third and fourth iterations. \n", "\n", "As a homework, also calculate the phonons of PbTe at $T = 500$ K and $T = 700$ K. \n", "HINT: Simply change the global variable for the target temperature ($T$) and repeat the ZG calculations.\n", "**This is the great advantage of using Jupyter Notebooks, where the repetition of commands and redesigning submission scripts are no longer time-consuming**." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\underline{\\large{\\rm To\\,this\\,end\\,we\\,also\\,discuss\\,two\\,final\\,important\\,points}}$\n", "\n", "**(a)** A quicker and more accurate way than checking the phonon dispersion is to plot the Frobenius norm ($||.||$) of the leading component of the IFCs matrix as suggested in Ref. [Phys. Rev. B 84, 180301(R) (2011)]. This information can be found by analysis of the first 3 × 3 matrix in ${\\tt FORCE\\_CONSTANTS\\_sym\\_1188.00K\\_iter\\_XX}$, where ${\\tt XX}$ indicates the iteration. We note that convergence in the IFCs guarantees essentially minimization of the system’s free energy. \n", "\n", "**(b)** A full self-consistent phonon theory also minimizes the trial free energy with respect to nuclear coordinates. As seen in the lectures, one can employ the Newton-Raphson method and find the nuclear coordinates for which $\\langle \\partial U / \\partial \\tau_{\\kappa \\alpha}\\rangle_T = 0$. This requires to solve self-consistently\n", "the equation\n", "\n", "$\n", "\\tau^{\\rm new}_{p \\kappa \\alpha} (T) = \\tau_{p \\kappa \\alpha} (T) + \\tilde{C}^{-1}_{p \\kappa \\alpha, p \\kappa \\alpha} (T) \\langle F_{p \\kappa \\alpha}\\rangle_T\n", "$\n", "\n", "using at each iterative step $\\tilde{C}_{p \\kappa \\alpha, p \\kappa \\alpha} (T)$. In order to\n", "account for this feature in the A-SDM we need to set the flag ${\\tt{update\\_equil = .true.}}$ when\n", "$\\tt{ read\\_fd\\_forces = .true.}$. If we use this flag for the case of cubic PbTe,\n", "then the code will give $\\tau^{\\rm new}_{p \\kappa \\alpha} (T) = \\tau_{p \\kappa \\alpha} (T)$\n", "(i.e. no change of the nuclear coordinates) at every iterative step. This comes as no surprise\n", "since symmetries are enforced and atoms in PbTe occupy only special Wyckoff positions. However, for\n", "systems containing atoms at general Wyckoff positions, the equation above will give new thermal\n", "equilibrium positions at each temperature that contribute to the minimization of the free energy. See for\n", "example the case of hydride compounds explored in Ref. [Commun. Phys. 6, 298 (2023)]. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }