Scrapbook (Posts about quantum-chemistry)

QM/MM

author — Sat, 25 Feb 2023 04:24:30 GMT

Reading materials

Chapter 13 of Cramer, C. J. Essentials of Computational Chemistry: Theories and Models, 2nd ed.; John Wiley & Sons, 2013.
References in the "Molecular Simulation -> QM/MM" folder of the group Zotero library, especially the following reviews:

Bramley, G. A.; Beynon, O. T.; Stishenko, P. V.; Logsdail, A. J. The Application of QM/MM Simulations in Heterogeneous Catalysis. Phys. Chem. Chem. Phys. 2023, 10.1039.D2CP04537K.
Chung, L. W.; Sameera, W. M. C.; Ramozzi, R.; Page, A. J.; Hatanaka, M.; Petrova, G. P.; Harris, T. V.; Li, X.; Ke, Z.; Liu, F.; Li, H.-B.; Ding, L.; Morokuma, K. The ONIOM Method and Its Applications. Chem. Rev. 2015, 115, 5678–5796.
Senn, H. M.; Thiel, W. QM/MM Methods for Biomolecular Systems. Angew. Chem. Int. Ed. 2009, 48, 1198–1229.
Lin, H.; Truhlar, D. G. QM/MM: What Have We Learned, Where Are We, and Where Do We Go from Here? Theor. Chem. Acc. 2007, 117, 185–199.

Software codes for performing QM/MM

ChemShell: A copy is uploaded to our group SharePoint folder.
ONIOM methods in Gaussian.
GROMACS/CP2K.
GULP has very good support for shell models for ionic materials and can interface with QMPot, TURBOMOLE, and ABINIT. A copy is uploaded to our group SharePoint folder.
Tinker (next version) is a molecular mechanics code and can interface with GAMESS-UK and Q-Chem.
INAQS supports both Born-Oppenheimer, Ehrenfest, and surface hopping (non-adiabatic) dynamics.

DFT+U

author — Fri, 28 Aug 2020 21:17:00 GMT

References in the "DFT+U" folder of the group Zotero library.
Tutorials for VASP
Tutorials for Quantum-ESPRESSO
- Calculating linear response and self-consistent U parameters: single site
- Calculating linear response and self-consistent U parameters: multiple sites

VASP How-tos

author — Fri, 11 Jan 2019 21:45:24 GMT

Tutorials

Work through tutorials SharePoint folder from a 2003 VASP workshop.
Tutorials in SharePoint folder for first-principle simulation codes.
Papers in the group Zotero library, inside folders labeled classics.
Classic texts listed under Computational modeling and Catalysis.
Official YouTube channel of VASP.

Set up vasp-tools on the group server

SSH (PuTTY for Windows) to the group server and complete the steps below.

cd ~
ln -sf /share/apps/vasp-tools .
cp -a /home/common/sample-input/vasp/my-vasp-tools .
module add vasp-tools/linux

Edit ~/my-vasp-tools/user_specs to suit your system and use your Email address.

To find out the available options setrun supports, locate VASPROOT from the output of the following command:

module show vasp-tools

Typically, the result will be $HOME/vasp-tools, you can then examine the set of system and job types:

find $HOME/vasp-tools/runfiles/system/ -mindepth 2 -maxdepth 2 -type d  # for system types, or
find $HOME/vasp-tools/runfiles/jobtype/ -mindepth 2 -maxdepth 2 -type d  # for job types

You will see something like $HOME/vasp-tools/runfiles/system/gas/molecule and $HOME/vasp-tools/runfiles/jobtype/nrg/low, which means you can use -s gas/molecule and -j nrg/low for isolated molecular calculation and low-precision single-point energy calculation, respectively.

To create new systems or job types, or override existing ones, simply create the necessary folder hierarchy in ~/my-vasp-tools. For example, if we want to use a different INCAR template for gas/molecule, copy the existing files from $HOME/vasp-tools to use as the basis:

