Tianyou Mou’s Personal Website

Recommendation Systems

2022-01-02T00:00:00+00:00

What is a recommendation system

Recommendation engines are a subclass of machine learning which generally deal with ranking or rating products/users. Recommender systems are algorithms aim at suggesting relevant items to users. They have been widely applied by many big name companies like Youtube, Amazon, Netflix and others to increase the engagement with users and the platform. Recommendation systems are employed since they can generate more profit when companies use efficient systems and help them stand out from competitors. There are many real life examples, YouTube uses recommendations to suggest you other videos similar to the ones you liked or repeatedly watched. Amazon also uses them to suggest products to users when they are browsing items. Here, I will go through different paradigms of recommendation systems with implementation of them.

Various recommendation systems and how to define a good system

There are three major paradigms of recommendation systems: collaborative filtering methods, content based methods, and a combination of them called hybrid methods. The collaborative filtering recommendation systems are methods that are based solely on the past interactions between users and items in order to predict new recommendations. While for the content based approaches additional information about users and items can be used. For example of a movies recommendation system, additional information can be the age, the job or any other personal information for users as well as the actors, the category of the movies or items. The hybrid system make a combination of both systems.

The evaluation of recommendation systems is necessary since we have to decide which algorithm fits the best in our situation. It’s normal to use metrics based evaluation like error measurement metric like mean absolute error. This means you train the model with only a part of the available data and test with the remaining. This method of evaluation is solely dependent on the dataset and approach used to generate the recommendation. So common statistical accuracy measures to evaluate accuracy of the recommender can be employed, for example, root mean squared deviation (RMSD), mean absolute error (MAE), and k fold cross validation.

Data preparation

I will present different methods of creating recommendation engines and the associated implementations in Python. Here I provide a script to synthesize a dataset associated to books. This dataset will be used for applications of recommendation systems in the following sections.

import pandas as pd
from random import randint

def generate_data(n_books = 3000, n_genres = 10, n_authors = 450, n_publishers = 50, n_readers = 30000, dataset_size = 100000):
    '''
    This function will generate a dataset with features associated to
    book data set. The dataset will have the following columns : 
        - book_id (String) : Unique identified for the book
        - book_rating (Integer) : A value between 0 and 10
        - reader_id (String) : Unique identifier for the user
        - book_genre (Integer) : An integer representing a genre for the book, 
                                 value is between 1 and 15, indicating that 
                                 there are 15 unique genres. Each book can only
                                 have 1 genre
        - author_id (String) : Unique identifier for the author of the book
        - num_pages (Integer) : Random value between 70 and 500
        - publisher_id (String) : A unique identifier for the publisher of the book
        - publish_year (Integer) : The year of book publishing
        - book_price (Integer) : The sale price of the book
        - text_lang (Integer) : The language of the book - returns an integer which 
                                is mapped to some language
        
    params:
        n_books (Integer) : The number of books you want the dataset to have
        n_genres (Integer) : Number of genres to be chosen from
        n_authors (Integer) : Number of authors to be generated
        n_publishers (Integer) : Number of publishers for the dataset
        n_readers (Integer) : Number of readers for the dataset
        dataset_size (Integer) : The number of rows to be generated 
        
    example:
        data = generate_data()
    '''
    
    d = pd.DataFrame(
        {
            'book_id' : [randint(1, n_books) for _ in range(dataset_size)],
            'author_id' : [randint(1, n_authors) for _ in range(dataset_size)],
            'book_genre' : [randint(1, n_genres) for _ in range(dataset_size)],
            'reader_id' : [randint(1, n_readers) for _ in range(dataset_size)],
            'num_pages' : [randint(75, 700) for _ in range(dataset_size)],
            'book_rating' : [randint(1, 10) for _ in range(dataset_size)],
            'publisher_id' : [randint(1, n_publishers) for _ in range(dataset_size)],
            'publish_year' : [randint(2000, 2021) for _ in range(dataset_size)],
            'book_price' : [randint(1, 200) for _ in range(dataset_size)],
            'text_lang' : [randint(1,7) for _ in range(dataset_size)]
        }
    ).drop_duplicates()
    return d
  
d = generate_data(dataset_size = 100000)
d.to_csv('data.csv', index = False)

Collaborative Filtering Recommendation System

Collaborative filtering is the process of predicting the interests of a user by identifying preferences and information from many users. This is done by filtering data for information or patterns using techniques involving collaboration among multiple agents, data sources, etc. The idea behind the collaborative filtering is that if user A and B have similar taste in a product, then A and B are likely to have similar taste in other products as well.

There are two common types of approaches in collaborative filtering, memory based and model based approach.

Memory based approaches

Often referred to as neighbourhood collaborative filtering. Essentially, ratings of user-item combinations are predicted on the basis of their neighbourhoods. This can be further split into user based collaborative filtering and item based collaborative filtering. User based essentially means that likeminded users are going to yield strong and similar recommendations. Item based collaborative filtering recommends items based on the similarity between items calculated using user ratings of those items.

Model based approaches

They are predictive models using machine learning. Features associated to the dataset are parameterized as inputs of the model to try to solve an optimization related problem. Model based approaches include using things like decision trees, rule based approaches, latent factor models etc.

Implementation

Import data from generate_data function (function provided above) or download the CSV from here.
Generate a pivot table with readers on the index and books on the column and values being the ratings
Calculate similarity between items and users using svds.
Generate item recommendations based on user_id.

import pandas as pd
import numpy as np

from scipy.sparse import csr_matrix
from scipy.sparse.linalg import svds

def normalize(pred_ratings):
    '''
    This function will normalize the input pred_ratings
    
    params:
        pred_ratings (List -> List) : The prediction ratings 
    '''
    return (pred_ratings - pred_ratings.min()) / (pred_ratings.max() - pred_ratings.min())
  
def generate_prediction_df(mat, pt_df, n_factors):
    '''
    This function will calculate the single value decomposition of the input matrix
    given n_factors. It will then generate and normalize the user rating predictions.
    
    params:
        mat (CSR Matrix) : scipy csr matrix corresponding to the pivot table (pt_df)
        pt_df (DataFrame) : pandas dataframe which is a pivot table
        n_factors (Integer) : Number of singular values and vectors to compute. 
                              Must be 1 <= n_factors < min(mat.shape). 
    '''
    
    if not 1 <= n_factors < min(mat.shape):
        raise ValueError("Must be 1 <= n_factors < min(mat.shape)")
        
    # matrix factorization
    u, s, v = svds(mat, k = n_factors)
    s = np.diag(s)

    # calculate pred ratings
    pred_ratings = np.dot(np.dot(u, s), v) 
    pred_ratings = normalize(pred_ratings)
    
    # convert to df
    pred_df = pd.DataFrame(
        pred_ratings,
        columns = pt_df.columns,
        index = list(pt_df.index)
    ).transpose()
    return pred_df

def recommend_items(pred_df, usr_id, n_recs):
    '''
    Given a usr_id and pred_df this function will recommend
    items to the user.
    
    params:
        pred_df (DataFrame) : generated from `generate_prediction_df` function
        usr_id (Integer) : The user you wish to get item recommendations for
        n_recs (Integer) : The number of recommendations you want for this user
    '''
    
    usr_pred = pred_df[usr_id].sort_values(ascending = False).reset_index().rename(columns = {usr_id : 'sim'})
    rec_df = usr_pred.sort_values(by = 'sim', ascending = False).head(n_recs)
    return rec_df
  
if __name__ == '__main__':
    # constants
    PATH = '../data/data.csv'

    # import data
    df = pd.read_csv(PATH)
    print(df.shape)

    # generate a pivot table with readers on the index and books on the column and values being the ratings
    pt_df = df.pivot_table(
        columns = 'book_id',
        index = 'reader_id',
        values = 'book_rating'
    ).fillna(0)

    # convert to a csr matrix
    mat = pt_df.values
    mat = csr_matrix(mat)
    
    pred_df = generate_prediction_df(mat, pt_df, 10)

    # generate recommendations
    print(recommend_items(pred_df, 5, 5))

Content Based Recommendation System

Content based systems generates recommendations based on the users preferences and profile. They try to match users to items which they’ve liked previously. The level of similarity between items is generally established based on attributes of items liked by the user. Unlike most collaborative filtering models which leverage ratings between target user and other users, content based models focus on the ratings provided by the target user themselves. In essence, the content based approach leverages different sources of data to generate recommendations.

The simplest forms of content based systems require the following sources of data (these requirements can increase based on the complexity of the system you’re trying to build):

Item level data source

You need a strong source of data associated to the attributes of the item. For our scenario, we have things like book price, num_pages, published_year, etc. The more information you know regarding the item, the more beneficial it will be for your system.

User level data source

You need some sort of user feedback based on the item you’re providing recommendations for. This level of feedback can be either implicit or explicit. In our sample data, we’re working with user ratings of books they’ve read. The more user feedback you can track, the more beneficial it will be for your system.

###Implementation

Import data from generate_data function (function provided above) or download the CSV from here
Normalize book_price, book_ratings, num_pages
One hot encode publish_year, book_genre, text_lang
Given a book_id input, calculate the cosine similarity and return top n books similar to the input

import pandas as pd
import numpy as np
from numpy import dot
from numpy.linalg import norm 

def normalize(data):
    '''
    This function will normalize the input data to be between 0 and 1
    
    params:
        data (List) : The list of values you want to normalize
    
    returns:
        The input data normalized between 0 and 1
    '''
    min_val = min(data)
    if min_val < 0:
        data = [x + abs(min_val) for x in data]
    max_val = max(data)
    return [x/max_val for x in data]

def ohe(df, enc_col):
    '''
    This function will one hot encode the specified column and add it back
    onto the input dataframe
    
    params:
        df (DataFrame) : The dataframe you wish for the results to be appended to
        enc_col (String) : The column you want to OHE
    
    returns:
        The OHE columns added onto the input dataframe
    '''
    
    ohe_df = pd.get_dummies(df[enc_col])
    ohe_df.reset_index(drop = True, inplace = True)
    return pd.concat([df, ohe_df], axis = 1)

class CBRecommend():
    def __init__(self, df):
        self.df = df
        
    def cosine_sim(self, v1,v2):
        '''
        This function will calculate the cosine similarity between two vectors
        '''
        return sum(dot(v1,v2)/(norm(v1)*norm(v2)))
    
    def recommend(self, book_id, n_rec):
        """
        df (dataframe): The dataframe
        song_id (string): Representing the song name
        n_rec (int): amount of rec user wants
        """
        
        # calculate similarity of input book_id vector w.r.t all other vectors
        inputVec = self.df.loc[book_id].values
        self.df['sim']= self.df.apply(lambda x: self.cosine_sim(inputVec, x.values), axis=1)

        # returns top n user specified books
        return self.df.nlargest(columns='sim',n=n_rec)

if __name__ == '__main__':
    # constants
    PATH = '../data/data.csv'

    # import data
    df = pd.read_csv(PATH)

    # normalize the num_pages, ratings, price columns
    df['num_pages_norm'] = normalize(df['num_pages'].values)
    df['book_rating_norm'] = normalize(df['book_rating'].values)
    df['book_price_norm'] = normalize(df['book_price'].values)
    
    # OHE on publish_year and genre
    df = ohe(df = df, enc_col = 'publish_year')
    df = ohe(df = df, enc_col = 'book_genre')
    df = ohe(df = df, enc_col = 'text_lang')
    
    # drop redundant columns
    cols = ['publish_year', 'book_genre', 'num_pages', 'book_rating', 'book_price', 'text_lang']
    df.drop(columns = cols, inplace = True)
    df.set_index('book_id', inplace = True)
    
    # ran on a sample as an example
    t = df.copy()
    cbr = CBRecommend(df = t)
    print(cbr.recommend(book_id = t.index[0], n_rec = 5))

Hybrid Recommendation System

Various methods of recommendations systems have their own benefits and flaws. Often, many of these methods may seem restrictive when used in isolation, especially when multiple sources of data is available for the problem. Hybrid recommender systems are ones designed to use different available data sources to generate robust inferences.

Hybrid recommendation systems have two predominant designs, parallel and sequential. The parallel design provides the input to multiple recommendation systems, each of those recommendations are combined to generate one output. The sequential design provides the input parameters to a single recommendation engine, the output is passed on to the following recommender in a sequence. Refer to the figure below for a visual representation of both designs.

Takeaways

Please be advised that this is just an introduction to recommendation engines. There are many more types and approaches to building out strong recommendation engines which are not covered in this article. Some notable ones are generating recommendation through link prediction, algorithmic approaches, bayesian models, markov models, etc…

The aim of the article was to provide an intuitive understanding and implementation of the foundational methods used for recommendation systems (collaborative filtering, content based and hybrid). Collaborative filtering is the process of predicting the interests of a user by identifying preferences and information from many users, whereas content based systems generates recommendations based on the users preferences and profile. Hybrid systems are often a combination of many recommendation systems.

Comparison between CE-TinNet and LCNN

2021-11-02T00:00:00+00:00

Overview

The origin of cluster expansions can be traced back to the early 1950s, when Kikuchi developed an Ising model-based cluster variation method to study order-disorder phenomena. In 1984, Sanchez et al. developed a general formalism for the description of configurational cluster expansions in terms of a complete basis set expansion. In simple terms, CE decomposes the energy of a configuration into one-body, two-body, and higher-order interaction terms (‘clusters’), and each term has a corresponding weight called effective cluster interaction (ECI) analogous to the interaction strength. The energy can be exactly reproduced only if all clusters are included in the CE. However, the ECIs for clusters that contain a large number of sites or a large distance between sites are usually negligible. Therefore, the CEs can be truncated to a sum over finite numbers of cluster functions with little loss of accuracy.

