Materials Informatics (MLE4217/5219)

https://mle4217-5219.matsci.dev
Admin
An interactive textbook and course on Materials Informatics that teaches data-driven methods,...
Tokens:118,178
Snippets:917
Trust Score:4.8
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install Xcode Command Line Tools (macOS)

Source: https://mle4217-5219.matsci.dev/orientation/setup-local

This command installs the necessary command-line developer tools for macOS, which are often required for compiling software and other development tasks. It's a prerequisite for some development workflows on macOS.

```bash
xcode-select --install
```

--------------------------------

### Install line_profiler Package

Source: https://mle4217-5219.matsci.dev/computer/scaling

Installs the `line_profiler` package, which is required for line-by-line profiling of Python code. This is a prerequisite for the profiling examples.

```bash
!pip install line_profiler
```

--------------------------------

### Setup VASP Phonon Workflow with atomate2

Source: https://mle4217-5219.matsci.dev/high-throughput/high-throughput

This snippet shows how to set up a phonon calculation workflow for VASP using the `PhononMaker` from `atomate2`. This is typically used for calculations on High-Performance Computing (HPC) clusters. The example assumes a `silicon_structure` object is already defined.

```python
from atomate2.vasp.flows.phonons import PhononMaker
# Assuming silicon_structure is defined elsewhere
# from pymatgen.core import Structure
# silicon_structure = Structure.from_file("POSCAR") 

phonon_flow = PhononMaker(born_maker=None).make(structure=silicon_structure)

phonon_flow.draw_graph().show()
```

--------------------------------

### Install ASAP3 Package for EMT Potential

Source: https://mle4217-5219.matsci.dev/models-and-theories-ii/md-mc

Installs the ASAP3 package, which provides a faster implementation of the EMT potential compared to the default ASE version. This is recommended for improved performance in MD simulations.

```shell
!pip install asap3

```

--------------------------------

### Install spglib package using pip (Windows Administrator)

Source: https://mle4217-5219.matsci.dev/orientation/setup-local

This command attempts to install the 'spglib' Python package. It is recommended to run this in an administrator mode of the Anaconda Prompt, especially if encountering installation errors related to dependencies like Visual Studio C++ build tools on Windows.

```bash
pip install spglib
```

--------------------------------

### Install Atomate2 and Dependencies

Source: https://mle4217-5219.matsci.dev/high-throughput/high-throughput

Installs the atomate2 library along with mace-torch, phonopy, and seekpath using pip. These are essential for running MACE potential calculations and related analysis within atomate 2.

```python
!pip install atomate2 mace-torch phonopy seekpath

```

--------------------------------

### Basic Markdown for GitHub Files

Source: https://mle4217-5219.matsci.dev/programming/github

Provides examples of basic Markdown syntax used in GitHub files like README.md for formatting text, creating links, and including images. Markdown enhances readability and organization.

```markdown
# Heading

**Bold text** and *italic text*.

[Link to a website](https://example.com)

![Alt text](image.jpg)
```

--------------------------------

### Python Loop Examples

Source: https://mle4217-5219.matsci.dev/programming/python-introduction

Demonstrates the implementation of 'for' and 'while' loops in Python, including the use of 'break' and 'continue' statements. Loops are essential for iterating over sequences and repeating code execution.

```python
# For loop
for i in range(5):
    print(i)

# While loop
count = 0
while count < 5:
    print(count)
    count += 1

# Break and continue
print("Break example")
for i in range(10):
    if i == 5:
        break
    if i % 2 == 0:
        continue
    print(i)
```

--------------------------------

### Install Numba using pip

Source: https://mle4217-5219.matsci.dev/models-and-theories-ii/md-mc

Installs the Numba library, which is used to compile Python code into machine code for performance acceleration. This is a prerequisite for using Numba's decorators.

```bash
!pip install numba
```

--------------------------------

### Install MACE-Torch for Machine Learning Force Fields

Source: https://mle4217-5219.matsci.dev/optimization/optimization

