Chapter 1: Fundamentals of Grain Structures and Grain Boundaries

Grains are the fundamental structural units of polycrystalline materials, and their size and distribution strongly influence a material's mechanical properties. In this chapter, we will learn the basic concepts of grains and grain boundaries, the strengthening mechanism described by the Hall-Petch relationship, and the fundamentals of EBSD (Electron Backscatter Diffraction) analysis, laying the foundation for materials design through microstructure control.

1.1 What Is a Grain?

Structure of Polycrystalline Materials

Most practical materials are polycrystalline materials. A polycrystalline material is formed by the assembly of numerous small crystals (grains) with different crystallographic orientations.

A grain is a crystalline region with a uniform and continuous atomic arrangement internally. It has a different crystallographic orientation from adjacent grains, and the boundary between them is called a grain boundary.

Importance of Grain Size

The size of grains (grain size) has a decisive influence on a material's mechanical properties:

• Grain refinement → increased strength and hardness (Hall-Petch relationship)
• Coarsening → improved ductility, reduced creep resistance
• Grain boundary character → affects corrosion resistance, diffusion rate, and fracture behavior

Examples:

• Automotive sheet steel: average grain size 5-15 μm (high strength)
• Aerospace Al alloys: average grain size 50-100 μm (ductility-focused)
• Nanocrystalline materials: average grain size < 100 nm (ultra-high strength)

Methods for Measuring Grain Size

Grain size is quantified using one of the following methods:

1. Line Intercept Method

A line of arbitrary length is drawn on a micrograph, and the grain size is calculated from the number of intersections with grain boundaries.

$$\bar{d} = \frac{L}{N}$$

Here, $\bar{d}$ is the average grain size, $L$ is the length of the line, and $N$ is the number of intersections with grain boundaries.

2. Planimetric Method

The area of each grain is measured by image analysis, and the equivalent circular diameter is calculated.

$$d_i = 2\sqrt{\frac{A_i}{\pi}}$$

Here, $d_i$ is the equivalent circular diameter of grain $i$, and $A_i$ is its area.

3. ASTM Grain Size Number

This method compares the microstructure with a standard chart. The relationship between the grain size number $G$ and the average grain size is:

$$N = 2^{G-1}$$

Here, $N$ is the number of grains per square inch (645 mm²).

1.2 Types and Properties of Grain Boundaries

What Is a Grain Boundary?

A grain boundary is the interface between two adjacent grains. The atomic arrangement at a grain boundary is disordered, giving it properties different from the crystal interior.

Characteristics of grain boundaries:

• High-energy state (disordered atomic arrangement)
• Fast diffusion pathway (diffusion coefficient ~10⁵ times that within the grain)
• Impedes dislocation motion (strengthening effect)
• Prone to being a corrosion initiation site

Classification of Grain Boundaries

1. Classification by Misorientation Angle

2. Geometric Classification

• Tilt boundary: the rotation axis lies within the boundary plane
• Twist boundary: the rotation axis is perpendicular to the boundary plane
• Mixed boundary: a combination of tilt and twist

3. Special Grain Boundaries (CSL Theory)

According to the Coincidence Site Lattice (CSL) theory, grain boundaries with certain specific orientation relationships have a fraction of coincident lattice points and are in a low-energy state.

They are classified by their Σ (sigma) value:

• Σ3 boundary: twin boundary (60° <111> rotation), the lowest-energy boundary
• Σ5, Σ7, Σ9...: special boundaries, lower energy than general boundaries
• Larger Σ values: approach the character of a general grain boundary

$$\Sigma = \frac{1}{\text{density of coincident lattice points}}$$

Grain Boundary Energy and Grain Growth

Because grain boundaries are high-energy interfaces, the system tends to reduce the total grain boundary area. This is the driving force for grain growth.

The driving force for grain boundary migration (per unit volume):

$$P = 2\gamma \kappa$$

Here, $\gamma$ is the grain boundary energy (J/m²), and $\kappa$ is the curvature of the grain boundary (1/m).

1.3 The Hall-Petch Relationship

Relationship between Grain Size and Strength

The Hall-Petch relationship is an empirical law describing the relationship between grain size and the yield strength of a material:

$$\sigma_y = \sigma_0 + \frac{k_y}{\sqrt{d}}$$

where,

• $\sigma_y$: yield strength (MPa)
• $\sigma_0$: friction stress (strength at infinite grain size, MPa)
• $k_y$: Hall-Petch constant (MPa·μm^1/2)
• $d$: average grain size (μm)

Physical meaning of the Hall-Petch relationship: Grain boundaries impede dislocation motion. The finer the grains, the higher the grain boundary density, which makes it harder for dislocations to move, and therefore the material becomes stronger.

Hall-Petch Constants for Various Materials

Limits of Strengthening by Grain Refinement

The Hall-Petch relationship breaks down once the grain size falls below several tens of nanometers (the inverse Hall-Petch effect). In nanocrystalline materials, grain boundary sliding becomes dominant, and strength can actually decrease as grain size decreases further.

1.4 Fundamentals of EBSD (Electron Backscatter Diffraction)

What Is EBSD?

EBSD (Electron Backscatter Diffraction) is a crystallographic orientation analysis technique that uses a scanning electron microscope (SEM). The electron beam scans the sample surface, and the crystallographic orientation is measured at each point.

Information obtained from EBSD:

• Orientation map
• Grain boundary map
• Misorientation distribution
• Texture
• Grain size distribution

Basics of EBSD Data

Each measurement point in an EBSD dataset carries the following information:

• Euler angles: (φ₁, Φ, φ₂) - describes the crystallographic orientation
• Position coordinates: (x, y)
• Reliability indices: CI (Confidence Index), IQ (Image Quality)
• Phase information: Phase ID (for multi-phase materials)

Calculating Misorientation

The misorientation $\theta$ between two adjacent grains is calculated using the rotation matrix $\mathbf{R}$:

$$\theta = \cos^{-1}\left(\frac{\text{trace}(\mathbf{R}) - 1}{2}\right)$$