The construction of CEs includes data generation by DFT calculations, structure selection and cluster selection. When referring to surface reactions, the training becomes more challenging due to the loss of translational symmetry at the interface and the increase of the complexity of adsorbate interactions and the number of surface species. While DFT calculations typically require a large number of computational resources, it has become more or less standardized in catalysis research. In contrast, the algorithms driving structure selection and cluster selection are arguably more critical to the overall accuracy of the CEs. Therefore, significant efforts have been put into developing approaches to generate effective clusters for a given training set. The goal of the selection algorithm is to find the clusters that have physical contributions to lateral interactions. Early CEs relied on heuristic methods to manually select clusters, while recent approaches incorporate automated ML approaches to systematically optimize the selection process. Multiple automated selection algorithms have been developed for CEs including MIT Ab-initio Phase Stability (MAPS), genetic algorithm (GA), and steepest descent (SD), which incorporate various well-established ML approaches such as cross validation, feature selection, pattern recognition, and regularization.

Here I employed an artificial neural network called CE-TinNet to predict the cluster expansions of the studied structures and predict the formation/adsorption energies. As a benchmark, I also used a previous model LCNN developed by Lym et. al, and the state-of-the-art CGCNN model to make a prediction for the same property.

Lattice convolution neural network

The lattice convolutional neural network (LCNN) is a Python library for deep learning of lattice system developed by the Vlachos group at the University of Delaware and Jung group at KAIST. The model has been built in hope to improve upon cluster expansion methods, linear regression based on the clusters in the lattice. The LCNN performs better than the cluster expansion and cluster expansion based machine learning methods with sufficient number of data points.

Lym et al. developed a novel lattice convolutional neural network (LCNN) that improved the formation energy prediction compared to state-of-the-art CE methods by 20-30% (Figure a). Featurization process extracts features of each site’s neighbor lists using one-hot encoding. The extracted information then undergoes lattice convolutional (LConv) layers which are built to construct the local environment by considering the nearest neighbors and including permutations to account for the symmetry of the lattice. Activation and summation are followed for new site features. Once all convolution operations are performed, the representation of the lattice is obtained. Followed by the site-wise activation and linear multiplication, the formation energy of each image can be predicted. They applied the LCNN model to study the coverage of O and NO adsorption on Pt(111) surface, the model captures the local environment of adsorbates, and a one-hot encoding input and the predicted site formation energy distribution are shown in Figure b and c, respectively. Compared to CE models, the LCNN achieves the best performance with a test root mean squared error (RMSE) of 4.4 meV/site using less training data. The effect of van der Waals (vdW) forces on lateral interactions have also been studied by comparing the formation energy with and without vdW forces for an example of all unique configurations in a unit cell containing up to 12 adsorption sites (1,581,607 in total). The convex hull diagrams of LCNN computed formation energies trained using PBE-D3 (with vdW forces) and PBE (without vdW forces) datasets are shown in Figure d and e, respectively. They found that the trend in the convex hull has changed by the vdW interactions. Particularly, the global ground state configuration for PBE is observed at 0.78 monolayer (ML) of NO, whereas it is 1.0 ML of NO for PBE-D3.

Crystal Graph Convolutional Neural Networks

The use of machine learning methods for accelerating the design of crystalline materials usually requires manually constructed feature vectors or complex transformation of atom coordinates to input the crystal structure, which either constrains the model to certain crystal types or makes it difficult to provide chemical insights. Thus, they developed a crystal graph convolutional neural networks framework to directly learn material properties from the connection of atoms in the crystal, providing a universal and interpretable representation of crystalline materials. Their method provides a highly accurate prediction of density functional theory calculated properties for eight different properties of crystals with various structure types and compositions.

Dataset

All the data used to train, validate, andtest the machine-learning models on the Pt(111) system wasprovided by Bajpai et al. The formation energy per site is calculated by:

$
\begin{align} \begin{split} Pt + \frac{\theta_O}{2}O_2 + \theta_{NO}NO \rightarrow PtO_{\theta_O}NO_{\theta_{NO}} \> \> \> (\sigma) \end{split} \end{align} $

$
\begin{align} \begin{split} E_F(\sigma) = \frac{E_0(\sigma)-E_0(0)}{N} - \frac{\theta_O}{2}E_{0,O_2} - \theta_{NO}E_{0,NO} \end{split} \end{align} $

The Pt(111) surface can be covered by NO, O adsorbate with 600 data points in total, and the unit cell is expanded when there are more adsorbates or at high coverages.

The details of data preprocessing can be found in my previous post

Results and discussion

CE-TinNet is a ML based model that considers the lateral interactions between the adsorbates and surface atoms. It outperforms the LCNN when considering the adsorbate-adsorbate interactions for NO and O adsorption on Platinum.

More studies have been down on different surfaces with various adsorbates, and I’ll share more results when it’s ready to be published.

CO2 electroreduction on Bismuth with Ionic Liquids

2021-10-01T21:14:20+00:00

Introduction

Electrochemical reduction of CO₂ has attracted researchers’ attention as it has the potential to utilize the abundant greenhouse gas in the Earth’s atmosphere and store intermittent energy from solar panels and wind turbines in chemical bonds. Many metals show activities in reducing CO₂ in aqueous phase. However, with the competition of the hydrogen evolution reaction, the selectivity is poor towards valued chemicals. Also, the high overpotential needed to drive the reactions causes low efficiencies that inhibits the practical applications.

CO₂ cycle

Many metals show CO2₂ reduction activity

Current Knowledge and Focus

By using Bismuth (Bi) as catalysts and ionic liquids (ILs) as electrolytes under electrochemical conditions:

CO₂ was reduced to CO instead of formate.
The CO₂ reduction overpotential was reduced.
The selectivity was enhanced since the HER was compressed.

The underlying mechanism remains elusive due to the multi-step kinetics and the unclear interactions between ILs and key intermediates

CO₂ Reduction in ILs

Exhibit an almost complete conversion of CO₂ to CO (96.1 % FE_CO), and a mass activity for CO evolution (MA_CO) of 15.6 mA mg−1 at -2.0 V vs Ag/AgCl (~ 0.3 V overpotential).

Reaction Pathways of CO₂ Reduction in ILs

Determining Energetics

Total reaction from CO₂ to CO

Using thermodynamic cycle to determine reaction barriers

Modeling Solid-Electrolyte Interfaces

Calculation Details

VASP package
PBE functionals
3 by 3 by 3 unit cell
Monkhorst-Pack mesh of 4 by 4 by 1
VASPsol hybrid solvation
Constant potential calculation

Electrostatic potential plot

Tuning the number of electrons in the system to change the Fermi level

Electrolyte-dependent Energy Pathways

Compared with aqueous phase condition, free formation energies of key intermediates are lowered in non-aqueous phase, and CO is produced.

Conclusions

Constant potential calculations can capture selectivity trends from aqueous phase and IL non-aqueous phase.
By employing ILs as co-catalysts on Bi surfaces, thermodynamic barriers are reduced since the stabilization of *CO2 and *COOH by hydrogen bonding, and CO is obtained as the final product.

References

CE-TinNet

2021-09-01T00:00:00+00:00

Dependencies

TinNet
The Alloy-Theoretic Automated Toolkit (ATAT)
PyTorch (v1.3.1)
Pymatgen
Python3
Numpy

Background

Surface properties of materials are important for catalysis applications. Recent advances in computing power make density functional theory (DFT) to be possible to gain insights into the reactions happening on the catalyst surfaces. However, the surface environments are way more complex and adsorbates on surfaces can have many configurations. One possible way to solve this issue is by employing the cluster expansion to consider the adsorbate-adsorbate interactions.

Cluster expansion

Cluster expansion is developed based on the Ising model. With infinite terms of interactions considered, the exact energy of the system is obtained. The Hamiltonian describing the energy of the system can be espressed as

$
\begin{align} \begin{split} E = \pi * V \end{split} \end{align} $

π is the correlation matrix which is obtained through ATAT package and V is the interaction energy which can be fitted by using DFT true values. Although it works well with pure metal surfaces[], the complexity increase dramatically when considering a alloy surface with various adsorbates. So a nonlinear CNN fitting model is employed to consider not only the ads-ads interactions on the surface layer, but the local environment of the metal layer, which helps improve the accuracy of predicting the formation energy of adsorbates.

DFT database pool

DFT database is provided by Bajpai et al. including pure Pt (111) with NO and O adsorbates.There are 648 images in total. The energy to train in this field is usually the formation energy per site, $E_F(\sigma)$.

$
\begin{align} \begin{split} Pt + \frac{\theta_O}{2}O_2 + \theta_{NO}NO \rightarrow PtO_{\theta_O}NO_{\theta_{NO}} \> \> \> (\sigma) \end{split} \end{align} $

$
\begin{align} \begin{split} E_F(\sigma) = \frac{E_0(\sigma)-E_0(0)}{N} - \frac{\theta_O}{2}E_{0,O_2} - \theta_{NO}E_{0,NO} \end{split} \end{align} $

Preparing Input for CE-TinNet

ASE db file or any other file format. Containing the input images and energy to train

Image format is pretty flexible as long as it can be recognized by Voronoi. The energy

Preparing the dataset structure format

Pure Pt(111) with NO and O adsorbates

From LCNN there are preprocessed data samples to be used. In structure

python lcnn_to_str.py

Cu dopant in Pt(111) with NO and O adsorbates

In this work, for convenience the VASP POSCAR format is used since it can be easily converted to other formats.

python Grab_POS.py

Also there is a function Cvrt_Cart_Frac.py which can convert the coordinates from Cartisan to fractional (Direct) coordinate for the convenience of next step since ATAT use fractional coordinate.

Preparing the correlation matrix using the Alloy-Theoretic Automated Toolkit (ATAT)

CM.txt file containing the needed correlation matrix for each image.

Prepare the dataset into the str.in format which can be recognized by the ATAT package.

python POS_to_str.py

The format of str.in can be simply obtained from the ATAT manual.

Once all str.in format structures are ready, one can use the Str_to_arr.py to generate the needed CM.txt file. The specific code to implement is called corrdump which can read in the lat.in and str.in, and use criterion as the cut off to choose how many clusters to include.

Can choose to use clusters from literature or generate them from the ATAT package directly.

python Str_to_arr.py

corrdump requires several input options:

reads the lattice file (-l option)
find all symmetrically distinct clusters satisfying the conditions specified by two ways:
- distance between nodes: -2 through -6 (-2=2.1 means pairs shorter than 2.1 units is selected.)
- read in clusters directly from other sources: -c -cf=filename(usually clusters.out)
reads the structure file (-s option)

With all inputs, it determines the corresponding correlation factor for each cluster for this specific structure read in. The output is in one line with the same order as the clusters.out. While for a dataset with multiple images/strctures, multiple lines of correlation factors are generated and a m*n array can be generated where m is the number of images and n is the number of clusters included

Preparing the data images and energies

For convenience, the ASE db format is used to be the dataset which can have the images in various struture format and have the according energy for each image.

python Gen_formation_db.py

Formation energy per site which has been mentioned before is used as the training target.

For Cu1Pt(111) system, it was calculated by…

Training and Evaluating

python training.py

Hyperparameter optimization

ray tune is employed to tune the hyperparameters in the model.

Data Mining for Catalyst Materials

2021-08-01T00:00:00+00:00

Overview

Catalyst materials are playing important roles in the whole world. Catalysts are composed of different chemical species, leading to the different catalytic performances. While catalysts are often composed of a single kind of metal, they can also be a combination of several or even more than five kinds of different metals. So the whole possible catalyst space is huge, which means it’s extremely hard to directly synthesize each of them and tell which one performs better for a specific case. Thus, machine learning methods step in to help screen the catalysts, but ML methods usually require large data sets for accuracy. Nowadays, many research scientists developed databases for ML usage, but these kind of databases are very large, and include probably all possibly combinations, which may not be the case for a specific catalytic reaction which only needs a small part of this database. So, there is a need to filter the large database to clean the data for a specific problem.

Open Catalyst Project data screening

The Open Catalyst Project is a collaborative research effort between Facebook AI Research (FAIR) and Carnegie Mellon University’s (CMU) Department of Chemical Engineering. The aim is to use AI to model and discover new catalysts for use in renewable energy storage to help in addressing climate change.

An open challenge is finding low-cost catalysts to drive these reactions at high rates. Through the use of quantum mechanical simulations (density functional theory), new catalyst structures can be tested and evaluated. Unfortunately, the high computational cost of these simulations limits the number of structures that may be tested. The use of AI or machine learning may provide a method to efficiently approximate these calculations, leading to new approaches in finding effective catalysts.

To enable the broader research community to participate in this important project, we are releasing the Open Catalyst Dataset for training ML models. The dataset contains 1.2 million molecular relaxations with results from over 250 million DFT calculations. In addition to the data, baseline models and code are provided on our Github page. View the leaderboard to see the latest results and to submit your own to the evaluation server! Join the discuss forum to join the discussion with the community and ask any questions.

However, it’s not efficient to grab useful data from that huge database, so I set up a couple of codes for quick inquiries.