This command installs or upgrades the mace-torch package, which provides machine learning force fields (foundation models) trained on Materials Project data, such as MACE (Multi-atomic Cluster Expansion). This is a prerequisite for using these advanced force fields in geometry optimization tasks.

```shell
!pip install mace-torch --upgrade
```

--------------------------------

### Python Module and Package Importing Examples

Source: https://mle4217-5219.matsci.dev/programming/python-introduction

Illustrates various ways to import and use modules and packages in Python. This includes importing built-in modules like 'math', external libraries like 'numpy', and custom-created modules and packages. It shows how to use the 'import' and 'from ... import' statements.

```python
import math
print(math.sqrt(16))
```

```python
import numpy as np
array = np.array([1, 2, 3])
print(array)
```

```python
def greet(name):
     return f"Hello, {name}!"

```

```python
from mymodule import greet
print(greet("Alice"))
```

```python
from mypackage import module1
i.greet("Alice")
```

--------------------------------

### Install Packages with pip in Miniconda

Source: https://mle4217-5219.matsci.dev/programming/python-introduction

Command to install multiple Python packages into an activated Miniconda environment using pip. Common data science and visualization libraries are listed as an example.

```bash
pip install numpy pandas matplotlib jupyter

```

--------------------------------

### Molecular Dynamics Simulation Setup (Python)

Source: https://mle4217-5219.matsci.dev/machine-learning-potentials/mlp

Sets up and runs a molecular dynamics simulation using ASE. It supports NVE, NVT, and NPT ensembles, allowing for configuration of time steps, temperature, and output intervals. Dependencies include ASE and os modules.

```python
from ase.md.velocitydistribution import MaxwellBoltzmannDistribution,Stationary
from ase.md.nvtberendsen import NVTBerendsen
from ase.md.verlet import VelocityVerlet
from ase.md.npt import NPT
from ase.md import MDLogger
from ase import units
from ase.io import write
import os
from time import perf_counter
from ase.calculators.singlepoint import SinglePointCalculator

def run_md(atoms, calculator, ensemble, time_step, temperature, num_md_steps, num_interval, output_filename):
    # Set calculator (EMT in this case)
    atoms.calc = calculator

    # Set the momenta corresponding to the given "temperature"
    MaxwellBoltzmannDistribution(atoms, temperature_K=temperature,force_temp=True)
    Stationary(atoms)  # Set zero total momentum to avoid drifting

    # Set output filenames
    log_filename = output_filename + ".log"
    print("log_filename = ",log_filename)
    traj_filename = output_filename + ".traj"
    print("traj_filename = ",traj_filename)

    xyz_file = output_filename + ".xyz"
    print("xyz_filename = ",xyz_file)

    # Remove old files if they exist
    if os.path.exists(log_filename): os.remove(log_filename)
    if os.path.exists(traj_filename): os.remove(traj_filename)
    if os.path.exists(xyz_file): os.remove(xyz_file)  
    # Define the MD dynamics class object
    if ensemble == 'nve':
        dyn = VelocityVerlet(atoms,
                             time_step * units.fs,
                             trajectory = traj_filename,
                             loginterval=num_interval
                            )
    elif ensemble == 'nvt':
        dyn = NVTBerendsen(atoms,
                           time_step * units.fs,
                           temperature_K=temperature,
                           taut=100.0 * units.fs,
                           trajectory = traj_filename,
                           loginterval=num_interval
                          )
    elif ensemble == 'npt':
        sigma   = 1.0     # External pressure in bar
        ttime   = 20.0    # Time constant in fs
        pfactor = 2e6     # Barostat parameter in GPa
        dyn = NPT(atoms,
          time_step*units.fs,
          temperature_K = temperature,
          externalstress = sigma*units.bar,
          ttime = ttime*units.fs,
          pfactor = pfactor*units.GPa*(units.fs**2),
          logfile = log_filename,
          trajectory = traj_filename,
          loginterval=num_interval
          )
    else:
        raise ValueError("Invalid ensemble, must be nve, nvt, or npt")
    
    # Print statements
    def print_dyn():
        imd = dyn.get_number_of_steps()
        etot  = atoms.get_total_energy()
        temp_K = atoms.get_temperature()
        stress = atoms.get_stress(include_ideal_gas=True)/units.GPa
        stress_ave = (stress[0]+stress[1]+stress[2])/3.0
        elapsed_time = perf_counter() - start_time
        print(f"  {imd: >3}   {etot:.3f}    {temp_K:.2f}    {stress_ave:.2f}  {stress[0]:.2f}  {stress[1]:.2f}  {stress[2]:.2f}  {stress[3]:.2f}  {stress[4]:.2f}  {stress[5]:.2f}    {elapsed_time:.3f}")


    def save_xyz():
        # Save the current configuration to the trajectory file
        atoms_copy = dyn.atoms.copy()
        atoms_copy.calc = SinglePointCalculator(atoms_copy,
                                                energy=atoms.get_potential_energy(),
                                                forces = atoms.get_forces(),
                                                stress = atoms.get_stress(include_ideal_gas=True))
        # atoms_copy.info['REF_energy']=  atoms.get_potential_energy()
        # atoms_copy.set_array(forces,'REF_forces')
        write(xyz_file, atoms_copy, format='extxyz', append=True)

    dyn.attach(print_dyn, interval=num_interval)
    dyn.attach(save_xyz, interval=num_interval)

    # Set MD logger
    dyn.attach(MDLogger(dyn, atoms, log_filename, header=True, stress=True,peratom=True, mode="w"), interval=num_interval)

    # Now run MD simulation
    print(f"    imd     Etot(eV)    T(K)    stress(mean,xx,yy,zz,yz,xz,xy)(GPa)  elapsed_time(sec)")
    start_time = perf_counter()
    dyn.run(num_md_steps)

```