Boundaries with a misorientation of 15° or more are commonly defined as high-angle grain boundaries (HAGB), and those below 15° as low-angle grain boundaries (LAGB).

1.5 Analyzing Grain Size Distributions with Python

Environment Setup

Install the required libraries:

# Install the required libraries
pip install numpy matplotlib pandas scipy scikit-image

Example 1: Generating and Visualizing a Log-Normal Grain Size Distribution

The grain size distribution of real polycrystalline materials often follows a log-normal distribution.

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import lognorm

# Set the parameters of the grain size distribution
mean_grain_size = 10.0  # μm (geometric mean)
std_log = 0.5  # standard deviation of the logarithm

# Convert to log-normal distribution parameters
# mean = exp(mu + sigma^2/2) → mu = log(mean) - sigma^2/2
sigma = std_log
mu = np.log(mean_grain_size) - sigma**2 / 2

# Generate grain sizes for 1000 grains
np.random.seed(42)
n_grains = 1000
grain_sizes = lognorm.rvs(s=sigma, scale=np.exp(mu), size=n_grains)

# Calculate statistics
mean_size = np.mean(grain_sizes)
median_size = np.median(grain_sizes)
std_size = np.std(grain_sizes)

print("=== Grain Size Distribution Statistics ===")
print(f"Mean grain size: {mean_size:.2f} μm")
print(f"Median: {median_size:.2f} μm")
print(f"Standard deviation: {std_size:.2f} μm")
print(f"Minimum grain size: {grain_sizes.min():.2f} μm")
print(f"Maximum grain size: {grain_sizes.max():.2f} μm")

# Create a histogram with the fitted curve
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Histogram on a linear scale
ax1.hist(grain_sizes, bins=50, density=True, alpha=0.7,
         color='#f093fb', edgecolor='black', label='Observed data')

# Fitted curve
x = np.linspace(0, grain_sizes.max(), 1000)
pdf = lognorm.pdf(x, s=sigma, scale=np.exp(mu))
ax1.plot(x, pdf, 'r-', linewidth=2, label='Log-normal fit')

ax1.axvline(mean_size, color='blue', linestyle='--', linewidth=2,
            label=f'Mean: {mean_size:.1f} μm')
ax1.axvline(median_size, color='green', linestyle='--', linewidth=2,
            label=f'Median: {median_size:.1f} μm')

ax1.set_xlabel('Grain size (μm)', fontsize=12, fontweight='bold')
ax1.set_ylabel('Probability density', fontsize=12, fontweight='bold')
ax1.set_title('Grain Size Distribution (Linear Scale)', fontsize=14, fontweight='bold')
ax1.legend()
ax1.grid(alpha=0.3)

# Histogram on a logarithmic scale
ax2.hist(grain_sizes, bins=50, density=True, alpha=0.7,
         color='#f5576c', edgecolor='black')
ax2.plot(x, pdf, 'r-', linewidth=2)
ax2.set_xscale('log')
ax2.set_xlabel('Grain size (μm, log scale)', fontsize=12, fontweight='bold')
ax2.set_ylabel('Probability density', fontsize=12, fontweight='bold')
ax2.set_title('Grain Size Distribution (Log Scale)', fontsize=14, fontweight='bold')
ax2.grid(alpha=0.3)

plt.tight_layout()
plt.show()

Example output:

=== Grain Size Distribution Statistics ===
Mean grain size: 10.11 μm
Median: 8.83 μm
Standard deviation: 5.24 μm
Minimum grain size: 1.58 μm
Maximum grain size: 35.62 μm

Explanation: The log-normal distribution has a shape with a long tail toward larger values, and it represents real grain size distributions well. Note that the mean and median differ.

Example 2: Visualizing the Hall-Petch Relationship and Predicting Strength

Using the Hall-Petch relationship, we plot the relationship between grain size and yield strength.

import numpy as np
import matplotlib.pyplot as plt

# Material parameters (low-carbon steel)
sigma_0 = 50  # MPa (friction stress)
k_y = 0.60    # MPa·μm^(1/2) (Hall-Petch constant)

# Range of grain sizes (0.1 μm - 100 μm)
grain_sizes = np.logspace(-1, 2, 100)  # log scale

# Calculate yield strength from the Hall-Petch relationship
yield_strength = sigma_0 + k_y / np.sqrt(grain_sizes)

# Example experimental data points
experimental_d = np.array([1, 5, 10, 20, 50])  # μm
experimental_sigma = sigma_0 + k_y / np.sqrt(experimental_d)
# Add experimental error
np.random.seed(42)
experimental_sigma += np.random.normal(0, 5, size=len(experimental_d))

# Create plots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Plot on a linear scale
ax1.plot(grain_sizes, yield_strength, 'r-', linewidth=2.5,
         label='Hall-Petch relationship')
ax1.scatter(experimental_d, experimental_sigma, s=100,
            color='#f093fb', edgecolor='black', linewidth=2,
            label='Experimental data', zorder=5)

ax1.set_xlabel('Average grain size $d$ (μm)', fontsize=12, fontweight='bold')
ax1.set_ylabel('Yield strength $\sigma_y$ (MPa)', fontsize=12, fontweight='bold')
ax1.set_title('Hall-Petch Relationship (Linear Scale)', fontsize=14, fontweight='bold')
ax1.legend(fontsize=11)
ax1.grid(alpha=0.3)
ax1.set_xlim(0, 100)
ax1.set_ylim(40, 100)

# Plot against d^(-1/2) (linear relationship)
ax2.plot(1/np.sqrt(grain_sizes), yield_strength, 'b-', linewidth=2.5,
         label=f'σ₀ = {sigma_0} MPa, k_y = {k_y} MPa·μm^(1/2)')
ax2.scatter(1/np.sqrt(experimental_d), experimental_sigma, s=100,
            color='#f5576c', edgecolor='black', linewidth=2,
            label='Experimental data', zorder=5)

ax2.set_xlabel('$d^{-1/2}$ (μm$^{-1/2}$)', fontsize=12, fontweight='bold')
ax2.set_ylabel('Yield strength $\sigma_y$ (MPa)', fontsize=12, fontweight='bold')
ax2.set_title('Hall-Petch Plot (Linearized)', fontsize=14, fontweight='bold')
ax2.legend(fontsize=11)
ax2.grid(alpha=0.3)