mkdir -p ~/my-vasp-tools/runfiles/system/gas
cp -a ~/vasp-tools/runfiles/system/gas/molecule ~/my-vasp-tools/runfiles/system/gas/

We then make the necessary changes to INCAR files in all sub directories. We can also add KPOINTS files to these sub directories and skip the -K option when running setrun.

Similarly, create/copy and edit files in ~/my-vasp-tools/runfiles/jobtype to customize new job types to use with the -j option of setrun.

Make sure to understand Step 4 under Shotgun basic workflow. Remember to copy the VASP executable to the target HPC machine. Where the VASP executable should be located is determined by the submission script. For example, /home/common/bin/sub-vasp-bridges.script has the following line PROG="$HOME/vasp-tools/hosts/mesabi/vaspexec/vasp5.4.1_ifort_impi_mkl_vtst_vaspsol", which means a binary executable named vasp5.4.1_ifort_impi_mkl_vtst_vaspsol should exist in your home directory on Bridges under vasp-tools/hosts/mesabi/vaspexec. We can rsync the executable as follows:

rsync -avzP /share/apps/vasp-tools/hosts/mesabi bridges:.
ssh bridges 'mkdir -p ~/vasp-tools/hosts; mv mesabi ~/vasp-tools/hosts/'

VASP executable: If VASP has not been compiled on a new HPC system, we can use a build for a different HPC machine assuming they have the same microarchitecture (see this list). Most VASP builds were compiled with Intel compilers + MKL. Remember to module add the latest Intel compiler suite.

Set up Open Studio

Log in with your UMass email at Open Studio .
Download the token script from the drop-down menu at the top right corner and copy it to your ~/my-vasp-tools/bin folder on the group server.
Give the script executable permission and create the ~/website folder:

chmod +x ~/my-vasp-tools/bin/post2web.sh
mkdir -p ~/website

After the setup, results_opt, results_neb, and results_dim scripts will upload VASP results to your Google Drive and return a link for web visualization.
You can customize the look and feel, make measurements, or even use Jmol console commands (right click on the visualization pane). You can save the customization by clicking the Export Online button.

Single-point energy calculations / geometry optimizations

This video gives a good introduction on geometry optimization, covering the theory, and discussing the different algorithms implemented in VASP. Below is the sequence of steps for running a VASP calculation to compute a single-point energy or to optimize a structure.

On your workstation

Use Schrodinger or any other suitable software to prepare the structure to be optimized, export it as a .pdb file.
Use rsync / scp / WinSCP (Windows only) to upload the file to group server.

On the group server

Convert the .pdb file to VASP POSCAR format. It may be necessary to edit the .pdb file by deleting all the "CONECT" lines using a text editor.

cd /path/to/projects/ABC/moleculeX/reactant  # go to the directory where the .pdb file is uploaded.
module add python/conda3.6  # in order to use the ASE python module
ase convert moleculeX-reactant.pdb POSCAR  # converts the .pdb file to POSCAR

Set up other input files.
```
module add vasp-tools  # in order to use the setrun script (and others)
setrun -f PBE -F D3BJ -p PAW54 -K 1x1x1 -s gas/molecule -j opt/high
```
setrun generates 3 directories: STEP1, STEP2, STEP3, for a 3-stage optimization. STEP3 uses high K-point but low precision. It's mostly for metals and not relevant for isolated molecules or zeolite systems. Remove it by
```
rm -r STEP3
```
In the above command, -s gas/molecule specifies the type of system and -j opt/high specifies the job type.
Prepare submission scripts. The best practice is to write a generic submission script and put it in the local asset directory (e.g., /path/to/projects/ABC/bin/). Then create symbolic links:
```
ln -sf ../../bin/sub-vasp.script .  # Run in current directory /path/to/projects/ABC/moleculeX/reactant
```
NOTE: these symlinks must use relative paths instead of absolute paths, because the local asset directory will be synced to the remote target under your home directory, which may have a different absolute path.
Submit the job using shotgun
```
shotgun submit -c 8 -m 5200 -n 1 -t 24 -r ghpcc06 -q long -j ../../bin/sub-vasp-ghpcc.script  # submitting the job
```
NOTE: the ./ part in ./sub-vasp-ghpcc.script is required. See shotgun --help submit for a list of options that can be used.

