Turns out this was a national effort to research the question: “What would happen if you put a bunch of 16-year-olds in front of a $20M supercomputer?” Answer? They could do a LOT. From my initial exposure to supercomputing while spending several summers at the Cornell Theory Center (now the Cornell University Center for Advanced Computing), I was recruited by the CTC Director, Dr. Larry Lee, to move to the North Carolina Supercomputing Center (NCSC, now closed) to develop supercomputing activities for high school students in North Carolina. 40 years later, I’m still working as a computational science educator, now teaching part-time at a high school in North Carolina.

NCSC was one of a few number of state-supported supercomputing centers, funded by the North Carolina General Assembly, and designed to primarily support the three universities that were at the corners of the Research Triangle Park (RTP): Duke, UNC-Chapel Hill, and North Carolina State. NCSC provided compute cycles (access to advanced processors, storage, and technical/scientific support). We were primarily a “Cray” shop, with supercomputers from that supercomputing vendor. Supercomputers, by the way, are colloquially referred to as “big iron”, and the term “high-performance computing” (HPC) is also commonly used.

The list below (culled from ChatGPT) shows the progression of Cray implementation over the years:

The NCSC Supercomputer Pipeline

• Cray Y-MP (Installed Early 1990s): This served as NCSC’s foundational workhorse. It relied on traditional vector processing to handle massive computational arrays simultaneously.

• Cray T3D (Installed 1994): NCSC introduced this system to transition users to Massively Parallel Processing (MPP). It featured 150-MHz processors and functioned as a co-processor paired alongside the Y-MP to manage highly distributed computational tasks.

• Cray T90 (Installed 1995): Replacing the Y-MP, the T90 was the last of Cray’s pure single-memory parallel vector processors. It utilized total liquid immersion cooling to support faster floating-point math hardware before the T3E arrived in 1996.

Most supercomputing centers, then and now, are supported by the National Science Foundation (NSF). At one point, they funded five supercomputing centers, decided that they didn’t want to do that any longer, and held a competition between the five to reduce the number to two. The San Diego Supercomputing Center (SDSC) and the National Center for Supercomputing (NCSA) emerged victorious. Two of the others, the Cornell Theory Center and the Pittsburgh Supercomputing Center (PSC), continued with funding from various universities. A fifth one in New Jersey closed its doors permanently.

Fast forward a number of years: in a (successful) effort to make access to HPC more accessible to researchers nationwide, the NSF funded the project XSEDE (Extreme Science and Engineering Discovery Environment). In this program, researchers (and educators) could submit a proposal for some scientific investigation. The XSEDE team would evaluate the proposal, and, if accepted, assign that researcher to one of several participating XSEDE centers, including all of the ones so far mentioned. The XSEDE program was discontinued in 2022, but reborn as ACCESS: Advanced Cyberinfrastructure Coordination Ecosystem: Services & Support. Like XSEDE, researchers apply for time, and are assigned to a center.

Education is also a priority for programs like ACCESS, and my school has had an allocation since 2007. In applying for an allocation, the researcher will request specific resources and amounts of those resources.

Part of our proposal looked like this in my 2007 proposal:

Requested Resources

PSC Regular Memory (Bridges): 25,280

Abstract

This proposal requests computational time on Bridges Regular Memory to support two activities at the North Carolina School of Science and Mathematics (NCSSM), a state-supported residential school for gifted science and math high school students, and a constituent member of the University of North Carolina. First, the allocation will support the course “Computational Chemistry” (Chem 412, high school), a semester-long course in the technologies, techniques, and tools of computational chemistry, which primarily uses Gaussian 09. Students in this course are presented with topics including mathematics in computational chemistry, molecular orbital theory and molecular symmetry, applications, and research in computational chemistry. The course culminates in a small research project and completion of a journal-style article. Second, the allocation will also support independent research students in chemistry, who work over a period of one year on a large-scale research project in chemistry or quantum physics.

As shown in the graphic below, in 2025 I requested 2.93K units of graphical processing unit (GPU) time, 240K units of regular CPU processing time, and 6.1K of storage. We were assigned to the Pittsburgh Supercomputing Center, with our allocation on the new Bridges-2 supercomputer.

I’m not a hardware guy, but the graphic below describes some of the hardware configurations of the various platforms. It’s definitely “big iron”. We use “regular memory” and the GPU nodes.

So, what can we do on this thing that can’t be done on regular computers, or at least not as efficiently? The biggest advantage comes from parallel processing. On regular computers, there are a small number of CPU processors. My MacBook has four CPUs, so technically that’s parallel processing, in which a problem or task is divided among multiple processsors. On an HPC machine, the researcher has hundreds or thousands of processors to apply to any given task. Divide and conquer. Each processor does one small part of the job, and then sends its result back to a central location to put it all together. Most parallel processing machines use a communications system called “MPI” (Message Passing Interface), to distribute the task over multiple “compute cores”. A core is a single CPU, think of it as one single-processor laptop. The graphic below is from Hangun:

A supercomputer is basically a collection of nodes, which are in turn a collection of cores. The graphic below shows a series of nodes, each with multiple cores, all connected by a network that uses a communications protocol such as MPI to solve the problem:

Nodes, memory, and processors (source: http://assets.geoexpro.com

All of this is supported by a large amount of computer storage: think of this as an extremely large hard disk! One of the biggest challenges in using HPC resources is managing one’s allocation of storage space. We get 6.1K gigabytes (GB) of storage on the PSC “Ocean” platform. Contrary to the name, our allocation is not the size of the ocean! As the allocations manager for my project, I probably spend most of my time managing how my students are using (or, in some cases, abusing) our allotment of storage.

As readers might recall, I’m primarily a computational chemist, although through my work at NCSC and other locations, I’ve done work in many disciplines, including the humanities.

For my students, I wrote a document, “Gotwals Guide to Supercomputing”, providing start-to-finish instructions on logging in, communicating with the supercomputer using the UNIX operating system, creating and submitting a “job”, and managing the “queue”, where students can see other researchers “in line” for access to processors.

I run a one-day “Supercomputing Explorations” workshop for my students, and the workshop materials can be seen at https://tinyurl.com/gotwalsoutreach. We do a very simple compute task — finding the molecular energy of a water molecule — but one that requires students to set up the environment, create directories (folders) on the Ocean storage platform, learn how to use a UNIX-based text editor (we use “nano”, although I’m an old guy that prefers “vi”), create a “job” file using a system called SLURM (Single Linux Utility Resource Manager), and creating an input file that describes the water molecule and what kind of calculation we want to do.

Let’s start with the water input file that we’ll send to a quantum chemistry software package known as Gaussian16 (G16). We show the file called “water.inp” below. We start by asking for four nodes, the number of shared processors (NProcShared). Then we describe what we want: we want a single point energy calculation (SP) using a mathematical method known as B3LYP with a set of mathematics called a basis set, in this case 6-31G(d). Then we have the name of the molecule, H2O. The next line says that the molecule has a total charge of zero (oxygen = -2; each hydrogen is +1, for a total of 0). The “1” is a multiplicity, in this case a singlet, all 10 electrons in water are paired in orbitals (five sets of two).

We then describe the geometry of the molecule: oxygen is the central atom, designated as “Atom 1”. The two hydrogens are each attached to Atom 1, with bond lengths (B1 and B2) of 0.942 angstroms, and a bond angle (A1) between the three atoms of 105.5 degrees. This is the simplest G16 input file one might encounter.

Next, we create the SLURM file, more commonly known as the “job” file, so ours is “water.job”. We start with four specific SLURM commands:

1. SBATCH -p RM: establishing which processor, in our case, Regular Memory.

2. SBATCH -t: we’re allocating 30 minutes to this job, absolutely killing a mosquito with a hammer. This is probably a 3-minute job. If you don’t allocate enough time, the job won’t complete. Allocating too much time takes resources away from others, and playing nice on a queue-based supercomputer is the right thing to do!

3. SBATCH -N 4: we’re setting the number nodes to four, just like we did in the input file (NProcShared=4).

4. SBATCH -ntasks-per-node=28: we’re allocating 28 cores (CPUs) to each node, again, a massive case of overkill for a really simple calculation. When a student wants to do an independent project on Bridges-2, they have to meet with me to talk about nodes and cores, and also about storage needs. Once students are trained, they can use the supercomputer for independent projects, but they have to meet with me first to make sure they’re just not throwing stuff against the wall to see what sticks. If they want to do that, they do it on their own machines.

I also have it set up so I get an email when the job is completed, or, as tends to be more common on a supercomputer, the job fails.

I then load the Gaussian 16 quantum chemistry software program, installed in Bridges-2 as a “module”. I “source” the login for G16, established by the supercomputing center. I then set up a directory (folder for laptop/desktop users), identify the input file name (water.inp), make sure I’m in the right SLURM directory ($SLURM_SUBMIT_DIR), and finally, “pipe” (< and >) the input file and output file to G16. By setting a variable — $filename — this script becomes easily reusable for the next job.

Once the input file and job file are ready, you use another SLURM command — sbatch — to submit the job to the queue, and they you go away and come back a day or two later to see the results. The SLURM command “squeue” lets you check where you are in the queue, but I encourage students not to be checking this, just come back later and look at results:

All of this is the easy part of supercomputing: the hard part is analyzing the output results, typically a “log” file. Below is a screenshot of some of the results, along with a “fortune cookie” (a famous feature of Gaussian16), and a table of compute results. Notice that this job took about 40 seconds, so our request for 30 minutes was much more than needed!

This is an extraordinarily easy job. I currently have students working a molecular dynamics study of a protein called HSP90 which is bound to a drug called geldanamycin, a drug that has some impact on myasthenia gravis, an autoimmune neuromuscular disease that I was diagnosed with last August. This is an very complicated calculation that uses an MD program called GROMACS. Shown below is a PARTIAL list of the various input files, job files, temporary output files, and other files needed to do the calculation. All of these need to be generated BEFORE submitting the job to actually do the MD run, and the results will be an animation that shows atoms moving over time. The goal of this is to determine how stable the protein is, and whether or not the geldanamycin drug will stay in the active site of the target protein. This is a great example of why supercomputing is so important to the scientific community. You can run compute-intensive programs like GROMACS on a laptop, but you need at least four processors, a really good fan, a big hard drive, and lots of time. While GROMACS is running on a laptop, it’s really not much good for anything else, because the CPUs will be pretty much consumed with the GROMACS jobs.

Speaking for myself and my students, we are immensely grateful to the National Science Foundation, the ACCESS program, and the Pittsburgh Supercomputing Center for recognizing the importance of providing HPC resources to “early scientists” like the ones I work with every day.

With that, dear readers, it’s time to bring a close to the “Confessions” series of monthly articles. I hope that you have had as much fun reading them as I have writing them. It’s time to embrace the fact that I really am retired, and start spending a little more time with my spouse, my music (cello and bass viola da gamba), and providing daycare for the new grandkid. For those of you who are students, I strongly encourage you to look at the field of computational science, whether you are in the life or physical sciences or the humanities/social sciences. It’s an amazing way to do science, however you might define that word.

Yours in computing,

Bob

References:

1. Hangün, Batuhan. (2022). Performance evaluation of a parallel image enhancement technique for dark images on multithreaded CPU and GPU architectures. 10.13140/RG.2.2.32436.17280.

I have to admit, I started off as a skeptic of data science (and still am to some degree). When I first got into the data science thing a number of years ago, it sure did seem like statistics, just on bigger data sets. A good friend of mine, a professor of statistics at Duke, was pretty much in agreement. However, after a number of years of teaching a course called “Data Science for Scientists”, it’s pretty clear that there is a lot more to it.

One of the biggest “conversations” that I have seen in the data science community revolves around which programming language to use. There are a million opinions about Python vs. R vs. fill-in-the-blank software. I’m fundamentally a Wolfram Mathematica user, which has a robust library of commands specifically for data science, but that software is never a part of the conversation; it’s basically Python vs. R. It’s a stupid argument, sort of like Pepsi vs. Coke, Macs vs. PCs, etc. If you are a Pepsi drinker, you are convinced that Coke drinkers are an inferior brand of human being. More true in the Mac vs. PC argument (me? “Once you Mac you never go Bac”). Probably even MORE true in the Python vs. R discussion.

In 2007, my school got a call from the Jackson Lab (which I have written about previously), looking to train advanced high school students in bioinformatics, which is basically data science for genomics studies. The “Jax Lab” bioinformatics head was (and still is) an R person, so when you get an opportunity to have your students engage in a world-class scientific facility like Jax, you don’t argue about using Python instead of R.

Given that, this post is VERY R-centric. I’ve read all of the arguments about ease of use, efficiency, portability, etc., and I’m still Team R. So, if you are a Python user, we still like you, but if you want to continue reading, you’ll need to suck it up and read about R!

For my data science course, my students primarily used an R package called “tidyverse”, developed by Hadley Wickham, now a development scientist at Posit (formerly RStudio). The tidyverse R package is actually a series of eight tools that can be used individually or in combination:

• ggplot2: Creates graphics and data visualizations based on the grammar of graphics.

• dplyr: Provides verbs and tools for data manipulation and transformation.

• tidyr: Reshapes and organizes messy data into a clean, tidy format.

• readr: Fast and friendly importing of rectangular data like CSV files.

• tibble: A modern, easier-to-use re-imagining of standard R data frames.

• purrr: Enhances R’s functional programming capabilities with tools for mapping functions over vectors.

• stringr: Simplifies working with text strings.

• forcats: Solves common data handling problems with categorical factors.

Here’s a really simple example that uses the stringr package in tidyverse. I have a dataset that has sort of unworkable column names. They have lots of extra periods in them, sort of makes it unworkable for regular typing, so I want to change them to something more useable:

Given that, I load the tidyverse library and read in my data. Now, I use the functions str_replace_all and str_to_lower, functions in the stringr package, to clean these up:

# load libraries and data
library(tidyverse)
data <- read.csv("http://chemistry.ncssm.edu/data/demoStrings.csv")names(data) <- str_replace_all(names(data), "\\.+", "_")
names(data) <- str_replace_all(names(data), "\\.+", "_")
names(data) <- str_replace_all(names(data), "_$", "")
names(data) <- str_to_lower(names(data))

Once done, I get something like this:

I could have done this with just “base R”, no special packages like tidyverse, but that package really makes things easier!

A more interesting example was developed for a “Digital Humanities” class, team-taught by an instructor of humanities and myself starting in 2022. We gave students a dataset of the results of the 20216 Presidential election, the data looking like this:

We wanted students to use scientific visualization, primarily using the tidyverse graphics package, ggplot2. An example of a plot for the Republicans is show in the codeblock below. What we are doing is setting the party colors to blue and red, then using ggplot2 to map the election data by creating an “aesthetic” (aes) with Republican points on the x-axis. We colored the data by party, and set up a scale of percentages scaled again to party color. We used the function facet_wrap to put in the names of the states, and created a plot label with the labs function. ggplot2 also has different '“themes” that you can use, and we used a fairly generic theme of axis.text:

# set party colors
party_colors <- c("#2E74C0", "#CB454A")
#
## Point margins by the Republicans
pointMarginRepubs <- ggplot(data=election, 
  mapping=aes(x=r_points, y=reorder(state, r_points), color=party)) + 
  geom_vline(xintercept=0, color="gray10") +
  geom_point(linewidth=2) + 
  scale_color_manual(values=party_colors) + 
    scale_x_continuous(breaks=c(-90,-80, -70, -60,-50, -40, -30, -20, -10,0, 10, 20, 30, 40,50,60,70,80,90), 
                       labels=c("90\n (Clinton)", "80", "70", "60", "50", "40", "30","20", "10", "0", "10", "20", "30","40","50", "60", "70","80", "90\n(Trump)")) + 
  facet_wrap(~ census, ncol=1, scales="free_y") + 
  guides(color=FALSE) + 
  labs(title = "Point Margin \n by Republicans (RRG)", x="Point Margin", y="") + 
  theme(axis.text=element_text(size=8))

We do the same for the Democratic data, then use a gridding package to combine the two plots. The resulting graphic is below (my initials are in there to keep the kids from simply copying my results!):

We also used ggplot2 to create maps of the United States with vote totals and differences between Trump and Clinton:

# Trump Votes
trump <- ggplot(data=us_states_elec, aes(x=long, y=lat, group=group, 
fill=pct_trump))+ geom_polygon(color="gray90", size=0.1) + 
coord_map(projection="albers", lat0=25, lat1=50)  + theme_map() + 
labs(title = "Trump Election Results 2016 (RRG)",fill="Trump \n %")
# Clinton Votes
clinton <- ggplot(data=us_states_elec, aes(x=long, y=lat, group=group, 
fill=pct_clinton))+ geom_polygon(color="gray90", size=0.1) + 
coord_map(projection="albers", lat0=25, lat1=50) + theme_map() + 
labs(title = "Clinton Election Results 2016 (RRG)",fill="Clinton \n %")
#
# Calculate and plot difference
diff <- abs(us_states_elec$pct_trump-us_states_elec$pct_clinton)
diffPlot <- ggplot(data=us_states_elec, aes(x=long, y=lat, group=group, 
fill=diff))+ geom_polygon(color="gray90", size=0.1) + 
coord_map(projection="albers", lat0=25, lat1=50)+ theme_map() + 
labs(title = "Election Results 2016 (RRG)",fill="Diff") 
#
grid.arrange(niceMap, trump, clinton, diffPlot, ncol=2, nrow=2)

There are a million tutorials, YouTube videos, and books out there on how to use pacakges such as tidyverse. My favorite ggplot2-centric book is “Data Visualization” by Kieran Healy, a local Duke professor (disclaimer: no financial interest, it’s just a really useful book):

So the REAL difference between traditional statistics and data science is arguably the rise of machine learning, which actually was started by Alan Turing in the early 1950s, but that has only really had an impact over the past 10-15 years. In my “Data Science for Scientists” class, this is where we spent the most time, and that’s likely true for most data science classes.

The graphic below is the best I’ve ever found to capture the essence of machine learning. The graphic shows three main areas: unsupervised learning, supervised learning, and reinforcement learning.

We use unsupervised learning when we have a large data set and don’t have any idea what the data is telling us. For example, many datasets have a large number of variables. You can create a plot of one variable (a line), two variables (an x-y scatter plot), and three variables (a 3D plot), but you can’t plot four, five, six variables. We can use “meaningful compression”, sometimes called “dimensionality reduction” to reduce, say, a 40-variable dataset to a 2D dataset, using a technique known as Principal Component Analysis (PCA). The graphic below shows how this works. Fortunately, every data science-capable programming language — Python, R, Mathematica, MatLab, etc. — has a function to do all of this simply by typing a command like “pca”. There are only a million tutorials on YouTube on how to do a PCA analysis and analyze the results.

Source: https://devopedia.org/principal-component-analysis

Here’s a PCA analysis I did using R. For this dataset, we have 100 genes and a measure of how well the gene is expressed. I have 10 variables in this data, five wild-type genes and five “knock-out” genes. The data represents the amount of expression.

Notice how easy it is to run a PCA analysis: I just apply the “prcomp” command to the dataset. This reduces the dataset from 10 variables to two variables, called PCA1 and PCA2. Because I now have two dimensions, I can plot that as an x-y scatter plot. Notice that the wild-type genes are on one side, and the knockouts on the other.

Unsupervised learning also creates algorithms to target products and recommend specific movies or activities. We have a new granddaughter, and of course I’m searching for toys and other baby stuff, and now all of my feeds are full of ads for those products. I’ve probably confused the algorithms, because it knows that I’m a senior citizen and is wondering why I’m looking for baby stuff, but I’m sure it’s figured out that I’m a grandparent.

I’ll not say much about reinforcement learning, except to say I had a research student several years ago who was a major gamer, and he developed a reinforcement machine learning system to help him win his game. It was a significant piece of work (he’s now at Georgia Tech, and is going to set the world on fire).

Supervised learning is used when we have a pretty good idea of what’s in the dataset, and now we want to develop a predictive model, a model that we can apply to other data and have it tell us something about that data. My favorite example is image classification. For an assignment in both my data science and digital humanities, I give kids portrait paintings from five famous artists, including a modern artist (Kehinde Wiley, who painted the famous portrait of President Obama). It’s a very small dataset, so constructed so that kids can load it on a laptop without taking too much time. We call this the training set, used to train the computer to build a predictive model:

I’m doing this, by the way, in Mathematica, well-designed to do image classification. Notice that each artist has five portraits, again, a very small dataset.

Now I set up the classification. Mathematica has a number of built-in predictive machine learning methods, such as random forest, nearest neighbor, etc. I picked four of the more common methods for this assignment. Now, I build a predictive model called “painter”, and tell the classification system that I want to use Method 3, logistic regression. Using the Information command, I learn that this method has an accuracy of about 60%, surprisingly good considering the size of the training dataset. It shows four classes of data, the names of the four artists, and tells me it took about six seconds to create the predictive model.

OK, now what? I can now apply the predictive model to other portraits from my four artists, what is called the test set. The predictive model gets three of them correct; it sees the Rembrandt as a Wiley, not bad given my 60% accuracy value:

Now we can apply the predictive model to other artists. In this data, I have Picasso, Degas, Renoir, etc.

How did we do? Here’s a partial results page. It thinks the Degas portrait looks more like Wiley than any of the other three artists, and that Michaelangelo looks like something Andy Wyeth would have done:

For fun, I had Mathematica take my picture. It thinks I look like something Kehinde Wiley would have painted. Maybe if I had combed my hair, I would have looked more like a Rockwell or Rembrandt!

As before, if you want to jump onto the data science bandwagon, there are lots of ways out there to do so: books, YouTube videos, and the like. Prefer Python? Only a million Python-centric books and websites. Pick your favorite programming language, and you’ll find more resources than you can use. The programming is really lots of fun; the challenge is making sure your data is “clean” (no missing data, no weird datapoints, etc.). Hadley Wickham, creator of tidyverse, says the data has to be “tidy”. The other challenge is managing large datasets, which require lots of hard drive storage, fast processor speeds, and other data-handling resources.

We are, unfortunately, coming to the end of this series. I’m planning on doing one more post in September, which will be one year of “Confessions”. I’ll be talking about high-performance computing (HPC), better known as supercomputing, and I’ll describe how we use the Bridges-2 supercomputer at the Pittsburgh Supercomputing Center to do computational chemistry calculations.

(And, apologies for the lateness of this post: vacation and music camp sort of got in the way!)

We’ll see you in September1 at 6 am! On time!

So, what to do with all of this data? Certainly, the relatively new field of data science has been developed to deal with the large quantities of data being generated by remote sensing devices, laboratory equipment, and, more appropriately to “Confessions”, supercomputers and other high-performance computing technologies. Lots of data science talks about making sure the data is “tidy” and accessible to analytic techniques; filtering data to generate smaller subsets that be handled more easily; and, finally, and the subject of this post, the transformation of raw numeric data into images and animations — scientific visualization, or sciviz — that can help the scientist understand what information is contained in that data.

As “veteran readers” of this post know, I’m a computational chemist, so I care a great deal about molecules and their properties. In 2014 or so, I had a visiting scholar appointment at the University of Richmond, and the (Carol) Parish lab to which I was assigned was looking at a molecule called didehydrofuran, a furan (a four-carbon, one-oxygen ring) that was missing (“de”) two (“di”) hydrogen (“hydro”) atoms. This molecule was thought to be of significance in drug design and discovery, the process of trying to develop new drugs. The molecule looks like this:

One of the calculations we did was natural bond orbitals (molecular orbitals). The output file of raw data is 20-30 pages in length, a VERY small example of which is shown below:

Needless to say, nobody, even computational chemistry experts, wants to look at lots of raw numbers. Instead, we can use scientific visualization to render some of this data into what are quite beautiful graphics. For example, we can visualize a feature called an electrostatic potential, mapped onto the electron density of the molecule:

This simple rendering tells us a great deal about how this molecule behaves in the presence of other molecules. The red areas are places where there are many electrons, and we, accordingly, call these areas “electron-rich”. Likewise, the blue areas are “electron-poor”. If another molecule is positively charged, it will “attack” the electron-rich area, and negative molecules will attack the electron-poor region. This molecule, in the computational chemistry software package, can be rotated so the chemist can see all aspects of the molecule.

Readers also know that I do a great deal of computational biology (bioinformatics) and medical chemistry (drug design and discovery). Readers might also remember that I have an autoimmune disorder called myasthenia gravis. With this disorder, my body produces deranged antibodies that block signals to my muscles, resulting in symptoms such as difficulty swallowing, difficult speaking, droopy eyelids, and general muscle fatigue. One of the drugs that I have just started taking (intramuscular injections into my belly, what a fun time!) is efgartigimod, or Vyvgart. Watch carefully, and you’ll see ads for this on the telly.

This drug interacts with a protein called “FcRn” (fragment crystallized receptor neonatal). This protein was originally thought to be the thing that resulted in immunity for neonatals (new babies), but the thinking has changed, but the name has stuck. Efgartigimod inhibits this protein by docking, or binding, into specific pockets (cavities, binding sites, all the same thing). Docked correctly, the drug disables this protein, and reduces my myasthenia symptoms.

The protein raw data file is stored on Protein Data Bank, and is a long file of numbers. Accordingly, we want to visualize what those numbers mean. PDB has its own internal visualization capacity, and shows us what is known as the protein secondary structure. It also has an interactive tool to look at various aspects of this protein and the drug.

PDB’s visualization resources are, however, limited, and so we turn to another piece of software: PyMol. As its commercial says, “PyMOL is a user-sponsored molecular visualization system on an open-source foundation, maintained and distributed by Schrödinger.” PyMol has a very robust interface for visualizing a wide variety of features of proteins downloaded from PDB, but it also has a scripting capability where the user can develop text-based scripts and run them in PyMol. I recently ran a one-day workshop teaching students how to script PyMol. We used proteins that are found in myasthenia gravis for our case study, including efgartigimod, shown below, using PDBID: 7Q15. In this visualization, we show the protein as wire frame and the drug as sticks. We are also showing binding sites, places on the protein where the drug binds, showing them as transparent surfaces. In the code, under “Identify engineered residues”, we can highlight specific parts of the protein, including specific residues (amino acids), such as amino acids 252, 254, and 256.

Tools like PyMol are single-purpose visualization tools, in this case molecular visualization of protein and protein-ligand (drug) structures. There are also a number of general-purpose visualization tools. Indeed, most modern mathematical computing software packages, such as Mathematica, MatLab, Microsoft Excel, all come with their own internal visualization capabilities, some more advanced and robust than others.

My favorite general-purpose visualization tool is Paraview, developed by the US Department of Energy. Its description states: “ParaView is an open-source, multi-platform data analysis and visualization application for large-scale scientific data. It’s designed to visualize complex 2D and 3D datasets (including time series) and to scale from desktops to supercomputers.”

Tools like Paraview are interactive 3-D, so it’s hard to capture its capabilities here in a flat 2-D environment. Some examples are, however, instructive. Below we show a section of a jet engine. In the image on the left, we show the general structure, a long cylinder with a core section cut out part way down the tube. On the right, we show the engine temperatures, with red obviously representing hot areas of the structure:

I can also apply a wide variety of filters, such as clip. In this visualization, I show the original structure as a wireframe, and the clip (based on temperature) superimposed on the wireframe structure:

We can also visualize really interesting datasets, such as MRI (magnetic resonance imaging) data. Here, we see the MRI of a patient on the operating table, with an endotracheal tube in his mouth. We can also use the clip filter as we did above to see a slice of the brain. It’s easy to take multiple slices, compile them as an animation, and see the brain from top to bottom:

One of my favorite visualizations is the eruption of Mt. St. Helens in 1980. Located in Washington state, the mountain lost its entire north flank in a volcanic eruption triggered by a small earthquake. 57 people were killed in this incident, and it was the largest volcanic eruption in US history.

In the image on the left, we show Mt. St. Helens before the eruption, using the filter “Warp by Scalar”, and magnified by 2. On the right, we show the original mountain as a wireframe, and then the erupted mountain superimposed on the wireframe. It is a little hard to see in this static image, but in the software the user can rotate the image and clearly see the hole in the mountain from when it erupted.

I have two sci viz stories. The first isn’t that interesting, but the highest paid person at the North Carolina Supercomputing Center in the Research Triangle Park was a 25-year-old guy with a BA in art who was our visualization expert. They guy was a magician, he could turn any set of data, regardless of the discipline, into the most amazing 2-D and 3-D images and animations. Without him, the scientific work being supported by the Center would have been almost meaningless: lots of supercomputer-generated data with not a way to analyze it.

The second is more interesting. When I started doing supercomputing with students in the late 1980s, we would spend our summer at the Cornell Theory Center on the Cornell campus. We had a two-day workshop (as a part of the larger six-week experience) on scientific visualization. So here we are, sitting in the lecture hall in front of our workstations, all logged in and ready to go, waiting for the instructor. In the “you can’t make this stuff up” category, in walks a blind guy. With a dog. Needless to say, the kids were all looking at each other with a high degree of teenage skepticism. But once he started, all doubts were removed. He’d gave some instruction, then came around to troubleshoot. He’d ask the kid to describe what was on the screen, and then was able to tell the kid exactly how to fix whatever the problem was. I was a Braille teacher and transcriber in a former life, so I had spent a lot of time with visually-impaired folks. As a result, I knew that their abilities were unlimited, but even for me, this was a pretty incredible experience. I occasionally chat with students from that time, and this continues to be a topic of conversation, “hey, remember the blind guy that taught scientific visualization? Pretty cool.”

By the way, both PyMol and Paraview are open-source tools, so you can download them and play with them on your own. There are a number of example datasets out there for you to explore, and you are encouraged to do so. As before, trying to capture the capabilities in a 2D manner doesn’t do justice to the tools.

I mentioned data science in this post, and we’ll take a look at that next month. I taught a course, “Data Science for Scientists”, and we mostly used tools in R created by Hadley Wickham, a package called “tidyverse”. That’ll be our topic for August, and I hope to see you back for that conversation.

Stay cool out there. Hitting 100+ here in North Carolina this week.

(One last thing: our school recently hosted an art exhibit at the North Carolina Museum of Life and Science here in Durham entitled “Art of a Scientist”, where our art students partnered with kids doing scientific research to create artistically interesting representations of that research. I had several kids partner with me on the didehydrofuran project, creating an exhibit as shown below. And that’s me in the very bottom corner of the story on the left.)

Scientifically, however, it was the most amazing time. We saw a number of extraordinarily successful, innovations, most notably, the rapid development of a vaccine using the mRNA technology to deliver the virus to the right spot. The turnaround time for the development of this vaccine was something like 11 months, which is a process that normally takes multiple years. Not only was this vaccine able to target the appropriate receptors in the host cell, but the technology was adaptable enough to be able to address other viruses or changes in the SARS-CoV2 virus.

That leads us to the second major innovation, and the focus of this “Confessions” post. That innovation was the development of rapid global sequencing. This innovation lead to near-real-time sequencing, allowing scientists to track emergence/spread of variants of the SARS-CoV-2 virus (Alpha, Delta, Omicron), enable policy adjustments, inform vaccine updates, and more accurately target public-health responses.

So let’s talk about this thing called genomic epidemiology. We talked about general epidemiology back in the March edition of “Confessions”, so consider taking a look at that. We’ll apply similar computational techniques to the study of viral mutation.

Before we start, a short primer on general evolution. You can skip this if it’s already familiar. All organisms have DNA, and the structure of DNA produces genes which end up producing proteins, which do the work and provide the structure for the organism. The nucleotides that make up DNA — adenosine (A), cytosine (C), thymine (T), and guanine (G) — can mutate, or change. For example, an A can become a T. These mutations can be harmful or not. They can change the nature of the gene which can affect the protein. For example, sickle cell disease (SCD) is caused by a single-point mutation in the hemoglobin (HBB, human beta (β)-globin) gene. The genetic change a single nucleotide substitution in a sequence of three nucleotides of HBB (GAG → GTG). This changes an amino acid — glutamic acid (Glu, E) — to valine (Val, V) at position 6 of β‑globin (written E6V or p.Glu6Val). Subsequently, this produces hemoglobin-S (HbS).

We can track these changes using genomic epidemiology. In this case, we’ll track the hemoglobin gene HBB in 14 organisms, such as human, chimps (PANTR), cows (BOVIN), rabbits (RABIT), horse, sheep, pig, etc. We’ll use UniProt for this. We do a search for HBB, pick our organisms, go to “Tools” and do a genetic alignment, and then select “Tree”. Here’s what we get:

What we see here are changes over millions of years of evolutionary time, beginning with the very first organism on the left, moving from left to right as time progressed. We can see different branching over time. For example, we see that the HBB gene in chickens (CHICK) has evolved very recently (relatively), and has a close genetic similarity to guinea pigs (CAVPO). Humans are very similar to chimpanzees, not much of a surprise.

It’s an acquired taste, but I like cladograms more than phylogenetic trees. These group organisms based on common ancestors. The figure below shows groupings into clades, so we can say that all of the organisms in the blue clade have a common ancestor, so we can study just that clade if we choose.

In our cladogram, we can see that we are in the same clade with chimps. Moving back in time, we are in the same clade with other primates (MACAR and PAPAN), and even further back, we have some ties to rabbits! Cows and sheep are in the same clade.

Virus, like all organisms, mutate over time. The description below, from the journal article “Mechanisms of viral mutation” captures the essence of viral mutation. SARS-CoV-2 is, as you might remember from COVID days, an RNA virus:

The remarkable capacity of some viruses to adapt to new hosts and environments is highly dependent on their ability to generate de novo (from scratch) diversity in a short period of time. Rates of spontaneous mutation vary amply among viruses. RNA viruses mutate faster than DNA viruses, single-stranded viruses mutate faster than double-strand virus, and genome size appears to correlate negatively with mutation rate.

The figure below shows a sample timeline of how viruses have evolved over time. In this figure, paleoviruses are those viruses that have gone extinct. The lab “mya” refers to millions of years ago. The term hominoids refers to humans, their fossil ancestors, and other anthropoid apes, which includes primates belonging to the family Pongidae, which includes the chimpanzee, bonobo, gorilla, and orangutan.

Notice from the phylogenetic tree that there are three major clades: humans and other hominoids; Old World monkeys (baboons and macaques); and New World monkeys (lemurs,spider monkeys, howler monkeys, etc.). Note that viral mutations for New World monkeys is relatively recent in evolutionary scale, if we are considering the three major clades on the phylogenetic tree.

Now we’ll use another computational tool, NextStrain, which was designed to track viral mutations in the influenza virus, then adapted to follow SARS-CoV-2 in 2020. The data comes from GISAID (Global Initiative on Sharing All Influenza Data), an international, public‑health–focused platform for rapid sharing of viral genomic data, metadata, and related analyses.

We’re going to look at SARS-CoV-2, but the reader is encouraged to look at other viruses. (I was hoping to see the hantavirus, which is starting to appear worldwide, and has many genomic epidemiologists worried that this might be the next pandemic, but data from GISAID has not appeared as of this post).

We’ll start by looking at the entire progression of mutations since 2020. Time is shown on the x-axis, and the mutations as dots. The default view is by clade, color-coded. Notice that this tree stops in 2025, when GISAID stopped collecting data.

Fortunately, the National Center for Biotechnology Information (NCBI) and its GenBank have continued to collect and post data, and the tree is shown below:

One of the most recent clades is 25I. This corresponds to the genomic clade containing lineage BA.3.2 (nicknamed “Cicada”). BA.3.2 is a descendant of the Omicron BA.3 family and has been placed under active monitoring by public‑health agencies. NextStrain is really an interactive resource, so it’s a little difficult to capture its essence with screenshots, and you are encouraged to go play!

If I click on one of the red dots, I get something like this. We see that a person was identified in Colorado in mid-April. It shows that there are 52 mutations to the “spike” receptor on the protein to which the SARS virus attaches itself. This protein is ACE2, angiotensin converting enzyme-2. A picture of the virus and how it attaches to a host cell is shown later in the post.

We can also zoom in on specific mutations. The graphic below contains more information than we need, but it shows the SARS-CoV-2 virus binding the spike protein (S) of the ACE2 receptor. Mutations in the virus affect how well, or if at all, the virus will bind to the S receptor. Once the virus attaches to the spike protein of the ACE2 receptor, it enters the host cell, does its damage, and then reproduces to go infect another cell. The graphic shows various drugs, like remdesivir, which can disrupt one or more of the processes needed to replicate the virus.

We can look at mutations in the S1 spike protein on the virus. We know, for example, that there was a mutation in amino acid 614 of the spike protein that was suspected of causing an increased amount of binding to the ACE2 receptor. What changed? I asked NextStrain to do a genotype survey, selected the “S” (spike protein), and specified amino acid 614. The color scheme shows a mutation from amino acid “D” to amino acid “G”. We can see that the mutation D614G has persisted to this day, and is incorporated into virtually all of the '“modern” variants of the spike protein on the SARS virus.

What are D and G? These are the one-letter codes for amino acids. Using the chart below, we see that D is aspartic acid, and G is glycine. Viruses with D614G showed higher infectivity in cell culture and higher viral loads in upper respiratory samples. Epidemiological data in 2020-2021 were consistent with increased transmission between people.

We can also look at a map of the distribution of the virus worldwide. We can see that, at the time of this post, that most of the strains of SARS-CoV-2 virus in the US are of the clade 25G (no fancy name), with a smattering of other clades.

The literature suggests that one of the mutations on the spike protein is at position 346, and it’s primarily an R346T mutation (arginine→threonine). Like other mutations, this one facilitates the binding activity of the virus to the ACE2 spike protein.

For the hardcore computational types out there, NextStrain uses a combination of computational tools, mostly powered by Python (including libraries such as BioPython), JavaScript for various visualization chores, and a number of specialized tools, such as Pangolin, which stands for Phylogenetic Assignment of Named Global Outbreak Lineages. The virus was first detected, according to some scientists, in the animal called pangolin, a nocturnal animal found in Asia. Cute,huh?

Source: https://conscious-explorer.com/magazine/conserving-pangolin-worlds-most-trafficked-mammal

As before, computational tools like NextStrain/NCBI/GenBank are best understood if you play around with them. There is more documentation on the site than you might ever use, but it’s there if you need or want it! Have fun! As before, it’s one of my favorite computational resources, even now in our relatively post-pandemic environment.

Next month, we’ll take a look at this thing called scientific visualization, the art and science of rendering massive amounts of raw data into pretty pictures. We’ll look at protein structures, data from wind tunnel experiments, MRI images of a head, and before/after pictures of Mount St. Helen, which erupted in 1980. Come back in July!

References

1. Sanjuán, Rafael, and Pilar Domingo-Calap. “Mechanisms of viral mutation.” Cellular and molecular life sciences : CMLS vol. 73,23 (2016): 4433-4448. doi:10.1007/s00018-016-2299-6

2. https://ncssm.instructure.com/courses/411/files/2036344?module_item_id=512897, ComputingCoVID19_Computing_Genomic_Epidemiology (Jan 2021).pdf, accessed May 30, 2026.

3. https://cen.acs.org/biological-chemistry/genomics/

   genomic-epidemiology-tracking-spread-COVID/98/i17, accessed May

   24, 2020.

4. https://en.wikipedia.org/wiki/Viral_evolution, accessed May 24, 2020

   [4] https://en.wikipedia.org/wiki/Clade, accessed May 24, 2020

   [5] Bacigalupe, Rodrigo. (2017). Population Genomic Analysis of Bacterial Pathogen Niche Adaptation.

5. Hadfield, James et al. “Nextstrain: real-time tracking of pathogen evolu-

   tion.” Bioinformatics (Oxford, England) vol. 34,23 (2018): 4121-4123.

   doi:10.1093/bioinformatics/bty407

6. Elbe, S., and Buckland-Merrett, G. (2017) Data, disease and diplomacy: GISAID’s innovative contribution to global health. Global Challenges, 1:33-46. doi:10.1002/gch2.1018. PMCID: 31565258

7. Korber B, Fischer WM, Gnanakaran S, et al. Tracking changes in SARS‑CoV‑2 Spike: evidence that D614G increases infectivity of the COVID‑19 virus. Cell. 2020;182(4):812–827.e19. DOI: 10.1016/j.cell.2020.06.043 — genomic/epidemiologic evidence for rapid global rise and association with increased infectivity.
   https://doi.org/10.1016/j.cell.2020.06.043

8. https://www.who.int/docs/default-source/coronaviruse/25062025_xfg_ire.pdf, WHO TAG-VE Risk Evaluation for SARS-CoV-2 Variant Under Monitoring: XFG, accessed May 30, 2026.

Many years ago, I received a small grant from the Fox Family Foundation [1], a small funding agency here in the Durham, North Carolina area. This grant was designed to provide support for a project in computational agriculture, specifically a project involving soil erosion and water runoff. When I came to the North Carolina Supercomputing Center in 1996 from Washington DC, my first visit was to a local high school was to Pittsboro, North Carolina, located about 10 miles south of Chapel Hill, the location of one of the best universities in the world. I was invited to come talk to a group of students about supercomputing and its role in the sciences. I figured that since this high school was so close to the University of North Carolina, most of the students would be the children of university faculty.

I realized my mistake when I drove into the parking lot. Probably 90% of the cars in the parking lot were working farm trucks, and a majority of them had license plates that said “Farm Use Only”. Needless to say, my talk on the role of supercomputing in the study of computational chemistry did not go over very well. I realized that if I was going to reach my goal of bringing computational sciences to high school students in a very rural state like North Carolina, I was going to have to come up with projects that were more suitable and relatable to the students that I would be working with. Because of this experience, I submitted a proposal in computational agriculture to the Fox Family Foundation. What came out of that was the project called “Farmer Mark's Field”.

“Farmer Mark” (Waller) is a local Durham tobacco farmer whose family has worked the farms in Durham for many generations. Mark would not only farm his own family farm, but he would also do contract farming all over Durham County. There was many a morning driving to work where I got stuck behind Farmer Mark or his dad in one of their tractors going to one of the outlying farms in Durham County. I figured out pretty quickly how to time my departures to avoid getting stuck behind them! Farmer Mark no longer grows tobacco, but he has transitioned his family farm into an eco-tourism “pick your own strawberries” attraction that is very well-attended.

The Waller family Farm is located at the intersection of Mount Sinai Road and Kerley Road in Durham County. It's a small tract of of land. The field is shown in the image below, with a small pond immediately to the east of the field. There is a large elementary school just south of the field across Mount Sinai Road.

The second image below shows a three dimensional viewpoint of the field with the school and the bottom part of the photograph. It's a little hard to see here, but there is decidedly a northwest to southeast corner slope to this field.

For this project, we superimposed, a topographic map over top of a drawing of the field. We divided the topo map into a matrix of five columns and 10 rows. Each box is 10' x 10'. You can see in the graphic below that the topographic lines are roughly in two foot segments. You can see the 380’ and the 370’, so the lines in between 370’ and 380’ or 372’, 374’, etc. Then, we put a dot in the center of each of the boxes. What the students did at this point was to assign an estimated elevation value to each one of the 50 boxes. In order to do this, they needed to learn some estimation skills. Most of the dots do not fall directly on a elevation line.

The data for the elevation markings for each of the 50 boxes was entered into a Microsoft Excel spreadsheet. The grid layout above was designed explicitly so that a correlates to Microsoft Excel, with row numbers and letters at the top of the columns. You can see the results in the graphic below.

Then we used a slope formula, where we took the maximum value and the minimum value, subtracted them, and then divide them by the max value. All of this was multiplied by 100 to give us a percentage. You can see that the results of this calculation shows a 7.4% slope. We also graphed this using a 3D plot in Excel to show a downward slope from the northwest corner down to the southeast corner. You can sort of see this in the 3D photograph above, but it’s really hard to see in the aerial pictures. If you were to stand on the field, you could decidedly see the slope going from the northwest corner down to the southeast corner.

Now that we have a profile for the field, based on elevation, and we have determined the slope, now we can start looking at using a computational soil erosion model to look at water runoff, and the amount of soil erosion that's happening in the field. To make these calculations, we use the Water Erosion Prediction Project, or WEPP (https://milford.nserl.purdue.edu/), out of Purdue University.

Almost all of these soil, erosion models use the Universal Soil Loss Equation, or USLE. The screenshot below comes from Wikipedia, and shows some of the mathematics for this soil loss equation. There are a number of variations for this equation, and there's discussion in the agricultural community as to which model is the most accurate.

In the model interface, shown below, we set our parameters in the panel on the far left-hand side. We are in North Carolina, so we have pulled that on the drop-down menu. The closest weather station to us in Durham is in Chapel Hill, so we've selected that for our weather/precipitation option. From our topographic map, we know that our field size is 100' x 50'. We also know from our topo map and our Excel calculations that we have a uniform slope and a slope of 7%.

Now we have to decide what soil type we are dealing with in Durham County. There is a type of soil called Durham, so we have chosen that option. We also have to choose a field or farming management option, what the farmer is going to do with the field. I have chosen to leave the field fallow, or unplanted, and also not tilled (plowed).

Once we calculate the USLE, we get the results in the panel on the right hand side. We can now see the soil and water runoff numbers on the bottom part of the right hand panel. Notice that we have about 43 inches of precipitation per year. We have about four inches of average annual runoff and we have about 2.2 tons/acre/year of soil loss. Our average sediment yield is about 2.2 ton/acre/year, which represents sediment actually leaving the source area (not just eroded soil), accounting for deposition and storage within the basin. Given that our average annual runoff, and our average sediment yield are the same, almost all of the soil is leaving the field and going somewhere else. What we see in the graph at the bottom right is the cumulative soil loss over 100 feet.

We can look at a text summary of some of this information that helps us sort of drill down and see where the average annual runoff is coming from, and where the annual soil loss is coming from. For example, we can see that most of the soil loss is coming from rainfall, but some of it is also coming from snow melt or other winter conditions.

We also should talk a little bit about the soil type (Durham) and the management style (we picked fallow in this case). For Durham soil, our soil is known as LCOS, Loamy Course Sand. Notice that our soil, especially at the top layer is 83% sand and only 1.25% organic material. It also has a fair amount of rock in it. In Durham, all the gardeners joke that our soil is like kitty litter. I am not a gardener, but I am the hole digger for my wife's garden, and I can attest to how hard it is to dig into Durham type soil!

The study of soil types is a project in and of itself, and it is a fascinating area of science. We can show a soil triangle; notice that Durham soil is in the far bottom left corner, where we are mostly sand, and a small percentage of clay. It's not very good soil for planting things, so we spend a lot of time at the garden store buying topsoil.

Now we're going to ask Farmer Mark to actually do something in his field. He plants strawberries, so there are a number of tillage or management systems that he can use. Strawberries are not an option in the pulldown menu for tillage types, so we're going to plant barley, a type of grain. We're going to use conventional tillage, with a technique called Palouse, a management system that is well suited for hilly terrains. The table below shows what Farmer Mark should be doing, and when. Notice that he starts around April 1 and is done by October.

Let's take a look at our results for planting barley with conventional village. Notice that we have significantly less runoff, from four inches per year to 2.6 inches per year. Also noticed that soil loss and sediment yield are much reduced compared to leaving the field fallow.

I can also use the WEPP worksheet to calculate the effect of multiple management styles for my conditions. The graphic below shows a number of them, and you can look at the soil loss to see which management style might be the best. When I had the kids do this, they would find the best option for lowest soil loss, but we also talked about the fact that the best management style may not be one that is economically viable for the farmer. At that point, they were asked to look at management styles that might make some money for the farmer, and then compare those.

The Farmer Mark’s field Project has been used with hundreds of middle school and high school students over the years, and has been presented multiple times at conferences like the National Science Teachers Association and the North Carolina Science Teachers Association. The skills that students learn in this model are very diverse, and it's a project that resonates very well with many students, especially here in the farming state of North Carolina. Project materials can be found at: https://ncssm.instructure.com/courses/411.

Next month, we're going to take a look at some computational biology, specifically how viruses mutate over periods of time. We’ll take a look at the SARS-CoV-2 virus that was responsible and is still responsible for COVID-19, and will also take a look at the flu virus. Hope you can join us!

And many thanks to the Fox Family Foundation for their funding support for the Farmer Mark’s Field project!

References:

1. Fox Family Foundation, https://foxfoundation.org/

2. USLE, https://en.wikipedia.org/wiki/Universal_Soil_Loss_Equation

”Farmer Mark’s field” is a computational project designed to help students study various aspects of an agricultural system, specifically ground water runoff and soil erosion. In this case study, you are asked to collect data, analyze that data using a spreadsheet and then, using the results of their spreadsheet, run a soil erosion/agriculture m…

Read more

As I’m writing this, I’m sitting in a lovely hospital bed on the 4th floor of Durham Regional Hospital (an affiliate of Duke Medical Center, or “Little Duke” as it’s known in town). I’m here getting treated for issues related to my myasthenia gravis. MG is an autoimmune neuromuscular disorder, resulting in various muscular symptoms, such as eyelid drooping (dysplopia), difficult swallowing (dysarthria), and difficult speaking (dysphagia). My particular disorder is “ocularbulbar”, meaning affecting the muscles in the head and the neck, the most common type of MG, hence the symptoms in those areas.

The cause for this disorder is that my body’s own antibodies block a neurotransmitter called acetylcholine from binding to muscle fiber receptors, resulting in reduced muscular function. . The graphic below shows the release of acetylcholine (Ach) being released from a neuron and binding to the acetylcholine receptor (AchR) on the muscle that triggers contractions. In my case, my own antibodies are blocking access to those receptors, reducing the ability of my muscles to do what they are supposed to be doing. Bummer.

Acetylcholine is an endogenous molecule, meaning it’s not a drug we take — it’s already in our body. It’s an organic molecule, meaning it’s primarily carbon (C), but also with some nitrogen (N), oxygen (O), and hydrogen (H). I show two representations, one an expanded chemical formula showing the bonds, and one “ball and stick” model, where the carbons are gray, oxygens red, nitrogens blue, and hydrogens white.

Because acetylcholine is a pretty important neurotransmitter for muscle function, and I have antibodies blocking the receptors, I need as much acetylcholine as I can get. Unfortunately, acetylcholine undergoes a chemical reaction in the brain that breaks it down to acetate and choline. The chemical that does this is a protein called “acetylcholinesterase”, an enzyme (I know this because the name ends in “-ase”).

So, I take a drug called pyridiostigmine (“Mestinon”), shown below. This is an acetylcholinesterase inhibitor, and it prevents acetylcholine from breaking down into its two products. Yay for me, more acetylcholine. I notice within 30-45 minutes after taking this drug that things are working better. I can swallow, open my eyelids pretty much all the way, and talk to my wife and students with them being able to understand me. That’s a good thing.

But hey, most of you are healthy and pharmaceutical chemistry is not a central part of your daily life, like it is mine. Sure, you might pop a couple ibuprofen when you’ve been a little overzealous in the gym, but you don’t plan your life around medications. So, we’re going to use an example of how chemistry works in YOUR everyday life that does NOT include drug chemistry. That’s sort of the point of this post — chemistry in everyday life.

When I was thinking about this post, I probably had 18 or so examples of how chemistry is important to YOU in your everyday life; choosing one was a bit of a challenge. I looked at topics such as batteries, baking and cooking, microwave ovens, and several others. I finally settled, however, on a topic that is a little more interesting (at least to me): how self-darkening, or photochromic, glasses work. It’s really interesting chemistry, and lends itself to the use of computational science, which is, of course, the entire point of Confessions of a Computational Scientist. The other topics are OK, but not really targets for computational chemistry.

Many people who wear glasses don’t like to have to carry two pairs of glasses, one for inside, and one for outside in the sun. Me, I’m cheap, so I use clip-on sunglasses, which my wife hates, says they make me look like a dork. She’s not wrong.

Self-darkening sunglasses, as the name suggests, are those glasses that change color (darken) in response to ultraviolet (UV) light, the light coming from the sun. Self-darkening glasses contain a photochromatic (photo: light; chromatic; color) chemical compound known as napthopyran. This compound is a relatively large organic (carbon-containing) compound that contains five rings with an oxygen atom embedded in one of the rings (see the graphic below). Upon exposure to ultraviolet light, one of the oxygen bonds breaks (the red-colored bond in the napthopyran, connecting the oxygen to the rest of the molecule), resulting in a lengthening of the structure. This new compound, indendonapthopyran, has different properties than the napthopyran. Specifically, napthopyran only absorbs radiation in the UV range of 200 nanometers (nm), while indendonapthopyran absorbs radiation in both the UV region and in the visible region (400-700 nm).

Notice in this reaction that the reaction arrows point both ways. This means napthopyran can turn into indendonapthopyran, and indendo can turn back into naptho. Cool.

It might be useful to back up a little and do a little science review. If you know this part, skip ahead!

Atoms and molecules (combinations of atoms) contain electrons, very small negatively charged particles that are found near the nucleus of an atom, which is positively charged. Electrons live in “orbitals”, which represent energy levels. Each orbital can have a maximum of two electrons; think of an orbital as a two-seater sports car. When they occupy the same orbital, they must have opposite spin, a guy named Pauli said that. We represent the electrons with arrows, and the direction indicates spin.

Electrons want to be in the lowest energy state possible, sort of like the teenagers that I teach. On the lefthand side of this graphic, electrons are in the ground state. If I hit the electrons with light energy, represented by the “hv” notation, one (or more) of the electrons will “jump” up to a higher energy level, the excited state. Take away the light energy, and the electron(s) will return to the ground state. You don’t need to worry about the other notation stuff, such as “n” and and the “pi/pi*” symbol.

In our case, the light energy that is hitting the electrons comes from the sun, and has several types: ultraviolet (UV), visible, and infrared (IR). As we move from left to right on the UV-VIS-IR section of the electromagnetic spectrum shown below we have UV (UVC, UVB, and UVA), visible, and infrared. Going from left to right, the shorter wavelengths of UV radiation get longer, until they become long IR wavelengths. If we were to look at the entire spectrum, we’d see that even longer wavelengths are microwave and radio waves. Both useful in everyday like. I use both everyday in my microwave oven and in my car radio. So do you. Yay, chemistry (rats…I should say physics):

Notice that we have different types of light energy coming from the Sun: ultraviolet (UV), visible, and infrared (IR). We can only see the visible light, and going from right to left, we use the acronym ROYGBIV to remember the order: red orange yellow green blue indigo violet. IR radiation, which goes from 700 nanometers (nm) to about one (1) millimeter (mm) in length of the wavelength, can cause skin burns and damage to eyes.

For glasses, we are interested in the UV side of the spectrum, which goes right to left (longer to shorter) in wavelengths from 400 nm to 100 nm. There are three varieties of UV radiation: UVA, UVB, and UVC. Each corresponds to a part of the UV wavelength range, with UVA having the longest wavelengths and UVC the shortest.

Now it’s time to bring computational chemistry into play to study photochromic glasses (the paid subscribers will do these calculations directly; I’m showing you results here).

Using our computational chemistry server (http://chemistry.ncssm.edu), we build each of the molecules shown above: napthopyran and indendonapthopyran. Once done, we request that the comp chem server perform an “Excited States and UV-VIS” calculation using a piece of quantum chemisty software known as Gaussian16 (https://gaussian.com/). We use a technique called ZINDO: Zerner’s intermediate neglect of differential overlap, which, if you are a computational chemistry student, you will spend time learning about. Luckily for you, you’re probably NOT a computational chemistry student, so you don’t have to learn it. Phew!

We asked the server to calculate 40 different excited states. The more you do, the more accurate your results will be, but more calculations also requires more compute time. More would be necessary if you were doing research for publication, but it isn’t for a teaching unit.

Here’s what the server told us: it said that most of the UV radiation was absorbed in Excited State 22 (out of 40). Lots of data here, and I won’t do all of it, but here’s the important stuff. The “f” number — 0.5047 — is the oscillator strength, a measure of the impact of the UV absorption. The other oscillator strengths were much lower, suggesting that they were not very important. The associated wavelength for this is 207.56 nm. Looking back at the UV-VIS-IR spectrum above, this puts us pretty squarely in the UVC range. In this range, the glasses are absorbing UV radiation at that wavelength, and our glasses are clear.

We can show these results as a graph, with the wavelengths on the x-axis, and the oscillator strength on the y-axis. There is clearly a big peak at a little over 200 nm, and I could zoom in to see the 207 nm explicitly.

Now we do the same thing with the indendonapthopyran. Like with the napthopyran, we see a peak around 210 nm or so, but we also see a peak around 420 nm. Take a look at the UV-VIS-IR spectrum above. Where is 420 nm? It’s in the visible part of the spectrum. So the 210 nm is the napthopyran — the closed form of the compound, with the oxygen bridge intact — absorbing UV radiation, and the 420 nm is the indendonapthopyran —the open form of the compound with the oxygen bridge broken — absorbing the visible radiation. 420 nm is dark, violet-bluish, so the glasses appear dark. [NOTE! If you were to look up these numbers on Wikipedia or ChatGPT, they would be lower; the calculations from the comp chem server have some amount of error, so when we do a calculation using excited states/UV-Vis, we typically apply a “fudge factor” of about 11%, getting us to about 380 nm for the indendonapthopyran value that you would see in ChatGPT for experimental data.]

These kinds of computational studies allow us to study individual atoms, individual molecules, or, in this case, reaction mechanisms, such as the absorption of electromagnetic energy in the naptho-indendo reaction. There is a strong connection between what an experimental (bench) chemist does and what a computational chemist does. Computational chemists can run "theoretical” experiments, which can tell us that a chemical system or reaction can exist or happen. If our results suggest that the system/reaction won’t work, then we save the experimental chemist a great deal of time and expense. Getting back to the original conversation in this post, finding a new drug used to be egregiously time-consuming and slow. Now, we can use computational methods in drug design and discovery (a course I teach) to screen thousands and millions of potential drugs (a method known as high-throughput screening, or HTS). If our computational results suggest a “hit”, THEN we can go into the lab, synthesize that drug, and start testing it in Petri dishes, small animals, and, hopefully, eventually humans.

OK, thanks, I feel better. I’ve presented a number of different topics in Confessions, and it’s nice to “run home to Mama” every once in a while — after all, I am a computational/physical chemist. I love the “xkcd” cartoon series, and this cartoon on “purity” is pretty funny, but it’s also really true. What you saw in the UV study is just applied physics, specifically quantum physics. Us chemists like to say “chemistry is the central science”, then the physicists remind us the chemistry is just the “physics of electrons”, and then the math people stomp on all of us. Fortunately or unfortunately, the mathematicians win.

Next month we’re going to cross back over into the social sciences, and take a look at computational history. We’ll look at using computational tools to study the Civil War and also take a look at presidential elections from the past two or three cycles.

On the paid side, folks will use a real computational chemistry server to do a case study on the photochromic glasses. Join us! Until next time, have a great April, and don’t forget your taxes!

In this case study, we are going to use computational chemistry to look at an item that many people use on a re…

Read more

Two years later, we’re back in school. During the intervening summers, because we had to cancel all of our summer programs, I developed a two-week online course entitled “Computing COVID-19”. In this course, we spent a week on the structural/molecular biology of the SARS-CoV-2 virus and a week on the drug design and discovery of COVID-targeted drugs. The course attracted over 100 students and was also offered to a group of senior citizens through Duke University's continuing education program. [The course is available at https://tinyurl.com/gotwalsoutreach.]

Needless to say, computational epidemiology was a critical component of this course, both in general epidemic modeling and in genomic epidemiology, where we examined how the SARS-CoV-2 virus was mutating and spreading over time and across space.

This post will describe the basics of computational epidemiology, starting with the simplest algorithm: the SIR model. The SIR model was developed in 1927 (!) by William Kermack and Anderson McKendrick, who were the first to develop a mathematical model based on differential equations. These equations, which are sometimes classified as systems dynamics or systems thinking, describe a population divided into three groups, or compartments:

1. Susceptible: healthy people who are able to get the disease if exposed.

2. Infecteds: people who have the disease.

3. Recovereds: sick people who have gotten better.

This model assumes that once recovered, you have immunity from further infection. One of the key questions in the early stages of the COVID-19 pandemic was whether or not, once infected with and recovered from COVID-19, you could get it again. Unfortunately, we quickly learned that having COVID-19 did not protect you from reinfection.

The equations below are the classic Kermack-McKendrick SIR model. The triangle represents the Greek letter delta, meaning a “change in”. Most textbooks show the Greek letter as a “d”, so you will more typically see “dS”; typesetting the Greek letter is sometimes problematic. This means that the susceptible population is changing over time, or as a function of dt, the change in time.

On the right-hand side of each equation, we show the mathematics that describes how susceptibles change. Notice that it starts with a minus sign, indicating that this population decreases over time. The lowercase variable “r” represents the infection probability, the likelihood that, if exposed, you will get the disease. This value varies by disease, and these constants are available from organizations such as the Centers for Disease Control (CDC) in Atlanta, GA (well, they used to be available, but everything coming out of that organization is probably suspect these days!).

The infection probability is multiplied by the number of susceptible people at a given time. So, for example, if we are running the model for 30 days, the change in susceptibles differs at Day 10 from that at Day 20. Same for the infected population.

Notice that the same mathematics — rSI — is seen as a positive value for dI, the change in the infecteds. This means that susceptible people who are now infected are added to that population. But, infected people also recover, and that’s the aI, where “a” is the recovery rate, again, determined by the disease. There is no value of “a'“ for diseases like AIDS, because there is no recovery. Notice that aI is a subtraction, meaning a decrease in that group. Finally, for dR, the recovered infected people are added to the recovered population based on the aI value.

This is what is known as a closed model: we start with a fixed population, no one comes in, no one goes out. Nobody dies in this model; you start with some number of people, and you end up with the same number of people.

For these models, you need some starting values, called “initial values”. These are measures of how many people, in our case, you have at the beginning of the model, typically known as “Time 0”. We’re going to model 48-hour flu in a closed population boarding school, such as mine. Between students, faculty, and staff, we have about 1000 people in the building. We set our S0 — our initial number of susceptibles — at 999 bodies. Our I0 is set at 1; a kid returns from break with the flu. Our R0 is set at 0; nobody has recovered yet.

We also have to decide on some model settings. We’re going to run our model from Time 0 to Time 30, with units in days. We need to set our “step size,” which is the time interval at which the model is recalculated. We’ll set our dt at 0.25, which means the model recalculates every six (6) hours. And because we are using differential equations, those need to be solved using integral calculus. We have a variety of integration methods at our disposal. Depending on how old you are and how far away from college calculus you might be, you might recall Euler’s Method. It’s a terrible method, but we teach it because it’s easy. In 40+ years of running these models, I’ve never ever used Euler’s. I always use Runge-Kutta 4 (RK4), a much more robust integration method.

I have a variety of options for computer software to implement this algorithm. I can use standard programming tools such as Python or R; I can use computer algebra systems such as MATLAB or Mathematica; or I can use specific software packages that are designed to solve time-based differential equations, and that’s my choice.

My preference is STELLA Architect (Systems Thinking with Experimental Learning Lab Activities), sold by ISEE Systems. We have a site license at school, but it’s ridiculously expensive. Because I want the paid subscribers to be able to actually build some of these models, I’m going to use Vensim PLE, which is free for personal and educational use. It looks pretty much exactly like STELLA, so it’s a good option.

OK, so I built the model in Vensim, and it looks like this:

Each box is called a stock, and it “holds” people. The flows — a pipe-like arrow — represent the movement of people from one stock to the next. We have a flow that I’ve called “get sick”, and it represents the rSI part of the algorithm. We have a flow called “get better” that represents the aI part of the algorithm. The blue arrows represent inputs: for “get sick”, we need to know the infection probability (a), the current Susceptible population (S), and the current Infected population (I). S is defined as 999, I as 1, and R as 0 at the start of the model. The infection probability is defined as 1/500, the standard CDC value for flu, which means that, all things considered, you have about a one in 500 chance of getting the flu if exposed. The recovery rate is defined as 1/2, since this is the 48-hour flu, and our model is in days. Do the math!

OK, so what happens when we run this model? We get the classic SIR graph:

Of particular note is the “epidemic hump”, showing that, around late in Day 5, we have a significant number of sick people, a little over 400. Eventually, because it’s a closed population, pretty much everyone recovers.

What happens, however, if we vaccinate some very small percentage of the healthy people? In this modification, we vaccinate 10% of the susceptibles and observe that we significantly “flatten the curve,” meaning we reduce the number of infected individuals. This modification is a bit too simplistic to have scientific validity, but it does show that vaccinating some percentage of the population yields real benefits. Because this is a closed community, it’s not a realistic portrayal of what happens in a population in which people are being born, people are dying (either from the disease or natural causes), and other parameters are in play.

Needless to say, these models can become very complicated very quickly. Below is a representation of a variation on a theme, the SEIR model, in which we introduce the population “Exposed” (E) to the mix. In this model, we do not have a closed population — each group of people can die (either from disease or other causes). Notice that susceptibles are vaccinated and move directly to the recovereds box, and that this model implies immunity once in the recovereds box.

There are a wide variety of variations in the SIR model, such as:

1. Death-specific models: people die of natural causes separately from death from disease.

2. Vaccination models: SIRV would be an example, and the model above is really SVEIR.

3. Quarantine/Isolation models: SEIQR

4. Age-structured models: These models recognize that different ages of people experience epidemics differently, and we saw this painfully in the COVID-19 pandemic. My 96-year-old mother was one of those who passed from COVID-19, having a very weakened immune system compared to a 40-year-old.

I’m not a huge fan of AI, but I did ask ChatGPT to come up with a comparison table, and it’s pretty interesting:

This post has already gotten longer than normal, so we’ll only briefly mention genomic epidemiology. This is where you can track the changes, or mutations, in a virus such as SARS-CoV-2 over time and place. To do this, you can use a resource called NextStrain. You can track multiple viruses. The link goes directly to the SARS-CoV-2 virus. What see are mutations over time.

A screenshot from NextStrain looks like the graphic below. Notice the expansion of the mutations from 2020 to the present. Different strains, such as Omicron, are identified along the axis.

Clicking on a specific node will show you where that mutation was found, when, by whom, and in what population. It’s a fascinating exploration, and the interested reader is encouraged to do so. If you need guidance, there is a PDF entitled “ComputingCoVID19_Computing_Genomic_Epidemiology.pdf” on the outreach site mentioned early.

Next month, the plan is to “run home to Mama”, a return to computational quantum chemistry. I love being a computational chemist, and there is so much to talk about in that domain! See you next month!

The SIR algorithm is a series of three coupled ordinary differential equations (ODEs), coupled because there is the same chunk of “mathematical stuff” connecting two …

Read more

Read more

Our biggest group was the environmental sciences group. Their primary area of study was in air quality modeling (AQM) and numerical/computational weather prediction. One of their big projects was helping to develop “NC WeatherScope”, a weather prediction tool for WRAL, our local news station. The partnership between WRAL and NCSC was particularly unique. Not only did NCSC provide compute cycles, but its mathematicians and computer scientists were heavily involved in solving the sparse matrices that are used in weather prediction. Sparse matrices are datasets with rows and columns, with the majority of the entries being zeros. For numerical weather prediction (NWP) models, they are essential mathematics.

Speaking of mathematics, most environmental models are based on the passing of time, and are represented with differential equations. “DiffyQ’s” describe the change in some quantity based on something else changing, in our case, time. One of the classic environmental science models is the NPZ model: nutrients (N), phytoplankton (P), and zooplankton (Z). This model measures the concentration of inorganic nutrients (such as nitrates), the biomass of the phytoplankton, and the biomass of the zooplankton. Nutrients are produced from various sources, such as runoff from farms and lost by flushing and sediment burial. Phytoplankton grow based on the nutrients available, and there are various mathematical mechanisms by which this can be calculated, such as Michaelis/Menten or Monod kinetics. Zooplankton graze on the phytoplankton, and both phytoplankton and zooplankton can die and be recirculated back to available nutrients. All of this takes place in a well-defined water column, such as a lake or river.

The differential equations are shown below. We measure the change in nutrients (d for “delta”, or “change in”) over time, dN/dt. Likewise for phytoplankton and zooplankton. The model contains a number of parameters, such as “mu_max” (looks like a “u” below), which represents the growth rate of the phytoplankton. Each part of the function on the right describes flow into or out of the measured quantity. For example, the very first chunk of math for dN/dt shows the flow of concentration of nutrients out of N because the phytoplankton are consuming those nutrients. You can see the same math as a positive value in the first part of the dP/dt function:

We use R/RStudio to model this, using a special package/library called “deSolve” to solve the differential equations. We set the various parameters are follows:

# Parameters (example set)

par <- c(

mu_max = 1.0, # 1/day

KN = 0.5, # nutrient half-sat

g_max = 0.6, # 1/day

KP = 0.7, # grazing half-sat

mP = 0.05, # 1/day

mZ = 0.03, # 1/day

gamma = 0.7, # assimilation efficiency

rho = 0.7, # fraction of phyto mortality recycled to N

eps = 0.9 # fraction of zoo mortality recycled to N

)

We ran the model for 200 days, getting these results:

The model shows that the phytoplankton consume a lot of the nutrients quickly, and grow rapidly, and the zooplankton follow suit, but as the nutrients are reduced, the phytoplankton and zooplankton die out fairly quickly. Without a constant influx of nutrients, the phytoplankton and zooplankton don’t survive.

We don’t have that problem in North Carolina. NC is a major producer of hogs, and hogs are a major producer of hog poop. The majority of hog farms are on the banks of the Neuse River, which starts in my hometown of Durham, NC and touches many of the “larger” cities in NC, including Raleigh, Smithfield, Goldsboro, Kinston, and New Bern, eventually ending up in the Pamlico Sound and the Atlantic Ocean.

We can model the Neuse hog poop flow using a systems dynamics tool called “STELLA”, from ISEE Systems [1]. The boxes represent the amount of poop in that particular city. Poop moves from one city to another based on the volume of water n that city, the flow rate, and how long the poop “dwells” in that city. We can change the amount of poop and the frequency of poop discharge in each city. Eventually, the poop ends up in the Pamlico Sound, which is unfortunate, because another major industry in NC is tourism, and the Pamlico Sound and the beaches near it are major tourist attractions.

This process is summarized well by ChatGPT:

Hog farm waste → elevated nitrogen & phosphorus in water → enhanced nutrient availability for phytoplankton → increased primary production / algal blooms → changes in zooplankton dynamics. Nutrient-driven eutrophication alters planktonic food webs, with potential cascading effects on water quality and higher trophic levels.

The various blooms and increases/decreases in the biomass of various organisms in the water can affect the amount of oxygen dissolved in the water (DO), which fish need to breathe. Fish need about 5 mg/L of oxygen to survive. The model below shows the variations over 24 hours of dissolved oxygen in a hypothetical body of water. We can see various processes, such as photosynthesis and turbulence, which increase dissolved oxygen, and processes such as biochemical oxygen demand, fish respiration, and release to the atmosphere, which reduce it. The model shows a general increase in DO over 24 hours. If, however, the temperature is higher and/or there is no turbulence, or if the biochemical oxygen demand is high, the DO would be too low to sustain fish. We periodically have “fish kills” in North Carolina, especially when we get hit with a hurricane and the hog waste flows right into the Neuse or other bodies of water. When this happens, the microorganisms in the water use existing oxygen in the water to decompose the poop, and that’s biochemical oxygen demand (BOD). This is an oxidizing, or oxygen-dependent, chemical reaction. BOD in hog “lagoons” can be as high as 1,000-20,000 mg/L.

And it’s not just the water that is affected by our hog lagoons. Hog wastes produces volatile organic compounds (VOCs), which directly affect our air quality by changing the production of ozone in the atmosphere.

In the late 1990’s, my computational science group implemented an early generation air quality model called EKMA, the Empirical Kinetic Modeling Approach. This method was implemented using a software package called OZIP, the Ozone Isopleth Plotting package. This package allowed users to test various scenarios, such as increasing/decreasing concentrations of VOCs and nitrogen oxides, such as NO and NO2. Based on the ratios of these atmospheric gases, we could predict how much we would need to reduce one or another to get to a target ozone concentration, measured in parts per million (ppm).

The sample scenario below shows a target of 0.24 ppm (extraordinarily high —the safe value is 0.07 ppm). With a ratio of eight to 1 VOC to NOx, if we change our NOx by 20%, we would need to reduce our VOCs by 75% (!) to get to a remotely safe value of 0.12 ppm ozone. Running these models demonstrates how difficult it is for states to achieve within-range air quality scores. States who are in “non-attainment” are responsible for getting the state to legal levels, and they do so by fining polluters, such as power plants and factories. The graph shows isopleths, lines of equal concentration. For example, the 0.12 ppm isopleth shows the concentration of ozone at various concentrations of NOx and VOCs (NMOCs)L

Air quality models are extraordinarily complicated, as suggested by the graphic below. We have to understand the chemical reactions happening, such as photolysis and oxidation, as well as issues such as transport and phase change. It matters if we are trying to predict local air quality, regional air quality, or global air quality. [Side note: we developed the implementation of the EKMA/OZIP model as a part of an EPA grant to help re-train environmental scientists to be able to do air quality modeling (AQM), because the need was so great. We developed a series of six courses to atmospheric chemistry and air quality modeling. The company doing this work, the Shodor Education Foundation, has closed its doors, so the link and/or the models on tose pages may not work. We are looking to “rehome” these resources.].

The EKMA/OZIP model uses a variety of methods to calculate concentrations of atmospheric gasses, such as VOCs, NOx, ozone, and carbon monoxide/dioxide. For example, we can use a Langragian approach, which follows a column of air across a terrain. Pardon the poor quality of graphics — I drew this in the late 1990s, graphics tools (and my skills) weren’t quite as good as they are now! We can follow a column of air as it moves across the terrain, picking up chemicals and other factors as it moves.

We can also use an Eularian model, which divides some area into grids. On each grid, we have a box, shown in the second graphic. In that box, we can measure inputs and outputs, chemical transformations, emissions from power plants and hog farms, and study the effect of prevailing winds and solar radiation on each of the boxes on the grid.

Air quality models have grown in sophistication since the early generation models suck as EKMA/OZIP. Newer tools, such as CMAQ (EPA) and WRF-Chem (National Center for Atmospheric Research, NCAR), provide significantly more robust and integrated tools to consider a wide variety of factors in predicting air quality.

Speaking of integrated, one take-away from this post: what happens in the water affects what happens in the air. What happens in the air affects what happens in the water. These systems are very complicated, and it’s often the case that computational models emphasize one or the other, which means they are too simplistic and may not represent what is really happening. Fortunately, organizations like NCAR have numerous high-performance computers (supercomputing) that allow for multiple-system models to operate and “talk” to each other. Unfortunately, the current administration is trying its best to reduce or eliminate organizations such as NCAR, because of their emphasis on climate change science. From the Washington Post [2]: “The situation [NCAR budget reductions] remains contested: the administration/OMB announced a review and restructuring intent, lawmakers have mobilized to protect NCAR in appropriations/negotiations, and the outcome depends on ongoing NSF/agency actions and Congress’s appropriations language. Agency‑level details and formal decisions (e.g., specific reorganization steps or timing) were still [as of this writing] in flux publicly.”

One take-away that I learned from my work in air quality modeling and meteorology: I will never again criticize meteorologists on the 6 o’clock news, now that I understand how complicated weather prediction is. The number of variables/factors that must be considered to get it right are huge, and it’s actually surprising that they get it right as regularly as they do! So be NICE to your local meteorologist!

In the paid subscriber’s post, we’ll look at a Gaussian Plume Model, an air quality model that studies the effect of polluted air coming from a smokestack and its effect on people living downwind from the emission. Join us!

In March, we’ll return to the 2020s (sorry) and look at the spread of disease — epidemiology, including the use of genetic epidemiology tools to study the progress of mutations in viruses such as SARS-CoV-2 and the flu!

References:

1. isee systems. Stella Architect. Version 1.6.2, isee systems, n.d. Web. 29 Jan. 2026.

   https://www.iseesystems.com

2. https://www.washingtonpost.com/climate-environment/2025/12/17/trump-national-center-atmospheric-research-climate/

My school’s response was to call me into the office with this offer. I complained loudly that I was a computational quantum chemist, hadn’t studied biology since college (1975), and thus wasn’t the right person. The administration, however, couldn’t get past the “computational” part of “computational biology”, so I was voluntold to be the lead on this project. I recruited three of the better students from the Research in Chemistry program, with the permission of that instructor, and, for the first year, they alternated between doing their very advanced chemistry research and, along with me, learning the technologies, techniques, and tools of quantitative biology and bioinformatics.

After the first year, recognizing the unsustainability of students “double dipping”, we formalized the program in the class “Research in Computational Science”, which also included students doing independent research in other computational areas. The Jax Lab program continued for 10 years, at which time the NIH funding ran out. 10 years is a good run for anything coming from NSF or NIH!

So what did the kids do? Mostly, they conducted quantitative trait loci (QTL) analyses using a special package in R/RStudio called “qtl”. Quantitative trait loci is a statistical technique used to identify locations on chromosomes (hence, loci) that might contain a gene or genes that are responsible for a specific phenotypic trait (hence, trait!) such as hypertension, obesity, or Type II diabetes. Our group focused on obesity and Type II diabetes.

To conduct our studies, we used cross data between two strains of mice. Our data was a cross between a BTBR mouse, a mouse that is genetically engineered to exhibit characteristics such as obesity and Type II diabetes. It’s also used in autism studies. The BTBR mouse was crossed with a generic mouse, the C57Bl/6J, the famous “Black 6” mouse, that contains a normal mouse genome. The BTBR mouse is shown in the top graphic, with its characteristic white stripes, and the C57Bl/6J mouse is shown below. Cute,huh!

A cross of these two strains is shown below, in this case looking for phenotypes of social behavior. This particular cross shows an intercross, in which the children of the parents are mated with each other, to produce subsequent generations of offspring. Typically, data analysis is done on the 20th, or F20, generation of mice. By that time the mice are genetically identical. Sometimes a backcross is done, in which an child mouse is mated back to its parent. You should be understand why we do this with mice and not humans!

Source: https://www.researchgate.net/figure/Study-design-A-and-B-Intercrosses-of-BTBR-and-C57BL-6-mice-were-performed-to-produce-F2_fig1_275046974

For a QTL analysis, we’re looking for a region on a specific chromosome that might contain a gene(s) that are statistically indicative of causing a specific phenotype, such as obesity or T2 diabetes. The graphic below shows a cartoon example. On the chromosomes of each parent, we have identified genetic markers — short regions of DNA, about 200 base pairs in length. These markers are not equally spaced (as are mile markers on a highway), but are at specific locations on a chromosome. The location of these markers is quantified by identifying its location in units of centiMorgans (cM). If we can identify a region of interest and its proximity to one or more genetic markers, then we can use more powerful gene location tools to hone in on a specific gene(s) of interest.

Source: https://passel2.unl.edu/view/lesson/aa527da941e0/3

To do this, we need data. The graphic below shows a typical QTL dataset, stored in comma-separated value (CSV) format. This highly edited dataset shows data for the BTBR/B6 cross. Starting at the left, we have the gender of the mouse. The next column shows an indicator for the parental grandmother, data we need to validate the statistics. Then we have five phenotypes: glucose levels, insulin at 4 weeks, triglycerides at 4 weeks, and HOMA (Homeostasis Model Assessment), a measure of insulin resistance and pancreatic beta-cell functioning. The data also contains the weight at 10 weeks.

Following that phenotype data, we now have the genotype data. Column H shows that there is a genetic marker, rs13475697, located on Chromsome 1 at location 1.6449 cM. For the first mouse, it inherited a BTBR allele from one parent and a BTBR allele from the other parent, so it’s coded “BB”, and we call this homozygous dominant. The next mouse is “BR”, so it inherited the BTBR allele from one parent and the Black 6 allele from the other parent. We call this genome heterozygous.

Notice in the dataset that there are several missing data points, very typical of QTL dataset.

Students conducted QTL studies using the R/RStudio program, and using a specific library/package developed for R called “Rqtl”. Rqtl was developed, by the way, by Karl Broman at the University of Wisconsin-Madison. That’s Karl on the right, next to yours truly. He’s younger. Smarter, too!

For this example (including a complete demonstration of code in the paid subscriber post) we’re going to use a much simpler QTL dataset. The BTBR/B6 dataset is full of landmines, so we’ll avoid that. We’re going to use blood pressure hypertension data in a dataset called “hyper.csv”. It looks like this:

Starting at the left, we see the phenotype of BP, looking at the systolic, or top number, of a blood pressure. There is a cute little blood pressure cuff that goes on the tail of the mouse to take this measurement! Then we see the sex and the parental grandmother. Now we have the genotype data. The first mouse has the genome “H” on Chromosome 1 at a location 3.3 cM, and this marker has the name D1MIT296. “H” means heterozygous, with a cross between an A/J mouse and a B6 mouse. This mouse has an “A” allele and a “B” allele. The third mouse has the genome “A”, which is shorthand for AA, meaning the mouse got both alleles from the A/J mouse, and this is the homozygous dominant version. Interestingly, there are no “B” mice, which is homozygous recessive with the “BB” alleles.

In this post, we’re not going to show the step-by-step code on how to do a QTL analysis of this particular dataset. We’ll do that in the paid subscriber version and then give you a different dataset to run. Join us there! We will, however, show the results here.

The goal of a QTL analysis is to produce what is called a mainscan. This shows all of the chromosomes — in the case of a mouse, that would be 19 autosomes and the X chromosome — on the X-axis, and what is called a “LOD” (likelihood of odds) score on the Y-axis. If the LOD score is higher than 3.0, then there is a statistically significant chance of their being a meaningful gene(s) near that particular genetic marker.

Here is the mainscan for the hyper.csv dataset, focusing on blood pressure (in this case, the only phenotype in the dataset):

One can see a clear peak on Chromosome 4, with a LOD score around 8. That means we really need to look at Chromosome 4 more closely to find a gene(s) that are causal for blood pressure. But note that we also have a smaller peak on Chromosome 1. This peak has a LOD score of about 3.5, which means that there might be a gene(s) on Chromosome 1 that contribute to blood pressure. When you have more than one gene influencing a phenotype, we call that a “complex trait”. Unfortunately, most genetic disorders are complex traits, which means you can’t just fix one gene and that fixes the disorder. Sickle cell anemia is a good example of a disease with just one gene, the HBB (hemoglobin) gene. Using technologies such as CRISPR gene splicing, we’re pretty close to being able to fix that one gene. It’s harder with complex traits!

We can also create an effect plot for a specific marker. For example, the QTL on Chromosome 4 is near marker D4Mit164. We can see that mice with the AA homozygous dominant genome tend have a higher blood pressure than AB heterozygous mice. We get the same results for the QTL on Chromosome 1.

Finally, we can zoom in on the peak on Chromosome 1 or 4. We’ll pick Chromosome 1 because it’s more interesting:

The green bar suggests that there is a high probability that the gene(s) we’re looking for will be between 37.2 and 83.3 cM. This helps us to spend our time looking where our probabilities might be the best, and not waste time or money looking at locations that are not likely to have value.

There are several other interesting graphics that we can produce. We can look at a map of where all of the genetic markers are, and it’s clear that they are not evenly-spaced, and some chromosomes have more than others. We can look at a map of missing data, and it’s pretty obvious that this dataset has a lot of missing data. Finally, we can look at a recombination frequency. We use this map mostly as a diagnostic — if there is a red “hot spot” below the diagonal, that means our data might be questionable and results should be accepted cautiously. In ours, even though we have a lot of missing data, what data we have is pretty clean.

Most QTL datasets contain a significant number of artifacts and challenges that our students were required to deal with prior to running the QTL analyses. The students also learned how to do BIC analyses: Bayesian Information Criterion. This analysis allows analysts to look at causal relationships between variables. For example, in the graphic below, the question is: “What causes insulin production?”. We run a BIC analysis just on insulin (INS), and get a score of 751.7, a meaningless number that will be used as a reference number. Then, the hypothesis is: “Insulin production is different in male mice than in female mice”. We do a BIC analysis (which is, by the way, dependent on a linear regression model (lm) between the two variables). Our score with sex is 648.7. If the new BIC score is 10 or more units lower than the reference, then that variable is causal. Therefore, mouse gender musst be taken into account for all insulin studies. Next, we add in a QTL (Q1) to sex, in a multiple regression analysis. Our score there is 635.5, more than 10 lower than our previous score. Q1 is therefore causal with gender, and we must consider that going forward. We add in another QTL (Q2). Its BIC score is only 634.6, not 10 or more less, so, going forward, we can ignore Q2 in our studies.

The second BIC chart shows possible relationships between sex, insulin production, and glucose. Needless to say, it can get very complicated very quickly, especially if you have complex traits with a significant number of QTLs.

So, the take-away here is that we can use advanced quantitative biology technologies, techniques, and tools to go gene hunting. QTL points us in the right direction; now we can use more advanced techniques to really hone in on a specific gene or, in the case of a complex trait, some series of genes.

Reminder, we’ll dive into the code in the paid subscriber version; hope to see you there.

In February, we’re going to look at how computational science can be used in environment science, with a specific focus on air quality and air quality modeling! Hope you will join us for that, and, in the meantime, all the best for a great 2026! Learning new stuff is always one of the best things that you can do for yourself, and I’m hopeful that “Confessions” is one way to help you do that!

Your challenge will be to implement demonstrated code on a slightly more complicated dataset by Sugiyama et. al.:

Read more

If you enjoy Confessions of a Computational Scientist, it would mean the world to me if you invited friends to subscribe and read with us. If you refer friends, you will receive benefits that give you special access to Confessions of a Computational Scientist.

How to participate

1. Share Confessions of a Computational Scientist. When you use the referral link below, or the “Share” button on any post, you'll get credit for any new subscribers. Simply send the link in a text, email, or share it on social media with friends.

Refer a friend

2. Earn benefits. When more friends use your referral link to subscribe (free or paid), you’ll receive special benefits.

• Get a 1 month comp for 3 referrals

• Get a 3 month comp for 5 referrals

• Get a 6 month comp for 25 referrals

Visit the leaderboard

To learn more, check out Substack’s FAQ.

Thank you for helping get the word out about Confessions of a Computational Scientist!

Read more

My very advanced STEM (science, technology, engineering, and math), ranked as the #1 public high school in the US, offers a very substantial catalog of courses in many aspects of STEM, including all of my computational courses, excellent engineering courses (aerospace, biomedical, electrical, statics, you get the idea), and substantial courses in computer science and mathematics.

Interestingly, we also have a world-class humanities program. Juniors (we’re juniors and seniors only) take a course called “American Studies”, a hybrid English literature/history course, team-taught by an instructor of English and an instructor of history. The course has an extensive reading list in both domains, and, while juniors tend to hate it, when they come back to the school for reunions, they point to “AmStud” as one of the most transformative courses of their time with us. Interesting, given we’re primarily a STEM school.

Kids applying to our school (applications required, but tuition-free) know that our humanities program is highly rigorous, and many will apply specifically for that program, knowing that they will have to “endure” a full checklist of graduation requirements in biology, chemistry, physics, mathematics, and either computer science or engineering. Given that, we can pretty easily identify the “science and math” kids and the “humanities” kids. Students (and faculty) from the two areas rarely interact, a situation exacerbated by the long, wide breezeway connecting the two buildings. We are definitely “silo’d”, intellectually and physically, typical in many academic institutions.

In 2017, the administration sought ways to address this divide, issuing a Request for Proposals (RFP) for interdisciplinary courses. To no surprise, I submitted a proposal for a “Digital Humanities” course, along with one of my favorite humanities instructors. Proposal accepted, we began developing the course, which was offered to seniors in their final semester of high school as an elective. The overall goal was to get the science/math kids and the humanities kids interacting around a common interest and learning to work collaboratively, using each other’s strengths to complete a task.

We began very traditionally, using computational methods to analyze literary texts, such as Jane Austen’s “Sense and Sensibility” and other works. My favorite author is Kurt Vonnegut, so I used his works as a demonstration. Then the students were asked to find authors of their choice, mostly using Project Gutenberg as a source for plain-text versions of literary works.

Text analysis has several components, beginning with basic analytics: word counts, sentence counts, and lengths, etc. The graphic below shows an example of this for Vonnegut’s “2BR02B”. “2 B R 0 2 B” is a science fiction short story by Kurt Vonnegut, originally published in the digest magazine Worlds of IF Science Fiction for January 1962, and collected in Vonnegut’s Bagombo Snuff Box (1999). The title is pronounced “2 B R naught 2 B” and references the famous phrase “to be, or not to be” from William Shakespeare’s Hamlet.

Our students used the Wolfram software package Mathematica[1], which provides a LEGO-like programming environment, where students can use built-in functions in combination to perform various operations. Below is an example of basic text analysis:

Once done with the basics, we looked at some of the more interesting capabilities of tools like Mathematica. For example, the students conducted readability studies examining reading levels from both quantitative and qualitative perspectives. The most useful metric was the grade level score: Vonnegut typically wrote for readers at the sixth-grade level.

One of the more interesting features of Mathematica is the “WordCloud” command, shown below. In this code, we’ve taken out all of the stop words, words like “the”, “and”, “of”, “with”. We also removed proper names, since Vonnegut has many characters in his books.

Finally, we conducted a Sentiment Analysis study of this work of literature. This looks at each sentence and, using machine learning (in this case, the “Logistic Regression” algorithm), determines whether it has a positive, negative, or neutral tone, or is indeterminate. Readers of Vonnegut will likely agree with the preponderance of negative sentiments!

We can also look at specific parts of speech, such as nouns and verbs:

We want our students to learn about the work, but also about the writer. Towards that end, students created an Author Profile. Once this code was written, they could change the author's name and create a profile. Yes, they could do this in Google or ChatGPT, but now they have WORM code: write once, read many. Change the name, get the profile:

Finally, we want students to see the author’s works over their writing time. Creating a timeline of their works is easy with Mathematica’s TimeLinePlot:

When this course started in 2017-2018, it was apparent that our politics were going to be, um, “interesting”. Once we got past the basics of text analysis, we began turning to computational studies to examine a variety of political events. We taught the students how to conduct network analyses by looking at the relationships between Trump and Vladimir Putin, and the various minions and organizations supporting each of them. We provided them with data from Vox.com[2]. An example of a centrality network is shown below. Students also constructed betweenness networks and compared the two types of results. The centrality network shows that Trump had more relationships (more “popular”), but the betweenness network shows that Putin is more influential. Not much has changed since 2017:

In 2017, there was a national movement to remove Confederate monuments from various locations. In our town, the Confederate monument in front of our courthouse was removed violently, as was the case in many cities. Accordingly, we did a study of Confederate monuments, using data from the Southern Poverty Law Center[3]:

Just as is the case now, after doing this for a while, we were all overwhelmed with the firehose of political information coming our way, so we retreated to the apolitical domain of art history. Using machine learning, we trained our machine to recognize four prominent portrait artists: Norman Rockwell (American, 1894-1978), Andrew Wyeth (American, 1917-2009), Rembrandt (Dutch, 1606-1669), and Kehinde Wiley (1977-present), a Nigerian-American portrait artist who painted the Obama portraits for the National Portrait Gallery.

Once trained, we asked our model to “classify” other portraits by a diverse group of artists to see which of the four artists they most resembled. Our results were interesting and sparked many fun discussions. A sample is shown:

Kids also took their own picture to see which artist captured them the best. Me, I’m Kehinde Wiley — I don’t see it, but that’s what the model thinks:

Alas, the course was cancelled in 2024 due to staffing issues. But developing and teaching this course opened up an entirely new world of computational science challenges and opportunities, and I still have my “Introduction to Computational Sciences” students do a social sciences/humanities project of their own choosing. The projects coming in are always interesting, and have only increased my interest in the digital humanities, and I regret that I didn’t start this work many years earlier. The “take-home” message for my students, and for you, is that the computational sciences are not restricted to the traditional science domains. If you can study it, computational science can help you!

In the paid version, the case study/lab will focus on protests, another artifact of our time. Using data from ACLED (Armed Conflict Location and Event Data Project), participants will use R/RStudio code to study protests by different groups across categories and time frames. In the example, we’ll look at events in North Carolina, specifically incidents involving a sole perpetrator, from January 1, 2020, to December 8, 2023.

We also will look at events on January 6, 2021. The kids were surprised to see that January 6th was not just the nonsense happening in Washington, DC, but also included events in many state capitols:

References:

1. Wolfram Research, Inc. *Wolfram Mathematica*. Version 14.0, Wolfram Research, Inc., 2024, www.wolfram.com/mathematica.

2. Levitz, Eric. “The Trump-Russia Network, Mapped.” *Vox*, 6 Mar. 2017, https://www.vox.com/mischiefs-of-faction/2017/3/6/14820506/trump-russia-network-mapped.

3. Southern Poverty Law Center. *Whose Heritage? Public Symbols of the Confederacy*. Southern Poverty Law Center, www.splcenter.org/resources/reports/whose-heritage-public-symbols-confederacy-3/.

Overview:

For this lab, we will solve the Schrödinger equation, shown below, using the ab initio Hartree-Fock method with the STO-3G basis set. The primary mathematical equation to be solved in computational chemistry is the Schrödinger equation, shown below. In this equation, H is an operator known as the Hamiltonian operator, Ψ is the wavefunction, an…

Read more

We cook chicken with an oven, a microwave, the outdoor grill, the air fryer (my favorite kitchen gadget!), and occasionally on the grill in our backyard fire pit.

We use barbecue sauce, teriyaki sauce, garlic, sometimes just salt and pepper, and a lot of Panko bread crumbs with eggs and flour.

If chicken ever goes away, we’ll be living on peanut butter and jelly sandwiches. But for the sake of this post, let’s assume we can get chicken at our local Food Lion.

OK, so you are a chicken chef. You have five decisions to make, or five things you need to know:

1. Starting shape: what’s in the freezer? We rarely have a whole chicken, but we have a lot of frozen chicken breasts, chicken thighs, and several bags of chicken nuggets for the grandkid for after school.

2. Final product: OK, in the Gotwals household, it’s Tuesday night, and that generally means baked chicken breasts with veggies. Yum.

3. Available tools: we have all of the regular cooking tools: oven, microwave, air fryer, and even an outdoor grill.

4. Instructions: cooks call these recipes. I’m not an intuitive chef at all, so I regularly use ChatGPT to give me recipes, which I follow to the letter. No creativity whatsoever.

5. Resources: this refers to what stuff I have in my cabinets. We always have Panko breadcrumbs, flour, eggs, and our spice rack is generally always full and up-to-date. I’m particularly partial to Dash Seasoning (disclaimer: I get no kickback!), so if I’m doing anything not in the recipe, it’s replacing paprika, oregano, etc. with a hefty dose of Dash. We also like garlic, so a pound or so of that tends to get dumped into the seasoning (well, not QUITE a pound, but a lot!).

Hopefully, you get the idea here. Cooking chicken isn’t hard, but there are things you need to know and things you need to decide. Figuring out Thing #2 is always the most challenging, and we try to switch things out so we don’t get bored.

Now, let’s talk about being a computational chemistry “chef”. We call these people computational chemists or molecular modelers. This coaster sits on my desk:

So I’m a molecular modeler, which my wife likes, because it pays the bills!

So, as a molecular modeler, what decisions do I have to make? It turns out that they are completely analogous to those of cooking chicken:

1. Starting shape: just like with chicken, I need to know what my molecule looks like. This means I have to know what atoms it contains, what the distance is between atoms (bond length, measured in units of angstroms, a very small number), the bond angle (measured in degrees), and, if there are four or more atoms, the dihedral angle, which tells me something about the 3D shape of the molecule.

   For example, let’s look at water. Water (H2O) contains one oxygen atom (the red thing) and two hydrogens (the white things). The bond length between the oxygen and hydrogens is 0.958 angtroms, and the bond angle is about 104.5 degrees. We don’t have a dihedral angle, because we only have three atoms. This molecule would lie flat on a table, with all three atoms touching the table: we call this planar.

   It should be noted that when I’m making baked chicken breasts for dinner, they come out of the freezer, well, frozen. I have to defrost them first. Same with molecules. We can build these with a graphics builder, but our ability to draw these things with exactly the correct geometry — atoms, bond lengths, angles, and dihedrals — is pretty limited. Before we do any calculation, we perform a geometry optimization, which, hopefully, leads us to the most optimal values for bond lengths, angles, and dihedrals. I did a geometry optimization on water, which gave me the 0.958 angstroms and 104.5 degrees. Getting an optimized molecule is harder than it sounds, and hundreds of papers are devoted to how to do this well.

   

2. Final product: like chicken, I need to know what I want when everything is done. Molecular calculations always produce the energy of the molecule, in various energy units, such as Hartrees, kilocalories/mole, kilojoules/mole, electron-Volts, etc. From the energy, other properties can be derived. These would include properties such as vibrational frequencies, molecular orbitals, transition states, UV-Vis or IR spectroscopy, etc. Like the chicken chef, some of these are pretty basic, such as molecular orbitals. More experienced molecular modelers have a shopping list of calculations that they know how to do, and it takes years of experience to master these. I can make baked chicken at home; I’m not going to make “Coq au Vin in the French Julia Child style”. We have a great French restaurant down the street, and they have that on their menu, and it’s really expensive. Likewise, my beginning students aren’t going to do Quantum Mechanical/Molecular Mechanical (QM/MM) Hybrid Simulation of Enzyme Catalysis calculations. Maybe by the time they get into a Ph.D. program, they’ll be able to do that. Takes years.

3. Available tools: instead of ovens or air fryers, I have a variety of computational chemistry software programs that I can use. Some, like MOPAC (Molecular Orbital Package) and GAMESS (General Atomic and Molecular Electronic Structure System), are in the public domain (free). Others, like Gaussian and Spartan, are commercially available and are decidedly NOT free. We use Gaussian16 (the most recent version on our computational chemistry server, and, with generous support from the vendor, we were able to provide an $8,000 piece of code to our students. Thanks,Mike and Aeleen Frisch from Gaussian, Inc.!

   Choosing a computational “engine” requires lots of experience. Beginning chicken chefs are probably limited to the use of a microwave, but, as they develop competence and confidence, will venture to other tools. I’m a Gaussian guy, it’s the software I learned many years ago, so it’s my “run home to Mama” choice. I use MOPAC and GAMESS on occasion, and some of the newer tools such as VASP or NWChem, but 99% of the time, I use Gaussian. It’s considered by most to be the industry standard, and it’s very robust. It can do very simple calculations — good for beginners — but is also powerful enough for even the most experienced chemist.

4. Instructions: these are analogous to recipes for a chef. I need to make a decision about which mathematical method I might use. Each has its advantages and disadvantages. Picking the right one determines how accurate my answer might be, and even more importantly, how computationally expensive a calculation might be. This refers to how long the calculation will take and how many processors on a computer I might use.

   1. ab initio: this is Latin for “from scratch” or “from the beginning”. This method calculates 100% of the answer in real time, meaning once you hit the “run” button, all of your calculation happens while you wait. Needless to say, this method is generally used for small molecules, under 100 atoms or so. It was the first method developed in the early 1970s by John Pople, who was awarded the Nobel Prize for this work. He developed the Gaussian software based on this work. There are several “flavors” of ab initio, the most common being the Hartree-Fock (HF) method, developed independently by the British physicist Doug Hartree and Russian physicist Vladimir Fock. The unit of energy in computational chemistry is the Hartree, named in honor of that person. HF isn’t a very popular method these days; other, more robust methods, including what are known as post-HF methods, are significantly more accurate.

   2. Semi-empirical: “semi” means “some”, and “empirical” means data. For this method, some of the calculation is pre-determined, and stored in datasets called "parameterization sets”. Mostly, we pre-compute the inner, or core, electrons, which do not contribute a great deal to the final result. We do calculate the valence electrons, the ones that are typically involved in chemical reactions. Using semi-empirical greatly speeds up a calculation, with some penalty for accuracy. Standard parameter datasets are called things like AM1, PM3, PM6, PM7, and some of the more specialized sets, such as NDO (“neglect of differential overlap”). Needless to say, the choice of a parameterization set requires knowledge and experience, and we all have our favorites. With semi-empirical, we can calculate larger molecules, in the 100s of atoms, without having to wait for days/weeks to get our answer.

   3. Density Functional Theory (DFT): This is argued by some, but not others, to be an ab initio method (I’m in favor), although it calculates chemical information using a very different approach. While most computational chemistry uses a representation of electrons known as a wavefunction, DFT uses the electron density of the molecule as the starting point. Pretty much everyone would agree that DFT is the most popular method now for small molecules, and older methods such as ab initio/HF are passe. There is even an annual ranking of preferred variations of DFT. Most use the B3LYP method, the Becke (Ontario) 3-term Lee-Yang-Parr (UNC-Chapel Hill) hybrid method. Other opinions differ. May the best computational chemist win.

   4. Molecular Mechanics (MM): This is the method of choice for larger molecules, such as proteins, with 1000s of atoms. With MM, we use classical physics, where you can think of each atom like a ping-pong ball, connected to all of the other balls with springs. The energy of the molecule is calculated by stretching or compressing these springs, allowing them to snap back to their normal state, and measuring the amount of energy required. We completely ignore the behavior of the electrons, so it’s not a quantum method. It’s good old-fashioned high school physics.

5. Resources: pretty much regardless of the method, we need some data to kick-start our calculation. These are called basis sets, and are analogous to the spices and other things I have in my pantry cabinet. There are a LOT of basis sets: for example, if my molecule has carbon, oxygen, and hydrogen, I have a choice of 476 different basis sets! Trust me, we all have our favorites, and you can imagine a night at the bar after a conference with a bunch of well-lubricated computational chemists, all arguing the merits of a particular basis set! No fisticuffs, but close!

Source:

https://www.basissetexchange.org/

What do these numbers look like? For a simple hydrogen molecule (H2), using the most simple basis set, the numbers look like this:

These numbers represent the data I need to put into the mathematics of the various methods, such as HF. Notice that this is called a “minimal” basis set, because it’s as rock-bottom simple as you can get. No self-respecting chemist would EVER use an STO-3G (Slater-Type Orbital with three Gaussians), unless there was a very specific reason.

So, at the end of the day, we can cook chicken or we can cook molecules. The table below shows each of these things and what we need to know, have, and do. Looking at this chart, it’s deceivingly simple, even simplistic. If you have ever tried to do either thing, you know that it’s anything but. My first attempts at cooking chicken resulted in undercooked, overcooked, burnt on occasion, or as bland as eating cardboard. Likewise, my students struggle with the most basic of calculations, with a calculation frequently returning the message “Failed”. They persevere, however, and at the end of the course, they tell me that they can’t remember a time (which was only 15 weeks earlier) when they didn’t know what a Hartree-Fock calculation did.

Speaking of Hartree-Fock: for the paid subscribers (hint, hint, nudge, nudge, wink, wink), the lab is as follows:

1. Starting shape: water, H2O, with bond lengths of 1.0 angstroms and bond angle of 104.5 degrees.

2. Final product: determine the energy of each of the 10 electrons (eight for oxygen, one each for the hydrogens) and then use those values to calculate the Hartree-Fock energy of the entire molecule. Our final energy value will be in energy units of Hartrees (thanks, Doug! Jolly good show!)

3. Available tools: we’ll use Gaussian16. You don’t have that in all likelihood, so I’ll run the calculation and provide you with the “log” file, the results of the calculation. We’ll then use a customized spreadsheet to calculate the results of the data in the Gaussian log.

4. Instructions: we’ll use an ab initio method, specifically a Restricted Hartree-Fock (RHF) method. Restricted means that all of the 10 electrons are paired.

5. Resources: We’ll use an STO-3G basis set. Again, we’d never use that in real life, but we want to be able to do the simplest thing possible, given that we’ll be doing most of the calculation by hand, with a spreadsheet.

Come join us on the paid side! No worries if not; hopefully, you’ll now have an idea of what a computational chemistry/molecular modeler does every day, and what s/he needs to know, have, and do. I’ve been doing computational chemistry since 1986 or so, and I still learn new things every day, mostly from reading the professional literature, including the Journal of Computational Chemistry. I also learn a great deal from my students, mostly from trying to figure out the error messages they get, which I can never replicate. Thanks, kids!

What’s up in December? We’ll venture out of science for the moment and look at how computational science is used in the social sciences and the humanities. I call that “Jane Austen meets computing!”. Hope you can join us!

Read more