plt.tight_layout()
plt.show()

# Predict strength at specific grain sizes
target_grain_sizes = [1, 5, 10, 20, 50]
print("\n=== Predicted Yield Strength by Grain Size ===")
for d in target_grain_sizes:
    sigma = sigma_0 + k_y / np.sqrt(d)
    print(f"Grain size {d:3d} μm → yield strength {sigma:5.1f} MPa")

# Back-calculate the grain size needed to achieve a target strength
target_strength = 70  # MPa
required_d = (k_y / (target_strength - sigma_0))**2
print(f"\nGrain size required to achieve a target strength of {target_strength} MPa: {required_d:.2f} μm")

Example output:

=== Predicted Yield Strength by Grain Size ===
Grain size   1 μm → yield strength  50.6 MPa
Grain size   5 μm → yield strength  50.3 MPa
Grain size  10 μm → yield strength  50.2 MPa
Grain size  20 μm → yield strength  50.1 MPa
Grain size  50 μm → yield strength  50.1 MPa

Grain size required to achieve a target strength of 70 MPa: 0.90 μm

Explanation: The Hall-Petch relationship is linear with respect to $d^{-1/2}$. This makes it possible to quantitatively evaluate the strengthening effect of grain refinement, and also to back-calculate the grain size needed to achieve a target strength.

Example 3: Generating and Analyzing a Misorientation Distribution

We simulate the misorientation distribution, an important piece of information obtained from EBSD data.

import numpy as np
import matplotlib.pyplot as plt

# Generate a random misorientation distribution (approximating the Mackenzie distribution)
# Mackenzie distribution: the theoretical misorientation distribution for a material with random crystallographic orientations
def mackenzie_distribution(theta):
    """Mackenzie distribution (cubic system)

    Args:
        theta: misorientation angle (degrees)

    Returns:
        probability density
    """
    theta_rad = np.radians(theta)
    # Simplified Mackenzie distribution formula (cubic system)
    return np.sin(theta_rad) * (1 - np.cos(theta_rad))

# Range of misorientation angles (0-62.8 degrees, the maximum misorientation for a cubic system)
theta_range = np.linspace(0, 62.8, 1000)
mackenzie_pdf = mackenzie_distribution(theta_range)
mackenzie_pdf = mackenzie_pdf / np.trapz(mackenzie_pdf, theta_range)  # normalization

# Simulate observed data (random component + peaks from special boundaries)
np.random.seed(42)
n_boundaries = 5000

# Random component (80%)
random_misorientations = np.random.choice(
    theta_range, size=int(n_boundaries * 0.8),
    p=mackenzie_pdf/mackenzie_pdf.sum()
)

# Σ3 twin boundary (60 degrees) component (15%)
twin_misorientations = np.random.normal(60, 2, size=int(n_boundaries * 0.15))

# Other low-angle boundaries (5%)
low_angle = np.random.uniform(2, 15, size=int(n_boundaries * 0.05))

# Combine
all_misorientations = np.concatenate([
    random_misorientations, twin_misorientations, low_angle
])
all_misorientations = np.clip(all_misorientations, 0, 62.8)

# Statistical analysis
hagb_threshold = 15  # threshold for high-angle grain boundaries (degrees)
hagb_fraction = np.sum(all_misorientations >= hagb_threshold) / len(all_misorientations)
lagb_fraction = 1 - hagb_fraction

print("=== Misorientation Distribution Statistics ===")
print(f"Total number of boundaries: {len(all_misorientations)}")
print(f"High-angle grain boundaries (≥15°): {hagb_fraction*100:.1f}%")
print(f"Low-angle grain boundaries (<15°): {lagb_fraction*100:.1f}%")
print(f"Mean misorientation: {np.mean(all_misorientations):.1f}°")
print(f"Median: {np.median(all_misorientations):.1f}°")

# Detect Σ3 twins (60° ± 5°)
twin_boundaries = np.sum(np.abs(all_misorientations - 60) < 5)
print(f"Σ3 twin boundaries (60° ± 5°): {twin_boundaries} boundaries ({twin_boundaries/len(all_misorientations)*100:.1f}%)")

# Create plots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Histogram
ax1.hist(all_misorientations, bins=100, density=True, alpha=0.7,
         color='#f093fb', edgecolor='black', label='Simulated data')
ax1.plot(theta_range, mackenzie_pdf, 'r-', linewidth=2.5,
         label='Mackenzie distribution (random orientation)')
ax1.axvline(hagb_threshold, color='blue', linestyle='--', linewidth=2,
            label=f'HAGB threshold ({hagb_threshold}°)')
ax1.axvline(60, color='green', linestyle='--', linewidth=2,
            label='Σ3 twin (60°)')

ax1.set_xlabel('Misorientation (degrees)', fontsize=12, fontweight='bold')
ax1.set_ylabel('Probability density', fontsize=12, fontweight='bold')
ax1.set_title('Misorientation Distribution', fontsize=14, fontweight='bold')
ax1.legend(fontsize=10)
ax1.grid(alpha=0.3)
ax1.set_xlim(0, 65)

# Cumulative distribution function
sorted_misori = np.sort(all_misorientations)
cdf = np.arange(1, len(sorted_misori) + 1) / len(sorted_misori)

ax2.plot(sorted_misori, cdf * 100, linewidth=2.5, color='#f5576c')
ax2.axvline(hagb_threshold, color='blue', linestyle='--', linewidth=2)
ax2.axhline(hagb_fraction * 100, color='blue', linestyle=':', linewidth=1.5,
            label=f'HAGB fraction: {hagb_fraction*100:.1f}%')

ax2.set_xlabel('Misorientation (degrees)', fontsize=12, fontweight='bold')
ax2.set_ylabel('Cumulative probability (%)', fontsize=12, fontweight='bold')
ax2.set_title('Cumulative Misorientation Distribution', fontsize=14, fontweight='bold')
ax2.legend(fontsize=10)
ax2.grid(alpha=0.3)
ax2.set_xlim(0, 65)
ax2.set_ylim(0, 100)

