Interstitial energy refers to the energy required to insert an atom into the interstitial site of a crystal lattice. In this guide, we will calculate the interstitial energy of carbon in a body-centered cubic (BCC) iron lattice using the LAMMPS molecular dynamics software.

We will:

1. Set up a perfect BCC iron lattice and calculate its potential energy.
2. Insert a carbon atom into an octahedral interstitial site, relax the system and calculate its potential energy.
3. Calculate the potential energy of a carbon atom in diamond structure.
4. Compute the interstitial energy of carbon.

Step 1: Setting Up the Simulation

First, install LAMMPS if you haven’t already. You can download it from the official LAMMPS website.

We will use an embedded-atom method (EAM) potential for the iron and carbon interaction. Make sure you have the potential files in your working directory. You can download the Fe-C EAM potential file from OpenKIM or other sources.

Lattice Setup

We begin by defining a perfect BCC iron lattice. Below is the LAMMPS input script to set up the simulation box and create atoms for the BCC lattice. Here is the lammps command:

# Interstitial Energy of Carbon in BCC Iron

units metal
dimension 3
boundary p p p
atom_style atomic

# Define the BCC lattice with lattice constant 2.87 Angstroms (typical for Fe, but changes according to the potential)
lattice bcc 2.87
region box block 0 10 0 10 0 10
create_box 2 box

# Create Fe atoms in the BCC structure
create_atoms 1 box

# Define the potential (Fe-C alloy EAM potential)
pair_style eam
pair_coeff * * Fe_C.eam.alloy Fe C

# Assign masses to the atom types
mass 1 55.845  # Iron
mass 2 12.011  # Carbon

# Set up neighbor lists and thermodynamics output
neighbor 2.0 bin
neigh_modify delay 5

thermo 100
thermo_style custom step temp pe

# Minimize the system to get the energy of pure BCC iron
minimize 1.0e-6 1.0e-8 1000 10000

# Write the minimized configuration to a file
write_data bcc_iron.data

Step 2: Insert Carbon Atom into Octahedral Interstitial Site

Once you’ve generated the BCC iron lattice and minimized the system, the next step is to insert a carbon atom into an octahedral interstitial site.

The octahedral interstitial site in a BCC unit cell is located at fractional coordinates such as (0.5, 0.5, 0), (0.5, 0, 0.5), and (0, 0.5, 0.5). We will insert a carbon atom at (0.5, 0.5, 0), which corresponds to one of the octahedral sites in the BCC lattice.

Add the following lines to the LAMMPS script:

# Insert a carbon atom at an octahedral site (0.5, 0.5, 0)
create_atoms 2 single 1.435 1.435 0.0 unit box # Position in Angstroms based on lattice constant 2.87 Å

# Minimize the system again after inserting the carbon atom
minimize 1.0e-6 1.0e-8 1000 10000

# Write the minimized configuration with the carbon interstitial
write_data fe_c_interstitial.data

To extract these energies, you can modify the LAMMPS script to output the potential energies at each stage:

# Output the total energy of the system
variable E_Fe equal pe  # Energy of pure BCC iron
print "Energy of pure BCC iron: ${E_Fe} eV"

# After inserting the carbon atom
variable E_Fe_C equal pe  # Energy of BCC iron with carbon interstitial
print "Energy of BCC iron with carbon interstitial: ${E_Fe_C} eV"

Step 3: Calculate the potential energy of a carbon atom in diamond structure

The carbon energy can be obtained from a separate calculation in LAMMPS of carbon atomic energy in diamond structure.

# -----------------------------------------------------------
# LAMMPS script to find the equilibrium lattice constant
# of carbon in a diamond structure and save results to file
# -----------------------------------------------------------

log             eos_diamond.log           
label           loop_start

variable        a equal 3.5                      # Initial guess for the lattice constant
variable        da equal 0.005                    # Increment for the lattice constant
variable        steps equal 20                   # Number of steps for varying the lattice constant

variable        i loop 1 ${steps}
variable        latparam equal ${a}+${da}*${i}

clear
units           metal
dimension       3
boundary        p p p
atom_style      atomic
atom_modify     map yes

#-------Define geometry  (2d X 2d) ---------------------
lattice         diamond ${latparam}
region          box block 0 1 0 1 0 1 units lattice
create_box      2 box
create_atoms    2 box

#-------Define interatomic potential--------------------
pair_style      eam
pair_coeff      * * Fe_C.eam.alloy Fe C
neighbor        2.0 bin
neigh_modify    every 1 delay 0 check yes

#-------Define atom mass (no needed for moelcular statics) 
mass            1 55.845
mass            2 12.011