NEB calculations

The nudged elastic band method uses a series of structures to approximate the states along a reaction pathway and optimize them in a way so that they approach the minimum energy pathway. Below is the sequence of steps for setting up a NEB calculation.

On your workstation, use Schrodinger to gradually modify your reactant structure and morph it into the desired product structure. Save 4 -- 8 intermediate states, depending on how complicated the reaction is. Since we will use linear interpolation of Cartesian coordinates to construct the initial guess for the reaction pathway, translation is therefore easy while rotation is difficult.
NOTE: make sure you understand this point. To help with understanding this, construct two "reactions": pure translation and pure rotation of a single methane molecule. Use only reactant and product to construct a 8-image pathway for both cases (see below for the steps). Visualize the movie of the two pathways created and pay attention to how bonds are compressed in the rotation "reaction". We would want to avoid feeding obviously unphysical structures to DFT calculations.
Optimize the reactant and product structures, following the steps under Geometry Optimizations.
Export the intermediate states as .pdb files and upload them to group server.

SSH to group server. On the group server, convert all the .pdb files to POSCARs:

cd /path/to/projects/ABC/moleculeX/NEB  # go to the directory where the intermediate images are uploaded.
module add python/conda3.6  # in order to use the ASE python module
ase convert moleculeX-intermediate1.pdb POSCAR1
ase convert moleculeX-intermediate2.pdb POSCAR2
# ... say you have saved five intermediate images ...
ase convert moleculeX-intermediate5.pdb POSCAR5

Copy the optimized reactant and product structures as POSCAR0 and POSCAR6. Make sure to use the FINAL optimized structure from STEP2, not the stage 1 result in STEP1.

cp -a /path/to/projects/ABC/moleculeX/reactant/STEP2/CONTCAR POSCAR0
cp -a /path/to/projects/ABC/moleculeX/product/STEP2/CONTCAR POSCAR6

Set up the input files:

module add vasp-tools  # in order to use the setrun script (and others)
setrun -f PBE -F D3BJ -p PAW54 -K 1x1x1 -s zeolite/surface -j neb/high -i 8

-i 8 specifies that this is a 8-image setup. For challenging reactions, you can increase the number of images to, say, 16, using -i 16

Visualize the output movie file POSCAR.res that represents the initial guess of the reaction pathway, and make sure that it matches your expectation.
Edit INCAR to replace IMAGES = $IMAGES with the actual number of images used; e.g., IMAGES = 8. You can also do it from the command line:
```
sed -i 's/$IMAGES/8/' INCAR
```

Link the submission scripts:

ln -sf ../../bin/sub-vasp.script .  # Run in current directory /path/to/projects/ABC/moleculeX/NEB

Submit the job using shotgun
```
shotgun submit -n 2 -t 24 -r unity-40Cx2 -j ../../bin/sub-vasp-ghpcc.script  # submitting the job
```
Here we are requesting 2 full nodes, all 40 cores on each node, for a total of 80 (physical) cores. See the hyper-threading section here for physical vs. logical cores. With 80 cores, each image will be run on 80/8 = 10 cores. Always aim for an even number of cores per image by 1) targeting an HPC with nodes that have physical cores that can divide your images evenly or 2) adjusting the number of cores per image to fit the HPC's architecture. Use 8-12 cores per image, usually no more than 12 cores. For example, a 16-image job could run on Anvil which has nodes with 128 cores, so the job will use 8 cores per image. Since NEB calculations typically use many cores, there is no good reason to request -c N with N less than the full core count per node.
After the calculation converges, copy OUTCARs for reactant and product to the corresponding directories. Then, perform analysis and move the NEB trajectory movie from the ~/website folder. Make sure the copied movie file corresponds to the current calculation since the files may be in a sub-directory such as ~/website/X where X is an integer. One way to verify is to compare file time-stamps using ls -alhF. Another way is to compare file contents using vim -d ~/website/1/neb2.dat /path/to/calc/neb2.dat
```
cp -a /path/to/projects/ABC/moleculeX/reactant/STEP2/OUTCAR 00/
cp -a /path/to/projects/ABC/moleculeX/product/STEP2/OUTCAR 09/
module add vasp-tools  # in order to use the results_neb script (and others)
results_neb
mv ~/website/CONTCAR.res .
```