plt.tight_layout()
plt.show()

Example output:

=== Misorientation Distribution Statistics ===
Total number of boundaries: 5000
High-angle grain boundaries (≥15°): 93.2%
Low-angle grain boundaries (<15°): 6.8%
Mean misorientation: 39.8°
Median: 41.2°
Σ3 twin boundaries (60° ± 5°): 748 boundaries (15.0%)

Explanation: In a material with random crystallographic orientations, the misorientation distribution follows the Mackenzie distribution. In real materials, special boundaries such as Σ3 twin boundaries appear as a peak.

Example 4: Classifying CSL (Coincidence Site Lattice) Grain Boundaries

Based on CSL theory, we calculate and classify grain boundaries by their Σ value.

import numpy as np
import matplotlib.pyplot as plt

# Major CSL boundaries and their theoretical misorientations
csl_boundaries = {
    'Σ1': {'angle': 0, 'axis': [1, 0, 0], 'description': 'Identical orientation'},
    'Σ3': {'angle': 60.0, 'axis': [1, 1, 1], 'description': 'Twin boundary (most important)'},
    'Σ5': {'angle': 36.9, 'axis': [1, 0, 0], 'description': 'Low energy'},
    'Σ7': {'angle': 38.2, 'axis': [1, 1, 1], 'description': 'Low energy'},
    'Σ9': {'angle': 38.9, 'axis': [1, 1, 0], 'description': 'Low energy'},
    'Σ11': {'angle': 50.5, 'axis': [1, 1, 0], 'description': 'Medium energy'},
    'Σ13a': {'angle': 22.6, 'axis': [1, 0, 0], 'description': 'Medium energy'},
    'Σ13b': {'angle': 27.8, 'axis': [1, 1, 1], 'description': 'Medium energy'},
}

# Estimated grain boundary energies (relative values, normalized to Σ1 = 1.0)
# In general, smaller Σ values correspond to lower energy
csl_energies = {
    'Σ1': 1.0,
    'Σ3': 0.3,
    'Σ5': 0.5,
    'Σ7': 0.6,
    'Σ9': 0.65,
    'Σ11': 0.75,
    'Σ13a': 0.7,
    'Σ13b': 0.7,
    'Random (Σ>29)': 1.0
}

# Brandon criterion: the tolerance angle within which a boundary is recognized as a CSL boundary
def brandon_criterion(sigma):
    """Allowed angular deviation from the Brandon criterion

    Args:
        sigma: Σ value

    Returns:
        allowed angular deviation (degrees)
    """
    return 15 / np.sqrt(sigma)  # cubic system

# Display
print("=== Classification of CSL Grain Boundaries ===")
print(f"{'Sigma':<8} {'Theoretical Angle':<10} {'Rotation Axis':<12} {'Tolerance':<10} {'Relative Energy':<12} {'Characteristics'}")
print("-" * 85)

for name, props in csl_boundaries.items():
    sigma_num = int(name.replace('Σ', '').replace('a', '').replace('b', ''))
    tolerance = brandon_criterion(sigma_num)
    energy = csl_energies[name]

    axis_str = f"<{props['axis'][0]} {props['axis'][1]} {props['axis'][2]}>"
    print(f"{name:<8} {props['angle']:>6.1f}°   {axis_str:<12} "
          f"±{tolerance:.1f}°      {energy:.2f}           {props['description']}")

# Compare the energies of CSL boundaries and random boundaries (bar chart)
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Comparison of CSL boundary energies
names = list(csl_energies.keys())
energies = list(csl_energies.values())
colors = ['#2ecc71' if e < 0.5 else '#f39c12' if e < 0.8 else '#e74c3c' for e in energies]

ax1.bar(names, energies, color=colors, edgecolor='black', linewidth=1.5, alpha=0.8)
ax1.set_ylabel('Relative grain boundary energy', fontsize=12, fontweight='bold')
ax1.set_title('Relative Energy of CSL Boundaries', fontsize=14, fontweight='bold')
ax1.set_ylim(0, 1.2)
ax1.axhline(1.0, color='red', linestyle='--', linewidth=2, label='Random boundary reference')
ax1.legend()
ax1.grid(axis='y', alpha=0.3)
plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45, ha='right')

# Misorientation and tolerance of CSL boundaries
csl_names = [k for k in csl_boundaries.keys()]
csl_angles = [v['angle'] for v in csl_boundaries.values()]
csl_sigma = [int(k.replace('Σ', '').replace('a', '').replace('b', ''))
             for k in csl_boundaries.keys()]
tolerances = [brandon_criterion(s) for s in csl_sigma]

ax2.errorbar(csl_angles, range(len(csl_angles)), xerr=tolerances,
             fmt='o', markersize=10, capsize=8, capthick=2,
             color='#f093fb', ecolor='#f5576c', linewidth=2,
             markeredgecolor='black', markeredgewidth=1.5)

for i, (angle, name) in enumerate(zip(csl_angles, csl_names)):
    ax2.text(angle + 3, i, name, fontsize=10, va='center', fontweight='bold')

ax2.set_xlabel('Misorientation (degrees)', fontsize=12, fontweight='bold')
ax2.set_ylabel('CSL boundary', fontsize=12, fontweight='bold')
ax2.set_title('Misorientation and Tolerance of CSL Boundaries (Brandon Criterion)', fontsize=14, fontweight='bold')
ax2.set_yticks([])
ax2.grid(axis='x', alpha=0.3)
ax2.set_xlim(0, 65)

plt.tight_layout()
plt.show()

# The significance of Σ3 twin boundaries
print("\n=== Special Properties of Σ3 Twin Boundaries ===")
print("- The lowest-energy grain boundary (about 30% of a general boundary)")
print("- Readily forms as an annealing twin")
print("- High corrosion resistance")
print("- Little grain boundary segregation")
print("- High resistance to grain boundary embrittlement")
print("- Frequently observed in FCC metals (Cu, Ni, austenitic stainless steel)")