#-------Compute------------------------------------------
compute 	eng all pe/atom
compute 	new all temp
compute 	csym all centro/atom bcc
compute 	poten all pe
compute 	stress all stress/atom NULL

#------Relaxation----------------------------------------
thermo          100
thermo_style    custom step pe lx ly lz pxx pyy pzz pxy pxz pyz press

min_style       cg
minimize        1e-30 10e-12 100000000 1000000000

#-----Calculate the lattice parameter--------------------
variable        tmp equal "lx"
variable        LX equal ${tmp}
variable        tmp equal "ly"
variable        LY equal ${tmp}
variable        tmp equal "lz"
variable        LZ equal ${tmp}
variable        tmp equal "atoms"
variable        N equal ${tmp}
variable        V equal (${LX}*${LY}*${LZ})
variable        alat equal (${LX}+${LY}+${LZ})/3
variable        tmp equal "pe"
variable        pe0 equal ${tmp}
variable        teng equal ${pe0}/${N}
variable        vol  equal ${V}/${N}

#-----output to datafolder-------------------------------- 
print           "${vol} ${teng} ${alat}" append ./volume_diamond.dat

#-----jump to next loop-----------------------------------
next            i
jump            in.eos_C_dia loop_start

Step 4: Compute the interstitial energy of carbon.

Calculating Interstitial Energy Now that we have the system both with and without the carbon atom, we can calculate the interstitial energy. The interstitial energy is given by: [ E_{inter} = E_{Fe+C} - E_{Fe} - E_{C} ] Where:

• $ E_{Fe+C} $ is the energy of the iron lattice with the carbon atom.
• $ E_{Fe} $ is the energy of the pure iron lattice.
• $ E_{C} $ is the energy of an isolated carbon atom.

By following this process, you can calculate the interstitial energy of carbon in iron using LAMMPS. This value is useful in understanding how carbon atoms interact with the iron lattice, which is important for studying phenomena like carbon diffusion in steels. Feel free to modify the script to use different lattice sizes or to insert multiple interstitial atoms. The same approach can be extended to calculate interstitial energies for other elements in different metals.

Happy simulating!

Bash (short for Bourne-Again SHell) is a powerful command-line shell and scripting language commonly used on Unix-like systems such as Linux and macOS. Bash scripts enable you to automate repetitive tasks, manage system operations, and create complex workflows in an efficient way.

Table of Contents

1. What Is Bash?
2. Creating and Running a Bash Script
3. Variables and Command Substitution
4. User Input and Command-Line Arguments
5. Control Structures
   • If-Else Statement
   • For Loops
   • While Loops
   • Case Statements
6. Functions
7. Working with Files
8. Useful Built-in Commands
9. Error Handling and Debugging
10. Practical Examples
11. Best Practices
12. Further Reading and Resources

What Is Bash?

Bash is both a command interpreter and a scripting language:

• Command interpreter (shell): It lets you type and execute commands interactively in a terminal.
• Scripting language: You can create files (scripts) containing a sequence of commands, which are then run automatically, saving time and reducing errors.

Creating and Running a Bash Script

1). Create a new file (e.g., myscript.sh) with any text editor (vi, nano, gedit, etc.). 2). Add the shebang line at the top of the file to specify the interpreter:

   #!/bin/bash

3). Write your script by adding commands you would normally run in the terminal:

#!/bin/bash
echo "Hello, world!"

4). Make the script executable by running:

#!/bin/bash
chmod +x myscript.sh

5). Execute the script:

./myscript.sh

or

bash myscript.sh

Variables and Command Substitution

In Bash, you can create and use variables to store information, such as strings, numbers, or the output of commands.

Creating Variables

#!/bin/bash
name="Alice"
number=42

echo "My name is $name and my favorite number is $number."

Command Substitution

Command substitution lets you assign the output of a command to a variable:

#!/bin/bash
current_date=$(date)
echo "Today's date is $current_date."

Alternatively, older syntax uses backticks:

current_date=`date`

User Input and Command-Line Arguments

Reading User Input with read

#!/bin/bash
echo "Please enter your name:"
read user_name
echo "Hello, $user_name!"

Command-Line Arguments

$1, $2, $3, etc. represent the arguments passed to the script:

#!/bin/bash
echo "The first argument is $1"
echo "The second argument is $2"

To handle many arguments, you can use $@ or $* to represent all arguments.

Control Structures

Control structures allow you to alter the flow of your Bash scripts.

If-Else Statement

#!/bin/bash
aa=3.14
bb=3.14
c=$(echo "$aa == $bb" | bc)  # compares numerical values

if [[ "$c" -eq 1 ]]; then
  echo "true"
else
  echo "false"
fi

String Comparison Example

