CASTING 0.1.4

A continuous action space tree search for inverse design (CASTING)

CASTING

A Continuous Action Space Tree search for INverse desiGn (CASTING) Framework and Materials Discovery

Table of Contents

• Introduction
• Prerequisites
• Installation
• Running the code
• Optimization of Gold nanocluster
• Carbon metastable polymorphs
• Citation
• License

Introduction

A pseudocode implementation of CASTING framework (Paper) for optimization of atomic nanoclusters only. This code uses MCTS (Monte Carlo Tree Search) as base optimizer.

    Fast and accurate prediction of optimal crystal structure, topology, and microstructures is important for accelerating the design and discovery of new materials. Material properties are strongly correlated to the underlying structure and topology – inverse design is emerging as a powerful tool to discover new and increasingly complex materials that meet targeted functionalities. CASTING provides a unified framework for fast, scalable and accurate prediction & design of materials.

(back to top)

Prerequisites

This package requires:

• scipy
• LAMMPS
• pymatgen
• pandas
• numpy
• networkx
• ase

(back to top)

Installation

Manual Installation

Install the anaconda package. Then,

conda env create --name CASTING
conda activate CASTING
git clone https://github.com/sbanik2/CASTING.git
pip install -r requirements.txt
python setup.py install

Installation with pypi

pip install CASTING

***The package requires python lammps binding to run. First, lammps package needs to be downloaded from LAMMPS download and compiled. The instructions on python integration can be found here LAMMPS-Python.

(back to top)

Running the code

First, all the parameters crystal (constrains), LAMMPS parameters (pair style, pair coefficient etc.) and the perturbation parameter need to be set. The composition is given for e.g., a Au<2>Al<3> as "composition":{"Au":2,"Al:3"}. In a file (for e.g., RunOpt.py) we define,

from CASTING.utilis import r_datafame,get_lattice
from CASTING.MCTS import MCTS
from CASTING.clusterfun import createRandomData
from CASTING.lammpsEvaluate import LammpsEvaluator
from CASTING.perturb import perturbate


# In[6]:

import random
import numpy as np

seed = 12

random.seed(seed)
np.random.seed(seed)



# In[9]:


r_min = {"Au-Au":2}       # minimum allowed interatomic distance
r_max = {"Au-Au":4}      # maximum allowed interatomic distance
box_dim = 50                  # box dimension 

#--------crystal constrains-----------

constrains = {
    "composition":{"Au":1},
    "atoms":13,
    "r_min":r_datafame(r_min),
    "r_max":r_datafame(r_max),
    "lattice":get_lattice(box_dim),  
    }




#-------------perturbation------------


pt = {
    'max_mutation': 0.05,  # mutation  in fraction of  box length
}



#-----------------lammps parameters-------------------

lammps_par = {
    'constrains':constrains,
    'pair_style': "pair_style eam",
    'pair_coeff': "pair_coeff * * Au.eam"   # Provide full path of potential file here
}
    

Once the parameters are set, the evaluator (LAMMPS calculator) & the perturbator is to be initialized and a structure for root node is created.

rootdata = createRandomData(constrains,multiplier= 10)

perturb = perturbate(**pt). perturb
evaluator = LammpsEvaluator(**lammps_par).evaluate 

Finally, Call MCTS with all the hyperparameters added. Details of individual hyperparameters for the optimizer can be found here Paper.

       
MCTS(
   rootdata,
   perturb ,
   evaluator,
   niterations=2000,
   headexpand=10,
   nexpand=3,
   nsimulate=3,
   nplayouts=10,
   exploreconstant=1,
   maxdepth=12,
   a=0,
   selected_node=0,
)
       

Run the code

python RunOpt.py 

The optimization produces a "dumpfile.dat" output containing all the crystal parameters and the energy values as the output. To extract the structures in either 'poscar' or 'cif' format, one can use the 'StructureWriter' module.

from CASTING.writer import StructureWriter

num_to_write = 10 # number of stuctures to extract
writer = StructureWriter(
                        "dumpfile.dat",
                         outpath="structures",
                         objfile="energy.dat",
                         file_format="poscar" # "poscar" or "cif"
                         ) 
writer.write( num_to_write, sort=True) # sort to arrange in increasing order of energy

This will extract 'num_to_write' number of structures in ascending order of objective.

(back to top)

Optimization of Gold nanocluster

An example optimization of Gold (Au) nanocluster is given in "example" directory. We have used CASTING to optimize the already known global minima (Sutton-Chen) of 13 atom Au nanocluster (Icosahedral structure). Details on additional examples can be found in Paper.

(back to top)

Launch in Colab

An example optimization of a Gold (Au) - Sutton-Chen nanocluster in the form of a Jupyter notebook that does not require LAMMPS Python binding has been provided in the notebooks directory. This can be launched in Google Colab using the link.

Carbon metastable polymorphs

We have also used CASTING to sample metastable polymorphs of Carbon(C). All the structures are then further relaxed with DFT. The unique polymorphs and their corresponding DFT energies have been provided in “C_polymorphs” directory.

(back to top)

Citation

@article{banik2023continuous,
  title={A continuous action space tree search for INverse desiGn (CASTING) framework for materials discovery},
  author={Banik, Suvo and Loefller, Troy and Manna, Sukriti and Chan, Henry and Srinivasan, Srilok and Darancet, Pierre and Hexemer, Alexander and Sankaranarayanan, Subramanian KRS},
  journal={npj Computational Materials},
  volume={9},
  number={1},
  pages={1--16},
  year={2023},
  publisher={Nature Publishing Group}
}

(back to top)

License

CASTING is distributed under MIT License. See LICENSE for details.

(back to top)