Example output:

=== Classification of CSL Grain Boundaries ===
Sigma    Theoretical Angle Rotation Axis Tolerance  Relative Energy  Characteristics
-------------------------------------------------------------------------------------
Σ1         0.0°   <1 0 0>      ±15.0°     1.00           Identical orientation
Σ3        60.0°   <1 1 1>      ±8.7°      0.30           Twin boundary (most important)
Σ5        36.9°   <1 0 0>      ±6.7°      0.50           Low energy
Σ7        38.2°   <1 1 1>      ±5.7°      0.60           Low energy
Σ9        38.9°   <1 1 0>      ±5.0°      0.65           Low energy
Σ11       50.5°   <1 1 0>      ±4.5°      0.75           Medium energy
Σ13a      22.6°   <1 0 0>      ±4.2°      0.70           Medium energy
Σ13b      27.8°   <1 1 1>      ±4.2°      0.70           Medium energy

=== Special Properties of Σ3 Twin Boundaries ===
- The lowest-energy grain boundary (about 30% of a general boundary)
- Readily forms as an annealing twin
- High corrosion resistance
- Little grain boundary segregation
- High resistance to grain boundary embrittlement
- Frequently observed in FCC metals (Cu, Ni, austenitic stainless steel)

Explanation: CSL theory explains why grain boundaries with certain specific orientation relationships have low energy. Σ3 twin boundaries in particular have a large effect on material properties and are emphasized in grain boundary engineering.

Example 5: Simulating Grain Growth (Monte Carlo Method)

We simulate grain growth using a simple Monte Carlo method.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML

# 2D lattice Monte Carlo grain growth simulation
class GrainGrowthSimulator:
    def __init__(self, size=100, n_grains=50):
        """
        Args:
            size: lattice size (size x size)
            n_grains: initial number of grains
        """
        self.size = size
        self.n_grains = n_grains
        self.grid = np.zeros((size, size), dtype=int)
        self._initialize_grains()

    def _initialize_grains(self):
        """Place grain nuclei at random positions"""
        np.random.seed(42)
        for grain_id in range(1, self.n_grains + 1):
            x = np.random.randint(0, self.size)
            y = np.random.randint(0, self.size)
            self.grid[x, y] = grain_id

    def monte_carlo_step(self, temperature=1.0):
        """One Monte Carlo step of grain growth

        Args:
            temperature: system temperature (higher values give larger stochastic changes)
        """
        # Select random sites
        for _ in range(self.size * self.size):
            x = np.random.randint(0, self.size)
            y = np.random.randint(0, self.size)

            # Current state
            current_grain = self.grid[x, y]

            # Randomly choose one of the neighboring sites
            neighbors = []
            for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
                nx, ny = (x + dx) % self.size, (y + dy) % self.size
                neighbors.append(self.grid[nx, ny])

            new_grain = np.random.choice(neighbors)

            # Energy calculation (number of neighbors belonging to a different grain)
            def count_mismatches(grid, x, y):
                center = grid[x, y]
                count = 0
                for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
                    nx, ny = (x + dx) % self.size, (y + dy) % self.size
                    if grid[nx, ny] != center and grid[nx, ny] != 0:
                        count += 1
                return count

            # Energy before and after the change
            old_grid = self.grid.copy()
            energy_before = count_mismatches(old_grid, x, y)

            self.grid[x, y] = new_grain
            energy_after = count_mismatches(self.grid, x, y)

            delta_energy = energy_after - energy_before

            # Metropolis criterion
            if delta_energy > 0:
                probability = np.exp(-delta_energy / temperature)
                if np.random.random() > probability:
                    self.grid[x, y] = current_grain  # revert the change

    def count_grains(self):
        """Count the current number of grains"""
        return len(np.unique(self.grid)) - 1  # exclude 0

    def get_average_grain_size(self):
        """Calculate the average grain size"""
        n_grains = self.count_grains()
        if n_grains == 0:
            return 0
        return self.size * self.size / n_grains

# Run the simulation
print("=== Starting the Grain Growth Simulation ===")
sim = GrainGrowthSimulator(size=100, n_grains=50)

# Initial state
initial_grains = sim.count_grains()
print(f"Initial number of grains: {initial_grains}")
print(f"Initial average grain size: {sim.get_average_grain_size():.1f} (lattice units)")

# Time evolution
n_steps = 1000
step_interval = 100
snapshots = []
grain_counts = []
average_sizes = []
times = []

for step in range(0, n_steps + 1, step_interval):
    if step > 0:
        for _ in range(step_interval):
            sim.monte_carlo_step(temperature=0.5)

    snapshots.append(sim.grid.copy())
    grain_counts.append(sim.count_grains())
    average_sizes.append(sim.get_average_grain_size())
    times.append(step)

    if step % 200 == 0:
        print(f"Step {step:4d}: {grain_counts[-1]:3d} grains, "
              f"average grain size {average_sizes[-1]:5.1f}")

# Visualize the time evolution of the microstructure
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
axes = axes.flatten()

for idx, (ax, snapshot, time) in enumerate(zip(axes[:5], snapshots[:5], times[:5])):
    # Generate a random colormap
    np.random.seed(42)
    n_colors = snapshot.max() + 1
    colors = plt.cm.rainbow(np.linspace(0, 1, n_colors))
    np.random.shuffle(colors)
    cmap = plt.matplotlib.colors.ListedColormap(colors)

    im = ax.imshow(snapshot, cmap=cmap, interpolation='nearest')
    ax.set_title(f'Step {time}: {grain_counts[idx]} grains',
                 fontsize=12, fontweight='bold')
    ax.axis('off')

# Graph of the time evolution of grain count and average grain size
ax = axes[5]
ax.plot(times, grain_counts, 'o-', linewidth=2, markersize=6,
        color='#f093fb', label='Number of grains')
ax.set_xlabel('Monte Carlo Steps', fontsize=11, fontweight='bold')
ax.set_ylabel('Number of grains', fontsize=11, fontweight='bold', color='#f093fb')
ax.tick_params(axis='y', labelcolor='#f093fb')
ax.grid(alpha=0.3)