Dimer calculations

Dimer calculations use three images to represent the transition state: a center image for the transition-state structure, and two others for the direction of the reaction pathways. The following is the sequence of steps for setting up a dimer calculation.

The initial structure for dimer optimizations needs to be reasonably close to a saddle point. It is usually obtained from a NEB calculation. Assuming NEB image 05 is closest to the transition state of interest, we copy it as the dimer center image.
```
cp -a /path/to/NEB/05/CONTCAR POSCAR
```

Next we need to provide a MODECAR file to represent the reaction direction. Using chemical intuition, pick either images 04 -> 05 or 05 -> 06 from the NEB calculation, and generate MODECAR.

cp -a /path/to/NEB/04/CONTCAR POSCAR02  # or cp -a /path/to/NEB/06/CONTCAR POSCAR02
module add vasp-tools  # in order to use the modemake, dimmovie, and setrun scripts
modemake POSCAR02 POSCAR  # or modemake POSCAR POSCAR02, the order does not really matter
dimmovie

dimmovie generates a movie file, which you can visualize to verify the structure and mode.

Set up the input files:
```
setrun -f PBE -F D3BJ -p PAW54 -K 1x1x1 -s zeolite/surface -j dim/high
```
setrun generates 3 directories: STEP1, STEP2, STEP3, for a 3-stage optimization. STEP3 uses high K-point but low precision. It's mostly for metals and not relevant for isolated molecules or zeolite systems. Remove it by
```
rm -r STEP3
```

Link the submission scripts:

ln -sf ../../bin/sub-vasp.script .  # Run in current directory /path/to/projects/ABC/moleculeX/dimer

Submit the job using shotgun

shotgun submit -c 8 -m 5200 -n 1 -t 24 -r ghpcc06 -q long -j ../../bin/sub-vasp-ghpcc.script  # submitting the job

After the calculation converges, perform the analysis in the STEP2 folder. The trajectory movie files CONTCAR.res and Dimer_Mode.res are saved in ~/website and can be moved to the job folder, especially before running another results_dim analysis since both files will be overwritten.
```
module add vasp-tools
cd /path/to/dim/STEP2
results_dim
mv ~/website/{CONTCAR.res,Dimer_Mode.res} .
```

Metadynamics

Metadynamics is used to estimate the free energy and other state functions of a system, where ergodicity is hindered by the form of the system's energy landscape.

VASP Settings

Standard MD-related tags.
To continue the Metadynamics run.
```
cp HILLSPOT PENALTYPOT
```

Plumed Analysis

Free energy calculated using bias potential (sum hills)
Free energy calculated by reweighting

Center-of-mass drifting

Our simulation box is an isolated system that experiences no external force and has no initial velocity, so its center of mass (COM) should not move. If it does, it is usually a symptom of bad numerics, i.e., energy and forces are not computed precisely enough.
Say if the COM moves with a velocity of v and each atom moves relative to the COM with velocity v_i, then v_i should be the velocity used to compute the system kinetic energy and temperature. However, with almost all MD codes, (v + v_i) will be used instead. So if the system is thermostatted at T (using the inflated velocity), the real temperature will be lower than T.
The ideal solution to this problem may be quite expensive. Oftentimes it can be permissible to remove the center of mass velocity.

Gaussian How-tos