1. Screen alloys with p-block metals and terminations of (111) and (100)

Import

import pandas as pd
import pickle
import os

Lists of all chemical elements in different blocks. Metals in l2 is the so-called p-block metals.

l1 = ['Pt']
l2 = ['Al','Ga','Ge','In','Sn','Sb','Tl','Pb','Bi','Po']
l3 = ['H','Li','Na','K','Rb','Cs','Fr',
      'Be','Mg','Ca','Sr','Ba','Ra',
      'Sc','Y','Lu','Lr',
      'Ti','Zr','Hf','Rf',
      'V','Nb','Ta','Db',
      'Cr','Mo','W','Sg',
      'Mn','Tc','Re','Bh',
      'Fe','Ru','Os','Hs',
      'Co','Rh','Ir','Mt',
      'Ni','Pd','Ds',
      'Zn','Cd','Hg','Cn',
      'B','Nh',
      'C','Si','Fl',
      'N','As',
      'O','S','Se','Te',
      'F','Cl','Br','I','At','P']
l4 = ['Li','Na','K','Rb','Cs','Fr',
      'Be','Mg','Ca','Sr','Ba','Ra',
      'Nh',
      'Si','Fl',
      'As',
      'Se','Te',
      'Cl','Br','At']
l5 = ['H','P','B','C','N','S','O','F','I']

Read in data and filter it.

f1 = pd.read_pickle('../OC.pkl')
dict1 = {}
dict2 = {}
f = {}

j = 0
k = 0

for i,n in enumerate(f1):
    if (f1[n]['miller_index'][0] == 1 and f1[n]['miller_index'][1] == 1 and f1[n]['miller_index'][2] == 1) or (f1[n]['m\
iller_index'][0] == 1 and f1[n]['miller_index'][1] == 0 and f1[n]['miller_index'][2] == 0):
        if any(word in f1[n]['bulk_symbols'] for word in l2):
            if any(word in f1[n]['bulk_symbols'] for word in l4):
                continue
            else:
                #f[n] = {f[n]['bulk_symbols'], f[n]['miller_index']}                                                    
                f[n] = f1[n]
                k += 1

Save data.

if os.path.exists('index.pickle'): os.remove('index.pickle')
if os.path.exists('index.txt'): os.remove('index.txt')