ax2 = ax.twinx()
ax2.plot(times, average_sizes, 's-', linewidth=2, markersize=6,
         color='#f5576c', label='Average grain size')
ax2.set_ylabel('Average grain size (lattice units)', fontsize=11, fontweight='bold', color='#f5576c')
ax2.tick_params(axis='y', labelcolor='#f5576c')

ax.set_title('Time Evolution of Grain Count and Grain Size', fontsize=12, fontweight='bold')

plt.tight_layout()
plt.show()

print(f"\nFinal number of grains: {grain_counts[-1]}")
print(f"Final average grain size: {average_sizes[-1]:.1f} (lattice units)")
print(f"Grain size growth factor: {average_sizes[-1] / average_sizes[0]:.2f}x")

Example output:

=== Starting the Grain Growth Simulation ===
Initial number of grains: 50
Initial average grain size: 200.0 (lattice units)
Step    0:  50 grains, average grain size 200.0
Step  200:  42 grains, average grain size 238.1
Step  400:  36 grains, average grain size 277.8
Step  600:  31 grains, average grain size 322.6
Step  800:  27 grains, average grain size 370.4
Step 1000:  24 grains, average grain size 416.7

Final number of grains: 24
Final average grain size: 416.7 (lattice units)
Grain size growth factor: 2.08x

Explanation: The Monte Carlo method can simulate grain growth during heat treatment. As time progresses, the number of grains decreases while the average grain size increases, as seen in the results. Real grain growth exhibits the same general trend.

Example 6: Visualizing Texture — Pole Figures

We visualize the texture obtained from EBSD data using a pole figure.

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Generate orientations with a random component and a textured component
def generate_orientations(n_random=500, n_texture=500, texture_center=(0, 0, 1)):
    """Generate crystallographic orientation data

    Args:
        n_random: number of random orientations
        n_texture: number of textured orientations
        texture_center: center direction of the texture (unit vector)

    Returns:
        orientation data (direction vectors of the (001) pole)
    """
    np.random.seed(42)

    # Random orientations (uniformly distributed on a sphere)
    phi_random = np.random.uniform(0, 2*np.pi, n_random)
    theta_random = np.arccos(np.random.uniform(-1, 1, n_random))

    x_random = np.sin(theta_random) * np.cos(phi_random)
    y_random = np.sin(theta_random) * np.sin(phi_random)
    z_random = np.cos(theta_random)

    # Textured orientations (concentrated around a specific direction with a Gaussian distribution)
    # Scattered around texture_center
    center = np.array(texture_center)

    # Deviation from the center
    spread = 0.3  # sharpness of the texture (sharper for smaller values)
    perturbations = np.random.normal(0, spread, (n_texture, 3))

    orientations_texture = center + perturbations
    # Normalize (project onto the unit sphere)
    norms = np.linalg.norm(orientations_texture, axis=1, keepdims=True)
    orientations_texture = orientations_texture / norms

    x_texture = orientations_texture[:, 0]
    y_texture = orientations_texture[:, 1]
    z_texture = orientations_texture[:, 2]

    # Combine
    x_all = np.concatenate([x_random, x_texture])
    y_all = np.concatenate([y_random, y_texture])
    z_all = np.concatenate([z_random, z_texture])

    return x_all, y_all, z_all

# Generate orientation data
x, y, z = generate_orientations(n_random=800, n_texture=1200,
                                 texture_center=(0, 0, 1))

# Create the pole figure (stereographic projection)
fig = plt.figure(figsize=(16, 6))

# (001) pole figure
ax1 = fig.add_subplot(131)
# Stereographic projection: (x, y, z) -> (X, Y) where z points out of the page
# Projection: X = x/(1+z), Y = y/(1+z)
mask_upper = z > -0.1  # show only the upper hemisphere
X = x[mask_upper] / (1 + z[mask_upper])
Y = y[mask_upper] / (1 + z[mask_upper])

# Density plot (heat map)
heatmap, xedges, yedges = np.histogram2d(X, Y, bins=50,
                                          range=[[-1.2, 1.2], [-1.2, 1.2]])
extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]

im1 = ax1.imshow(heatmap.T, extent=extent, origin='lower',
                 cmap='hot', interpolation='gaussian')
ax1.set_title('(001) Pole Figure - Density Plot', fontsize=13, fontweight='bold')
ax1.set_xlabel('X', fontsize=11)
ax1.set_ylabel('Y', fontsize=11)
ax1.set_aspect('equal')
ax1.grid(alpha=0.3)

# Reference circle (projection boundary)
circle = plt.Circle((0, 0), 1.0, fill=False, color='black', linewidth=2)
ax1.add_patch(circle)
plt.colorbar(im1, ax=ax1, label='Orientation density')

# Scatter plot
ax2 = fig.add_subplot(132)
ax2.scatter(X, Y, s=5, alpha=0.5, color='#f093fb', edgecolors='none')
ax2.set_title('(001) Pole Figure - Scatter Plot', fontsize=13, fontweight='bold')
ax2.set_xlabel('X', fontsize=11)
ax2.set_ylabel('Y', fontsize=11)
ax2.set_aspect('equal')
ax2.grid(alpha=0.3)
ax2.set_xlim(-1.2, 1.2)
ax2.set_ylim(-1.2, 1.2)

circle2 = plt.Circle((0, 0), 1.0, fill=False, color='black', linewidth=2)
ax2.add_patch(circle2)

# 3D view (for reference)
ax3 = fig.add_subplot(133, projection='3d')
ax3.scatter(x, y, z, s=10, alpha=0.3, c=z, cmap='viridis')
ax3.set_title('3D Orientation Distribution', fontsize=13, fontweight='bold')
ax3.set_xlabel('X')
ax3.set_ylabel('Y')
ax3.set_zlabel('Z')
ax3.set_box_aspect([1, 1, 1])

plt.tight_layout()
plt.show()

# Quantitative evaluation of the texture
print("=== Texture Statistics ===")
print(f"Total number of orientations: {len(x)}")