author — Mon, 05 Dec 2016 23:02:55 GMT

Licensing

XSEDE was updated to ACCESS in Fall 2022, see this "cheatsheet" page for help transitioning. To use Gaussian on XSEDE machines:

SDSC Expanse: Open a help ticket on ACCESS using these instructions
PSC Bridges2: Fill out this request form, no need for the help ticket
TACC Stampede2: Fill out the license form here and submit an ACCESS help ticket with license form attached

Single-point energy calculations / geometry optimizations

Below is the sequence of steps for running a Gaussian calculation to compute a single-point energy or to optimize a structure.

Use GaussView or any other suitable software to prepare the structure to be optimized, export it in the XYZ / MOL / MOL2 format, where you can extract the Cartesian coordinates.
Create an appropriate folder hierarchy and construct a Gaussian input file called gaussian.gjf:
```
cd /path/to/projects/ABC/moleculeX
vim gaussian.gjf
```
A basic Gaussian input file may look like the following. You can read about the different keywords on its website. Important notes and common changes include:
- Gaussian has a very strict formatting: the empty lines between different sections, the four stars and two empty lines after the basis set definition.
- Lines starting with a exclamation mark are comment lines and ignored.
- DFT functional: M062X, M06L.
- Basis set and Gen keyword: AUG-cc-pVDZ, AUG-cc-pVTZ; 3-21G, 6-311+G(3df,3pd); etc.
- Charge and spin states: 0 1 means a neutral singlet.
- Fill in the Cartesian coordinates you prepared earlier.
- nprocshared and mem will be adjusted automatically by the submission script below.
```
%nprocshared=128
%mem=253000MB
%chk=gaussian.chk
# M062X/Gen/Auto
# Opt
!# Opt=ReadFC
!# Geom=(Check, NewDefinition) Guess=Read
# Integral(Grid=UltraFine) SCF=(Tight,IntRep,XQC) NoSymm
!#p Integral(Grid=UltraFine) SCF=(Conver=4,VarAcc,IntRep,XQC,MaxCycle=512,VShift=400) NoSymm

Molecule

0   1
 H               -118.70001270  -91.91738745 -127.75908914
... More lines of Cartesian coordinates
 O               -120.07157063  -94.57259547 -129.34664170

H O 0
AUG-cc-pVTZ
****
```
Prepare submission scripts. The best practice is to write a generic submission script and put it in the local asset directory (e.g., /path/to/projects/ABC/bin/). Then create symbolic links:
```
ln -sf ../bin/sub-gaussian.script .  # Run in current directory /path/to/projects/ABC/moleculeX
```
NOTE: these symlinks must use relative paths instead of absolute paths, because the local asset directory will be synced to the remote target under your home directory, which may have a different absolute path.
Submit the job using shotgun
```
shotgun submit -c 8 -m 2000 -n 1 -t 24 -r bridges2 -q RM-shared -j ../../bin/sub-gaussian-bridges2.script  # submitting the job
```
NOTE: the ./ part in ./sub-gaussian-bridges2.script is required. See shotgun --help submit for a list of options that can be used.
If the job runs out of time and you want to continue the calculation, you have two choices:
- Copy the Cartesian coordinates of the last configuration from output file gaussian.log to gaussian.gjf. There is a script that may help with this task:
```
/home/common/sample-input/gaussian/bin/g_copy_last_geom.sh gaussian.log gaussian.gjf
```
- Read frequencies and coordinates from the checkpoint file gaussian.chk by commenting and un-commenting the relevant lines.
```
!# Opt
# Opt=ReadFC
# Geom=(Check, NewDefinition) Guess=Read
```
You also need to comment out or delete the coordinates lines. When all is done, rename the output files and submit the job again:
```
mv gaussian.log equil1.log
shotgun submit -c 8 -m 2000 -n 1 -t 24 -r bridges2 -q RM-shared -j ../../bin/sub-gaussian-bridges2.script  # submitting the job
```
If you keep the structure of the sample input file, you can try using a script to make this change:
```
/home/common/sample-input/gaussian/bin/g_change.sh -c gaussian.gjf  # -c for continuation, absence of the flag will switch back to the normal calculation
```