#!/bin/bash
flag_0="DISLOCATION"

if [ "$flag_0" = "DISLOCATION" ]; then
  echo "equal 000"
else
  echo "not equal 000"
fi

Common Operators:

• -eq, -ne, -gt, -ge, -lt, -le: numeric comparisons
• -z, -n: check if a string is empty or not
• =, !=: string equality or inequality

For Loops

#!/bin/bash
for ((i=1; i<=200; i=i+5))
do
  echo $i
  echo loop.$i.dump
done

Another form (iterating over a list):

#!/bin/bash
for fruit in apple banana cherry
do
  echo "I like $fruit"
done

While Loops

#!/bin/bash
count=1
while [ $count -le 5 ]
do
  echo "Count is: $count"
  ((count++))
done

Case Statements

#!/bin/bash
echo "Enter a number between 1 and 3:"
read number

case $number in
  1)
    echo "You chose one."
    ;;
  2)
    echo "You chose two."
    ;;
  3)
    echo "You chose three."
    ;;
  *)
    echo "Invalid choice!"
    ;;
esac

Functions

Functions allow you to group related commands for easier reuse and better structure:

#!/bin/bash

function greet {
  echo "Hello, $1!"
}

greet "Alice"
greet "Bob"

• $1, $2, etc., in functions refer to the function’s arguments.
• The return command can return an integer status code, and echo can be used to produce function output.

Working with Files

Check if a File Exists and Is Not Empty

#!/bin/bash
if [ -s pidfile ]; then
  echo "hi"
else
  echo "empty"
fi

Creating, Appending, and Reading Files

#!/bin/bash
# Creating or overwriting a file
echo "Hello" > myfile.txt

# Appending to a file
echo "World" >> myfile.txt

# Reading a file line by line
while IFS= read -r line
do
  echo "Line: $line"
done < myfile.txt

Useful Built-in Commands

• echo: Prints arguments to standard output.
• read: Reads a line of input from standard input.
• cd: Changes the current directory.
• pwd: Prints the current working directory.
• ls, cp, mv, rm: Basic file and directory management commands.
• test or [ ]: Evaluates conditional expressions (used in if statements).
• exit: Exits the script with an optional status code (0 for success).

Error Handling and Debugging

set Options

• set -e: Exit the script when any command fails.
• set -u: Treat unset variables as errors.
• set -o pipefail: Return exit code of the last command that failed in a pipeline. Include them near the top of your script:

  #!/bin/bash
  set -euo pipefail
  

Using trap

#!/bin/bash
trap 'echo "An error occurred. Exiting..."' ERR

some_command_that_might_fail
echo "This won't run if the above command fails."

Debug Mode

• Verbose mode: bash -v myscript.sh
• Debug mode: bash -x myscript.sh (prints each command with its expanded arguments)

Practical Examples

1. Monitoring Disk Usage ``` #!/bin/bash threshold=80

current_usage=$(df -h / | tail -1 | awk ‘{print $5}’ | sed ‘s/%//’) if [ $current_usage -gt $threshold ]; then echo “Warning: Disk usage is above $threshold%!” else echo “Disk usage is under control at $current_usage%.” fi

2. Backup Script

#!/bin/bash source_dir=”/home/user/documents” backup_dir=”/home/user/backup” timestamp=$(date +%Y%m%d%H%M)

mkdir -p “$backup_dir” cp -r “$source_dir” “${backup_dir}/documents_${timestamp}”

echo “Backup of $source_dir completed at ${timestamp}.” ```

Best Practices

1. Use Meaningful Names: Give variables and functions descriptive names (count, backup_files, greet_user).
2. Comment Your Code: Explain why certain commands are used, especially if they’re not obvious.
3. Validate Inputs: Check that arguments and user inputs are valid before using them.
4. Quote Variables: Put variables in quotes (“$var”) to prevent globbing and word splitting issues.
5. Prefer $() for Command Substitution: It’s more readable than backticks.
6. Use set -euo pipefail: Helps catch errors early and makes your script more robust.
7. Test Incrementally: Run sections of your script as you build it to catch errors before they spread.

Further Reading and Resources

• Official Bash Manual: https://www.gnu.org/software/bash/manual/
• Advanced Bash-Scripting Guide: https://tldp.org/LDP/abs/html/
• Linux Command Tutorials: https://linuxcommand.org/

This blog is purely for educational purposes. Linear elastic fracture mechanics is of vital importance in engineering applications, especially predicting material failure. The readers are redireted to the book of Fracture : an advanced treatise. Vol. 2, Mathematical fundamentals by H. Liebowitz et al. for the detailed derivation of the elastic fields in anisotropic medium.

The code