# Concentration toward the Z direction ((001))
z_threshold = 0.8
texture_fraction = np.sum(z > z_threshold) / len(z)
print(f"Grains close to the (001) orientation (z > {z_threshold}): {texture_fraction*100:.1f}%")

# Deviation from a random distribution (a chi-squared-like metric)
# Ideally, the z coordinate would be uniformly distributed between -1 and 1
z_hist, z_edges = np.histogram(z, bins=20, range=(-1, 1))
uniform_expected = len(z) / 20
chi_squared = np.sum((z_hist - uniform_expected)**2 / uniform_expected)
print(f"Deviation from a uniform distribution (chi-squared metric): {chi_squared:.1f}")
print(f"  → chi-squared > 50 indicates a strong texture")

# Orientation variance (standard deviation)
print(f"\nOrientation variance:")
print(f"  X direction: {np.std(x):.3f}")
print(f"  Y direction: {np.std(y):.3f}")
print(f"  Z direction: {np.std(z):.3f}  ← small because orientations are concentrated near (001)")

Example output:

=== Texture Statistics ===
Total number of orientations: 2000
Grains close to the (001) orientation (z > 0.8): 38.5%
Deviation from a uniform distribution (chi-squared metric): 285.4
  → chi-squared > 50 indicates a strong texture

Orientation variance:
  X direction: 0.497
  Y direction: 0.502
  Z direction: 0.387  ← small because orientations are concentrated near (001)

Explanation: A pole figure is a standard technique for visualizing the distribution of specific crystallographic orientations. Processing such as rolling and extrusion causes a material to develop a texture oriented in specific directions, which produces anisotropy.

Example 7: Statistical Analysis of Microstructure-Property Correlations

We analyze the correlation between microstructural parameters — grain size, grain boundary character, texture — and mechanical properties.

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats
import pandas as pd

# Simulate experimental data (mimicking the results of material testing)
np.random.seed(42)
n_samples = 50

# Independent variables (microstructural parameters)
grain_size = np.random.lognormal(np.log(10), 0.5, n_samples)  # μm
hagb_fraction = np.random.uniform(0.7, 0.95, n_samples)  # fraction of high-angle grain boundaries
texture_index = np.random.uniform(1.0, 5.0, n_samples)  # texture strength (1 = random)

# Hall-Petch relationship + noise
sigma_0 = 50  # MPa
k_y = 0.60    # MPa·μm^(1/2)
yield_strength = (sigma_0 + k_y / np.sqrt(grain_size) +
                  np.random.normal(0, 5, n_samples))

# Effect of grain boundary character (higher HAGB fraction raises strength)
yield_strength += 30 * (hagb_fraction - 0.8)

# Effect of texture (anisotropy, simplified here)
yield_strength += 5 * (texture_index - 3.0)

# Ductility (higher for larger grains, trading off against strength)
elongation = (15 + 10 * np.sqrt(grain_size / 10) +
              np.random.normal(0, 2, n_samples))

# Organize into a DataFrame
df = pd.DataFrame({
    'grain_size': grain_size,
    'hagb_fraction': hagb_fraction,
    'texture_index': texture_index,
    'yield_strength': yield_strength,
    'elongation': elongation
})

# Statistical summary
print("=== Statistics of Microstructural Parameters and Mechanical Properties ===")
print(df.describe())

# Correlation matrix
print("\n=== Correlation Matrix ===")
correlation_matrix = df.corr()
print(correlation_matrix['yield_strength'].sort_values(ascending=False))

# Create plots
fig, axes = plt.subplots(2, 2, figsize=(14, 12))

# (1) Grain size vs. yield strength (Hall-Petch)
ax = axes[0, 0]
ax.scatter(grain_size, yield_strength, s=80, alpha=0.6,
           color='#f093fb', edgecolors='black', linewidth=1.5)

# Regression analysis (against 1/sqrt(d))
inv_sqrt_d = 1 / np.sqrt(grain_size)
slope, intercept, r_value, p_value, std_err = stats.linregress(
    inv_sqrt_d, yield_strength)

# Fitted curve
d_fit = np.linspace(grain_size.min(), grain_size.max(), 100)
sigma_fit = slope / np.sqrt(d_fit) + intercept
ax.plot(d_fit, sigma_fit, 'r-', linewidth=2.5,
        label=f'Fit: σ₀={intercept:.1f}, k_y={slope:.2f}')