Pseudopotentials for heavy atoms

You may want to use effective core potentials starting from the first-row transition metal elements. You can use the [GenECP keyword and specify the flavor of pseudopotential. A basic example is given below. Again note the empty lines and four-star separators.

# M06L/GenECP/Auto
...skipping the remaining input until the last Cartesian coordinates line
Cr 0 -33.587176 33.370038 -45.351159

H C O F 0
AUG-cc-pVDZ
****
Cr 0
SDD
****

Cr 0
SDD

Constrained optimizations

On your workstation

In Materials Studio, you can constrain atoms by clicking the menu item Modify -> Constraints and tick Fix Cartesian position in the dialogue.
File -> Export the structure, choose the .xsd format, and click Options to select version 6.1.
Use rsync / scp / WinSCP (Windows only) to upload the file to group server.

On the group server

Convert the .xsd file to Gaussian format.

cd /path/to/projects/ABC/moleculeX  # go to the directory where the .xsd file is uploaded.
module add vasp-tools/linux materialsstudio  # in order to use the vasp-tools Materials Studio integration
msvasp ms2gaussian moleculeX.xsd gaussian.gjf  # converts the .xsd file to Gaussian format

Edit gaussian.gjf to include other input parameters.

Stretching/bending/torsion scans

See the tutorial in the linked section header above to perform Gaussian scans.

Free energy calculations using implicit solvent models

In order to find the free energy of your system in the solvent, follow the following steps:

Add the following keyword to the Route section of the input file to calculate the harmonic frequencies at the end of a geometry optimization job. Thermochemistry will be calculated at 298K unless specified otherwise.
NOTE Please read and understand the document written by Joseph W. Ochterski from Gaussian, Inc. on our group's Google Drive or on the Gaussian website
```
# Freq
# Temperature=523
```
Add the following keyword to the Route section of the input file with an appropriate solvent model. The SMD solvation model developed by Cramer and Truhlar at Minnesota is often a good choice.
```
# SCRF=(SMD,Solvent=n-Octanol)
```
In certain cases (see discussions here and here), depending on the system and the solvation model, it may be more appropriate to perform a gas-phase optimization and a single-point energy calculation at the gas phase optimized structure. The solvent phase free energy is then calculated as G_solv = E_solv + ΔG_{corr_gas}, where, G_solv is the free energy of the system in the solvent, E_solv is the electronic energy of the system in the solvent, and ΔG_{corr_gas} is the gas phase thermal correction term to the free energy.

If you keep the structure of the sample input file, you can use a script to switch on and off solvation and frequency calculations:

/home/common/sample-input/gaussian/bin/g_change.sh -f -s gaussian.gjf  # -f for frequency, -g for solvation, absence of a flag will turn off the corresponding option

Calculations of redox potentials

On Zotero, the Electrochemistry/Redox folder includes a few useful papers. Of particular interest is Ho, J.; Coote, M. L.; Cramer, C. J.; Truhlar, D. G. Chapter 6 Theoretical Calculation of Reduction Potentials. In Organic Electrochemistry; CRC Press, 2016; pp 229–259.

Here we use an example from J. Am. Chem. Soc. 2019, 141, 6392, specifically one of the reactions illustrated in the top left panel of the figure: L₂Ni(+1)Br + e^- → L₂Ni(0) + Br^- (all species in DMF solvent). This is written as a reduction reaction. The reaction free energy can therefore be converted to the reduction potential via the Nernst equation.

To calculate the reaction free energy, three geometry optimization jobs need to be performed for the three chemical species using implicit DMF solvent. The following excerpt can be found near the end of the output files for L₂Ni(+1)Br:

 SCF Done:  E(UM06L) =  -1332.49281641
...
...
 Zero-point correction=                           0.428097 (Hartree/Particle)
 Thermal correction to Energy=                    0.458133
 Thermal correction to Enthalpy=                  0.459077
 Thermal correction to Gibbs Free Energy=         0.362588
 Sum of electronic and zero-point Energies=          -1332.064719
 Sum of electronic and thermal Energies=             -1332.034684
 Sum of electronic and thermal Enthalpies=           -1332.033739
 Sum of electronic and thermal Free Energies=        -1332.130229

There is a script to extract these numbers, but please make sure to double check the first few times you use the script for a new type of calculations.

/home/common/sample-input/gaussian/bin/g_grep_result.sh -g gaussian.log

Collecting the results into the table below, where all species were computed in DMF solution, except the last column, we have the electronic energy, enthalpy, and free energy at T = 298 K and ρ₀(1atm) = p/RT = 101325/8.3144621/298 = 40.89 mol/m³. From the last two columns, we can in principle compute the solvation free energy for Br^- [i.e., the reaction free energy for Br^- (gas, ρ₀) → Br^- (DMF, ρ₀) ]: − 13.554610 − (−13.468305) = − 0.086305 Ha = − 0.086305 * 2625.4997356709 kJ/mol = − 226.59 kJ/mol. However, in standard definition, solution-phase species should use a reference state with a density of ρ_1M = 1 mol/L = 1000 mol/m³ and we should compute the free energy for Br^- (gas, ρ₀) → Br^- (DMF, 1 M)]. To do this, we need to add the conversion factor G[Br^-(DMF, ρ_1M)] - G[Br^-(DMF, ρ₀)] = RTln (ρ_1M/ρ₀) = 8.3144621 * 298 * ln (1000/40.89) J/mol = 7.92 kJ/mol, to give − 226.59 + 7.92 = − 218.7 kJ/mol.