--------------------------------

### Python Print Statement Example

Source: https://mle4217-5219.matsci.dev/orientation/jupyter-workflow

This Python code snippet shows how to print a string variable. It defines a message and then outputs it to the console. This is a basic example of outputting information from a code cell.

```python
# This is a code cell showing an example
message = "This is from a code cell"
print(message)
```

--------------------------------

### Define and Call a Python Function

Source: https://mle4217-5219.matsci.dev/programming/python-introduction

Demonstrates the basic syntax for defining a function using the `def` keyword, specifying parameters, and calling the function. It shows how to return a value from a function.

```python
def greet(name):
    return f"Hello, {name}!"

print(greet("Alice"))
```

--------------------------------

### Initiating MACE Training (Python)

Source: https://mle4217-5219.matsci.dev/machine-learning-potentials/mlp

This Python function encapsulates the process of starting MACE model training. It takes a configuration file path as input, sets up logging, and calls the MACE training utility. It requires the 'mace' library and its dependencies.

```python
import warnings
warnings.filterwarnings("ignore")
from mace.cli.run_train import main as mace_run_train_main
import sys
import logging

def train_mace(config_file_path):
    logging.getLogger().handlers.clear()
    sys.argv = ["program", "--config", config_file_path]
    mace_run_train_main()
```

--------------------------------

### Python Example for Markdown Cell Explanation

Source: https://mle4217-5219.matsci.dev/orientation/jupyter-workflow

This Python code snippet is intended to be placed within a code cell, but its content serves as an example of what might be explained or demonstrated in an adjacent Markdown cell. It includes a simple print statement.

```python
# Example of formatting in a markdown cell (this is a comment in code cell)
print("Run this cell to test Jupyter setup")
```

--------------------------------

### Python Descriptive Variable Naming

Source: https://mle4217-5219.matsci.dev/orientation/jupyter-workflow

This code snippet contrasts good and bad variable naming practices in Python. The 'GOOD' example uses descriptive names like `bulk_modulus_si`, while the 'BAD' example uses generic names like `x`, `y`, and `z`, highlighting the importance of clarity.