with open('index.pickle', 'wb') as handle:
    pickle.dump(f, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open('index.txt', 'w') as f:
    print(f, file=f)

print ('your job is done, total {} systems'.format(j))

2. Screen all combinations of transition metals and p-block metals based on the previous alloys with specific terminations.

f = pd.read_pickle('../l4/index.pickle')
dict1 = {}
dict2 = {}

j = 0
k = 0

for i,n in enumerate(f):
    m = 0; p = 0
    for word in l5:
        if word in f[n]['bulk_symbols']:
            string  = f[n]['bulk_symbols']
            results = [i for i in range(len(string)) if string.startswith(word, i)]
            print (results)
            for q in results:
                try:
                    small = f[n]['bulk_symbols'][q+1]
                    #                print (small)                                                                      
                    m += 1
                except:
                    break
		if (word == 'P' and (small in ['t','d','b','o'])) or \
                   (word == 'H' and (small in ['f','s','g'])) or \
                   (word == 'B' and (small in ['a','e','i','r','h'])) or \
                   (word == 'C' and (small in ['a','s','o','l','r','u','d','n'])) or \
                   (word == 'N' and (small in ['a','b','i','h'])) or \
                   (word == 'S' and (small in ['e','n','b','r','c','g','i'])) or \
                   (word == 'O' and small == 's') or \
                   (word == 'F' and (small in ['r','e','l'])) or \
                   (word == 'I' and (small in ['r','n'])):
                    p += 1

    print (f[n]['bulk_symbols'],m,p)
    if m == p:
        dict2[n] = {f[n]['bulk_symbols'], f[n]['miller_index']}
        dict1[n] = f[n]
        j += 1

3. Screen all bimetallic alloys since section 2 can have all possible combinations of alloys .

f1 = pd.read_pickle('../T+P/index.pickle')
dict1 = {}
dict2 = {}
f = {}

j = 0
k = 0

for i,n in enumerate(f1):
    r = 0
    for word in l2:
        if word in f1[n]['bulk_symbols']:
            r += 1
    if r == 1:
        f[n] = f1[n]

for i,n in enumerate(f):
    m = 0; p = 0; r = 0
    for word in l3:
        if word in f[n]['bulk_symbols']:
            r += 1
    if r == 1:
        dict2[n] = {f[n]['bulk_symbols'], f[n]['miller_index']}
        dict1[n] = f[n]
        j += 1

Materials Project data screening

By computing properties of all known materials, the Materials Project aims to remove guesswork from materials design in a variety of applications. Experimental research can be targeted to the most promising compounds from computational data sets. Researchers will be able to data-mine scientific trends in materials properties. By providing materials researchers with the information they need to design better, the Materials Project aims to accelerate innovation in materials research.

Utilize the ‘query’ function with different criteria for quick screening

import pandas as pd
import pickle
import os
from pymatgen import MPRester

data = m.query(criteria={"elements": {"$nin":l6,"$in": l2},"nelements": 2,"spacegroup.symbol":"Pm-3m"}, properties=["material_id","pretty_formula","spacegroup.symbol"])

with open('index', 'w') as txt:
    print(data, file = txt)

data1 = {}
for i,n in enumerate(data):
    if ('3' in data[i]['pretty_formula']) and all(num not in data[i]['pretty_formula'] for num in l_):
#        print (data[i])                                                                                                
        ID = data[i]['material_id']
        data1[ID] = data[i]
        z += 1

with open('index.pickle', 'wb') as handle:
    pickle.dump(data1, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open('index1', 'w') as txt:
    print(data1, file = txt)

print ('your job is done, total {} systems'.format(z))

Screen Pm3m type of crystal structure.

m = MPRester('MlyixfIghRqd56ET')

f = pd.read_pickle('../Bimetallic/index.pickle')

dict1 = {}
dict2 = {}
dict3 = {}

for i,n in enumerate(f):
    ID = f[n]['bulk_mpid']
    if ID in f1:
        if f1[ID]['spacegroup.symbol'] == 'Pm-3m':
            dict3[n] = f[n]
            dict2[n] = {f[n]['bulk_symbols'],f[n]['bulk_mpid'], f[n]['miller_index'],f1[ID]['spacegroup.symbol'],f[n]['ads_symbols']}
            dict1[n] = f[n]
            z += 1

if os.path.exists('index.pickle'): os.remove('index.pickle')
if os.path.exists('index'): os.remove('index')

with open('index.pickle', 'wb') as handle:
    pickle.dump(dict1, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open('index', 'w') as txt:
    print(dict2, file = txt)

print ('your job is done, total {} systems'.format(z))

Try to match the two data sets for A3B type of alloys

m = MPRester('MlyixfIghRqd56ET')

f = pd.read_pickle('../OC.pkl')
f1 = pd.read_pickle('../2e_1/index.pickle')
dict1 = {}
dict2 = {}
dict3 = {}

for i,n in enumerate(f):
    ID = f[n]['bulk_mpid']
    ADS = f[n]['ads_symbols']
    if ID in f1:
        if ADS == '*H':
            if (f[n]['miller_index'][0] == 1 and f[n]['miller_index'][1] == 1 and f[n]['miller_index'][2] == 1) \
            or (f[n]['miller_index'][0] == 1 and f[n]['miller_index'][1] == 0 and f[n]['miller_index'][2] == 0):
                dict2[n] = {f[n]['bulk_symbols'],f[n]['bulk_mpid'],f[n]['miller_index'],
                            f1[ID]['spacegroup.symbol'],f[n]['ads_symbols']}
                dict1[n] = f[n]
                z += 1

if os.path.exists('index.pickle'): os.remove('index.pickle')
if os.path.exists('index'): os.remove('index')

with open('index.pickle', 'wb') as handle:
    pickle.dump(dict1, handle, protocol=pickle.HIGHEST_PROTOCOL)
with open('index', 'w') as txt:
    print(dict2, file = txt)

print ('your job is done, total {} systems'.format(z))

Brief introduction to crystal structures.

Prospective and Economic Analysis for solar fertilizers

2021-04-28T18:32:20+00:00

Ammonia has an annual global production of more than 170 million metric tons, 85% of which are further processed to Nitrogen based fertilizers (Pattabathula and Richardson 2016). N fertilizers are estimated to feed half of the global population (Zhang et al. 2015). Thus, ammonia plays a key role in feeding the sustaining growing human population and helps solve the world hunger issue. In the early 1900s, Haber and Bosch invented a thermocatalytic process to synthesize ammonia from nitrogen and hydrogen, which is well known as the Haber-Bosch process right now, and it is currently the only industrialized process to produce ammonia. However, there are downsides of the process, firstly, the extreme reaction conditions, including higher temperature (700K) and pressure (100 bar), limit the production process in a centralized form from the economic view. Moreover, hydrogen is used as the feedstock for the production of ammonia, most of which (80%) is derived from the methane reforming process by using natural gas (Wang et al. 2018). Consequently, the H-B is carried out to be carbon intensive with approximately 2 tons of CO2 accompanying the production of each ton of NH3. For these reasons, the H-B process accounts for approximately 2% of the global energy consumption and 1.2% of the global emission of greenhouse gas (Appl 2000).

But with more than 100 years of development, the centralized plant is energy efficient with a thermochemical efficiency of up to 70%, and the cost of the production keeps decreasing. Nonetheless, the huge capacity of the plant requires a large amount of natural gas feedstock and a stable society environment to operate, which leads to the dense location of H-B plants in some developed and Asian countries (McArthur and McCord 2017). However, the demand of N based fertilizers is dispersed globally since the distribution of cropland and pasture worldwide is not concentrated. When the large scale ammonia production plant can not be conducted in some area, the need of N based fertilizers can only be met through long range or oversea transportation from the dense production locations to the fertilizer demanding locations and a unified storage place. The poor accessibility of fertilizers affect more obviously on some remote areas such as sub-Saharan Africa, where the average nitrogen fertilizer usage per hectare of cropland is inadequate to maintain soil fertility, leading to the crop yields not increasing substantially. As a result, a share of 10% to more than 60% of the total population in sub-Saharan is undernourished (https://ourworldindata.org/). Things become even worse when this severe circumstance won’t have much improvement in next decades since the H-B process plant remains unaffordable for remote countries and there is always a need for oversea transportation and storage. At the same time, for areas where fertilizers are easily available and then over fertilization more often becomes a problem. When the high concentrated fertilizers are applied during agricultural practices, nitrogen may runoff from farms and could contaminate the cropland surface and underground water, which will further pollute the ocean to form “dead zones” in coastal areas, such as the Gulf of Mexico (Diaz and Rosenberg 2008). Moreover, the gas emission of nitrous oxide from the ammonia based fertilizers accounts for another part of the greenhouse gas issue.

With the consideration of the high energy consumption and carbon footprint of the centralized ammonia production plant, one strategy is possible to overcome the challenges, which is by integrating renewable energies and a carbon free ammonia production process in a decentralized small-scale facility. Renewable energies are becoming increasingly abundant and more efficient energy sources for industrial practices with much lower environmental effect compared to fossil fuels. Solar energy here can integrate perfectly with agricultural applications since crops are usually growing in areas with adequate solar irradiation from the sun, which promise enough energy can be captured to provide the whole process. Meanwhile, huge effort has been devoted into the development of the carbon free ammonia production process, especially the electrochemical ammonia synthesis process. Electrochemical reduction from N2 to ammonia is an attractive approach for ammonia production since the reaction is usually conducted under mild conditions while using inexpensive N2 and H2O as feedstocks, which are also accessible to farms. The other aspect considered here is to conduct the nitrogen fixation process ultimately in a small on-site scale, and the product can be directly utilized at the point of production, which avoids the transportation and storage of fertilizers from centralized plants to farms.

Although the on-site electrochemical ammonia production shows substantial advantages than the traditional H-B process, there are still considerable challenges. One critical issue of this nitrogen fixation process is to break the stable triple bond between nitrogen atoms at ambient conditions. When operated by solar electricity, the electrochemical conversion of nitrogen and selectivity towards ammonia is far from realistic applications. On the other hand, there is a need to consider the concentration difference between the traditional fertilizers and the product from the on-site ammonia production process. The well developed H-B process can produce fertilizers in very high efficiency and increase the nitrogen concentration in the fertilizer to reduce the transportation and storage fee, however, the electrochemical NH3 production can only be expected to have a dilute nitrogen concentration with the limitation of the catalysts. As a result, how to efficiently utilize this low fixed nitrogen concentration to the agricultural practices becomes another aspect of the challenges.

In this project, we demonstrate the viability of practical application of the electrochemical nitrogen reduction to ammonia in a small on-site scale. The whole application system has been divided into 4 sub-systems: solar cells, a PEM fuel cell, an ammonia synthesizer, and a NH₃ agricultural application system. The advantages and challenges of each sub-system are discussed and possible strategies to improve the efficiency are given. Moreover, we develop an economic analysis model to evaluate the system, and provide the estimate of the performance targets of electrocatalysts to beat the traditional H-B process.

Energy system

The whole system can be divided into 4 sub-systems:

Solar cell

The solar cell convert the energy from the sunlight to electronic energy to drive the whole system.

PEM fuel cell

PEM fuel cell has two functions: clean up the air to remove the oxygen; utilize the side product hydrogen generated from the ammonia synthesizer.

Ammonia synthesizer

The reactor that utilizes N₂ and water to produce ammonia with electricity as the power.

Ammonia application

Ammonia can be applied to the agriculture by different ways: Biosolids and Fertigation.

Module system

The ammonia producing system is a module system, which can be connected with each other to save the cost.

Breakeven

The market price per ton of ammonia for the current state-of-the-art Haber-Bosch process is stable at around $600, while the price to produce one ton of ammonia by the complex system varied with the performance of the catalytic reaction. To achieve a breakeven price, the required faradaic efficiency (FE) for the nitrogen electro-reduction to ammonia catalytic reaction is around 42%, which is still much higher than the current FE (10% ~ 20%) for good performance catalysts.

Price Map

The price contour map shows the market price of ammonia produced by the complex system as a function of the electricity price and the faradaic efficiency. The two curves represent the average H-B ammonia price in Africa and USA, respectively. The complex system has a lower price when going further right from the curve.

Conclusion

The module ammonia producing system can utilize the electric energy and simple sources to produce value added product ammonia in a small scale, which can be applied in some undeveloped areas where the centralized H-B process is hard to be commercialized.
The current performance of catalysts cannot achieve the requirement of the facility, so further developments are needed.

Setting up your working environment

2021-04-02T00:00:00+00:00

How to log onto the ARC computing system

1.Install VPN

For users that want to use the ARC system off campus, a VPN is needed. Check out how to install and use the software through this website (they provide very detailed instructions and videos): VT4help. All different systems (Linux, MacOS and Windows) are supported. Make sure you connect to the VPN before logging onto the computing system when you are off campus.

2.Mac users login

Open your terminal software (in launchpad → other).

Login by ssh commands listed below. Our university’s supercomputing system has three available servers: Newriver, Cascades, and Tinkercliffs. You can log into any one of them to get access to your data since they are sharing the same storage.

Newriver: ssh -Y #yourid#@newriver1.arc.vt.edu OR ssh -Y #yourid#@newriver2.arc.vt.edu Cascades: ssh -Y #yourid#@cascades1.arc.vt.edu OR ssh -Y #yourid#@cascades2.arc.vt.edu Tinkercliffs: ssh -Y #yourid#@tinkercliffs1.arc.vt.edu OR ssh -Y #yourid#@tinkercliffs2.arc.vt.edu

Then press Enter you will be asked to type in your password which is your VT account password (not your network password). Nothing will show up when you type in your password but the system will recognize it, just make sure it’s correct and then press Enter. Prepare your phone’s DUO app ready with you since you will need a 2-step authentication.

Use this format since the 2-step authentication: mypassword,push (See https://arc.vt.edu/2fa/). After typing in your password, press Enter and your DUO app will ask you for authorization.

After the authorization, you will enter one of the arc computing systems successfully which looks like this:

3.Windows users login—By Installing SSH client

After installing the Pulse Secure software, a Secure Shell (SSH) software is needed to enable you to connect to the arc server. If you are using a Windows machine, you will need to download an SSH client, such as PuTTY or the SSH Secure Shell Client.

Here I give an instruction on how to use PuTTY as an example. Go to the website of PuTTY and download. Then choose the 64 bit windows version.

Follow the regular instructions and install the putty software. Then in the start menu you will the putty software and open it, a window will prompt out like this:

At the Host Name session, write into the server address. Available servers and addresses are listed below. Our university’s supercomputing system has three available servers: Newriver, Cascades, and Tinkercliffs. You can log into any one of them to get access to your data since they are sharing the same storage.

Newriver: newriver1.arc.vt.edu OR newriver2.arc.vt.edu Cascades: cascades1.arc.vt.edu OR cascades2.arc.vt.edu Tinkercliffs: tinkercliffs1.arc.vt.edu OR tinkercliffs2.arc.vt.edu

Try Newriver first and for all servers try suffix 1 first, and if suffix 1 is not working then try suffix 2. In most cases suffix 1 will work.

Then you press open to turn on the SSH (Maybe a security alert window will prompt out and you just choose no.) and you will see ‘login as’

Write into your arc account username. You can easily find it from the coldfront.arc.vt.edu website.

Then you will be asked to type in your password which is the same as your vt account password (not network password). Prepare your phone’s DUO app ready with you since you will need a 2-step authentication. After typing in your password, press Enter and your DUO app will ask you for authorization.

After this, you will enter the server file system finally.

4.Generate a ssh key for quick login next time.

(1). Generate keys

In your local terminal:

ssh-keygen -t rsa

Press [ENTER] key —- accept the default location. The ssh-keygen utility prompts you for a passphrase.
Press [ENTER] key —- accept the default (no passphrase). Or you can type in a passphrase.
Press [ENTER] key —- Continue to leave it empty. Or you can enter the passphrase a second time to continue.
After you confirm the passphrase, the system generates the key pair (private and public keys)

(2). Check saved keys

Your identification has been saved in /Users/myname/.ssh/id_rsa.

Your public key has been saved in /Users/myname/.ssh/id_rsa.pub.

Your private key is saved to the id_rsa file in the .ssh directory.

The key fingerprint is:

ae:89:72:0b:85:da:5a:f4:7c:1f:c2:43:fd:c6:44:38 myname@mymac.local

The key’s randomart image is:

(3). Save your public key to the server

Go to id_rsa.pub file you generated just now to copy your public key. (Remember to copy everything)

Go to ~/.ssh folder and open authorized_keys file.

paste your public key to this file.

Save the file.

Refer to this website for more explanations.

https://docs.joyent.com/public-cloud/getting-started/ssh-keys/generating-an-ssh-key-manually/manually-generating-your-ssh-key-in-mac-os-x

Setting up working environments:

It’s better to compile VASP first for some steps to be working. For this instruction, make sure you copy the right files from the right directory. ‘/path/to’ means you have to replace it with the specific path in your own account.

1.[./] First setup Miniconda3 environment.

./ directory here can be your home directory:

/home/yourid

You can make a new directory to put all packages in:

make usr

2.[./usr] Copy and paste Miniconda3 package from:

cp /work/common/hxin_lab/hxin/Installation/Miniconda3-latest-Linux-x86_64.sh ./

3.[./usr] Compile Miniconda3:

bash Miniconda3-latest-Linux-x86_64.sh 

By default Miniconda3 will be installed to your home directory, you can change the path to during the installation process. For example, you can change it to:

/home/youruserid/usr/miniconda3

4.[./usr] After setting up miniconda3, you can set up some ASE environments:

You can copy and paste the whole folder for specific versions of ASE to the usr directory.

cp -r /work/common/hxin_lab/hxin/Installation/ase-3.17.0 ./
cp -r /work/common/hxin_lab/hxin/Installation/ase-3.19.0 ./
cp -r /work/common/hxin_lab/hxin/Installation/ase-3.15 ./

5.[./] Setup priviatemodules

mkdir priviatemodules; cd priviatemodules
cp -r /work/common/hxin_lab/hxin/Installation/priviatemodules/* .

6.[./priviatemodules] Change paths for VASP modules. For this step, you have to compile VASP first, following another instruction for VASP compilation.

cd vasp_l; emacs 5.4.4-vtst

Change all paths to your own paths:

append-path PATH /path/to/vasp_suite/src/vasp.5.4.4/bin
setenv VASP_PP_PATH /path/to/vasp_suite/lib
setenv VASP_SCRIPT /path/to/priviatemodules/ase_vasp/run_vasp.py

7.[./priviatemodules] Change paths for ASE modules.

cd ase; emacs 3.19

Change all paths to your own paths:

append-path     PATH    /work/tianyou/usr/ase-3.19.0/ase-3.19.0/bin
append-path     PYTHONPATH    /work/tianyou/usr/ase-3.19.0/ase-3.19.0

emacs 3.17

Change all paths to your own paths:

append-path     PATH    /work/common/hxin_lab/hxin/cascades/usr/ase-3.17.0/ase-3.17.0/bin
append-path     PYTHONPATH    /work/common/hxin_lab/hxin/cascades/usr/ase-3.17.0/ase-3.17.0

emacs 3.15

Change all paths to your own paths:

append-path     PATH    /home/hxin/cascades/usr/ase-3.15/bin
append-path     PYTHONPATH   /home/hxin/cascades/usr/ase-3.15/lib/python2.7/site-packages

8.[./] Script

cp -r /work/common/hxin_lab/hxin/Installation/Script .

9.[./] Setup .modules.

Copy .modules files which contain modules for VASP running and need to be sourced every time before you want to use VASP.

cp /work/common/hxin_lab/hxin/Installation/modules/* .

ls -A will show hidden files in this directory

Edit .modules.vasp-vtst3 file and change the miniconda3 path:

module purge
module reset

module load VASP
module unload VASP/5.4.4-intel-2019b
module load vasp_l/5.4.4-vtst
module load ase/3.19

export PATH=“/path/to/miniconda3/bin:$PATH"

10.[./] Setup .bashrc

alias cdw="cd /work/$(whoami)"
alias ag="ase gui"

export PATH=/path/to/Script:$PATH
export PYTHONPATH=/path/to/Script:$PYTHONPATH
export PATH=/path/to/Script/vtst:$PATH
export PYTHONPATH=/path/to/Script/vtst:$PYTHONPATH

export MODULEPATH=/path/to/priviatemodules:$MODULEPATH

11.[./] Conda install numpy, scipy

Install necessary packages for conda:

source ~/.bashrc
source /path/to/.modules.vasp-vtst3

Install numpy: conda install -c anaconda numpy

Install scipy: conda install -c anaconda scipy 

For other unnecessary packages, you can search conda installation commands on google.

12.[./] Test with your Script.py and ASE GUI to see if all modules work or not.

13.[./] Every time you want to use VASP you have to type:

source /path/to/.modules.vasp-vtst3

For convenience you can also add this command to ~/.bashrc.

VASP Compilation

For this instruction, make sure you copy the right files from the right directory. ‘/path/to’ means you have to replace it with the specific path in your own account.

1.[./] First generate vasp folder as the root folder:

mkdir vasp_suite

For tinkercliffs, you can make it in the $WORK directory:

cd $WORK; mkdir vasp_suite

For a more systematic way, you can put vasp suite into the usr directory by:

cd $WORK; mkdir usr; cd usr; mkdir vasp_suite

Or compile it in the /home directory which can be used for all three servers.

2.[./vasp_suite] Generate vasp lib folder to save pseudopotential files:

mkdir lib

3.[./vasp_suite/lib] Download pseudopotential files you need, for instance: potpaw_LDA.52.tar.gz and potpaw_PBE.52.tar.gz. This is for the ase interface binary.

You can go to this folder to copy the pseudopotential source package:

/work/common/hxin_lab/hxin/Installation

For tinkercliffs, you can firstly copy and paste everything to your home directory: Login cascades, and then:

cp -r /work/common/hxin_lab/hxin/Installation ~

Then next time when you are on the tinkercliffs, you can copy from:

cp ~/Installation /path/to/where/you/want

4.[./vasp_suite/lib] Tar files:

tar -xvf potpaw_LDA.52.tar.gz ; tar -xvf potpaw_PBE.52.tar.gz

More info about tar command: https://www.freecodecamp.org/news/tar-in-linux-example-tar-gz-tar-file-and-tar-directory-and-tar-compress-commands/

This command will tar your .gz files and generate folders saving pseudo potentials

5.[./vasp_suite] Go back to the vasp_suite root folder and make another source folder:

mkdir src

6.[./vasp_suite/src] Go to src folder and download the vasp package: vasp.5.4.4.tar.gz

You can go to this folder to copy the vasp source package:

/work/common/hxin_lab/hxin/Installation

7.[./vasp_suite/src] Same way to tar this .gz file:

tar -xvf vasp.5.4.4.tar.gz

8.[./vasp_suite/src/vasp.5.4.4] Then go to the generated vasp.5.4.4 folder and such folders and files are in this folder:

arc bin build makefile README src

9.[./vasp_suite/src/vasp.5.4.4] Copy one of the makefile.include.arch files in ./arch to ./makefile.include. Take one that most closely reflects your system (hopefully). For instance, on a linux box with the Intel Composer suite:

cp arch/makefile.include.linux_intel  ./makefile.include

You can go to this folder to copy the makefile I’ve made:

/work/common/hxin_lab/hxin/Installation

For the tinkercliffs server, use this one instead:

/work/common/hxin_lab/hxin/Installation/tinkercliffs

10.[./vasp_suite/src/vasp.5.4.4] So right now we have this makefile.include file and then we need to set it up.

11.[./vasp_suite/src/vasp.5.4.4/] Add beef to vasp. Copy and paste the beef folder:

cp -r /work/common/hxin_lab/hxin/Installation/beef ./

Change BEEF tag in the makefile.include file to :

BEEF       = -L/path/to/vasp_suite/src/vasp.5.4.4/beef/lib -lbeef

Save and exit the makefile.include file.

12.[./vasp_suite/src/vasp.5.4.4/src] After setting up the makefile, for vtsttools installation, another several steps need to be done(No need if you don’t use VTST tools). Go to src folder under vasp.5.4.4:

cd ./vasp_suite/src/vasp.5.4.4/src

13.[./vasp_suite/src/vasp.5.4.4/src] In this folder, edit main.F file to find and replace (using ctrl+s for quick search):

CALL CHAIN_FORCE(T_INFO%NIONS,DYN%POSION,TOTEN,TIFOR, &
     LATT_CUR%A,LATT_CUR%B,IO%IU6)

with

CALL CHAIN_FORCE(T_INFO%NIONS,DYN%POSION,TOTEN,TIFOR, &
     TSIF,LATT_CUR%A,LATT_CUR%B,IO%IU6)

14.[./vasp_suite/src/] Backup your chain.F since vtsttools also has one. Go back to the upper folder and make a backup folder.

cd ./vasp_suite/src/ ; mkdir backup ; cd backup 
cp ./vasp_suite/src/vasp.5.4.4/src/chain.F ./

15.[./vasp_suite/src/] Download source codes of vtsttools by this command (using svn checkout):

svn co http://theory.cm.utexas.edu/svn/vtsttools 

Or directly copy from directory:

cp -r /work/common/hxin_lab/hxin/Installation/vtsttools ./

A vtsttools folder will be generated and contains 3 subfolders:

docs vtstcodes vtsttools

16.[./vasp_suite/src/vasp.5.4.4/src] Go to vasp.5.4.4/src folder, copy and paste all source codes from vtsttools which are inside of vtstcode folder:

cd ./vasp_suite/src/vasp.5.4.4/src
cp ./vasp_suite/src/vtsttools/vtstcode/* ./

17.[./vasp_suite/src/vasp.5.4.4/src] At the same folder, edit .objects file to change vasp source codes. Better way is to directly copy from

/work/common/hxin_lab/hxin/Installation/tinkercliffs/src/.objects

emacs .objects (or any tools available to you to edit the file) add the following objects before chain.o:

bfgs.o \
dynmat.o  \
instanton.o  \
lbfgs.o \
sd.o  \
cg.o \
dimer.o \
bbm.o \
fire.o \
lanczos.o \
neb.o  \
qm.o \
opt.o \

Make sure you delete all spaces after ‘\’ and then press ‘Enter’. Save and exit the .objects file.

18.[./vasp_suite/src] Download VASPsol from github for solvation calculations.

git clone https://github.com/henniggroup/VASPsol.git

19.[./vasp_suite/src] Change solvation source code:

cp ./VASPsol/src/solvation.F ./vasp.5.4.4/src/

20.[./vasp_suite/src/vasp.5.4.4] Make sure you add -Dsol_compat option to the list of precompiler options (CPP_OPTIONS) in the makefile.include

For the makefile.include file copied directly from the Installation folder, you don’t need to make any changes.

21.[./vasp_suite/src/vasp.5.4.4/] The last step is the actual compilation of VASP:

On newriver:

module purge; module load intel/15.3; module load openmpi/1.8.5; module load mkl

On cascades:

module purge; module load intel/15.3; module load openmpi/2.0.0; module load mkl

On tinkercliffs:

module load VASP

Then:

make std gam ncl

If you are encountering any errors, go to step 24 for some possible solutions.

After successful compilation, three binaries of vasp can be found in “./vasp_suite/src/vasp.5.4.4/bin”, namely the standard full k-point version “vasp_std”, the gamma-only version “vasp_gam” and the non-collinear version “vasp_ncl”.

22.Running vasp in parallel with, say 4 MPI ranks, is done using

mpirun -np 4 /path/to/vasp_std

Remember to set up all dependencies before running VASP.

23.[./vasp_suite/kernel] Make another directory for the vdw kernel.

cd ./vasp_suite; mkdir kernel
cp /work/common/hxin_lab/hxin/Installation/kernel/vdw_kernel.bindat ./ 

24.Potential Errors:

(a).If you get some errors like the screenshot below, you probably didn’t delete all spaces in step 17. Better to directly copy and paste the right one.

(b). If you get some errors like the screenshot below, you’ll probably need to set up your locale:

Edit your local bash_profile by opening a new terminal window and type: emacs ~/.bash_profile Add the following two lines to it and save.

export LC_ALL=en_US.UTF-8
export LANG=en_US.UTF-8

For more installation details check out the websites listed below.

https://www.vasp.at/wiki/index.php/A_CentOS_based_installation_of_VASP

https://cms.mpi.univie.ac.at/vasp/vasp/vasp.html

https://theory.cm.utexas.edu/vtsttools/installation.html

https://github.com/henniggroup/VASPsol

Quantum Espresso Compilation

1.[./] Make a new folder for q-e 6.5,

mkdir espresso6.5

2.[./espresso6.5] Go to espresso6.5 folder, and download q-e 6.5 package from Github (https://github.com/QEF/q-e) by typing command:

git clone https://github.com/QEF/q-e.git

Or directly copy from here:

cp -r /work/common/hxin_lab/hxin/cascades/usr/esp-6.5/q-e .

3.[./espresso6.5/q-e] A new folder q-e will be made and go to the q-e folder:

cd q-e

module purge

module reset

module load VASP

4.[./espresso6.5/q-e] For a quick installation we just use :

./configure [options]
make all

5.[./espresso6.5] Prepare the pseudopotential folder which contains all needed pseudopotential for quantum espresso to use.

An example folder is

/home/hxin/cascades/usr/esp-psp

Copy and paste esp-psp folder and add path to

Espresso module

export ASE_ESPRESSO_COMMAND="/home/hxin/cascades/usr/esp-6.5/q-e/bin/pw.x -in PREFIX.pwi > PREFIX.pwo"

Binaries go in bin/. For more information, see the general documentation in directory Doc/, package-specific documentation in ‘*/Doc/’.

User manual: https://www.quantum-espresso.org/Doc/user_guide.pdf

Error: https://lists.quantum-espresso.org/pipermail/users/2020-July/045079.html

Libxc: https://gitlab.com/libxc/libxc

Bash tools

2021-02-01T00:00:00+00:00

This is a tool to query the current running jobs in the server’s queue. It has the function that you can directly obtain more info than the ‘squeue’ command, which is the popular command for the slurm workload manager.

Key features:

Show the RunTime and TimeLimit as the same time, which helps you to get your job status.
Show the job’s running directory, which can be directly accessed. It can save lots of time to find the job’s directory when you are running multiple jobs

#!/usr/bin/env bash

if [ “$SYSNAME” = “newriver” ] || [ “$SYSNAME” = “blueridge” ] || [ “$SYSNAME” = “cascades” ]; then
JOBID=$(qstat | grep $(whoami)' ' | grep -Eo '[0-9]{6}')
elif [ “$SYSNAME” = “tinkercliffs” ]; then
JOBID=$(squeue -u $(whoami) | grep -Eo '[0-9]{6}')
elif [ “$SYSNAME” = “infer” ]; then
JOBID=$(squeue -u $(whoami) | grep -Eo '[0-9]{5}')
fi

RED='\033[0;31m'
NC='\033[0m'
BLUE='\e[34m'

QSUB=./Qsub.sh

NEWRIVERPATH=/work/common/hxin_lab/tianyou/Jobsub/newriver
NEWRIVERPATH1=/groups/hxin_lab/tianyou/Jobsub/newriver

SPACE=' '

if [ “$SYSNAME” = “newriver” ] || [ “$SYSNAME” = “blueridge” ]; then
for ID in $JOBID
  do
    CHECK=$(checkjob -v $ID) 
    JOBPATH1=$(echo $CHECK | grep -o -e /home.* -e /work.* -e /groups.* | cut -d ' ' -f 1)
    NEW=$(echo $JOBPATH1 | cut -d '/' -f -7)
    NEW1=$(echo $JOBPATH1 | cut -d '/' -f -8)
    QSTAT=$(qstat | grep $(whoami)' ' | grep $ID | cut -b 1-6,14,28-44,69-79,14)
    WALLTIME=$(echo $CHECK | grep -o WallTime.* | cut -b 10-33)
    if [ "$NEW" = "$NEWRIVERPATH" ]; then
    cd "$NEW1" 
    if test -f "$QSUB"; then
    REALPATH=$(cat Qsub.sh | grep -o -e /work.* -e /groups.*)
    echo -e $QSTAT${SPACE}${SPACE}$WALLTIME${SPACE}${RED}$REALPATH${NC}
    elif [ "$NEW" = "$NEWRIVERPATH" ]; then
    echo -e $QSTAT${SPACE}${SPACE}$WALLTIME${BLUE}' Not assigned yet.'${NC}
    else
    echo -e $QSTAT${SPACE}${SPACE}$WALLTIME${SPACE}${RED}$PWD${NC}
    fi
    else
    cd "$NEW"
    if test -f "$QSUB"; then
    REALPATH=$(cat Qsub.sh | grep -o /work.*)
    echo -e $QSTAT${SPACE}${SPACE}$WALLTIME${SPACE}${RED}$REALPATH${NC}
    elif [ "$(echo $JOBPATH1 | cut -d '/' -f -6)" = "$NEWRIVERPATH1" ]; then
    echo -e $QSTAT${SPACE}${SPACE}$WALLTIME${BLUE}' Not assigned yet.'${NC}
    else
    NP=$(echo $JOBPATH1 | rev | cut -d '/' -f 2- | rev)
    echo -e $QSTAT${SPACE}${SPACE}$WALLTIME${SPACE}${RED}$NP${NC}
    fi
    fi
  done
fi

CASCADESPATH=/groups/hxin_lab/tianyou/Jobsub/cascades

if [ “$SYSNAME” = “cascades” ]; then
for ID in $JOBID 
  do
    CHECK=$(scontrol show jobid $ID) # check job info
    JOBPATH1=$(echo $CHECK | grep -o -e /home.* -e /groups.* | cut -d ' ' -f 1) # check job path
    QSTAT=$(qstat | grep $(whoami)' ' | grep $ID | cut -b 1-6,7,15-30,62-72,7) # info from qstat
    WALLTIME=$(echo $CHECK | grep -o RunTime.* | cut -b 1-38) # wall time
    cd "$(echo $JOBPATH1 | cut -d '/' -f -6)"
    if test -f "$QSUB"; then # check if in the Jobsub folder
    REALPATH=$(cat Qsub.sh | grep -o -e /groups.* -e /work.*) # read real path from Qsub.sh file
    echo -e $QSTAT${SPACE}$WALLTIME${SPACE}${RED}$REALPATH${NC} 
    elif [ "$(echo $JOBPATH1 | cut -d '/' -f -6)" = "$CASCADESPATH" ]; then # if Qsub.sh not exist then not assigned yet.
    echo -e $QSTAT${SPACE}$WALLTIME${BLUE}' Not assigned yet.'${NC}
    else
    NP=$(echo $JOBPATH1 | rev | cut -d '/' -f 2- | rev) # if not in the Jobsub folder, then print real path read from job info
    echo -e $QSTAT${SPACE}$WALLTIME${SPACE}${RED}$NP${NC}
    fi
  done
fi

if [ “$SYSNAME” = “tinkercliffs” ] || [ “$SYSNAME” = “infer” ]; then
for ID in $JOBID
  do
    CHECK=$(scontrol show jobid $ID) # check job info
    JOBPATH1=$(echo $CHECK | grep -o -e /home.* -e /work.* -e /projects.* | cut -d ' ' -f 1) # check job path 
    QSTAT=$(squeue -u $(whoami)| grep $ID | cut -b 13-39,48-50) # info from qstat
    WALLTIME=$(echo $CHECK | grep -o RunTime.* | cut -b 1-38) # wall time
    cd "$(echo $JOBPATH1 | cut -d '/' -f -5)"
    if test -f "$QSUB"; then # check if in the Jobsub folder                                              
    REALPATH=$(cat Qsub.sh | grep -o -e /groups.* -e /work.*) # read real path from Qsub.sh file            
    echo -e $QSTAT${SPACE}$WALLTIME${SPACE}${RED}$REALPATH${NC}
    elif [ "$(echo $JOBPATH1 | cut -d '/' -f -6)" = "$CASCADESPATH" ]; then # if Qsub.sh not exist then not assigned yet.
    echo -e $QSTAT${SPACE}$WALLTIME${BLUE}' Not assigned yet.'${NC}
    else
    NP=$(echo $JOBPATH1 | rev | cut -d '/' -f 2- | rev) # if not in the Jobsub folder, then print real path read from job info                
    echo -e $QSTAT${SPACE}$WALLTIME${SPACE}${RED}$NP${NC}
    fi
  done
fi

Key features:

Show the RunTime and TimeLimit as the same time, which helps you to get your job status.
Show the job’s running directory, which can be directly accessed. It can save lots of time to find the job’s directory when you are running multiple jobs

if [ “$SYSNAME” = “newriver” ] || [ “$SYSNAME” = “blueridge” ]; then
tail -150 /work/common/hxin_lab/tianyou/Jobsub/newriver.txt > /work/common/hxin_lab/tianyou/Jobsub/newriver1.txt
cat /work/common/hxin_lab/tianyou/Jobsub/newriver1.txt
fi
if [ “$SYSNAME” = “cascades” ]; then
tail -150 /groups/hxin_lab/tianyou/Jobsub/cascades.txt > /groups/hxin_lab/tianyou/Jobsub/cascades1.txt
cat /groups/hxin_lab/tianyou/Jobsub/cascades.txt
fi
if [ “$SYSNAME” = “tinkercliffs” ]; then
tail -150 /home/tianyou/Jobsub/tinkercliffs.txt > /home/tianyou/Jobsub/tinkercliffs1.txt
cat /home/tianyou/Jobsub/tinkercliffs1.txt
fi

#!/usr/bin/env bash

RED='\033[0;31m'
NC='\033[0m'
BLUE='\e[34m'

QSUB=./Qsub.sh
STDE=./std.e
STDO=./std.o

PATHNAME=$PWD

while getopts  "h:q:" flag
do
  case $flag in
    h) echo "   -q - QUEUE is the queue to submit to (default is batch)"
       exit 0
     ;;
    q) if [ "$OPTARG" = "" ]; then
       JOBNAME=$(echo $PATHNAME | cut -d '/' -f 8)
       else
       JOBNAME=$(echo $OPTARG | cut -d '' -f 1)
       fi
       for JOB in $JOBNAME
        do 
	  if [ “$SYSNAME” = “newriver” ] || [ “$SYSNAME” = “blueridge” ]; then
	  cd /work/common/hxin_lab/tianyou/Jobsub/newriver/$JOB
	  elif [ “$SYSNAME” = “cascades” ]; then
	  cd /groups/hxin_lab/tianyou/Jobsub/cascades/$JOB
	  fi
	  echo -e ${RED}$PWD${NC}
	  if [ -e $QSUB ]; then rm ./Qsub.sh; fi
	  if [ -e $STDE ]; then rm ./std.e; fi
	  if [ -e $STDO ]; then rm ./std.o; fi
	  qsub Script.py.qsub
	done
     ;;
  esac 
done
shift $(($OPTIND - 1))

#!/usr/bin/env bash

rm ./Qsub.sh
rm ./std.*
qsub Script.py.qsub

Calculating Hartree Fock Energy of Hydrogen Using Python

2020-10-02T00:00:00+00:00

Overview

I employed this LCNN to train the Cluster expansion model and then compare with the CE-TinNet model.

Import needed libraries

import numpy as np 
import collections 
import copy
from scipy.special import comb
from scipy.special import factorial2
from scipy.special import factoria

Read Basis set info from the EMSL basis set exchange in the format of Gaussian 94.

file = open("basis.dat")
aodict = collections.defaultdict(list)
newatomtype = False
contract_num = None
origin = (0,0,0)
orbitalType = None
for line in file:
    if line.strip() == "****":
        newatomtype = True
        linecount = 0
    elif line.strip() != "****" and newatomtype == True:
        if linecount == 0:
            atomtype, _ = line.split()
            linecount += 1
            print(atomtype)
        elif linecount == 1:
            orbitalType, contract_num, _ = line.split()
            contract_num = int(contract_num)
            if orbitalType == "S":
                aos = Ao(origin, (0,0,0), contract_num)
                aodict[atomtype].append(aos)
            elif orbitalType == "P":
                aopx = Ao(origin,(1,0,0), contract_num)
                aopy = Ao(origin,(0,1,0), contract_num)
                aopz = Ao(origin,(0,0,1), contract_num)
                aodict[atomtype].append(aopx)
                aodict[atomtype].append(aopy)
                aodict[atomtype].append(aopz)
            elif orbitalType == "D":
                aodx2 = Ao(origin,(2,0,0), contract_num)
                aody2 = Ao(origin,(0,2,0), contract_num)
                aodz2 = Ao(origin,(0,0,2), contract_num)
                aodxy = Ao(origin,(1,1,0), contract_num)
                aodyz = Ao(origin,(0,1,1), contract_num)
                aodzx = Ao(origin,(1,0,1), contract_num)
                aodict[atomtype].append(aodx2)
                aodict[atomtype].append(aody2)
                aodict[atomtype].append(aodz2)
                aodict[atomtype].append(aodxy)
                aodict[atomtype].append(aodyz)
                aodict[atomtype].append(aodzx)
            elif orbitalType == "SP":
                aos = Ao(origin,(0,0,0), contract_num)
                aodict[atomtype].append(aos)
                aopx = Ao(origin,(1,0,0), contract_num)
                aopy = Ao(origin,(0,1,0), contract_num)
                aopz = Ao(origin,(0,0,1), contract_num)
                aodict[atomtype].append(aopx)
                aodict[atomtype].append(aopy)
                aodict[atomtype].append(aopz)
            linecount += 1
            print(orbitalType, contract_num)
        elif contract_num and 1 <linecount <= 1 + contract_num:
            if orbitalType == "S" or orbitalType == "P" or orbitalType == "D":
                exponent, coeff = line.split()
                exponent = float(exponent)
                coeff = float(coeff)
                if orbitalType == "S":
                    aos.exponents[linecount - 2] = exponent
                    aos.coeffs[linecount - 2] = coeff
                elif orbitalType == "P":
                    aopx.exponents[linecount - 2] = exponent
                    aopy.exponents[linecount - 2] = exponent
                    aopz.exponents[linecount - 2] = exponent
                    aopx.coeffs[linecount - 2] = coeff
                    aopy.coeffs[linecount - 2] = coeff
                    aopz.coeffs[linecount - 2] = coeff
                elif orbitalType == "D":
                    aodx2.exponents[linecount - 2] = exponent
                    aody2.exponents[linecount - 2] = exponent
                    aodz2.exponents[linecount - 2] = exponent
                    aodxy.exponents[linecount - 2] = exponent
                    aodyz.exponents[linecount - 2] = exponent
                    aodzx.exponents[linecount - 2] = exponent
                    aodx2.coeffs[linecount - 2] = coeff
                    aody2.coeffs[linecount - 2] = coeff
                    aodz2.coeffs[linecount - 2] = coeff
                    aodxy.coeffs[linecount - 2] = coeff
                    aodyz.coeffs[linecount - 2] = coeff
                    aodzx.coeffs[linecount - 2] = coeff
                print(exponent, coeff)
            elif orbitalType == "SP":
                exponent, coeffs, coeffp = line.split()
                exponent = float(exponent)
                coeffs = float(coeffs)
                coeffp = float(coeffp)
                aos.exponents[linecount - 2] = exponent
                aos.coeffs[linecount - 2] = coeffs
                aopx.exponents[linecount - 2] = exponent
                aopy.exponents[linecount - 2] = exponent
                aopz.exponents[linecount - 2] = exponent
                aopx.coeffs[linecount - 2] = coeffp
                aopy.coeffs[linecount - 2] = coeffp
                aopz.coeffs[linecount - 2] = coeffp
                print(exponent, coeffs, coeffp)
            if linecount < 1 + int(contract_num):
                linecount += 1
            else:
                linecount = 1
                
print(aodict)

H
S 2
5.447178 0.1562849787
0.82454724 0.9046908767
S 1
0.18319158 1.0
O
S 3
322.037 0.05923939339
48.4308 0.3514999608
10.4206 0.707657921
SP 2
7.40294 -0.4044535832 0.244586107
1.5762 1.221561761 0.8539553735
SP 1
0.373684 1.0 1.0
defaultdict(<class 'list'>, {'H': [S(0, 0, 0)[5.447178, 0.82454724][0.1562849787, 0.9046908767], S(0, 0, 0)[0.18319158][1.0]], 'O': [S(0, 0, 0)[322.037, 48.4308, 10.4206][0.05923939339, 0.3514999608, 0.707657921], S(0, 0, 0)[7.40294, 1.5762][-0.4044535832, 1.221561761], Px(0, 0, 0)[7.40294, 1.5762][0.244586107, 0.8539553735], Py(0, 0, 0)[7.40294, 1.5762][0.244586107, 0.8539553735], Pz(0, 0, 0)[7.40294, 1.5762][0.244586107, 0.8539553735], S(0, 0, 0)[0.373684][1.0], Px(0, 0, 0)[0.373684][1.0], Py(0, 0, 0)[0.373684][1.0], Pz(0, 0, 0)[0.373684][1.0]]})

geomfile = open("geom.dat")
aolist = []
atomlist = []
for line in geomfile:
    atomtype, x, y, z = line.split()
    x = float(x)
    y = float(y)
    z = float(z)
    x = x * 1.8897261339213 # from Angstrom to atomic unit
    y = y * 1.8897261339213 # from Angstrom to atomic unit
    z = z * 1.8897261339213 # ....
    atomlist.append((atomtype, (x, y, z)))
    if atomtype in aodict:
        for ao in aodict[atomtype]:
            aonew = copy.copy(ao)
            aonew.center = [x,y,z]
            aolist.append(aonew)
            
print(aolist)
print(len(aolist))

[S[-0.8398320884373042, 0.75589045356852, 0.0][322.037, 48.4308, 10.4206][0.05923939339, 0.3514999608, 0.707657921], S[-0.8398320884373042, 0.75589045356852, 0.0][7.40294, 1.5762][-0.4044535832, 1.221561761], Px[-0.8398320884373042, 0.75589045356852, 0.0][7.40294, 1.5762][0.244586107, 0.8539553735], Py[-0.8398320884373042, 0.75589045356852, 0.0][7.40294, 1.5762][0.244586107, 0.8539553735], Pz[-0.8398320884373042, 0.75589045356852, 0.0][7.40294, 1.5762][0.244586107, 0.8539553735], S[-0.8398320884373042, 0.75589045356852, 0.0][0.373684][1.0], Px[-0.8398320884373042, 0.75589045356852, 0.0][0.373684][1.0], Py[-0.8398320884373042, 0.75589045356852, 0.0][0.373684][1.0], Pz[-0.8398320884373042, 0.75589045356852, 0.0][0.373684][1.0], S[0.9932022614663569, 0.75589045356852, 0.0][5.447178, 0.82454724][0.1562849787, 0.9046908767], S[0.9932022614663569, 0.75589045356852, 0.0][0.18319158][1.0], S[-1.616887474705743, 1.9434321506473433, 1.1601406681369646][5.447178, 0.82454724][0.1562849787, 0.9046908767], S[-1.616887474705743, 1.9434321506473433, 1.1601406681369646][0.18319158][1.0]]
13

Define the function that calculates 1-electron and 2-electron integrals.

def gint(m, center1, exponent1, n, center2, exponent2): #calculate one electron integral of two gaussian primitives
    newcenter = (exponent1 * center1 + exponent2 * center2) / (exponent1 + exponent2)
    newexponent = exponent1 + exponent2
    tempexponent = exponent1 * exponent2 / (exponent1 + exponent2)
    e12 = np.exp(-tempexponent*(center1 - center2)**2)
    res = 0
    for i in range(m + 1):
        for j in range(n + 1):
            if (i + j) % 2 == 0:
                res += (np.sqrt(np.pi/newexponent)*comb(m, i)*comb(n, j)*
                        factorial2(i + j - 1)/(2*newexponent)**((i + j)/2)*
                        (newcenter - center1)**(m - i)*(newcenter - center2)**(n - j)
                       )
    res = e12 * res
    return res
                        

def E(l1, l2, t, center1, center2, exponent1, exponent2):#calculate the gaussian-hermite expansion coefficient using recurence
    newcenter = (exponent1 * center1 + exponent2 * center2) / (exponent1 + exponent2)
    sumexponent = exponent1 + exponent2
    diffcenter = center1 - center2
    redexponent = exponent1 * exponent2 / (exponent1 + exponent2)
    if t > l1 + l2:
        return 0
    if l1 < 0 or l2 < 0 or t < 0:
        return 0
    elif l1 == 0 and l2 == 0 and t == 0:
        return np.exp(-redexponent*diffcenter**2)
    elif l1 > 0:
        return (1/(2*sumexponent)*E(l1-1, l2, t - 1,center1,center2,exponent1,exponent2)
                +(newcenter - center1)*E(l1-1,l2,t,center1,center2,exponent1,exponent2)
                +(t + 1)*E(l1-1,l2, t+1, center1,center2,exponent1,exponent2))
    elif l1 == 0:
        return (1/(2*sumexponent)*E(l1, l2-1, t - 1,center1,center2,exponent1,exponent2)
                +(newcenter - center2)*E(l1,l2-1,t,center1,center2,exponent1,exponent2)
                +(t + 1)*E(l1,l2-1, t+1, center1,center2,exponent1,exponent2))
    return 0


def S(m1, m2, center1, center2, exponent1, exponent2): #calculate overlap type integral
    return np.sqrt(np.pi/(exponent1 + exponent2))*E(m1, m2, 0, center1, center2, exponent1, exponent2)


def T(m1, m2, center1, center2, exponent1, exponent2): #calculate kinetic type integral
    res = 0
    res += -2*exponent2*S(m1, m2 + 2, center1, center2, exponent1, exponent2)
    res += exponent2*(2*m2+1)*S(m1, m2, center1, center2, exponent1, exponent2)
    res += -1/2*m2*(m2-1)*S(m1, m2 - 2, center1, center2, exponent1, exponent2)
    return res
    

def F(n, x): #calculate Boys function value by numerical integration
    if x < 1e-7:
        return 1/(2*n + 1)
    if n == 20:
        res1 = 1/(2*n + 1)
        #if x < 1e-7:
        #    return res1
        for k in range(1,11):
            res1 += (-x)**k/factorial(k)/(2*n+2*k+1)
        res2 = factorial2(2*n-1)/2**(n+1)*np.sqrt(np.pi/x**(2*n+1))
        res = min(res1, res2)
        return res
    return (2*x*F(n+1,x)+np.exp(-x))/(2*n+1)


def R(t, u, v, n, p, x, y, z):
    if t < 0 or u < 0 or v < 0:
        return 0
    if t == 0 and u == 0 and v == 0:
        return (-2*p)**n*F(n,p*(x**2+y**2+z**2))
    if t > 0:
        return (t-1)*R(t-2,u,v,n+1,p,x,y,z)+x*R(t-1,u,v,n+1,p,x,y,z)
    if u > 0:
        return (u-1)*R(t,u-2,v,n+1,p,x,y,z)+y*R(t,u-1,v,n+1,p,x,y,z)
    if v > 0:
        return (v-1)*R(t,u,v-2,n+1,p,x,y,z)+z*R(t,u,v-1,n+1,p,x,y,z)
    
    
def overlap(ao1, ao2): #calculate overlap matrix <psi|phi>
    l1, m1, n1 = ao1.angular
    l2, m2, n2 = ao2.angular
    x1, y1, z1 = ao1.center
    x2, y2, z2 = ao2.center
    res = 0
    for i in range(len(ao1.coeffs)):
        for j in range(len(ao2.coeffs)):
            exponent1 = ao1.exponents[i]
            exponent2 = ao2.exponents[j]
            #res += (ao1.coeffs[i]*ao2.coeffs[j]*
            #        gint(l1, x1, exponent1, l2, x2, exponent2)*
            #        gint(m1, y1, exponent1, m2, y2, exponent2)*
            #        gint(n1, z1, exponent1, n2, z2, exponent2))
            res += (ao1.coeffs[i]*ao2.coeffs[j]*
                    S(l1, l2, x1, x2, exponent1, exponent2)*
                    S(m1, m2, y1, y2, exponent1, exponent2)*
                    S(n1, n2, z1, z2, exponent1, exponent2))
    return res




def kinetic(ao1, ao2): #calculate kinetic integral <psi|-1/2*del^2|phi>
    l1, m1, n1 = ao1.angular
    l2, m2, n2 = ao2.angular
    x1, y1, z1 = ao1.center
    x2, y2, z2 = ao2.center
    res = 0
    for i in range(len(ao1.coeffs)):
        for j in range(len(ao2.coeffs)):
            exponent1 = ao1.exponents[i]
            exponent2 = ao2.exponents[j]
            res += (ao1.coeffs[i]*ao2.coeffs[j]*
                    (T(l1,l2,x1,x2,exponent1,exponent2)*S(m1,m2,y1,y2,exponent1,exponent2)*S(n1,n2,z1,z2,exponent1,exponent2) +
                     S(l1,l2,x1,x2,exponent1,exponent2)*T(m1,m2,y1,y2,exponent1,exponent2)*S(n1,n2,z1,z2,exponent1,exponent2) +
                     S(l1,l2,x1,x2,exponent1,exponent2)*S(m1,m2,y1,y2,exponent1,exponent2)*T(n1,n2,z1,z2,exponent1,exponent2))
                   )
    return res


def oneelectron(ao1, centerC, ao2):
    l1, m1, n1 = ao1.angular
    l2, m2, n2 = ao2.angular
    a = l1 + m1 + n1
    b = l2 + m2 + n2
    c = a + b
    x1, y1, z1 = ao1.center
    x2, y2, z2 = ao2.center
    xc, yc, zc = centerC # coordinate of atom with charge Z
    res = 0
    for i in range(len(ao1.coeffs)):
        for j in range(len(ao2.coeffs)):
            exponent1 = ao1.exponents[i]
            exponent2 = ao2.exponents[j]
            p = exponent1 + exponent2
            xp = (exponent1*x1+exponent2*x2)/p
            yp = (exponent1*y1+exponent2*y2)/p
            zp = (exponent1*z1+exponent2*z2)/p
            xpc = xp - xc
            ypc = yp - yc
            zpc = zp - zc
            for t in range(c+1):
                for u in range(c+1):
                    for v in range(c+1):
                        res += (ao1.coeffs[i]*ao2.coeffs[j]*
                                2*np.pi/p*E(l1,l2,t,x1,x2,exponent1,exponent2)*
                                E(m1,m2,u,y1,y2,exponent1,exponent2)*
                                E(n1,n2,v,z1,z2,exponent1,exponent2)*
                                R(t,u,v,0,p,xpc,ypc,zpc))
    return res
                  
    
def twoelectron(ao1, ao2, ao3, ao4):
    res = 0
    l1, m1, n1 = ao1.angular
    l2, m2, n2 = ao2.angular
    l3, m3, n3 = ao3.angular
    l4, m4, n4 = ao4.angular
    x1, y1, z1 = ao1.center
    x2, y2, z2 = ao2.center
    x3, y3, z3 = ao3.center
    x4, y4, z4 = ao4.center
    a = l1 + m1 + n1
    b = l2 + m2 + n2
    c = l3 + m3 + n3
    d = l4 + m4 + n4
    for i in range(len(ao1.coeffs)):
        for j in range(len(ao2.coeffs)):
            for k in range(len(ao3.coeffs)):
                for l in range(len(ao4.coeffs)):
                    exponent1 = ao1.exponents[i]
                    exponent2 = ao2.exponents[j]
                    exponent3 = ao3.exponents[k]
                    exponent4 = ao4.exponents[l]
                    p = (exponent1 + exponent2)
                    q = (exponent3 + exponent4)
                    alpha = p*q/(p + q)
                    xp = (x1*exponent1+x2*exponent2)/p
                    yp = (y1*exponent1+y2*exponent2)/p
                    zp = (z1*exponent1+z2*exponent2)/p
                    xq = (x3*exponent3+x4*exponent4)/q
                    yq = (y3*exponent3+y4*exponent4)/q
                    zq = (z3*exponent3+z4*exponent4)/q
                    xpq = xp - xq
                    ypq = yp - yq
                    zpq = zp - zq
                    for t in range(a + b + 1):
                        for u in range(a + b + 1):
                            for v in range(a + b + 1):
                                for tau in range(c + d + 1):
                                    for miu in range(c + d + 1):
                                        for phi in range(c + d + 1):
                                            res += (ao1.coeffs[i]*ao2.coeffs[j]*ao3.coeffs[k]*ao4.coeffs[l]*
                                                    2*np.pi**(5/2)/p/q/np.sqrt(p+q)*
                                                    E(l1, l2, t, x1, x2, exponent1, exponent2)*
                                                    E(m1, m2, u, y1, y2, exponent1, exponent2)*
                                                    E(n1, n2, v, z1, z2, exponent1, exponent2)*
                                                    E(l3, l4, tau, x3, x4, exponent3, exponent4)*
                                                    E(m3, m4, miu, y3, y4, exponent3, exponent4)*
                                                    E(n3, n4, phi, z3, z4, exponent3, exponent4)*
                                                    (-1)**(tau + miu + phi)*
                                                    R(t+tau, u+miu, v+phi, 0, alpha, xpq, ypq, zpq)
                                                    )
    return res
                            
    
    
def atomtype2Charge(atomtype):
    if atomtype == "O":
        return 8
    if atomtype == "H":
        return 1
    if atomtype == "C":
        return 6
    if atomtype == "N":
        return 7
    if atomtype == "S":
        return 16
    
def coulombicAttraction(ao1, atomlist, ao2):
    res = 0
    for i in range(len(atomlist)):
        atomtype, centerC = atomlist[i]
        Z = atomtype2Charge(atomtype)
        res += (-Z)*oneelectron(ao1, centerC, ao2)
    return res

Overlap integral

n = len(aolist)
Smatrix = np.zeros((n,n))
for i in range(n):
    for j in range(n):
        Smatrix[i][j] = overlap(aolist[i], aolist[j])
    
print(Smatrix)

[[ 3.62762641e-02  9.95724217e-02 -5.24746189e-19  7.57023956e-18
00000000e+00  1.16908716e-01 -6.31013314e-19 -1.16984701e-17
00000000e+00  7.59400626e-03  6.54822558e-02  7.59411217e-03
54824705e-02]
 [ 9.95724217e-02  1.29603778e+00 -1.07089269e-18  2.14434851e-18
00000000e+00  2.39434918e+00  0.00000000e+00  0.00000000e+00
00000000e+00  2.62125225e-01  1.62011663e+00  2.62127794e-01
62012145e+00]
 [-5.24746189e-19 -1.07089269e-18  1.20081379e-01 -1.06558994e-33
00000000e+00  0.00000000e+00  4.51862544e-01  0.00000000e+00
00000000e+00  1.19818229e-01  2.25631906e-01 -5.07935538e-02
  -9.56496053e-02]
 [ 7.57023956e-18  2.14434851e-18 -1.06558994e-33  1.20081379e-01
00000000e+00  0.00000000e+00  0.00000000e+00  4.51862544e-01
00000000e+00 -4.79226865e-19  1.26359949e-16  7.76256934e-02
46177347e-01]
 [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
20081379e-01  0.00000000e+00  0.00000000e+00  0.00000000e+00
51862544e-01  0.00000000e+00  0.00000000e+00  7.58345782e-02
42804488e-01]
 [ 1.16908716e-01  2.39434918e+00  0.00000000e+00  0.00000000e+00
00000000e+00  8.61832884e+00  0.00000000e+00  0.00000000e+00
00000000e+00  1.63787924e+00  8.86555994e+00  1.63788694e+00
86557978e+00]
 [-6.31013314e-19  0.00000000e+00  4.51862544e-01  0.00000000e+00
00000000e+00  0.00000000e+00  5.76578663e+00  0.00000000e+00
00000000e+00  2.07467387e+00  5.34594035e+00 -8.79494754e-01
  -2.26624288e+00]
 [-1.16984701e-17  0.00000000e+00  0.00000000e+00  4.51862544e-01
00000000e+00  0.00000000e+00  0.00000000e+00  5.76578663e+00
00000000e+00 -1.77591852e-16 -9.84274877e-16  1.34409556e+00
46340552e+00]
 [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
51862544e-01  0.00000000e+00  0.00000000e+00  0.00000000e+00
76578663e+00  0.00000000e+00  0.00000000e+00  1.31308225e+00
38349180e+00]
 [ 7.59400626e-03  2.62125225e-01  1.19818229e-01 -4.79226865e-19
00000000e+00  1.63787924e+00  2.07467387e+00 -1.77591852e-16
00000000e+00  2.25610663e+00  5.04483670e+00  4.17535237e-02
19856776e+00]
 [ 6.54822558e-02  1.62011663e+00  2.25631906e-01  1.26359949e-16
00000000e+00  8.86555994e+00  5.34594035e+00 -9.84274877e-16
00000000e+00  5.04483670e+00  2.51085454e+01  1.19856776e+00
04515576e+01]
 [ 7.59411217e-03  2.62127794e-01 -5.07935538e-02  7.76256934e-02
58345782e-02  1.63788694e+00 -8.79494754e-01  1.34409556e+00
31308225e+00  4.17535237e-02  1.19856776e+00  2.25610663e+00
04483670e+00]
 [ 6.54824705e-02  1.62012145e+00 -9.56496053e-02  1.46177347e-01
42804488e-01  8.86557978e+00 -2.26624288e+00  3.46340552e+00
38349180e+00  1.19856776e+00  1.04515576e+01  5.04483670e+00
51085454e+01]]

Kinetic integral.

Tmatrix = np.zeros((n,n))
for i in range(n):
    for j in range(n):
        Tmatrix[i][j] = kinetic(aolist[i], aolist[j])
print(Tmatrix)

[[ 1.56594565e+00  4.78963614e-02 -4.05282580e-18  1.53233094e-17
   0.00000000e+00  1.19389125e-01 -1.15463480e-18 -1.97468072e-17
   0.00000000e+00 -1.91652006e-02 -4.52331856e-02 -1.91652712e-02
  -4.52329116e-02]
 [ 3.43170409e+00  2.67654637e+00  1.70224646e-16 -1.33174640e-16
   0.00000000e+00  1.26286426e+00  0.00000000e+00  0.00000000e+00
   0.00000000e+00 -2.25668938e-01 -1.21972362e+00 -2.25667652e-01
  -1.21971864e+00]
 [-7.37006012e-17 -1.17093927e-16  7.22035184e-01 -2.01906383e-32
   0.00000000e+00  0.00000000e+00  4.14183795e-01  0.00000000e+00
   0.00000000e+00  5.48239591e-02  2.35206952e-01 -2.32417873e-02
  -9.97091597e-02]
 [ 2.03161828e-16  1.38250474e-16 -2.01906383e-32  7.22035184e-01
   0.00000000e+00  0.00000000e+00  0.00000000e+00  4.14183795e-01
   0.00000000e+00  1.20452080e-18 -1.22044396e-16  3.55194649e-02
   1.52381396e-01]
 [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
   7.22035184e-01  0.00000000e+00  0.00000000e+00  0.00000000e+00
   4.14183795e-01  0.00000000e+00  0.00000000e+00  3.46998980e-02
   1.48865387e-01]
 [ 4.02359884e+00  3.74487537e+00  0.00000000e+00  0.00000000e+00
   0.00000000e+00 -3.26589848e+00  0.00000000e+00  0.00000000e+00
   0.00000000e+00  4.62021032e-02 -8.79149846e+00  4.62074924e-02
  -8.79149150e+00]
 [-8.33582092e-17  0.00000000e+00  1.84953836e+00  0.00000000e+00
   0.00000000e+00  0.00000000e+00 -3.64155552e+00  0.00000000e+00
   0.00000000e+00  1.45231763e+00  1.87336406e+00 -6.15668633e-01
  -7.94160441e-01]
 [-2.36657541e-16  0.00000000e+00  0.00000000e+00  1.84953836e+00
   0.00000000e+00  0.00000000e+00  0.00000000e+00 -3.64155552e+00
   0.00000000e+00  2.95102321e-16  1.62363285e-15  9.40900978e-01
   1.21368265e+00]
 [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
   1.84953836e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00
  -3.64155552e+00  0.00000000e+00  0.00000000e+00  9.19190873e-01
   1.18567845e+00]
 [ 2.54823773e-01  2.67169469e-01  4.21218474e-01 -1.53429924e-17
   0.00000000e+00 -1.64897744e+00 -1.81824719e+00  1.56768583e-16
   0.00000000e+00  2.94423203e+00  5.04566129e-02 -1.23635777e-01
  -2.81387679e+00]
 [ 2.23804340e+00  2.09632432e+00  7.87206118e-01  3.00934224e-16
   0.00000000e+00 -1.03178173e+01 -9.40091335e+00  1.73086159e-15
   0.00000000e+00  9.69998131e-01 -2.38637957e+01 -4.36962560e-01
  -1.90937675e+01]
 [ 2.54827376e-01  2.67173409e-01 -1.78564047e-01  2.72892069e-01
   2.66595428e-01 -1.64897455e+00  7.70784733e-01 -1.17795852e+00
  -1.15077861e+00 -1.23635777e-01 -2.81387679e+00  2.94423203e+00
   5.04566129e-02]
 [ 2.23805076e+00  2.09633131e+00 -3.33711532e-01  5.09997570e-01
   4.98230018e-01 -1.03178274e+01  3.98521751e+00 -6.09044355e+00
  -5.94991424e+00 -4.36962560e-01 -1.90937675e+01  9.69998131e-01
  -2.38637957e+01]]

coulombAttractionMatrix = np.zeros((n,n))
for i in range(n):
    for j in range(n):
        coulombAttractionMatrix[i][j] = coulombicAttraction(aolist[i], atomlist, aolist[j])
print(coulombAttractionMatrix)

[[-1.75499944e+00 -3.23464624e+00 -6.50279513e-04 -7.31307144e-04
  -7.14433153e-04 -3.79435897e+00 -8.94041634e-04 -1.00544332e-03
  -9.82243984e-04 -2.35608226e-01 -2.09923813e+00 -2.35611600e-01
  -2.09924507e+00]
 [-3.23464624e+00 -2.18381731e+01 -5.61648851e-02 -6.31632831e-02
  -6.17058699e-02 -3.16096986e+01 -1.13502598e-01 -1.27643676e-01
  -1.24698459e-01 -3.13830005e+00 -2.00748303e+01 -3.13833427e+00
  -2.00748975e+01]
 [-6.50279513e-04 -5.61648851e-02 -1.58622060e+00  4.90812422e-03
   4.79487544e-03 -8.10055273e-02 -4.37742871e+00  1.58149688e-02
   1.54500583e-02 -1.17389395e+00 -2.12548559e+00  4.86228914e-01
   8.27361978e-01]
 [-7.31307144e-04 -6.31632831e-02  4.90812422e-03 -1.57263886e+00
  -7.32781037e-03 -9.10978970e-02  1.58149688e-02 -4.33366509e+00
  -2.36116868e-02 -9.01200465e-03 -5.81850271e-02 -7.64342556e-01
  -1.40167890e+00]
 [-7.14433153e-04 -6.17058699e-02  4.79487544e-03 -7.32781037e-03
  -1.57229670e+00 -8.89959277e-02  1.54500583e-02 -2.36116868e-02
  -4.33256260e+00 -8.80406399e-03 -5.68424809e-02 -7.46706314e-01
  -1.36933693e+00]
 [-3.79435897e+00 -3.16096986e+01 -8.10055273e-02 -9.10978970e-02
  -8.89959277e-02 -7.64247324e+01 -8.20332421e-01 -9.22545531e-01
  -9.01258955e-01 -1.29565593e+01 -6.57448692e+01 -1.29566416e+01
  -6.57450367e+01]
 [-8.94041634e-04 -1.13502598e-01 -4.37742871e+00  1.58149688e-02
   1.54500583e-02 -8.20332421e-01 -3.63920009e+01  3.02820982e-01
   2.95833770e-01 -1.41485068e+01 -2.99722078e+01  5.88600845e+00
   1.17045986e+01]
 [-1.00544332e-03 -1.27643676e-01  1.58149688e-02 -4.33366509e+00
  -2.36116868e-02 -9.22545531e-01  3.02820982e-01 -3.55540295e+01
  -4.52110548e-01 -8.83188572e-02 -7.90717729e-01 -9.20368420e+00
  -1.97529156e+01]
 [-9.82243984e-04 -1.24698459e-01  1.54500583e-02 -2.36116868e-02
  -4.33256260e+00 -9.01258955e-01  2.95833770e-01 -4.52110548e-01
  -3.55329194e+01 -8.62810108e-02 -7.72472914e-01 -8.99132078e+00
  -1.92971420e+01]
 [-2.35608226e-01 -3.13830005e+00 -1.17389395e+00 -9.01200465e-03
  -8.80406399e-03 -1.29565593e+01 -1.41485068e+01 -8.83188572e-02
  -8.62810108e-02 -1.47653497e+01 -3.10434293e+01 -3.68548479e-01
  -8.32122150e+00]
 [-2.09923813e+00 -2.00748303e+01 -2.12548559e+00 -5.81850271e-02
  -5.68424809e-02 -6.57448692e+01 -2.99722078e+01 -7.90717729e-01
  -7.72472914e-01 -3.10434293e+01 -1.22003131e+02 -8.32123702e+00
  -6.20267447e+01]
 [-2.35611600e-01 -3.13833427e+00  4.86228914e-01 -7.64342556e-01
  -7.46706314e-01 -1.29566416e+01  5.88600845e+00 -9.20368420e+00
  -8.99132078e+00 -3.68548479e-01 -8.32123702e+00 -1.47653804e+01
  -3.10434873e+01]
 [-2.09924507e+00 -2.00748975e+01  8.27361978e-01 -1.40167890e+00
  -1.36933693e+00 -6.57450367e+01  1.17045986e+01 -1.97529156e+01
  -1.92971420e+01 -8.32122150e+00 -6.20267447e+01 -3.10434873e+01
  -1.22003284e+02]]

import time, sys
from IPython.display import clear_output
def update_progress(progress):
    bar_length = 20
    if isinstance(progress, int):
        progress = float(progress)
    if not isinstance(progress, float):
        progress = 0
    if progress < 0:
        progress = 0
    if progress >= 1:
        progress = 1
    block = int(round(bar_length * progress))
    clear_output(wait = True)
    text = "Progress: [{0}] {1:.1f}%".format( "#" * block + "-" * (bar_length - block), progress * 100)
    print(text)

    
coulombRepulsionTensor = np.zeros((n,n,n,n))
count = 0
for i in range(n):
    for j in range(n):
        for k in range(n):
            for l in range(n):
                coulombRepulsionTensor[i][j][k][l] = twoelectron(aolist[i],aolist[j],aolist[k],aolist[l])
                count += 1
                update_progress(count / n**4)
                
update_progress(1)
#print(coulombRepulsionTensor)

Progress: [####################] 100.0%

Build Fock matrix

from scipy.linalg import eigh
nelectrons = 1+1+8 #H H
norb = nelectrons // 2
maxiter = 100
C = np.eye(n) #coeffcient matrix
prev = float('inf')
tol = 1e-7
for i in range(maxiter):
    #start building Fock matrix
    JK = np.zeros((n,n))
    F = np.zeros((n,n)) 
    for j in range(n):
        for k in range(n):
            for l in range(n):
                for m in range(n):
                    for o in range(norb):
                        JK[j][k] += (C[l][o]*C[m][o] * 
                                    (2*coulombRepulsionTensor[j][k][l][m]-
                                     coulombRepulsionTensor[j][m][k][l]
                                    ))
    F = Tmatrix + coulombAttractionMatrix + JK #add kinetic integral and coulomb attraction integeral
    S = Smatrix #overlap matrix
    #now solve the FC=SCe (Hartree Fock Roothaan-Hall Equation)
    energy, C = eigh(F, S)
    EHF = 0
    for i in range(norb):
        EHF += 2*energy[i] - 1/2*JK[i][i]
    if abs(EHF - prev) < tol:
        print('SCF Converged')
        break
    delta = EHF - prev
    prev = EHF
    print('EHF:'+str(EHF)+" "+'prev:'+str(prev)+' '+'delta:'+str(delta))

EHF:-98.50144013664092 prev:-98.50144013664092 delta:-inf
EHF:-75.52313316329055 prev:-75.52313316329055 delta:22.97830697335037
EHF:-76.12168005535852 prev:-76.12168005535852 delta:-0.5985468920679722
EHF:-76.12473548753243 prev:-76.12473548753243 delta:-0.003055432173908912
EHF:-76.12635567733068 prev:-76.12635567733068 delta:-0.0016201897982455193
EHF:-76.12645217258822 prev:-76.12645217258822 delta:-9.649525753729904e-05
EHF:-76.12646225253813 prev:-76.12646225253813 delta:-1.0079949916530495e-05
EHF:-76.12646321190164 prev:-76.12646321190164 delta:-9.593635041937887e-07
EHF:-76.12646331382744 prev:-76.12646331382744 delta:-1.0192580646162241e-07
SCF Converged

Tips to Mount Remote directories

2020-06-03T00:00:00+00:00

Mount a local directory to servers

For a MacOS user: Go to https://osxfuse.github.io and download FUSE for MacOS and SSHFS softwares (you can download the latest versions of them) and install both following the instructions.

After installation, go to terminal and 3 steps to setup your folder:

cd ~
mkdir newriver
mkdir newriver_home

Tip 1: Using alias for quick usage

Open ~/.bash_profile, add two mount commands:

alias mount_newriver="sshfs #yourid#@newriver1.arc.vt.edu:/work/common/hxin_lab/#yourid#  /Users/#yourmacusername#/newriver”

alias mount_newriver_home="sshfs #yourid#@newriver1.arc.vt.edu:/home/#yourid# /Users/#yourmacusername#/newriver_home"

Save your .bash_profile.

To use Mount commands:

mount_newriver: To mount your work folder to server(/work/common/hxin_lab/#yourid#), you can edit this folder locally and the work folder on the server can also be updated. Since the server doesn’t support any visualization interfaces, using this mount command you can use ASE or material studios to visualize the structure of your system.
mount_newriver_home: same command as mount_newriver, but will mount your home folder(/home/#yourid#). Other operations are the same as mount_newriver.
umount_newriver and umount_newriver_home: every time you want to disconnect your mount from the server you can type those commands in your terminal.

Tip 2: Prevent losing connection

When your computer is asleep, you will lose connection to the server. Simple way to reconnect to it needs 3 steps:

Close all terminal windows and then right click the terminal app and then quit the app.
Reopen terminal and type: umount newriver
Then type: mount_newriver

Tianyou Mou’s Personal Website

Recommendation Systems

What is a recommendation system

Various recommendation systems and how to define a good system

Data preparation

Collaborative Filtering Recommendation System

Memory based approaches

Model based approaches

Implementation

Content Based Recommendation System

Item level data source

User level data source

Hybrid Recommendation System

Takeaways

Comparison between CE-TinNet and LCNN

Overview

Lattice convolution neural network

Crystal Graph Convolutional Neural Networks

Dataset

Results and discussion

CO2 electroreduction on Bismuth with Ionic Liquids

Introduction

CO2 cycle

Many metals show CO22 reduction activity

Current Knowledge and Focus

CO2 Reduction in ILs

Reaction Pathways of CO2 Reduction in ILs

Determining Energetics

Modeling Solid-Electrolyte Interfaces

Calculation Details

Electrostatic potential plot

Electrolyte-dependent Energy Pathways

Conclusions

References

CE-TinNet

Dependencies

Background

Cluster expansion

DFT database pool

Preparing Input for CE-TinNet

Preparing the dataset structure format

Pure Pt(111) with NO and O adsorbates

Cu dopant in Pt(111) with NO and O adsorbates

Preparing the correlation matrix using the Alloy-Theoretic Automated Toolkit (ATAT)

Preparing the data images and energies

Training and Evaluating

Hyperparameter optimization

Data Mining for Catalyst Materials

Overview

Open Catalyst Project data screening

1. Screen alloys with p-block metals and terminations of (111) and (100)

2. Screen all combinations of transition metals and p-block metals based on the previous alloys with specific terminations.

3. Screen all bimetallic alloys since section 2 can have all possible combinations of alloys .

Materials Project data screening

Utilize the ‘query’ function with different criteria for quick screening

Try to match the two data sets for A3B type of alloys

Brief introduction to crystal structures.

Prospective and Economic Analysis for solar fertilizers

Energy system

Module system

Breakeven

Price Map

Conclusion

Setting up your working environment

How to log onto the ARC computing system

Setting up working environments:

VASP Compilation

Quantum Espresso Compilation

Bash tools

Calculating Hartree Fock Energy of Hydrogen Using Python

Overview

Tips to Mount Remote directories

Mount a local directory to servers

Tip 1: Using alias for quick usage

Tip 2: Prevent losing connection

CO₂ cycle

Many metals show CO2₂ reduction activity

CO₂ Reduction in ILs

Reaction Pathways of CO₂ Reduction in ILs