Compared to the experimental value, -241.8 kJ/mol (Marcus, Y. Ions in solutions and their solvation, 2015 John Wiley & Sons, Inc.), the implicit solvation calculation is underestimated by 23 kJ/mol. It is common for these small ions to use the experimental solvation free energy instead. Therefore, we take G[Br^-(DMF, ρ_1M)] = − 13.468305 − 241.8/2625.4997356709 = − 13.5604018 Ha. Finally, the reaction free energy is G[Br^-(DMF, ρ_1M)] + G[L₂Ni(0)(DMF, ρ_1M)] - G[L₂Ni(+1)Br(DMF, ρ_1M)] = G[Br^-(DMF, ρ_1M)] + G[L₂Ni(0)(DMF, ρ₀)] - G[L₂Ni(+1)Br(DMF, ρ₀)] = − 13.5604018 − 1318.665092 − (−1332.130229) = − 0.0952648 Ha = − 250.12 kJ/mol.

Species	L₂Ni(+1)Br	L₂Ni(0)	Br^-	Br^- (gas)
E	-1332.492816	-1319.034577	-13.538435	-13.452129
H	-1332.033739	-1318.579726	-13.536074	-13.449769
G	-1332.130229	-1318.665092	-13.554610	-13.468305

Using the Nernst equation, we can convert this standard-state reaction free energy to standard reduction potential: − (−250.12) * 1000/96485.33289 = 2.59 V. Finally, if we want to compute reduction potential relative to the standard hydrogen electrode, we need to know the standard-state reaction free energy for H⁺ (DMF, 1 M) + e^- → 1/2H₂ (gas, 1 atm), and its corresponding standard reduction potential. This is a completely analogous calculation. We use the experimental solvation free energy for H⁺ in DMF, -1118.98 kJ/mol. Reaction free energy: − 1.17094/2 * 2625.4997356709 − (−0.01*2625.4997356709−1118.98) = − 391.92 kJ/mol, which is − (−391.92) * 1000/96485.33289 = 4.06 V. Therefore, the reduction potential for L₂Ni(+1)Br + e^- → L₂Ni(0) + Br^- is 2.59 − 4.06 = − 1.47 V. If we want to express this to other reference such as Ag/AgNO3 (10 mM), we just need to further subtract the potential of Ag/AgNO3 (10 mM) relative to SHE, which is − 1.47 − 0.5 = − 2.0 V.