```python
# GOOD - descriptive names
bulk_modulus_si = 185  # GPa
energy_per_atom = -4.63  # eV
lattice_constant_fcc = 3.61  # Å

print(f"Bulk modulus: {bulk_modulus_si} GPa")
print(f"Energy per atom: {energy_per_atom} eV")

# BAD - generic names
x = 185
y = -4.63
z = 3.61
```

--------------------------------

### Add README.md Content (Markdown)

Source: https://mle4217-5219.matsci.dev/computer/git-examples

Example content for a README.md file, typically used to provide an overview of a project. It uses Markdown formatting for headings and text.

```markdown
# MLE5219 Project
This is the README file for the MLE5219 project.
```

--------------------------------

### Python Code Organization in Jupyter Cells

Source: https://mle4217-5219.matsci.dev/orientation/jupyter-workflow

This example shows how to organize Python code logically across different Jupyter cells. It demonstrates separating imports, setup/constants, data generation, and analysis into distinct cells for better readability and maintainability.

```python
# Cell 1: Imports
import numpy as np
import matplotlib.pyplot as plt

# Cell 2: Setup and constants
A = 5.43  # Lattice constant (Å)
T = 298   # Temperature (K)

# Cell 3: Data generation
positions = np.array([[0, 0, 0], [0.25, 0.25, 0.25]])

# Cell 4: Analysis
print(f"Number of atoms: {len(positions)}")
print(f"Lattice constant: {A} Å")
print(f"Temperature: {T} K")
```

--------------------------------

### Launch ASE GUI for Visualization (Shell)

Source: https://mle4217-5219.matsci.dev/models-and-theories-i/ase

Provides a shell command to launch the Atomic Simulation Environment (ASE) graphical user interface (GUI) for visualizing structures from a file. This command assumes ASE is installed and the GUI executable is in the system's PATH.

```shell
!ase gui structures.xyz
```

--------------------------------

### Install Packages in Jupyter Notebook

Source: https://mle4217-5219.matsci.dev/programming/python-introduction

Command to install Python packages directly from within a Jupyter Notebook environment using the `!pip install` magic command. This installs the specified package into the notebook's active kernel environment.

```python
!pip install numpy

```

--------------------------------

### Initialize Git Repository (Command Line)

Source: https://mle4217-5219.matsci.dev/computer/git-examples

Initializes a new Git repository in the current directory. This command creates a hidden .git subdirectory that contains all the necessary repository files.

```bash
git init
```

--------------------------------

### Install mp_api Package

Source: https://mle4217-5219.matsci.dev/database/bulk-modulus

Installs the mp_api Python package, which is necessary for interacting with the Materials Project API. This is a prerequisite for fetching material data.

```python
# you can skip this if you've already installed the mp_api package.
!pip install mp_api
```

--------------------------------

### Create Pymatgen Lattice Object

Source: https://mle4217-5219.matsci.dev/atomistic-structure/crystal-structure

Demonstrates two methods for creating a pymatgen Lattice object: one using a matrix of lattice vectors and another using lattice parameters (a, b, c, alpha, beta, gamma). It also shows how to print the lattice and convert fractional coordinates to Cartesian coordinates.

```python
from pymatgen.core import Lattice

# Create a Lattice object
lattice = Lattice(matrix = [[5.43, 0, 0],  # ax, ay, az
                            [0, 5.43, 0],  # bx, by, bz
                            [0, 0, 5.43]]) # cx, cy, cz

# Another way to create this Lattice object
lattice = Lattice.from_parameters(a=5.43, b=5.43, c=5.43, alpha=90, beta=90, gamma=90)

print(lattice)


print(lattice.get_cartesian_coords([0.5, 0.5, 0.5]))
```

--------------------------------

### Install wulffpack Package (Shell)

Source: https://mle4217-5219.matsci.dev/atomistic-structure/advanced-structure

