{ "cells": [ { "cell_type": "markdown", "id": "397dd448", "metadata": {}, "source": [ "# 4.1 Stochastic Calculation of Band Gap Renormalization.\n", "In this example we will learn to do a stochastic Monte Carlo calculation for the band gap renormalization. For this type of calculation we need a phonon restart/checkpoint xml file using a Cartesian phonon calulcation or Normal Mode phonon calculation. \n", "\n", "This calulation is very similar to a normal-mode phonon calculation. First we generate the displacements and then using qbox we compute the total electronic energies and band energies for all displaced coordinates. Last step is very simple. We compute band gaps for each displaced coordinate average over all configurations. This would be our electron-phonon renormalized band gap at that particular temperature.\n", "\n", "We need to import pyepfd_io module to read the input file and we need coord_util module to create the displaced coordinate using the Monte Carlo / Stochastic method. Lets import them first." ] }, { "cell_type": "code", "execution_count": 1, "id": "570f6fb2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", " ███████████ \n", " ░░███░░░░░███ \n", " ░███ ░███ █████ ████ \n", " ░██████████ ░░███ ░███ \n", " ░███░░░░░░ ░███ ░███ \n", " ░███ ░███ ░███ \n", " █████ ░░███████ \n", " ░░░░░ ░░░░░███ \n", " ███ ░███ \n", " ░░██████ \n", " ░░░░░░ \n", " ██████████ ███████████ ███████████ ██████████ \n", "░░███░░░░░█░░███░░░░░███░░███░░░░░░█░░███░░░░███ \n", " ░███ █ ░ ░███ ░███ ░███ █ ░ ░███ ░░███\n", " ░██████ ░██████████ ░███████ ░███ ░███\n", " ░███░░█ ░███░░░░░░ ░███░░░█ ░███ ░███\n", " ░███ ░ █ ░███ ░███ ░ ░███ ███ \n", " ██████████ █████ █████ ██████████ \n", "░░░░░░░░░░ ░░░░░ ░░░░░ ░░░░░░░░░░ \n", "PyEPFD version : 1.1\n", "Author : Arpan Kundu\n", "Author Email : arpan.kundu@gmail.com\n", "Today : 2024-12-18 17:33:22.591930\n", "*************************************************\n", " CITATIONS \n", "=================================================\n", "Please cite the following 3 references: \n", "(1) A. Kundu et al, Phys. Rev. Mater (2021), 5, \n", "L070801, \n", "(2) A. Kundu and G Galli, \n", "J. Chem. Theory. Comput. (2023), 19, 4011\n", "(3) https://pyepfd.readthedocs.io/en/latest/\n", "*************************************************\n" ] } ], "source": [ "from pyepfd.coord_util import *\n", "from pyepfd.pyepfd_io import *" ] }, { "cell_type": "markdown", "id": "997d2ff3", "metadata": {}, "source": [ "Next, we will read all information from the checkpoint/restart XML file created in the previous step, i.e., Cartesian phonon calculation. We would instantiate an object named sd_inp (stochastic displacement input) of class read_pyepfd_info that belongs to coord_util object. The class read_pyepfd_info has several objects such as acoustic sum rule (asr), refined dynamical matrix (ref_dynmatrix), optimized coordinates(coord), atoms and cell. " ] }, { "cell_type": "code", "execution_count": 2, "id": "1c26f590", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Process-id0: Time spent on read_pyepfd_info class: 0.0005590915679931641 s.\n" ] } ], "source": [ "sd_inp = read_pyepfd_info(file_path='../1_cartesian_phonon/fdphonon.xml')" ] }, { "cell_type": "markdown", "id": "f79759fb", "metadata": {}, "source": [ "Now we will define the input dynamical matrix for stochastic displacement. If refined dynamical matrix (i.e. after performing acoustic sum rule) exists, it would take that one, otherwise it would take dynamical matrix object." ] }, { "cell_type": "code", "execution_count": 3, "id": "08abb5ee", "metadata": {}, "outputs": [], "source": [ "if sd_inp.ref_dynmatrix is not None:\n", " inp_dynmat = sd_inp.ref_dynmatrix\n", "else:\n", " inp_dynmat = sd_inp.dynmatrix" ] }, { "cell_type": "markdown", "id": "e2a6c244", "metadata": {}, "source": [ "Now we will initiate an xyz class in writing mode. Atoms are obtained from atom objects in sd_inp class" ] }, { "cell_type": "code", "execution_count": 4, "id": "ef1daf11", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Time spent on xyz class: 0.00039124488830566406 s.\n" ] } ], "source": [ "sd_xyz = xyz(file_path='mcap.xyz',io='w',atoms=sd_inp.atoms)" ] }, { "cell_type": "markdown", "id": "47eb85e7", "metadata": {}, "source": [ "Like displacing the atoms during a (E)NMFD phonon calculation, we instantiate an object named sdmoves (stochastic displacement moves) of ionic_mover class. Here we would use mode = 'SD', i.e. stochastic displacement. \n", "\n", "Moreover, we need to provide an algorithm (algo keyword) for stochastic displacement. 6 algorithms are available: \n", "(1)oneshot ('os'), \n", "\n", "(2)oneshot with antithetic pair ('osap'),\n", "\n", "(3)one shot with random sample of signs (osr), this is equivalent to thermal line sampling, see https://journals.aps.org/prb/abstract/10.1103/PhysRevB.93.014302\n", "\n", "(4) Same like 'osr' but with antithetic pairs.\n", "\n", "(5)Monte Carlo Sampling of Normal Modes ('mc')\n", "\n", "(6) Same as 'mc' but with antithetic pairs of each chosen random sample.\n", "\n", "Usually algorithm with antithetic pairs are recommended. Below example we are choosing MCAP. \n", "\n", "Here ngrid is the number of independent samples to be drawn for algorithms 3-6 described above. If an algorithm has antithetic pairs in it then actual numbers of configuration would be 2 times ngrid. In the below example chosen value of ngrid is 250 and so it would generate 500 configurations.\n", "\n", "We also need to chose a temperature. In the below example it is 100 K\n", "\n", "Therefore, the definition of sdmoves class would read as:" ] }, { "cell_type": "code", "execution_count": 5, "id": "28d9bdc5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ionic_mover._stoch_disp(mcap,250) is running with 1 MPI processes.\n", "Process-id = 0: 10% of SD iterations completed.\n", "Process-id = 0: 20% of SD iterations completed.\n", "Process-id = 0: 30% of SD iterations completed.\n", "Process-id = 0: 40% of SD iterations completed.\n", "Process-id = 0: 50% of SD iterations completed.\n", "Process-id = 0: 60% of SD iterations completed.\n", "Process-id = 0: 70% of SD iterations completed.\n", "Process-id = 0: 80% of SD iterations completed.\n", "Process-id = 0: 90% of SD iterations completed.\n", "Process-id = 0: 100% of SD iterations completed.\n", "Time spent on ionic_mover class: 0.026976823806762695 s.\n" ] } ], "source": [ "sdmoves = ionic_mover( atoms = sd_inp.atoms,\n", " opt_coord = sd_inp.coord, \n", " mode = 'SD', \n", " algo ='mcap', \n", " ngrid = 250,\n", " dynmat = inp_dynmat,\n", " asr = sd_inp.asr,\n", " temperature = 100)" ] }, { "cell_type": "markdown", "id": "31924b06", "metadata": {}, "source": [ "Now all the displaced coordinates are stored within sdmoves object. Next step is to write them into an xyz file using the sd_xyz class we initiated before. Note,this process is mpi parallelized." ] }, { "cell_type": "code", "execution_count": 6, "id": "4b35e228", "metadata": {}, "outputs": [], "source": [ "for j in range(sdmoves.disp_coord.shape[1]):\n", " sd_xyz.write(cell = sd_inp.cell,coord = sdmoves.disp_coord[:,j])\n", "del sd_xyz " ] }, { "cell_type": "code", "execution_count": 7, "id": "6f33517c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mcap.xyz\n" ] } ], "source": [ "%%bash \n", "ls mcap.xyz" ] }, { "cell_type": "markdown", "id": "b2c29089", "metadata": {}, "source": [ "Note that the last step was a Monte Carlo simulation that involves pseudo random numbers. Therefore each time you run the sdmoves class it would create a different set of displaced coordinates. Only one OS and OSAP algorithms would produce the same set of coordinates because it does not involves any pseudo random numbers. Let us restart the kernel for completion of the file writing.\n", "\n", "Also all code blocks can be included in a single file: mcap.py. In the following example we have written the mcap.py so that it accepts 2 command line arguments: (1) path to the XML restart file and (2) temperature.Let's have a look at this file again. " ] }, { "cell_type": "code", "execution_count": null, "id": "d54d6394", "metadata": {}, "outputs": [], "source": [ "# %load mcap.py\n", "import sys,os\n", "from pyepfd.coord_util import *\n", "from pyepfd.pyepfd_io import *\n", "\n", "#usage python3 mcap.py phonon_file T\n", "\n", "phonon_file = sys.argv[1]\n", "T = sys.argv[2]\n", "\n", "sd_inp = read_pyepfd_info(file_path = phonon_file)\n", "\n", "if sd_inp.ref_dynmatrix is not None:\n", " inp_dynmat = sd_inp.ref_dynmatrix\n", "else:\n", " inp_dynmat = sd_inp.dynmatrix\n", "\n", "# creating an xyz class to write the trajectory\n", "sd_xyz = xyz(file_path=f'{T}K.xyz',io='w',atoms=sd_inp.atoms)\n", "\n", "# Calling ionic mover class to perform Monte Carlo Antethetic Pair (MCAP) displacements\n", "sdmoves = ionic_mover( atoms = sd_inp.atoms,\n", " opt_coord = sd_inp.coord,\n", " mode = 'SD',\n", " algo ='mcap',\n", " ngrid = 250,\n", " dynmat = inp_dynmat,\n", " asr = sd_inp.asr,\n", " temperature = float(T))\n", "\n", "for j in range(sdmoves.disp_coord.shape[1]):\n", " sd_xyz.write(cell = sd_inp.cell,coord = sdmoves.disp_coord[:,j])\n", "del sd_xyz\n" ] }, { "cell_type": "markdown", "id": "9cb0e9a0", "metadata": {}, "source": [ "Now we will run the script using mpi process." ] }, { "cell_type": "code", "execution_count": 8, "id": "9675b5d6", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " \n", " ███████████ \n", " ░░███░░░░░███ \n", " ░███ ░███ █████ ████ \n", " ░██████████ ░░███ ░███ \n", " ░███░░░░░░ ░███ ░███ \n", " ░███ ░███ ░███ \n", " █████ ░░███████ \n", " ░░░░░ ░░░░░███ \n", " ███ ░███ \n", " ░░██████ \n", " ░░░░░░ \n", " ██████████ ███████████ ███████████ ██████████ \n", "░░███░░░░░█░░███░░░░░███░░███░░░░░░█░░███░░░░███ \n", " ░███ █ ░ ░███ ░███ ░███ █ ░ ░███ ░░███\n", " ░██████ ░██████████ ░███████ ░███ ░███\n", " ░███░░█ ░███░░░░░░ ░███░░░█ ░███ ░███\n", " ░███ ░ █ ░███ ░███ ░ ░███ ███ \n", " ██████████ █████ █████ ██████████ \n", "░░░░░░░░░░ ░░░░░ ░░░░░ ░░░░░░░░░░ \n", "PyEPFD version : 1.1\n", "Author : Arpan Kundu\n", "Author Email : arpan.kundu@gmail.com\n", "Today : 2024-12-18 17:40:01.930879\n", "*************************************************\n", " CITATIONS \n", "=================================================\n", "Please cite the following 3 references: \n", "(1) A. Kundu et al, Phys. Rev. Mater (2021), 5, \n", "L070801, \n", "(2) A. Kundu and G Galli, \n", "J. Chem. Theory. Comput. (2023), 19, 4011\n", "(3) https://pyepfd.readthedocs.io/en/latest/\n", "*************************************************\n", "Process-id0: Time spent on read_pyepfd_info class: 0.0003077983856201172 s.\n", "Time spent on xyz class: 6.985664367675781e-05 s.\n", "ionic_mover._stoch_disp(mcap,250) is running with 2 MPI processes.\n", "Process-id = 0: 10% of SD iterations completed.\n", "Process-id = 0: 20% of SD iterations completed.\n", "Process-id = 0: 30% of SD iterations completed.\n", "Process-id = 0: 40% of SD iterations completed.\n", "Process-id = 0: 50% of SD iterations completed.\n", "Process-id = 0: 60% of SD iterations completed.\n", "Process-id = 0: 70% of SD iterations completed.\n", "Process-id = 0: 80% of SD iterations completed.\n", "Process-id = 0: 90% of SD iterations completed.\n", "Process-id = 0: 100% of SD iterations completed.\n", "Time spent on ionic_mover class: 0.015214920043945312 s.\n" ] } ], "source": [ "%%bash\n", "mpirun -np 2 python3 mcap.py ../1_cartesian_phonon/fdphonon.xml 100" ] }, { "cell_type": "markdown", "id": "020d6b0f", "metadata": {}, "source": [ "This would create a file 100K.xyz containing the trajectory." ] }, { "cell_type": "code", "execution_count": 11, "id": "760f0bf3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "100K.xyz\n", "mcap.xyz\n", "saved_example.xyz\n" ] } ], "source": [ "%%bash \n", "ls *.xyz" ] }, { "cell_type": "markdown", "id": "f988ae2b", "metadata": {}, "source": [ "The next step is to prepare the qbox input files for computation of electronic properties, e.g., band energies for these configurations. This step is very similar to the previous examples 1.2 and 2.2. We will use xyz2qb tool. In this case we do not need to save the wave functions (unlike example 2.2)." ] }, { "cell_type": "code", "execution_count": 12, "id": "046a65cd", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[95mFile \u001b[94mmcap.xyz\u001b[95m has \u001b[94m3\u001b[95m number of atoms in each frame and a total \u001b[94m500\u001b[95m number of frames.\u001b[00m\n", "\u001b[95mNo of species: \u001b[94m2\u001b[00m\n", "\u001b[95mPresent species are: \u001b[94m\n", "C\n", "O\u001b[00m\n", "\u001b[95mThe file \u001b[94mmcap.xyz\u001b[95m is an i-PI output with\u001b[92m pos_unit: \u001b[94mangstrom\u001b[95m and \u001b[92mcell_unit: \u001b[94mangstrom\u001b[00m\n", "Enter start frame number: (Default = 1) \n", "Enter last frame number: (Default = 500) \n", "Enter step frame: (Default = 1) \n", "Enter qbox command for 1st iteration: (Default = ' randomize_wf, run -atomic_density 0 100 10')\n", "Hint: more than one commands should be separated by a comma.\n", "\n", "Enter qbox run command: (Default = ' run 0 60 10')\n", "Hint: more than one commands should be separated by a comma.\n", "\n", "Enter qbox plot command: (Default = ' None')\n", "Hints:\n", " (1) Example: plot options filename (without .cube extension) \n", " (2) More than one commands should be separated by a comma.\n", "\n", "Enter qbox spectrum command: (Default = ' None')\n", "Hints:\n", " (1) Example: spectrum options filename (without .dat extension) \n", " \n", "Do you want to save sample for each configurations (y/n)? (Default = n) \n", "Enter filename of qbox input: (Default = qbox.i) mcap-1.i\n", "Enter xc: (Default = PBE)B3LYP\n", "Enter wf_dyn: (Default = JD) \n", "Enter ecut (Ry): (Default = 50.0) \n", "Enter scf_tol (Ry): (Default = 1e-08) 1e-9\n", "Enter nempty: (Default = 100) 8\n", "Enter nspin (1/2): (Default = 1) \n", "Enter delta_spin: (Default = None) \n", "Enter net_charge: (Default = 0) \n", "Enter pseudopotential: (Default = ONCV_PBE-1.0) \n", "\u001b[91mWarning!\n", "Files: \u001b[94m\n", "C_ONCV_PBE-1.0.xml\n", "O_ONCV_PBE-1.0.xml\u001b[91m\n", "must be present in the following pseudo-potential directory.\n", "\u001b[00m../pseudos/\n" ] } ], "source": [ "%run ../../../utils/qbox_utils/xyz2qb.py mcap.xyz" ] }, { "cell_type": "markdown", "id": "4ba45692", "metadata": {}, "source": [ "This created a qbox input file with name mcap-1.i. Just like example 1.2, here also multiple input file can be (must for a large system) created. For that purpose the bash wrapper many_xyz2qb.sh located at util/qbox_util folder can be used instead of running xyz2qb.py multiple times. The next step is to submit those jobs and wait until all calculations finished properly.\n", "\n", "Here we already computed the HOMO-LUMOs for a set of MC trajectory (saved_example.xyz) generated for the same temperature and same algorithm. The related qbox input file is saved_example-1.i and the output file is saved_example-1.r. Taking this output file as an example, I will show how to compute renormalized bad gap. \n", "\n", "First we will extract the Kon-Sham eigenvalues for HOMO (band 7,8) and LUMO." ] }, { "cell_type": "code", "execution_count": 13, "id": "c0d2f5ec", "metadata": {}, "outputs": [], "source": [ "%%bash\n", "source ../../../env.sh\n", "rm -rf Eigenvalues #Removing the previous existing Eigenvalues folder\n", "extract_eigval.sh -prefix saved_example -seq 1 1 -orb 7 9" ] }, { "cell_type": "code", "execution_count": 14, "id": "2552ddb4", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#Orbital-7\t#Orbital-8\t#Orbital-9\n", "-10.487170364117\t-10.477806462848\t-1.023844849688\n", "-10.491930996223\t-10.476740223367\t-1.056185101151\n", "-10.485337121956\t-10.475223504189\t-1.081698326149\n", "-10.465087173793\t-10.443357728981\t-1.267443801201\n", "-10.472053419490\t-10.465358595320\t-0.970187929921\n", "-10.512543172977\t-10.512527824290\t-0.898384711847\n", "-10.527799679100\t-10.517207132901\t-0.923443428935\n", "-10.478123219864\t-10.462103393953\t-1.148608321486\n", "-10.339938214676\t-10.339440662568\t-0.954741724093\n", "-10.423617068754\t-10.401157571192\t-1.244167491779\n", "-10.532306461367\t-10.529566959494\t-0.894040197086\n", "-10.409028400597\t-10.399754091388\t-1.076863441171\n", "-10.477285216996\t-10.465041191181\t-1.139326536596\n", "-10.448040183680\t-10.431506465550\t-1.111545941111\n", "-10.478714643717\t-10.467120526323\t-1.114443749835\n", "-10.491228021287\t-10.489006381255\t-0.958756414210\n", "-10.487713978646\t-10.474126658401\t-0.999063507444\n", "-10.486938627166\t-10.481050436941\t-1.025233757119\n", "-10.421068833951\t-10.403397269651\t-1.193176789321\n", "-10.375467136826\t-10.371551646788\t-1.016743984958\n", "-10.403133578003\t-10.399024563790\t-0.977891719837\n", "-10.499967797745\t-10.497579430661\t-0.966816043298\n", "-10.454634021664\t-10.454160120113\t-1.003325292033\n", "-10.528476645895\t-10.524321592394\t-0.906084170125\n" ] } ], "source": [ "%%bash\n", "head -n 25 orbital_kp_0_0_0_is_0.dat" ] }, { "cell_type": "markdown", "id": "9bf57bc7", "metadata": {}, "source": [ "Generated orbital_kp_0_0_0.dat file lists energies for bands 7,8 (HOMO) and 9 (LUMO) for all 500 sampled configurations. We will compute the average HOMO energy for each configurations by taking the average energies of band 7 and 8. Then we compute the band gap for each configurations by subtracting the average HOMO energy from LUMO energy (band 9). \n", "\n", "This can be easily done using an \"awk\" command." ] }, { "cell_type": "code", "execution_count": 15, "id": "ec5bd174", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "9.45864\n", "9.42815\n", "9.39858\n", "9.18678\n", "9.49852\n", "9.61415\n", "9.59906\n", "9.3215\n", "9.38495\n", "9.16822\n", "9.6369\n", "9.32753\n", "9.33184\n", "9.32823\n", "9.35847\n", "9.53136\n", "9.48186\n", "9.45876\n", "9.21906\n", "9.35677\n", "9.42319\n", "9.53196\n", "9.45107\n", "9.62031\n", "9.61705\n" ] } ], "source": [ "%%bash\n", "awk '{print $3-($1+$2)/2}' orbital_kp_0_0_0_is_0.dat | sed '1d' > gap.dat\n", "head -n 25 gap.dat" ] }, { "cell_type": "markdown", "id": "c766dcb9", "metadata": {}, "source": [ "To obtain the renormalized gap, the next step is to average over all 500 configurations. " ] }, { "cell_type": "code", "execution_count": 16, "id": "06fa1d29", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from pyepfd.epfd import mc_convergence\n", "import matplotlib.pyplot as plt\n", "co2_100K = mc_convergence(file_path='gap.dat',algo='mcap', usecols=(0))\n", "mc = co2_100K.avg[:,0] #Our gap was in column 0 of the file\n", "emc = 2*co2_100K.sd_mean[:,0] # Error is 2 times standard deviation of mean\n", "plt.plot( [i+1 for i in range(len(mc))], mc, label='MC')\n", "plt.fill_between([i+1 for i in range(len(mc))], mc + emc, mc - emc, alpha = 0.3)\n", "plt.xlabel(\"# of independent samples\")\n", "plt.ylabel(\"Renormalized Gap (eV)\")\n", "plt.show()" ] } ], "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.8.10" } }, "nbformat": 4, "nbformat_minor": 5 }