Species	H⁺ (gas)	H₂ (gas)
E	0	-1.16958
H	0.00236	-1.15615
G	-0.01	-1.17094

You can find this and other computed results in the figure on pg. S27 of the Supporting Information.

Adsorbed Molecular Free Energy Correction

Unlike gas molecules, adsorbed molecules form chemical bonds with substrate, which limits the translational and rotational freedom of the adsorbed molecules. So the contribution of translation and rotation to entropy and enthalpy is significantly reduced (so called hindered translator / hindered rotor model). This does not mean no translational or rotational contribution.

One common method is to attribute the translational or rotational part of the contribution to vibration, that is, the 3N vibrations of the surface-adsorbing molecules (except the virtual frequency) are all used to calculate the correction of the thermo energy.

The small the vibration frequencies have large contribution to entropy. It is very likely that a small vibration frequency will lead to abnormal entropy and free energy correction. So, it suggests that when the free energy of the surface adsorption molecule is corrected, the contribution of the frequency below 50 cm^-1 is calculated as 50 cm^-1, and VASPKIT also does this. And VASPKIT neglects the electron motion because of its small contribution.

And the PV term is also delete. At last VASPKIT will output:

1. Zero-point energy ε_ZPE;

2. Thermal correction to U(T) = H(T) = ε_ZPE + ΔU_0 → T

3. Thermal correction to G(T) = ε_ZPE + ΔU_0 → T + TS = ε_ZPE + ΔG_0 → T

Example: Thermo energy correction for adsorbed O on Au(111)

(1) Fix all slab metal atoms, do frequency calculation for the adsorbed molecule. Check the frequencies:

   $ grep cm OUTCAR
      1 f  =   10.904836 THz    68.517103 2PiTHz  363.746154 cm-1    45.098792 meV
      2 f  =   10.827330 THz    68.030119 2PiTHz  361.160834 cm-1    44.778253 meV
      3 f  =   10.751668 THz    67.554721 2PiTHz  358.637024 cm-1    44.465340 meV

(2) In the same folder, run VASPKIT 501. Input temperature(K).

   501
    +-------------------------- Warm Tips --------------------------+
    This Feature Was Contributed by Nan XU, Qiang LI and Jincheng LIU.
        See An Example in vaspkit/examples/thermo_correction/ORR.
    Only vibrations! No Translation & Rotation & Electron contributions.
    +---------------------------------------------------------------+

    Please Enter The Temperature (K):

    ------------>>
   298.15
     -->> (01) Reading OUTCAR File...
    +-------------------------- Summary ----------------------------+
    Neglect PV contribution to translation for adsorbed molecules.
    To avoid abnormal entropy contribution,
    frequencies less than 50 cm-1 are set to 50 cm-1.
    U(T) = H(T) = ZPE + Delat_U(0->T)
    G(T) = H(T) - TS = ZPE + Delat_U(0->T) - TS

    Temperature (K): 298.1
    Zero-point energy E_ZPE   :       1.549 kcal/mol    0.067171 eV
    Thermal correction to U(T):       2.206 kcal/mol    0.095670 eV
    Thermal correction to H(T):       2.206 kcal/mol    0.095670 eV
    Thermal correction to G(T):       1.207 kcal/mol    0.052342 eV
    Entropy S                 :      14.021 J/(mol*K)   0.000145 eV

So, ZPE is 0.067171 eV. Thermal correction to U(T), H(T), and G(T) are 0.095670 eV, 0.187167 eV, and − 0.446723 eV, respectively.

Calculation of CM5 charges (Gaussian/cm5pac)

See the tutorial in the linked section header above to perform CM5 charge calculations.

NEB calculations

See the tutorial in the linked section header above to perform NEB calculations.