Installs the 'wulffpack' Python package using pip. This package is required for an alternative method of constructing Wulff shapes.

```shell
!pip install wulffpack
```

--------------------------------

### Install Seaborn Library (Shell)

Source: https://mle4217-5219.matsci.dev/database/bulk-modulus

Installs the seaborn library, a Python data visualization library based on matplotlib, which provides an interface for drawing attractive and informative statistical graphics.

```shell
pip install seaborn
```

--------------------------------

### Python Functions with Variable Arguments (*args and **kwargs)

Source: https://mle4217-5219.matsci.dev/programming/python-introduction

Illustrates how to use `*args` to accept a variable number of non-keyword arguments as a tuple and `**kwargs` to accept a variable number of keyword arguments as a dictionary within a function. This allows for flexible function definitions.

```python
def example_function(*args, **kwargs):
    for arg in args:
        print(f"arg: {arg}")
    for key, value in kwargs.items():
        print(f"{key}: {value}")

example_function(1, 2, 3, name="Alice", age=30)
```

--------------------------------

### Install Pandas using pip or conda

Source: https://mle4217-5219.matsci.dev/programming/pandas

Instructions for installing the Pandas library using either pip or conda package managers. This is a prerequisite for using Pandas in Python projects.

```shell
pip install pandas
```

```shell
conda install pandas
```

--------------------------------

### Setup and Run NPT MD for Thermal Expansion

Source: https://mle4217-5219.matsci.dev/models-and-theories-ii/md-mc

Sets up a 3x3x3 supercell of FCC copper with the EMT potential and runs NPT molecular dynamics simulations at various temperatures. The goal is to observe thermal expansion by varying temperature and recording lattice parameters from trajectory files.

```python
from ase.calculators.emt import EMT
from ase.build import bulk
from ase.md.npt import NPT
from ase import units

def run_md(atoms, calculator, ensemble, time_step, temperature, num_md_steps, num_interval, output_filename):
    atoms.calc = calculator
    if ensemble == 'nvt':
        dyn = NVT(atoms, timestep=time_step*units.fs, temperature=temperature*units.kB, trajectory=f"{output_filename}.traj", logfile=f"{output_filename}.log")
    elif ensemble == 'npt':
        dyn = NPT(atoms, timestep=time_step*units.fs, temperature=temperature*units.kB, pressure=0*units.Bar, trajectory=f"{output_filename}.traj", logfile=f"{output_filename}.log")
    else:
        raise ValueError("Ensemble must be 'nvt' or 'npt'")

    dyn.run(num_md_steps)

# Set up a fcc-Cu crystal
calculator = EMT()
atoms = bulk("Cu", "fcc", cubic=True, a=3.615)
atoms.pbc = True
atoms *= 3 # 3x3x3 supercell
print("atoms = ",atoms)

# input parameters
time_step    = 1.0      # MD step size in fsec
num_md_steps = 20000   # Total number of MD steps
num_interval = 10     # Print out interval for .log and .traj
ensemble = 'npt'

temperature_list = [200,300,400,500,600,700,800,900,1000]

for temperature in temperature_list:
    output_filename = f"./Cu_fcc_3x3x3_NPT_T{temperature}"
    run_md(atoms, calculator, ensemble, time_step, temperature, num_md_steps, num_interval, output_filename)
```

--------------------------------

### Search Materials by Chemical System (Python)

Source: https://mle4217-5219.matsci.dev/database/materials-project

This example demonstrates how to search for stable materials within a specific chemical system (e.g., 'Li-Fe-P-O') using the Materials Project API. It utilizes the MPRester class and allows for specifying desired fields to retrieve.

```python
from mp_api.client import MPRester

with MPRester(MP_API_KEY) as mpr:
    docs = mpr.materials.summary.search(
        chemsys="Li-Fe-P-O", is_stable=True,
        # fields=["material_id", "volume", "elements","structure"]
    )
```
Tokens:
Raw