Robert B. Wexler, PhD

Removing duplicate atoms from structures

2020-08-20T00:00:00+00:00

Sometimes structures contain duplicate atoms…I learned the hard way. I was recently running some calculations and was getting errors like WARNING: CNORMN: search vector ill defined. Additionally, I was finding that changing ALGO to All was producing the same error, leading to my conclusion that I likely had a problematic structure. Using , you can quickly check if a structure contains duplicate atoms.

from pymatgen.core.structure import Structure
s = Structure.from_file('POSCAR')
print(s.is_valid())

With that said and to the best of my knowledge, doesn’t have a method for removing duplicate atoms. For that, I turned to , is a tool to convert and manipulate atomic data files. has an option for removing duplicate atoms (https://atomsk.univ-lille.fr/doc/en/option_rmd.html); it’s really easy to use and it works great! What worked for me was

atomsk POSCAR -rmd 0.2 pos

which gave

  ___________________________________________________
 |              ___________                          |
 |     o---o    A T O M S K                          |
 |    o---o|    Version master                       |
 |    |   |o    (C) 2010 Pierre Hirel                |
 |    o---o     https://atomsk.univ-lille.fr         |
 |___________________________________________________|
 >>> Opening the input file: POSCAR
 ..> Input file was read successfully (54 atoms).
 >>> Removing atoms that are closer than 0.200 A.
 >>> Constructing neighbor list...
 ..> 18 atoms were removed, 36 atoms left.
 >>> Writing output file(s) (36 atoms):
 <?> This file already exists: POSCAR
     Do you want to overwrite it (y/n) (Y=overwrite all)?

to which I answered n and gave POSCAR.final as a filename. The final message was

 ..> Successfully wrote POSCAR file: POSCAR.final
 \o/ Program terminated successfully!
     Total time: 12.311 s.; CPU time: 0.007 s.

Bye bye duplicate atoms!

Visualizing crystal structures in Markdown using 3Dmol.js

2019-12-10T00:00:00+00:00

Have you ever wanted to embed a crystal structure visualization in your website? Oddly specific question, I know, but recently I found my wanting to do this. As you can see on my homepage, I have finally achieved success but it took a few days to work out the kinks. In order to make sure that no one else endures my pain, here is how you can do this in Markdown using html and 3Dmol.js.

Caveat: I’ve worked this out for Jekyll but I’m pretty sure the approach is extensible.

Step 1

Take your crystal structure file and convert it into a pdb file. I started out with an xsf but, in principle, you could start out from a [cif][https://www.iucr.org/resources/cif], VASP POSCAR, or any other crystal structure data file, for that matter. If you’re lucky, you might be starting out with a pdf file! You will need to find a software package that converts your file into a pdb. Some packages you might consider are VESTA, Avogadro, and Mercury; all of these are free. If you’re willing to shell out, you could also get CrystalMaker. For reference, I’ve used CrystalMaker and here is the pdb I generated. This structure is an Ag₁₀O₇ overlayer that happens to form on the Ag(111) surface in an O₂ atmosphere. For more information on this system and the ab initio grand canonical Monte Carlo method I used to find it, check out my recent paper in the Journal of Physical Chemistry C.

Step 2

Now you need to process your pdf file. It turns out that the JavaScript software that we will use, i.e. 3Dmol.js, requires all line breaks to be written as \n. Instead of doing this by hand, here’s how you can do it on the command line:

awk '{printf "%s\\n", $0}' <path to file> | sed "s/'/\\\'/g"

Hold on to this output, we will need it in a moment.

Step 3

OK, last but not least, now for the html and JavaScript part. First, I’ll present the code and then I’ll go line by line.

<html>
<head>
<script src="/3Dmol-min.js">
</script>
</head>
<div id="container-01" class="mol-container">
</div>
<style>
.mol-container {
  width: 60%;
  height: 400px;
  position: relative;
}
</style>
<script>
$(function() {
	let element = $('#container-01');
	let config = { backgroundColor : 'white' };
	let viewer = $3Dmol.createViewer( element, config );
	viewer.addModel("HEADER    5934-refined    \nREMARK   1\nREMARK   1 This file was generated by CrystalMaker X for macOS\nREMARK   1 http://crystalmaker.com\nREMARK   1\nCRYST1   11.452   11.452   28.630 120.00 120.00  60.00 P 1\nSCALE1      0.087322 -0.050415  0.035649        0.00000\nSCALE2     -0.000000  0.100830  0.035649        0.00000\nSCALE3      0.000000  0.000000  0.042779        0.00000\nATOM      1 Ag   MOL H   0      -0.716  -0.414   1.199  1.00  0.00          Ag0 \nATOM      2 Ag   MOL H   0       0.715   2.066   1.199  1.00  0.00          Ag0 \nATOM      3 Ag   MOL H   0       2.147   4.545   1.199  1.00  0.00          Ag0 \nATOM      4 Ag   MOL H   0       3.578   7.025   1.199  1.00  0.00          Ag0 \nATOM      5 Ag   MOL H   0       2.147  -0.414   1.199  1.00  0.00          Ag0 \nATOM      6 Ag   MOL H   0       3.578   2.066   1.199  1.00  0.00          Ag0 \nATOM      7 Ag   MOL H   0       5.010   4.545   1.200  1.00  0.00          Ag0 \nATOM      8 Ag   MOL H   0       6.441   7.024   1.200  1.00  0.00          Ag0 \nATOM      9 Ag   MOL H   0       5.010  -0.414   1.199  1.00  0.00          Ag0 \nATOM     10 Ag   MOL H   0       6.441   2.066   1.200  1.00  0.00          Ag0 \nATOM     11 Ag   MOL H   0       7.873   4.545   1.200  1.00  0.00          Ag0 \nATOM     12 Ag   MOL H   0       9.304   7.024   1.200  1.00  0.00          Ag0 \nATOM     13 Ag   MOL H   0       7.873  -0.414   1.199  1.00  0.00          Ag0 \nATOM     14 Ag   MOL H   0       9.304   2.066   1.200  1.00  0.00          Ag0 \nATOM     15 Ag   MOL H   0      10.735   4.546   1.200  1.00  0.00          Ag0 \nATOM     16 Ag   MOL H   0      12.167   7.025   1.198  1.00  0.00          Ag0 \nATOM     17 Ag   MOL H   0      -2.141  -1.237   3.524  1.00  0.00          Ag0 \nATOM     18 Ag   MOL H   0      10.737   1.253   3.505  1.00  0.00          Ag0 \nATOM     19 Ag   MOL H   0      12.151   3.730   3.541  1.00  0.00          Ag0 \nATOM     20 Ag   MOL H   0      13.597   6.208   3.515  1.00  0.00          Ag0 \nATOM     21 Ag   MOL H   0       0.723  -1.242   3.534  1.00  0.00          Ag0 \nATOM     22 Ag   MOL H   0       2.148   1.280   3.508  1.00  0.00          Ag0 \nATOM     23 Ag   MOL H   0       3.598   3.729   3.539  1.00  0.00          Ag0 \nATOM     24 Ag   MOL H   0       5.010   6.225   3.528  1.00  0.00          Ag0 \nATOM     25 Ag   MOL H   0       3.568  -1.243   3.534  1.00  0.00          Ag0 \nATOM     26 Ag   MOL H   0       5.010   1.253   3.504  1.00  0.00          Ag0 \nATOM     27 Ag   MOL H   0       6.446   3.725   3.562  1.00  0.00          Ag0 \nATOM     28 Ag   MOL H   0       7.872   6.199   3.529  1.00  0.00          Ag0 \nATOM     29 Ag   MOL H   0       6.431  -1.239   3.524  1.00  0.00          Ag0 \nATOM     30 Ag   MOL H   0       7.874   1.261   3.508  1.00  0.00          Ag0 \nATOM     31 Ag   MOL H   0       9.303   3.724   3.565  1.00  0.00          Ag0 \nATOM     32 Ag   MOL H   0      10.734   6.224   3.532  1.00  0.00          Ag0 \nATOM     33 Ag   MOL H   0       2.146   7.821   5.863  1.00  0.00          Ag0 \nATOM     34 Ag   MOL H   0      -2.108   0.399   5.777  1.00  0.00          Ag0 \nATOM     35 Ag   MOL H   0      -0.680   2.905   5.881  1.00  0.00          Ag0 \nATOM     36 Ag   MOL H   0      12.149   5.404   5.834  1.00  0.00          Ag0 \nATOM     37 Ag   MOL H   0      -0.700  -2.024   5.870  1.00  0.00          Ag0 \nATOM     38 Ag   MOL H   0       0.765   0.444   5.779  1.00  0.00          Ag0 \nATOM     39 Ag   MOL H   0       2.150   2.947   5.884  1.00  0.00          Ag0 \nATOM     40 Ag   MOL H   0       3.593   5.404   5.828  1.00  0.00          Ag0 \nATOM     41 Ag   MOL H   0       6.488   6.909   8.311  1.00  0.00          Ag0 \nATOM     42 Ag   MOL H   0       3.536   0.443   5.783  1.00  0.00          Ag0 \nATOM     43 Ag   MOL H   0       4.978   2.904   5.878  1.00  0.00          Ag0 \nATOM     44 Ag   MOL H   0       6.430   5.409   5.833  1.00  0.00          Ag0 \nATOM     45 Ag   MOL H   0       4.991  -2.025   5.876  1.00  0.00          Ag0 \nATOM     46 Ag   MOL H   0       6.411   0.399   5.779  1.00  0.00          Ag0 \nATOM     47 Ag   MOL H   0       7.874   2.993   5.951  1.00  0.00          Ag0 \nATOM     48 Ag   MOL H   0       9.287   3.968   8.340  1.00  0.00          Ag0 \nATOM     49  O   MOL H   0       2.158   5.468   8.890  1.00  0.00           O0 \nATOM     50  O   MOL H   0      -0.673   2.555   8.172  1.00  0.00           O0 \nATOM     51  O   MOL H   0       7.873   5.432   8.890  1.00  0.00           O0 \nATOM     52  O   MOL H   0      -0.699  -1.560   8.187  1.00  0.00           O0 \nATOM     53 Ag   MOL H   0      -0.682   0.497   8.155  1.00  0.00          Ag0 \nATOM     54 Ag   MOL H   0       0.779   3.991   8.329  1.00  0.00          Ag0 \nATOM     55  O   MOL H   0       5.001  -1.568   8.199  1.00  0.00           O0 \nATOM     56 Ag   MOL H   0       9.312   5.411   5.833  1.00  0.00          Ag0 \nATOM     57  O   MOL H   0       4.987   2.545   8.172  1.00  0.00           O0 \nATOM     58 Ag   MOL H   0       0.758   6.929   8.312  1.00  0.00          Ag0 \nATOM     59 Ag   MOL H   0       4.992   0.487   8.157  1.00  0.00          Ag0 \nATOM     60 Ag   MOL H   0       6.482   3.954   8.341  1.00  0.00          Ag0 \nATOM     61 Ag   MOL H   0       9.259   6.908   8.315  1.00  0.00          Ag0 \nATOM     62 Ag   MOL H   0       3.540   3.989   8.324  1.00  0.00          Ag0 \nATOM     63 Ag   MOL H   0       3.545   6.935   8.304  1.00  0.00          Ag0 \nATOM     64 Ag   MOL H   0       2.146  -2.050   5.892  1.00  0.00          Ag0 \nATOM     65  O   MOL H   0       7.878   1.176   7.076  1.00  0.00           O0 \n", "pdb");
	viewer.addUnitCell();
	viewer.setStyle({}, {sphere : {}});
	viewer.render();
});
</script>
</html>

Woah, nelly! It looks like a lot but it really isn’t. Everything is sandwiched between the html tags. Between the head tags is a script tag that contains the path to a minimal implementation of 3Dmol.js, which can be found here. 3Dmol.js contains different functions for reading, configuring, and plotting molecules and crystal structures. The div tag defines a container that will hold the crystal structure and the style tag defines its size. For example, we set the height to be 400 px and the width to be 60% of the that.

Finally, we get to the meat of the script where we pass the structure and define how we would like it plotted. The first and second lines of the function link to the container and set the background color to white, respectively. The third line reads these settings and creates a viewer, our molecular canvas, per say. Now’s the time where we add the structure. The addModel method has two arguments: (1) a string containing the contents of the crystal structure file and (2) a string identifying what type of file it is. The reason I chose to use pdb files is because pbd was the only file type I recognized that contained information about periodicity. Armed with the output of your awk command, add it between the two double quotes in the first argument below:

viewer.addModel("", "pdb")

As a final touch, the setStyle command, unsurprisingly, sets the atom/bond style; here, I have chosen to represent atoms by spheres with radii equal to their vdW radii (for more choices, follow this link). The last line of the code renders the image. I have copied the code below this text and it should produce the same image on my homepage.

Brilliant! There seem to be a ton of other things that you can do with 3Dmol.js. Have fun!

Introduction to the Atomic Simulation Environment

2019-08-31T00:00:00+00:00

The Atomic Simulation Environment (ASE) is a set of useful Python modules for manipulating and visualizing structures, setting up calculations/simulations, and converting between different file formats. Here is a link to ASE’s documentation: https://wiki.fysik.dtu.dk/ase/

Some things that you can do with ASE are as follows:

Visualize structures
Set up and run DFT/PAW calculations using VASP
Perform structure optimization using a wide range of algorithms, e.g. BFGS
Automate ENCUT and KPOINTS convergence tests

Installation
Working Examles

Installation

ASE can be installed using pip as follows:

pip install --user ase

Then you can import ASE just like any other Python module.

Working Examples

For the following working examples, I will first present the code block, then explain it line-by-line (for the most part), and finally show the result.

Visualizing the O₂ Dimer in a Box

from ase import Atoms, Atom
from ase.visualize import view

d = 1.208
o2 = Atoms([Atom("O", [0, 0, 0]), 
	    Atom("O", [0, 0, d])],
           cell = [(7, 0, 0),
                   (0, 7.5, 0),
                   (0, 0, 8)])
o2.set_pbc((True, True, True))
view(o2)

The first two lines import the ASE modules we will need to generate and visualize the O₂ dimer. An “Atom” object contains information about a particular atom, e.g. element symbol and position. An “Atoms” object contains information about the whole system, which in this case is two O atoms separated by 1.208 Å. Finally, the “view” function takes an “Atoms” object as an argument and opens the ASE GUI, which shows an interactive 3D rendering of the system. If you Ctrl click on both atoms, then the dialog box at the bottom of the GUI will print the bond distance.

Calculating the Total Energy of the O₂ Dimer Using VASP

Before you can run VASP using ASE, you have to tell ASE where the VASP executable and PAW potentials are located. ASE recommends that you create a directory called vasp in $HOME. In $HOME/vasp, create a file called run_vasp.py with the following contents:

import os
exitcode = os.system('$VASP_EXEC')
#exitcode = os.system('srun -n 40 $VASP_EXEC > log')

The first line imports a package called os that enables the use of shell commands in Python. The second line calls the VASP executable, which is globally defined as $VASP_EXEC on my computer. The third line, which is commented out, enables parallel execution of VASP over 40 cores using srun and writes the standard output to a file called log. This script needs to be modified if you want to change the number of cores. Next, ASE recommends that you create another directory inside $HOME/vasp called mypps where the PAW potentials will be stored. Inside $HOME/vasp/mypps there should be three subdirectories called potpaw, potpaw_GGA, and potpaw_PBE. The first and last contain LDA and GGA-PBE PAW potentials, respectively. You can leave potpaw_GGA empty. Finally, add the following to your .bashrc file so that ASE can find $HOME/vasp and its contents:

export VASP_SCRIPT=$HOME/vasp/run_vasp.py
export VASP_PP_PATH=$HOME/vasp/mypps

Now you are ready to run VASP using ASE.

from ase import Atoms, Atom
from ase.calculators.vasp import Vasp

d = 1.208
o2 = Atoms([Atom("O", [0, 0, 0], magmom = 1),
            Atom("O", [0, 0, d], magmom = 1)],
           cell = [(7, 0, 0),
                   (0, 7.5, 0),	Edit
                   (0, 0, 8)])
o2.set_pbc((True, True, True))

calc = Vasp(prec = "Accurate",
            ediff = 1E-5,
            xc = "pbe",
            gamma = True)
o2.set_calculator(calc)
total_energy = o2.get_potential_energy()
print(total_energy)

The first ten lines are the same as the previous example with the exception that, on line 2, the Vasp calculator is imported from ase.calculators.vasp. The calculator is defined on line 12 and, for the most part, the calculator’s arguments are lower case versions of INCAR tags (https://cms.mpi.univie.ac.at/wiki/index.php/Category:INCAR). The only argument that is not an INCAR tag is gamma, which is True for Γ-point calculations and False otherwise. In lines 16 and 17, the VASP calculator calc is attached to the o2 object and the get_potential_energy method is called, running a VASP single-point calculation of the total energy. The final line prints the total energy, which is -9.81923384 eV (note: exact value depends on the PAW potentials).

Optimizing the Bond Length of O₂ Dimer

from ase import Atoms, Atom
from ase.calculators.vasp import Vasp
from ase.optimize import BFGS
import numpy as np

d = 1.208
o2 = Atoms([Atom("O", [0, 0, 0], magmom = 1),
            Atom("O", [0, 0, d], magmom = 1)],
           cell = [(7, 0, 0),
                   (0, 7.5, 0),
                   (0, 0, 8)])
o2.set_pbc((True, True, True))

calc = Vasp(prec = "Accurate",
            ediff = 1E-5,
            xc = "scan",
            gamma = True)
o2.set_calculator(calc)
dyn = BFGS(o2)
dyn.run(fmax = 1e-4)
positions = o2.get_positions()
print(positions)

The first 18 lines are the same as the total energy calculation with the exception that, on lines 3 and 4, the BFGS optimization algorithm is imported from ase.optimize and the numpy module is loaded as np (as is the convention). In line 19, the BFGS algorithm is initialized with the o2 object and, in line 20, the structure of the O₂ dimer is optimized using a force convergence threshold of 1e-4 eV/Å. Instead of performing the structure optimization within VASP by specifying the INCAR tag ISIF, ASE performs a series of SCF calculations and extracts the total energy and forces, i.e. the key ingredients for most structure optimization algorithms. After structure optimization is complete, the positions are extracted from the o2 object using the get_positions method and the bond length can be calculated by taking the norm of the minimum image vector pointing from one O to the other. The bond length should be approximately 1.22448 Å.

Testing ENCUT Convergence for the S₂ Dimer

The script for this last example is a little longer than the others so it will be presented in chunks. First, some python modules and methods are uploaded.

from ase import Atoms, Atom
from ase.calculators.vasp import Vasp
import numpy as np
import os

All of these modules and methods have been introduced in the previous working examples. Next, the S2 dimer is generated using the experimental bond length of 1.889 Å.

ds2 = 1.889
s2 = Atoms([Atom("S", [0, 0, 0], magmom = 1),
            Atom("S", [0, 0, ds2], magmom = 1)],
           cell = [7, 7.5, 8], pbc = [1, 1, 1])

magmom corresponds to the starting magnetic moment of an atom, which is chosen to be 1 because the magnetic moment of S₂ is 2 like O₂. Additionally, 3D periodic boundary conditions are defined by setting pbc = [1, 1, 1] where the three 1’s correspond to periodic boundary conditions along all three crystallographic axes. Finally, ENCUT convergence tests are prepared and performed.

encuts = np.arange(300, 650, 50)
for encut in encuts :
    direc = "ENCUT={}".format(encut)
    os.system("mkdir -p {}".format(direc))
    os.chdir(direc)
    calc = Vasp(xc = "PBE",
                pp = "PBE",
                gamma = True,
                encut = encut,
                ediff = 1e-4,
                ismear = 0,
                sigma = 0.05)
    s2.set_calculator(calc)
    s2.get_potential_energy()
    os.chdir("../")

In the first line of this code chunk, an array of ENCUT is defined from 300 eV to 600 eV (np.arange does not include 650 eV). Then, we loop through each value of ENCUT, create and enter a directory for that particular ENCUT, set up the VASP calculator, attach the calculator to the s2 object, and start the SCF calculation. Combined, this script will generate seven directories containing VASP inputs and outputs. You can then extract the total energies for each ENCUT and plot the convergence using your favorite plotting software (see below for a plot generated using matplotlib).

This is the end of the tutorial. Please feel free to suggest working examples if you have found interesting and useful ways to apply ASE in your research.

Unzipping files into folders with the same name in Linux

2019-07-15T00:00:00+00:00

Here is a little Python script that unzips files into folders with the same name in Linux. Take, for example, the file test.zip. If it contains a number of files and you unzip using unzip test.zip on Linux, then they will all be decompressed into your present working directory. If you wanted the files to go into a folder bearing the prefix of zip file, i.e. test, then you’d have to write a shell script…until now! Just because, I wrote a python script that does the same thing using unar. Now, unar can do this for one file but not for several, e.g. as defined using a wildcar *.zip. My script, called unzipr (because every Python script needs a fancy name), does just this. Please feel free to use and pass along if you find it helpful!

import sys
import os

filenames = sys.argv[1:]
for filename in filenames :
    os.system("unar -d {}".format(filename))

If you create an alias, i.e. add alias unzipr="python <path-to-unzipr>/unzipr.py" in your .bashrc, then you can unzip individual or multiple files seamlessly by executing unzipr *.zip on your command line. Happy zipping!

Finding descriptors for catalysis using random forests

2019-04-16T00:00:00+00:00

In this tutorial, I’m going to show you how easy it is to train and analyze a random forest regression model. The data we’re going to use is taken from my recent paper on tuning the hydrogen evolving activity of Ni₂P via strain. [1] The main idea of the paper is that surface nonmetal dopants, which replace P near the Ni₃ sites, can induce compressive and tensile strain on the Ni₃ sites leading to changes in their H binding strength.

In my study, I calculated the H binding energy at the Ni₃ site for different nonmetal dopants (B, C, N, O, Si, S, As, Se, & Te) and doping concentrations. There were 55 configurations in total…so I was working with a rather small data set. I should mention that for smaller data sets it’s generally advisable to use linear models, however, if care is taken, then random forests can be used as well. Regardless, always make sure to validate your proposed descriptors using an appropriate simulation technique such as density functional theory.

A quick word on random forests. Random forests are made up of decision trees. Each decision tree gets a random subset of the rows and columns of the data and is built using the CART algorithm. [2] For more information, please see chapter 2.4 of my thesis.

[1] Wexler, R. B.; Martirez, J. M. P.; Rappe, A. M. Chemical Pressure-Driven Enhancement of the Hydrogen Evolving Activity of Ni₂P from Nonmetal Surface Doping Interpreted via Machine Learning. J. Am. Chem. Soc. 2018, 140 (13), pp 4678-4683. DOI: 10.1021/jacs.8b00947

[2] L. Breiman, J. Friedman, R. Olshen, and C. Stone. Classification and Regression Trees. Wadsworth, Belmont, CA, 1984.*

# import necessary modules
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import r2_score
from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error

numpy and pandas are used for convenient data storage, matplotlib is used to generate plots, and the scikit learn is used for all things machine learning. For example, we use train_test_split to do as its name suggests, RandomForestRegressor trains a random forest, and r2_score, mean_squared_error, and mean_absolute_error are different evaluation metrics (you may like one of them more than the others, though MSE is probably the most robust).

# helper functions
def drop_nzv(df, min_var = 0.05) :
    """ drop near zero variance descriptors
    note: y should be your last column
    """
    to_drop = list()
    for i in range(df.shape[1] - 1) :
        descriptor = df.columns[i]
        data_type = df.dtypes[i]
        if (data_type == "int64") | (data_type == "float64") :
            variance = df.iloc[:, i].var()
            if variance <= min_var :
                to_drop.append(descriptor)
    to_drop = np.array(to_drop)
    return df.drop(to_drop, axis = 1)

def get_results(model, X, y) :
    r2 = r2_score(y, model.predict(X))
    rmse = np.sqrt(mean_squared_error(y, model.predict(X)))
    mae = mean_absolute_error(y, model.predict(X))
    return r2, rmse, mae

def plot_results(model, X_train, X_test, y_train, y_test, X_val = np.array([]), y_val = np.array([]), data_range = [-0.5, 0.5]) :
    plt.scatter(y_train, model.predict(X_train), color = "blue", alpha = 0.5)
    plt.scatter(y_test, model.predict(X_test), color = "red", alpha = 0.5)
    if X_val.size != 0 :
        plt.scatter(y_val, model.predict(X_val), color = "green")
    plt.plot(data_range, data_range, color = "black")
    plt.xlabel("DFT")
    plt.ylabel("Predicted")
    plt.show()

def plot_importances(model, descriptors) :
    plt.bar(np.arange(model.feature_importances_.shape[0]), model.feature_importances_)
    plt.xticks(np.arange(model.feature_importances_.shape[0]), descriptors, rotation=90$$)
    plt.show()

This chunk contains some functions that you may find useful. drop_nzv takes a dataframe and removes columns whose variance is small, i.e. they are nearly single valued and therefore cannot be used to describe variations in $y$. get_results takes a model and calculates the three performance metrics mentioned above. plot_results plots the actual $y$ vs. the prediction for both the training and test set.

At this point, we’re ready to start writing some real code. You can download the data from my paper at HERE.

# read and inspect data
df = pd.read_csv("/Users/rwexler/Downloads/Machine_Learning/processed_data.csv")
print(df.shape)
df.head()

(55, 31)

	Unnamed: 0	X	nX	X95_98	X95_100	X98_100	X98_95_100	X95_98_100	X95_100_98	Avg_Ni_Ni	...	q106_5	q107_6	Z	m	r	Avg_qNi	Std_qNi	Avg_qX	Std_qX	dGH
0	1	As	1	2.772373	2.728643	2.673381	58.146831	60.107425	61.745744	2.724799	...	-999.0000	-999.0	33	74.92	121	0.632433	0.016967	-0.370600	-999.000000	-0.467393
1	3	As	2	2.701154	2.593942	2.637543	59.709237	58.125061	62.165703	2.644213	...	-999.0000	-999.0	33	74.92	121	0.627867	0.015033	-0.404850	0.024537	-0.480859
2	5	As	3	2.682490	2.685299	2.680348	59.912592	60.095729	59.991680	2.682712	...	-999.0000	-999.0	33	74.92	121	0.619267	0.003819	-0.415900	0.004303	-0.352070
3	7	As	4	2.644063	2.569793	2.657188	61.260029	57.991838	60.748134	2.623681	...	-999.0000	-999.0	33	74.92	121	0.604533	0.026364	-0.409075	0.014458	-0.410929
4	9	As	5	2.675141	2.611050	2.575125	58.290699	59.609085	62.100216	2.620439	...	-0.3967	-999.0	33	74.92	121	0.589967	0.025755	-0.405520	0.014240	-0.441036

5 rows × 31 columns

As you can see, there are 55 rows and 31 columns. Information about each of the columns can be found in processed_data.txt, which comes along with the data. Suffice to say, there are some structure (bond length, angle, etc.) and charge (Lowdin charges) descriptors for each surface and it’s corresponding H binding energy at the Ni₃ site ($\Delta G_{\rm H}$) calculated using DFT with the GGA of PBE for the electron exchange and correlation and using DFT-D2 vdW corrections. If this terminology seems foreign to you, I recommend reading chapter 2.1 of my thesis. The first column is useless and can be removed as follows:

# drop first column
df = df.drop(["Unnamed: 0"], axis = 1)
df.head()

	X	nX	X95_98	X95_100	X98_100	X98_95_100	X95_98_100	X95_100_98	Avg_Ni_Ni	Std_Ni_Ni	...	q106_5	q107_6	Z	m	r	Avg_qNi	Std_qNi	Avg_qX	Std_qX	dGH
0	As	1	2.772373	2.728643	2.673381	58.146831	60.107425	61.745744	2.724799	0.049608	...	-999.0000	-999.0	33	74.92	121	0.632433	0.016967	-0.370600	-999.000000	-0.467393
1	As	2	2.701154	2.593942	2.637543	59.709237	58.125061	62.165703	2.644213	0.053916	...	-999.0000	-999.0	33	74.92	121	0.627867	0.015033	-0.404850	0.024537	-0.480859
2	As	3	2.682490	2.685299	2.680348	59.912592	60.095729	59.991680	2.682712	0.002483	...	-999.0000	-999.0	33	74.92	121	0.619267	0.003819	-0.415900	0.004303	-0.352070
3	As	4	2.644063	2.569793	2.657188	61.260029	57.991838	60.748134	2.623681	0.047128	...	-999.0000	-999.0	33	74.92	121	0.604533	0.026364	-0.409075	0.014458	-0.410929
4	As	5	2.675141	2.611050	2.575125	58.290699	59.609085	62.100216	2.620439	0.050665	...	-0.3967	-999.0	33	74.92	121	0.589967	0.025755	-0.405520	0.014240	-0.441036

5 rows × 30 columns

Viola! Now, let’s use our drop_nzv function to remove descriptors that have no predictive capability.

# drop near zero variance descriptors
df = drop_nzv(df)
df.head()

	X	nX	X95_98	X95_100	X98_100	X98_95_100	X95_98_100	X95_100_98	Avg_Ni_Ni	Std_Ni_Ni_Ni	...	q105_3	q108_4	q106_5	q107_6	Z	m	r	Avg_qX	Std_qX	dGH
0	As	1	2.772373	2.728643	2.673381	58.146831	60.107425	61.745744	2.724799	1.801860	...	-999.0000	-999.0000	-999.0000	-999.0	33	74.92	121	-0.370600	-999.000000	-0.467393
1	As	2	2.701154	2.593942	2.637543	59.709237	58.125061	62.165703	2.644213	2.035953	...	-999.0000	-999.0000	-999.0000	-999.0	33	74.92	121	-0.404850	0.024537	-0.480859
2	As	3	2.682490	2.685299	2.680348	59.912592	60.095729	59.991680	2.682712	0.091852	...	-0.4203	-999.0000	-999.0000	-999.0	33	74.92	121	-0.415900	0.004303	-0.352070
3	As	4	2.644063	2.569793	2.657188	61.260029	57.991838	60.748134	2.623681	1.757853	...	-0.4179	-0.3876	-999.0000	-999.0	33	74.92	121	-0.409075	0.014458	-0.410929
4	As	5	2.675141	2.611050	2.575125	58.290699	59.609085	62.100216	2.620439	1.934610	...	-0.4162	-0.3846	-0.3967	-999.0	33	74.92	121	-0.405520	0.014240	-0.441036

5 rows × 24 columns

As a final preprocessing step, we’ll want to remove descriptors that are highly correlated. The reason we may want to do this is because linearly dependent descriptors are redundant, i.e. only one is necessary to explain their affect on $y$, and models with fewer descriptors are often preferred, especially in the physical sciences! As such, I’ll remove descriptors that have correlation coefficients greater than 0.95. This chunk was adapted from an awesome blog post by Chris Albon.

# drop highly correlated descriptors
corr_matrix = df.iloc[:, :-1].corr().abs()
upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(np.bool))
to_drop = [column for column in upper.columns if any(upper[column] > 0.95)]
df = df.drop(to_drop, axis = 1)
print(df.shape)
df.head()

(55, 18)

	X	nX	X95_98	X95_100	X98_100	X98_95_100	X95_98_100	X95_100_98	Std_Ni_Ni_Ni	q104_1	q103_2	q105_3	q108_4	q106_5	q107_6	Z	r	dGH
0	As	1	2.772373	2.728643	2.673381	58.146831	60.107425	61.745744	1.801860	-0.3706	-999.0000	-999.0000	-999.0000	-999.0000	-999.0	33	121	-0.467393
1	As	2	2.701154	2.593942	2.637543	59.709237	58.125061	62.165703	2.035953	-0.3875	-0.4222	-999.0000	-999.0000	-999.0000	-999.0	33	121	-0.480859
2	As	3	2.682490	2.685299	2.680348	59.912592	60.095729	59.991680	0.091852	-0.4117	-0.4157	-0.4203	-999.0000	-999.0000	-999.0	33	121	-0.352070
3	As	4	2.644063	2.569793	2.657188	61.260029	57.991838	60.748134	1.757853	-0.4174	-0.4134	-0.4179	-0.3876	-999.0000	-999.0	33	121	-0.410929
4	As	5	2.675141	2.611050	2.575125	58.290699	59.609085	62.100216	1.934610	-0.4151	-0.4150	-0.4162	-0.3846	-0.3967	-999.0	33	121	-0.441036

After having cleaned up our data set, we’re now left with only 17 descriptors and 1 column for $y$ at the far right.

A critical step in the construction of machine learning models is splitting the data into a training and test set. The training set is used to build the model whereas the test set is kept aside, not analyzed, and used only for evaluating the “out of sample” error. The splitting should be done randomly, however, there are some more advanced schemes, e.g. those that split the data so that the distribution of $y$ values in each subset is more or less the same. Here, we’ll just randomly split the data. Often a good starting point is to use 2/3 of the data for training and 1/3 for testing, however, this is not a hard and fast rule and probably leans towards “too conservative”.

# split training and testing set
X = df.iloc[:, 1:-1]
y = df.dGH
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)

Tune random forest

`n_estimators`

Random forests have a few parameters that we’ll need to tune in order to minimize the test set error. The first is the number of trees in the random forests, a.k.a. n_estimators, which we’ll vary from 1 to 40.

# tune n_estimators
n_estimators_list = np.arange(1, 41, 1)
r2_train = np.zeros(n_estimators_list.shape)
r2_test = np.zeros(n_estimators_list.shape)
for i, n_estimators in enumerate(n_estimators_list) :
    regr_2 = RandomForestRegressor(n_estimators=n_estimators, random_state=42)
    regr_2.fit(X_train, y_train)
    r2_train[i] = get_results(regr_2, X_train, y_train)[0]
    r2_test[i] = get_results(regr_2, X_test, y_test)[0]
plt.plot(n_estimators_list, r2_train, color = "blue")
plt.plot(n_estimators_list, r2_test, color = "red")
plt.xlabel("n estimators")
plt.ylabel(r"R$^2$")
plt.grid(True)

The blue and red lines are the training and test set error, respectively. Tuning n_estimators ultimately boils down to choosing the value that minimizes test set error, or in the case of the plot above, maximizes $R^{2}$. Therefore, our tuning indicates that a small random forest with 4 trees is best.

`max_features`

Next, we’ll tune the number of features available to each tree during it’s training, a.k.a. max_features, from 1 (an overly simple and rather silly model unless that one descriptor rocks) to the total number of descriptors that survived our preprocessing above (17).

# max_features
max_features_list = np.arange(1, X_train.shape[1] + 1)
r2_train = np.zeros(max_features_list.shape)
r2_test = np.zeros(max_features_list.shape)
for i, max_features in enumerate(max_features_list) :
    regr_2 = RandomForestRegressor(max_features=max_features, random_state=42, n_estimators=4)
    regr_2.fit(X_train, y_train)
    r2_train[i] = get_results(regr_2, X_train, y_train)[0]
    r2_test[i] = get_results(regr_2, X_test, y_test)[0]
plt.plot(max_features_list, r2_train, color = "blue")
plt.plot(max_features_list, r2_test, color = "red")
plt.xlabel("max features")
plt.ylabel(r"R$^2$")
plt.grid(True)

Here you can see that the best model includes all of the descriptors.

`max_depth`

Finally, we may want to tune the maximum depth of the trees, a.k.a. max_depth, from 1 to some arbitrarily large number, e.g. 31.

# max_depth
max_depths = np.arange(1, 31, 1)
r2_train = np.zeros(max_depths.shape)
r2_test = np.zeros(max_depths.shape)
for i, max_depth in enumerate(max_depths) :
    regr_2 = RandomForestRegressor(max_depth=max_depth, random_state=42, n_estimators=4, max_features=16)
    regr_2.fit(X_train, y_train)
    r2_train[i] = get_results(regr_2, X_train, y_train)[0]
    r2_test[i] = get_results(regr_2, X_test, y_test)[0]
plt.plot(max_depths, r2_train, color = "blue")
plt.plot(max_depths, r2_test, color = "red")
plt.xlabel("max depth")
plt.ylabel(r"R$^2$")
plt.grid(True)

It’s clear that deeper trees are better, however, after 7 layers, depth does’nt improve the model and can only lead to overfitting. As such, we’ll stick with a model with 4 trees, 16 descriptors, and a maximum depth of 7 layers.

Now we’re ready to train our random forest regressor!

# train random forest
regr = RandomForestRegressor(n_estimators = 4,
                             max_features = 16,
                             max_depth = 7,
                             random_state=42)
regr.fit(X_train, y_train)

# print results
r2, rmse, mae = get_results(regr, X_test, y_test)
print("results")
print("-------")
print("r2   =", r2)
print("rmse =", rmse)
print("mae  =", mae)

# plot results
plot_results(regr, X_train, X_test, y_train, y_test)

# plot descriptor importances
plot_importances(regr, df.columns[:-1])

results
-------
r2   = 0.8510929000114282
rmse = 0.07531117819235955
mae  = 0.0525640930241579

All righty, then! Let’s take this piece by piece. First, your $R^{2}$ is 0.85, which is pretty darn good considering we only fed the model simple structure and charge descriptors. The RMSE and MAE are between 0.05 and 0.1 eV, which is excellent considering the intrinsic DFT accuracy for binding energies is around 0.1 eV. The first plot shows how well our random forest model did compared to DFT. The black line shows perfect performance. The blue and red dots correspond to the training and test data, respectively. Upon visual inspection and in conjuction with the metrics above, we have achieved a good fit.

Finally, because random forests are intrinsically nonlinear models, they aren’t as interpretable as, say, multiple linear regression models. However, we can look under the hood of the random forest model to see which descriptors were the most effective in making these predictions. Simply put, the most important features are those that reduce the training set error the most. There are various ways of calculating this reduction but their description is beyond the scope of this introduction.

So what does the bottom plot tell us? It tells us that the most important descriptor, i.e. the one with the largest bar, is for X95_98, which is the bond distance between two Ni’s at the Ni₃ site. This means that Ni-Ni bond distance is the most important descriptor of H binding strength. Since we kept the active site the same (Ni₃) and applied chemical perturbations around it (replacing P with other nonmetals), our random forest model suggests that dopants simply apply strain on the Ni₃ site, modulating its H binding strength via compression and expansion.

The end

I hope you enjoyed this introduction. Please feel free to get in touch if you have any questions/comments about this and/or suggestions for future content! And, as always, thanks for using this resource!

Generating thermal profiles for LAMMPS simulations

2019-03-25T00:00:00+00:00

This notebook generates thermal profiles for LAMMPS simulations. All you need to do is define the temperatures then the notebook will generate an NVT equilibration phase (10K steps), NPT equilibration phase (40K steps, P = 1.01325 bar), and NPT sampling step (40K steps, P = 1.01325 bar) for each temperature. Should be easy to make modifications. Please feel free to do so. If you’d like me to include your updates, then please shoot me an email with your notebook or Python script.

# loads numpy
import numpy as np

# define temperatures
temps = np.arange(10, 30, 10)
temps

array([10, 20])

# generate thermal profile
k = 1
for temp in temps :
    for i in range(3) :
        if i == 0 :
            # nvt equilibration
            print("fix {} all nvt temp {} {} 1.0".format(k, temp, temp))
            print("run 10000")
            print("unfix {}".format(k))
            print("")
        elif i == 1 :
            # npt equilibration
            print("fix {} all npt temp {} {} 1.0 aniso 1.01325 1.01325 5.0".format(k, temp, temp))
            print("run 40000")
            print("unfix {}".format(k))
            print("")
        else :
            # npt sampling
            print("fix {} all npt temp {} {} 1.0 aniso 1.01325 1.01325 5.0".format(k, temp, temp))
            print("dump {} all custom 200 dump{:03d}.xyz x y z".format(k, temp))
            print("dump_modify {} sort id".format(k))
            print("run 40000")
            print("write_restart BST.restart{:03d}".format(temp))
            print("undump {}".format(k))
            print("unfix {}".format(k))
            print("")
        k += 1

fix 1 all nvt temp 10 10 1.0
run 10000
unfix 1

fix 2 all npt temp 10 10 1.0 aniso 1.01325 1.01325 5.0
run 40000
unfix 2

fix 3 all npt temp 10 10 1.0 aniso 1.01325 1.01325 5.0
dump 3 all custom 200 dump010.xyz x y z
dump_modify 3 sort id
run 40000
write_restart BST.restart010
undump 3
unfix 3

fix 4 all nvt temp 20 20 1.0
run 10000
unfix 4

fix 5 all npt temp 20 20 1.0 aniso 1.01325 1.01325 5.0
run 40000
unfix 5

fix 6 all npt temp 20 20 1.0 aniso 1.01325 1.01325 5.0
dump 6 all custom 200 dump020.xyz x y z
dump_modify 6 sort id
run 40000
write_restart BST.restart020
undump 6
unfix 6

Visualizing dipolar structure dynamics in (Ba,Sr)TiO3

2019-03-25T00:00:00+00:00

This notebook outlines how to visualize the dipolar structure of 10% Sr-doped (Ba,Sr)TiO3 from bond valence molecular dynamics (BVMD) simulations. This recipe could be used to visualize the dynamics of any atom-centered vector property, e.g. magnetic moment, molecular orientation, etc. Please let me know if you have any questions, comments, or suggestions.

# Import modules I need
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import glob
from scipy.interpolate import griddata
from matplotlib.animation import FuncAnimation
from IPython.display import HTML

numpy offers efficient array operations, pandas provides efficient dataframe operations, matplotlib is used to make sophicated plots (e.g. animations), os gives command line control, glob is used to find files with particular names, and scipy has built-in functions for interpolation, which we’ll need to plot contours.

def count_lines(filename) :
    """function that counts the number of lines in a file named filename"""
    count = 0
    with open(filename, "r") as file :
        for line in file :
            count += 1
    return count

# Define user parameters

# Displacements
filename = "filesIwant/files.LocalP.dat100"
ntis = 1000
nstrs = int(count_lines(filename) / ntis)

# A-sites
datafilename = "data.BST"
data = np.array(os.popen("grep Atoms -A 1001 {} | tail -1000".format(datafilename)).read().split()).reshape((1000, 7)) # extracts Ti positions
subset = data[:, [2, -3, -2, -1]] # selects only the element id and cartesian coordinates (indices 2, -3, -2, -1 where negative indices count from the end of the list)
subset_df = pd.DataFrame(subset, columns = ["element", "x", "y", "z"]) # convert to a dataframe (which are easy to subset)
subset_df.element = subset_df.element.astype(float) # converts columns to floats
subset_df.x = subset_df.x.astype(float)
subset_df.y = subset_df.y.astype(float)
subset_df.z = subset_df.z.astype(float)
aplane = subset_df[subset_df.x < 2.5] # extracts a 10x10 slice of the structures for x < 2.5 A from the origin

filename is the name of a file containing the positions (x, y, z) and components (u, v, w) of the displacement (i.e. local dipole). You can download an example file here. The columns of this file correspond to x y z u v w. The rows correspond to a particular Ti’s displacement. There are nstrs structures and ntis Ti’s per structure; therefore, there are nstrs * ntis lines in the file.

datafilename is the name of a file containing the positions of the atoms. The structure is a 10x10x10 supercell of BST containing 10% Sr, and 5000 atoms total (hence ntis = 1000). You can download an example data file here.

# Read the Ti displacements into an array of dimension nstrs * ntis * 6, where 6 corresponds to x, y, z, u, v, w
# This may take a few seconds to complete
dip_traj = np.zeros((nstrs, ntis, 6))
with open(filename, "r") as file :
    for istr in range(nstrs) :
        for jti in range(ntis) :
            for line in file :
                dip_traj[istr, jti, :] = np.array(line.split()).astype(float)
                break

# Visualize dipolar structure dynamics

# Step 1: set up figure and axis
fig, ax = plt.subplots(figsize=(5, 5))
ax.set(xlim=(-5, 45), ylim=(-5, 45))

# Step 2: curate data
traj0 = dip_traj[0, :, :] # extract structure at time 0
df_traj0 = pd.DataFrame(traj0, columns = ["X", "Y", "Z", "U", "V", "W"]) # convert to a dataframe
plane0 = df_traj0[df_traj0.X < 2.5] # extract a 10x10 slice of the structures for x < 2.5 A from the origin
y = plane0.Y
z = plane0.Z
v = plane0.V
w = plane0.W
        
# Step 3: plot the Ti displacements and positions for time 0
qax = ax.quiver(y, z, v, w, scale = 4, zorder = 2, pivot = "middle")
ax.scatter(subset_df.y, subset_df.z, c = subset_df.element)

# Step 4: create a function that updates the displacements
def animate(i):
    """update the Ti displacements
    Note: the positions of the A-site atoms, Ba and Sr, are not updated (for simplicity)"""
    traji = dip_traj[i, :, :] # extract structure at time i
    df_traji = pd.DataFrame(traji, columns = ["X", "Y", "Z", "U", "V", "W"]) # convert to a dataframe
    planei = df_traji[df_traji.X < 2.5] # extract a 10x10 slice of the structures for x < 2.5 A from the origin
    v = planei.V
    w = planei.W
    qax.set_UVC(v, w) # update quiver plot
        
# Step 5: animate and show
anim = FuncAnimation(fig, animate, interval=100, frames=201)
#anim.save('dipolar_structure_dynamics.mp4')
HTML(anim.to_html5_video())

Your browser does not support the video tag.

Purple and yellow dots correspond to the positions of Ba and Sr, respectively, at time 0. Black arrows corresponds to the dynamic Ti displacements. For 100 K, you can see (partially) that the polarization is pointing along [111], which is consistent with low-temperature, ferroelectric, rhombohedral structure of 10% Sr BST. For more information on quiver plots, please see matplotlib’s documentation.

References:

gzip in parallel using pigz

2019-03-24T00:00:00+00:00

If you’re running MD simulations, then this is the post for you. It can sometimes be a nightmare to compress MD trajectories because they can be so large, like multiple GBs (or maybe even TBs if you’re working with gigantic systems). Up until now, I’ve found myself deleting MD trajectors but saving a restart file so that I can regenerate the data if I need to do further processing. This can be somewhat of a drag so I went searching for a way to compress MD trajectories in parallel. That’s when I came across pigz. If you already know how to make a tar.gz file, then it is really easy to use pigz. For example, the pigz command corresponding to

tar zcvf <filename>.tar.gz <filename/directory_name/etc>

tar cvf - <filename/directory_name/etc> | pigz -n <number_cores> <filename>.tar.gz

Enjoy!

Running Quantum Espresso on Conrad and Gordon

2019-01-29T00:00:00+00:00

Today, I figured out that there is a working pw.x executable for Quantum Espresso on the DoD machines Conrad and Gordon. It is located in /app/espresso/6.3-intel/bin. All you need is a PBS script with an execution line like

aprun -n 32 /app/espresso/6.3-intel/bin/pw.x < qe.in > qe.out

Also, you need to do module load intel prior to submitting the job. You can either add a line in your .bashrc or place it in the PBS script. Enjoy!

Compiling LAMMPS on Koehr

2019-01-28T00:00:00+00:00

Today, I was able to successfully compile LAMMPS on the DoD machine Koehr. First, I used mpicc as my C++ compiler. Then, I manually pointed the makefile to Intel’s MPI libraries using the following three lines of code:

MPI_INC =       -I/app/intel/parallel_studio_xe_2018_update1/impi/2018.1.163/intel64/include
MPI_PATH =      -L/app/intel/parallel_studio_xe_2018_update1/impi/2018.1.163/intel64/lib
MPI_LIB =

Finally, I manually pointed the makefile to the FFTW3 library as follows :

FFT_INC =       -I/app/COST/fftw3/3.3.5/intel/include
FFT_PATH =      -L/app/COST/fftw3/3.3.5/intel/lib
FFT_LIB =       -lfftw3

That’s all she wrote! Of course, I executed make in parallel as make -j 48 <Makefile suffix>. Next, I’m going to test this recipe on other DoD computers.

P.S. It is necessary to load the modules costinit, fftw3/intel/3.3.5, and compiler/intelmpi/18.0.1.163 prior to running LAMMPS. I added two lines in my .bashrc to take care of this. This can also be done in your PBS script.