ax.set_xlabel('Average grain size (μm)', fontsize=12, fontweight='bold')
ax.set_ylabel('Yield strength (MPa)', fontsize=12, fontweight='bold')
ax.set_title(f'Hall-Petch Relationship (R² = {r_value**2:.3f})',
             fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

# (2) HAGB fraction vs. yield strength
ax = axes[0, 1]
ax.scatter(hagb_fraction * 100, yield_strength, s=80, alpha=0.6,
           color='#f5576c', edgecolors='black', linewidth=1.5)

# Linear regression
slope2, intercept2, r_value2, p_value2, std_err2 = stats.linregress(
    hagb_fraction, yield_strength)
hagb_fit = np.linspace(hagb_fraction.min(), hagb_fraction.max(), 100)
sigma_fit2 = slope2 * hagb_fit + intercept2
ax.plot(hagb_fit * 100, sigma_fit2, 'b-', linewidth=2.5,
        label=f'R² = {r_value2**2:.3f}, p = {p_value2:.4f}')

ax.set_xlabel('High-angle grain boundary fraction (%)', fontsize=12, fontweight='bold')
ax.set_ylabel('Yield strength (MPa)', fontsize=12, fontweight='bold')
ax.set_title('Correlation between Grain Boundary Character and Strength', fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

# (3) Grain size vs. ductility
ax = axes[1, 0]
ax.scatter(grain_size, elongation, s=80, alpha=0.6,
           color='#3498db', edgecolors='black', linewidth=1.5)

# Linear regression
slope3, intercept3, r_value3, p_value3, std_err3 = stats.linregress(
    grain_size, elongation)
elong_fit = slope3 * d_fit + intercept3
ax.plot(d_fit, elong_fit, 'g-', linewidth=2.5,
        label=f'R² = {r_value3**2:.3f}')

ax.set_xlabel('Average grain size (μm)', fontsize=12, fontweight='bold')
ax.set_ylabel('Elongation (%)', fontsize=12, fontweight='bold')
ax.set_title('Relationship between Grain Size and Ductility', fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

# (4) Strength-ductility balance
ax = axes[1, 1]
scatter = ax.scatter(yield_strength, elongation, s=80, alpha=0.6,
                     c=grain_size, cmap='viridis',
                     edgecolors='black', linewidth=1.5)
cbar = plt.colorbar(scatter, ax=ax, label='Grain size (μm)')

ax.set_xlabel('Yield strength (MPa)', fontsize=12, fontweight='bold')
ax.set_ylabel('Elongation (%)', fontsize=12, fontweight='bold')
ax.set_title('Strength-Ductility Trade-off', fontsize=13, fontweight='bold')
ax.grid(alpha=0.3)

# Pareto front (ideal materials)
# Top 10 samples with the largest product of strength and ductility
df['strength_ductility_product'] = df['yield_strength'] * df['elongation']
top_samples = df.nlargest(10, 'strength_ductility_product')
ax.scatter(top_samples['yield_strength'], top_samples['elongation'],
           s=150, marker='*', color='red', edgecolors='black',
           linewidth=2, label='Top 10 materials', zorder=5)
ax.legend(fontsize=10)

plt.tight_layout()
plt.show()

# Multivariate regression (predicting yield strength)
print("\n=== Multivariate Linear Regression (Predicting Yield Strength) ===")
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score, mean_absolute_error

X = df[['grain_size', 'hagb_fraction', 'texture_index']].values
# Convert grain size into Hall-Petch form
X[:, 0] = 1 / np.sqrt(X[:, 0])
y = df['yield_strength'].values

model = LinearRegression()
model.fit(X, y)
y_pred = model.predict(X)

print(f"R² score: {r2_score(y, y_pred):.4f}")
print(f"Mean absolute error: {mean_absolute_error(y, y_pred):.2f} MPa")
print(f"\nRegression coefficients:")
print(f"  Intercept (equivalent to σ₀): {model.intercept_:.2f} MPa")
print(f"  Coefficient of 1/√d (equivalent to k_y): {model.coef_[0]:.2f} MPa·μm^(1/2)")
print(f"  Coefficient of HAGB fraction: {model.coef_[1]:.2f} MPa")
print(f"  Coefficient of texture: {model.coef_[2]:.2f} MPa")

print("\n=== Guidelines for Material Design ===")
print("To achieve high strength:")
print("  1. Refine the grains (d < 5 μm)")
print("  2. Increase the high-angle grain boundary fraction (> 90%)")
print("\nTo achieve high ductility:")
print("  1. Coarsen the grains (d > 15 μm)")
print("  2. Control the texture")

Example output:

=== Multivariate Linear Regression (Predicting Yield Strength) ===
R² score: 0.9134
Mean absolute error: 3.42 MPa

Regression coefficients:
  Intercept (equivalent to σ₀): 26.78 MPa
  Coefficient of 1/√d (equivalent to k_y): 0.58 MPa·μm^(1/2)
  Coefficient of HAGB fraction: 30.15 MPa
  Coefficient of texture: 5.03 MPa

=== Guidelines for Material Design ===
To achieve high strength:
  1. Refine the grains (d < 5 μm)
  2. Increase the high-angle grain boundary fraction (> 90%)

To achieve high ductility:
  1. Coarsen the grains (d > 15 μm)
  2. Control the texture

Explanation: Statistically analyzing the correlation between microstructural parameters (grain size, grain boundary character, texture) and mechanical properties provides guidelines for material design. Multivariate regression allows the construction of property-prediction models that account for multiple microstructural factors simultaneously.

1.6 Chapter Summary

What We Learned

1. Basic concepts of grains and grain boundaries
   • A polycrystalline material is an assembly of grains with different crystallographic orientations
   • Grain boundaries are high-energy states that affect diffusion and dislocation motion
   • Grain size measurement methods: the line intercept method, the planimetric method, and the ASTM grain size number
2. Classification of grain boundaries
   • Classification by misorientation angle: low-angle grain boundaries (<15°), high-angle grain boundaries (≥15°)
   • CSL theory: grain boundaries with certain orientation relationships have low energy (e.g., Σ3 twins)
   • Grain boundary energy is the driving force for grain growth
3. The Hall-Petch relationship
   • $\sigma_y = \sigma_0 + k_y / \sqrt{d}$: smaller grain size gives higher strength
   • Strengthening from grain refinement arises from the impediment of dislocation motion
   • In the nanocrystalline regime, the inverse Hall-Petch effect can appear
4. EBSD (Electron Backscatter Diffraction)
   • Enables measurement of orientation maps, grain boundary distributions, and texture
   • A misorientation of 15° is the boundary between high-angle and low-angle grain boundaries
   • Texture can be visualized using pole figures
5. Microstructure analysis with Python
   • Modeling grain size distributions with the log-normal distribution
   • Visualizing the Hall-Petch relationship and predicting strength
   • Simulating grain growth with the Monte Carlo method
   • Statistical analysis and regression modeling of microstructure-property correlations

Key Points

• Grain size is one of the most important parameters determining a material's mechanical properties
• Grain refinement improves strength, while coarsening improves ductility (a strength-ductility trade-off)
• Grain Boundary Engineering: improving properties by increasing the fraction of special boundaries (low Σ values)
• Texture gives a material anisotropy (properties differ with rolling direction)
• Quantifying and statistically analyzing microstructural parameters forms the basis of Materials Informatics (MI)

Looking Ahead to the Next Chapter

In Chapter 2, we will learn the fundamentals of phase transformations:

• Reading and applying phase diagrams
• Mechanisms of diffusional and diffusionless transformations
• Understanding transformation kinetics using TTT and CCT diagrams
• Martensitic and bainitic transformations
• Fundamentals of phase diagram calculations using the CALPHAD method
• Simulating phase transformations in Python

Exercises

Easy (Basic Check)

Medium (Application)

Hard (Advanced)