Chapter 1: Fundamentals of Grain Structures and Grain Boundaries

Grains are the fundamental structural units of polycrystalline materials, and their size and distribution significantly affect the mechanical properties of materials. In this chapter, we will learn the basic concepts of grains and grain boundaries, strengthening mechanisms through the Hall-Petch relationship, fundamentals of EBSD (Electron Backscatter Diffraction) analysis, and establish a foundation for materials design through microstructure control.

1.1 What are Grains?

Structure of Polycrystalline Materials

Most practical materials are polycrystalline materials. Polycrystalline materials are 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 is called a grain boundary.

Importance of Grains

The size of grains (grain size) has a decisive influence on the mechanical properties of materials:

• Grain refinement → Improvement in strength and hardness (Hall-Petch relationship)
• Grain coarsening → Improvement in ductility, reduction in creep resistance
• Grain boundary properties → Affect corrosion resistance, diffusion rate, and fracture behavior

Examples:

• Automotive steel sheets: 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)

Grain Size Measurement Methods

Grain size is quantified by one of the following methods:

1. Line Intercept Method

Draw an arbitrary straight line on the microstructure image and calculate from the number of intersections with grain boundaries.

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

where $\bar{d}$ is the average grain size, $L$ is the length of the line segment, and $N$ is the number of grain boundary intersections.

2. Planimetric Method

Measure the area of each grain by image analysis and calculate the equivalent circle diameter.

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

where $d_i$ is the equivalent circle diameter of grain $i$, and $A_i$ is its area.

3. ASTM Grain Size Number

A method of comparison with standard charts. Relationship between grain size number $G$ and average grain size:

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

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

1.2 Types and Properties of Grain Boundaries

What are Grain Boundaries?

A grain boundary is the interface between two adjacent grains. At grain boundaries, the atomic arrangement is disordered and has different properties from the crystal interior.

Characteristics of grain boundaries:

• High energy state (atomic disorder)
• Fast diffusion path (diffusion coefficient 10⁵ times higher than in crystal)
• Inhibit dislocation motion (strengthening effect)
• Prone to corrosion initiation

Classification of Grain Boundaries

1. Classification by Misorientation

2. Geometric Classification

• Tilt boundary: Rotation axis lies in the grain boundary plane
• Twist boundary: Rotation axis is perpendicular to the grain boundary plane
• Mixed boundary: Combination of tilt and twist

3. Special Grain Boundaries (CSL Theory)

According to Coincidence Site Lattice (CSL) theory, grain boundaries with certain orientation relationships have some lattice points in coincidence, resulting in a low energy state.

Classified by Σ (sigma) value:

• Σ3 boundary: Twin boundary (60° <111> rotation), lowest energy
• Σ5, Σ7, Σ9...: Special boundaries, lower energy than general boundaries
• Large Σ value: Close to general boundaries

$$\Sigma = \frac{1}{\text{一致格子点の密度}}$$

Grain Boundary Energy and Grain Growth

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

Driving force for grain boundary migration (per unit volume):

$$P = 2\gamma \kappa$$

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

1.3 Hall-Petch Relationship

Relationship between Grain Size and Strength

The Hall-Petch relationship is an empirical law showing the relationship between grain size and yield strength of materials:

$$\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 coefficient (MPa·μm^1/2)
• $d$: Average grain size (μm)

Physical meaning of the Hall-Petch relationship: Grain boundaries inhibit dislocation motion. Finer grains result in higher grain boundary density, making dislocation movement more difficult, thus strengthening the material.

Hall-Petch Coefficients by Material

Limits of Strengthening by Grain Refinement

The Hall-Petch relationship breaks down when grain size becomes smaller than several tens of nanometers (inverse Hall-Petch effect). In nanocrystalline materials, grain boundary sliding becomes dominant, and strength may decrease with decreasing grain size.

1.4 Fundamentals of EBSD (Electron Backscatter Diffraction)

What is EBSD?

EBSD (Electron Backscatter Diffraction) is a crystallographic orientation analysis technique using a scanning electron microscope (SEM). The sample surface is scanned with an electron beam to measure the crystallographic orientation at each point.

Information obtained from EBSD:

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

Basics of EBSD Data

EBSD data contains the following information at each measurement point:

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

Calculation of 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 misorientation ≥15° are generally defined as high-angle grain boundaries (HAGB), and those <15° as low-angle grain boundaries (LAGB).

1.5 Analysis of Grain Size Distribution Using Python

Environment Setup

Install the required libraries:

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

Code Example 1: Generation and Visualization of Lognormal Grain Size Distribution

Grain size distributions in actual polycrystalline materials often follow a lognormal distribution.

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0

"""
Example: Grain size distributions in actual polycrystalline materials

Purpose: Demonstrate data visualization techniques
Target: Intermediate
Execution time: 2-5 seconds
Dependencies: None
"""

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

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

# Convert lognormal 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"Average 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 histogram and fitting curve
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

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

# Fitting 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='Lognormal distribution 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 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()

Output example:

=== Grain Size Distribution Statistics ===
Average 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 lognormal distribution has a right-skewed shape and represents actual grain size distributions well. Note that the mean and median values differ.

Code Example 2: Visualization of Hall-Petch Relationship and Strength Prediction

Plot the relationship between grain size and yield strength using the Hall-Petch relationship.

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0

"""
Example: Plot the relationship between grain size and yield strength 

Purpose: Demonstrate data visualization techniques
Target: Intermediate
Execution time: 2-5 seconds
Dependencies: None
"""

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 coefficient)

# Grain size range (0.1 μm - 100 μm)
grain_sizes = np.logspace(-1, 2, 100)  # Logarithmic scale

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

# Experimental data points (example)
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 plot
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Plot on 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()

# Strength prediction for specific grain sizes
target_grain_sizes = [1, 5, 10, 20, 50]
print("\n=== Yield Strength Prediction 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")

# Calculate required grain size from target strength
target_strength = 70  # MPa
required_d = (k_y / (target_strength - sigma_0))**2
print(f"\nTarget strength {target_strength} Required grain size to achieve: {required_d:.2f} μm")

Output example:

=== Yield Strength Prediction 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

Target strength 70 Required grain size to achieve: 0.90 μm

Explanation: The Hall-Petch relationship is linear against $d^{-1/2}$. The strengthening effect by grain refinement can be quantitatively evaluated, and the grain size to achieve target strength can be calculated.

Code Example 3: Generation and Analysis of Misorientation Distribution

Simulate the misorientation distribution, which is important information from EBSD data.

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0

import numpy as np
import matplotlib.pyplot as plt

# Generate random misorientation distribution (approximate Mackenzie distribution)
# Mackenzie distribution: Theoretical misorientation distribution for materials with random crystallographic orientations
def mackenzie_distribution(theta):
    """Mackenzie distribution (cubic crystal system)

    Args:
        theta: Misorientation angle (degrees)

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

# Misorientation angle range (0-62.8 degrees, maximum for cubic)
theta_range = np.linspace(0, 62.8, 1000)
mackenzie_pdf = mackenzie_distribution(theta_range)
mackenzie_pdf = mackenzie_pdf / np.trapz(mackenzie_pdf, theta_range)  # Normalize

# Simulate measured data (random distribution + special boundary peaks)
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  # High-angle grain boundary threshold (degrees)
hagb_fraction = np.sum(all_misorientations >= hagb_threshold) / len(all_misorientations)
lagb_fraction = 1 - hagb_fraction

print("=== Misorientation Distribution Statistics ===")
print(f"Total grain 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"Average misorientation: {np.mean(all_misorientations):.1f}°")
print(f"Median: {np.median(all_misorientations):.1f}°")

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

# Create plot
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='Simulation 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()

Output example:

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

Explanation: In materials with random crystallographic orientations, misorientation follows the Mackenzie distribution. In actual materials, special boundaries such as Σ3 twin boundaries appear as peaks.

Code Example 4: Classification of CSL (Coincidence Site Lattice) Grain Boundaries

Calculate and classify grain boundaries based on Σ values using CSL theory.

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0

"""
Example: Calculate and classify grain boundaries based on Σ values us

Purpose: Demonstrate data visualization techniques
Target: Intermediate
Execution time: 2-5 seconds
Dependencies: None
"""

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'},
}

# Estimation of grain boundary energy (relative values, Σ1 = 1.0 reference)
# Generally, 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,
    'ランダム（Σ>29）': 1.0
}

# Brandon基準：CSL粒界として認識される許容角度範囲
def brandon_criterion(sigma):
    """Brandon基準による許容角度ずれ

    Args:
        sigma: Σ値

    Returns:
        許容角度ずれ（度）
    """
    return 15 / np.sqrt(sigma)  # 立方晶系

# 表示
print("=== CSLClassification of Grain Boundaries ===")
print(f"{'Σ値':<8} {'理論角度':<10} {'回転軸':<12} {'許容範囲':<10} {'相対エネルギー':<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']}")

# CSL粒界とランダム粒界のエネルギー比較（棒グラフ）
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# CSL粒界のエネルギー比較
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('相対粒界エネルギー', fontsize=12, fontweight='bold')
ax1.set_title('CSL粒界の相対エネルギー', fontsize=14, fontweight='bold')
ax1.set_ylim(0, 1.2)
ax1.axhline(1.0, color='red', linestyle='--', linewidth=2, label='ランダム粒界基準')
ax1.legend()
ax1.grid(axis='y', alpha=0.3)
plt.setp(ax1.xaxis.get_majorticklabels(), rotation=45, ha='right')

# CSL粒界の方位差と許容範囲
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粒界', fontsize=12, fontweight='bold')
ax2.set_title('CSL粒界の方位差と許容範囲（Brandon基準）', fontsize=14, fontweight='bold')
ax2.set_yticks([])
ax2.grid(axis='x', alpha=0.3)
ax2.set_xlim(0, 65)

plt.tight_layout()
plt.show()

# Σ3 twinの重要性
print("\n=== Σ3 twin境界の特別な性質 ===")
print("- 最もLow energyな粒界（一般粒界の約30%）")
print("- 焼鈍双晶（annealing twin）として形成されやすい")
print("- 腐食抵抗が高い")
print("- 粒界偏析が少ない")
print("- 粒界脆化に対する抵抗性が高い")
print("- FCC金属（Cu, Ni, オーステナイト系ステンレス鋼）で頻繁に観察される")

Output example:

=== CSLClassification of Grain Boundaries ===
Σ値      理論角度   回転軸       許容範囲   相対エネルギー  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

=== Σ3 twin境界の特別な性質 ===
- 最もLow energyな粒界（一般粒界の約30%）
- 焼鈍双晶（annealing twin）として形成されやすい
- 腐食抵抗が高い
- 粒界偏析が少ない
- 粒界脆化に対する抵抗性が高い
- FCC金属（Cu, Ni、オーステナイト系ステンレス鋼）で頻繁に観察される

解説: CSL理論は、特定の方位関係を持つ粒界がLow energyであることを説明します。特にΣ3 twin境界はMaterial特性に大きな影響を与え、粒界工学（Grain Boundary Engineering）で重視されます。

Code examples5: 粒成長のシミュレーション（Monte Carlo法）

簡単なMonte Carlo法により、粒成長をシミュレートします。

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0

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

# 2次元格子でのMonte Carlo粒成長シミュレーション
class GrainGrowthSimulator:
    def __init__(self, size=100, n_grains=50):
        """
        Args:
            size: 格子サイズ（size x size）
            n_grains: 初期結晶粒数
        """
        self.size = size
        self.n_grains = n_grains
        self.grid = np.zeros((size, size), dtype=int)
        self._initialize_grains()

    def _initialize_grains(self):
        """ランダムな位置に結晶粒の核を配置"""
        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):
        """Monte Carlo法による1ステップの粒成長

        Args:
            temperature: 系の温度（高いほど確率的変化が大きい）
        """
        # ランダムなサイト選択
        for _ in range(self.size * self.size):
            x = np.random.randint(0, self.size)
            y = np.random.randint(0, self.size)

            # 現在の状態
            current_grain = self.grid[x, y]

            # 隣接サイトからランダムに1つ選択
            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)

            # エネルギー計算（異なる粒の隣接数）
            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

            # 変更前後のエネルギー
            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基準
            if delta_energy > 0:
                probability = np.exp(-delta_energy / temperature)
                if np.random.random() > probability:
                    self.grid[x, y] = current_grain  # 変更を元に戻す

    def count_grains(self):
        """現在の結晶粒数をカウント"""
        return len(np.unique(self.grid)) - 1  # 0は除外

    def get_average_grain_size(self):
        """Average grain sizeを計算"""
        n_grains = self.count_grains()
        if n_grains == 0:
            return 0
        return self.size * self.size / n_grains

# シミュレーション実行
print("=== 粒成長シミュレーション開始 ===")
sim = GrainGrowthSimulator(size=100, n_grains=50)

# 初期状態
initial_grains = sim.count_grains()
print(f"初期結晶粒数: {initial_grains}")
print(f"初期Average grain size: {sim.get_average_grain_size():.1f} (格子単位)")

# 時間発展
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} 粒, "
              f"Average grain size {average_sizes[-1]:5.1f}")

# 組織の時間発展を可視化
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])):
    # ランダムな色マップ生成
    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')

# 粒数とAverage grain sizeの時間発展グラフ
ax = axes[5]
ax.plot(times, grain_counts, 'o-', linewidth=2, markersize=6,
        color='#f093fb', label='結晶粒数')
ax.set_xlabel('Monte Carlo Steps', fontsize=11, fontweight='bold')
ax.set_ylabel('結晶粒数', 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（格子単位）', fontsize=11, fontweight='bold', color='#f5576c')
ax2.tick_params(axis='y', labelcolor='#f5576c')

ax.set_title('粒数とGrain sizeの時間発展', fontsize=12, fontweight='bold')

plt.tight_layout()
plt.show()

print(f"\n最終結晶粒数: {grain_counts[-1]}")
print(f"最終Average grain size: {average_sizes[-1]:.1f} (格子単位)")
print(f"Grain sizeの増加率: {average_sizes[-1] / average_sizes[0]:.2f}倍")

Output example:

=== 粒成長シミュレーション開始 ===
初期結晶粒数: 50
初期Average grain size: 200.0 (格子単位)
Step    0:  50 粒, Average grain size 200.0
Step  200:  42 粒, Average grain size 238.1
Step  400:  36 粒, Average grain size 277.8
Step  600:  31 粒, Average grain size 322.6
Step  800:  27 粒, Average grain size 370.4
Step 1000:  24 粒, Average grain size 416.7

最終結晶粒数: 24
最終Average grain size: 416.7 (格子単位)
Grain sizeの増加率: 2.08倍

解説: Monte Carlo法により、熱処理中の粒成長をシミュレートできます。時間とともに結晶粒数が減少し、Average grain sizeが増加する様子が観察できます。実際の粒成長も同様の傾向を示します。

Code examples6: Textureの可視化 - 極点図

EBSDデータから得られる集合組織を極点図（Pole Figure）で可視化します。

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0

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

# ランダム方位と集合組織を持つ方位の生成
def generate_orientations(n_random=500, n_texture=500, texture_center=(0, 0, 1)):
    """結晶方位データの生成

    Args:
        n_random: ランダム方位の数
        n_texture: 集合組織を持つ方位の数
        texture_center: 集合組織の中心方向（単位ベクトル）

    Returns:
        方位データ（(001)極の方向ベクトル）
    """
    np.random.seed(42)

    # ランダム方位（球面上に一様min布）
    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)

    # 集合組織（ガウスmin布で特定方向に集中）
    # texture_centerを中心にばらつく
    center = np.array(texture_center)

    # 中心からのずれ
    spread = 0.3  # 集合組織の鋭さ（小さいほど鋭い）
    perturbations = np.random.normal(0, spread, (n_texture, 3))

    orientations_texture = center + perturbations
    # Normalize（単位球面上に投影）
    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]

    # 統合
    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

# 方位データ生成
x, y, z = generate_orientations(n_random=800, n_texture=1200,
                                 texture_center=(0, 0, 1))

# 極点図作成（等角投影）
fig = plt.figure(figsize=(16, 6))

# (001)極点図
ax1 = fig.add_subplot(131)
# 等角投影: (x, y, z) -> (X, Y) where z points out of page
# 投影: X = x/(1+z), Y = y/(1+z)
mask_upper = z > -0.1  # 上半球のみ表示
X = x[mask_upper] / (1 + z[mask_upper])
Y = y[mask_upper] / (1 + z[mask_upper])

# 密度プロット（ヒートマップ）
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)

# 参照円（投影範囲）
circle = plt.Circle((0, 0), 1.0, fill=False, color='black', linewidth=2)
ax1.add_patch(circle)
plt.colorbar(im1, ax=ax1, label='方位密度')

# 散布図表示
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表示（参考）
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()

# 集合組織の定量評価
print("=== 集合組織の統計 ===")
print(f"総方位数: {len(x)}")

# Z方向（(001)）への集中度
z_threshold = 0.8
texture_fraction = np.sum(z > z_threshold) / len(z)
print(f"(001)方位に近い結晶粒（z > {z_threshold}）: {texture_fraction*100:.1f}%")

# ランダムmin布からのずれ（χ²検定的な指標）
# 理想的にはz座標が-1から1に一様min布
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"一様min布からのずれ（χ²指標）: {chi_squared:.1f}")
print(f"  → χ² > 50 で強い集合組織あり")

# 方位min散（Standard deviation）
print(f"\n方位のmin散:")
print(f"  X方向: {np.std(x):.3f}")
print(f"  Y方向: {np.std(y):.3f}")
print(f"  Z方向: {np.std(z):.3f}  ← (001)に集中しているため小さい")

Output example:

=== 集合組織の統計 ===
総方位数: 2000
(001)方位に近い結晶粒（z > 0.8）: 38.5%
一様min布からのずれ（χ²指標）: 285.4
  → χ² > 50 で強い集合組織あり

方位のmin散:
  X方向: 0.497
  Y方向: 0.502
  Z方向: 0.387  ← (001)に集中しているため小さい

解説: 極点図（Pole Figure）は、特定の結晶方位のmin布を可視化する標準的な手法です。圧延や押出などの加工により、Materialは特定方向に配向した集合組織を持つようになり、異方性が生じます。

Code examples7: 組織-特性相関の統計解析

Grain size、粒界特性、集合組織などの組織パラメータと機械的性質の相関を解析します。

# Requirements:
# - Python 3.9+
# - matplotlib>=3.7.0
# - numpy>=1.24.0, <2.0.0
# - pandas>=2.0.0, <2.2.0
# - scipy>=1.11.0

"""
Example: Grain size、粒界特性、集合組織などの組織パラメータと機械的性質の相関を解析します。

Purpose: Demonstrate data visualization techniques
Target: Intermediate
Execution time: 30-60 seconds
Dependencies: None
"""

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

# Experimental dataのシミュレーション（Material試験の結果を模擬）
np.random.seed(42)
n_samples = 50

# 独立変数（組織パラメータ）
grain_size = np.random.lognormal(np.log(10), 0.5, n_samples)  # μm
hagb_fraction = np.random.uniform(0.7, 0.95, n_samples)  # 大傾角粒界の割合
texture_index = np.random.uniform(1.0, 5.0, n_samples)  # 集合組織の強さ（1=ランダム）

# Hall-Petch関係 + ノイズ
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))

# 粒界特性の影響（大傾角粒界が多いほど強度上昇）
yield_strength += 30 * (hagb_fraction - 0.8)

# 集合組織の影響（異方性、ここでは簡略化）
yield_strength += 5 * (texture_index - 3.0)

# 延性（Grain sizeが大きいほど高い、強度とトレードオフ）
elongation = (15 + 10 * np.sqrt(grain_size / 10) +
              np.random.normal(0, 2, n_samples))

# DataFrameに整理
df = pd.DataFrame({
    'grain_size': grain_size,
    'hagb_fraction': hagb_fraction,
    'texture_index': texture_index,
    'yield_strength': yield_strength,
    'elongation': elongation
})

# 統計サマリー
print("=== 組織パラメータと機械的性質の統計 ===")
print(df.describe())

# 相関行列
print("\n=== 相関行列 ===")
correlation_matrix = df.corr()
print(correlation_matrix['yield_strength'].sort_values(ascending=False))

# Create plot
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)

# 回帰min析（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)

# Fitting 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('MeanGrain size (μm)', fontsize=12, fontweight='bold')
ax.set_ylabel('Yield strength (MPa)', fontsize=12, fontweight='bold')
ax.set_title(f'Hall-Petch関係 (R² = {r_value**2:.3f})',
             fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

# (2) 大傾角粒界割合 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)

# 線形回帰
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('大傾角粒界割合 (%)', fontsize=12, fontweight='bold')
ax.set_ylabel('Yield strength (MPa)', fontsize=12, fontweight='bold')
ax.set_title('粒界特性と強度の相関', fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

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

# 線形回帰
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('MeanGrain size (μm)', fontsize=12, fontweight='bold')
ax.set_ylabel('伸び (%)', fontsize=12, fontweight='bold')
ax.set_title('Grain sizeと延性の関係', fontsize=13, fontweight='bold')
ax.legend(fontsize=10)
ax.grid(alpha=0.3)

# (4) 強度-延性バランス
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('伸び (%)', fontsize=12, fontweight='bold')
ax.set_title('強度-延性トレードオフ', fontsize=13, fontweight='bold')
ax.grid(alpha=0.3)

# パレートフロント（理想的なMaterial）
# 強度と延性の積が大きい上位10サンプル
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 10Material', zorder=5)
ax.legend(fontsize=10)

plt.tight_layout()
plt.show()

# 多変量回帰（Yield strengthを予測）
print("\n=== 多変量線形回帰（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
# Grain sizeはHall-Petch形式に変換
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² スコア: {r2_score(y, y_pred):.4f}")
print(f"Mean絶対誤差: {mean_absolute_error(y, y_pred):.2f} MPa")
print(f"\n回帰係数:")
print(f"  切片（σ₀相当）: {model.intercept_:.2f} MPa")
print(f"  1/√d の係数（k_y相当）: {model.coef_[0]:.2f} MPa·μm^(1/2)")
print(f"  HAGB fractionの係数: {model.coef_[1]:.2f} MPa")
print(f"  集合組織の係数: {model.coef_[2]:.2f} MPa")

print("\n=== Material設計の指針 ===")
print("高強度を得るには:")
print("  1. 細粒化（d < 5 μm）")
print("  2. 大傾角粒界割合を高める（> 90%）")
print("\n高延性を得るには:")
print("  1. 粗大粒（d > 15 μm）")
print("  2. 集合組織の制御")

Output example:

=== 多変量線形回帰（Yield strengthの予測）===
R² スコア: 0.9134
Mean絶対誤差: 3.42 MPa

回帰係数:
  切片（σ₀相当）: 26.78 MPa
  1/√d の係数（k_y相当）: 0.58 MPa·μm^(1/2)
  HAGB fractionの係数: 30.15 MPa
  集合組織の係数: 5.03 MPa

=== Material設計の指針 ===
高強度を得るには:
  1. 細粒化（d < 5 μm）
  2. 大傾角粒界割合を高める（> 90%）

高延性を得るには:
  1. 粗大粒（d > 15 μm）
  2. 集合組織の制御

解説: 組織パラメータ（Grain size、粒界特性、集合組織）と機械的性質の相関を統計的に解析することで、Material設計の指針が得られます。多変量回帰により、複数の組織因子を考慮した特性予測モデルを構築できます。

1.6 本章のまとめ

学んだこと

1. 結晶粒と粒界の基本概念
   • PolycrystallineMaterialは結晶方位が異なる結晶粒の集合体
   • 粒界は高エネルギー状態で、拡散や転位運動に影響
   • Grain size測定法：線min法、面積法、ASTM粒度番号
2. Classification of Grain Boundaries
   • 方位差によるmin類：小傾角粒界（<15°）、High-angle grain boundaries (≥15°)
   • CSL理論：特定の方位関係を持つ粒界はLow energy（Σ3 twinなど）
   • 粒界エネルギーが粒成長の駆動力
3. Hall-Petch関係
   • $\sigma_y = \sigma_0 + k_y / \sqrt{d}$：Grain sizeが小さいほど強度が高い
   • 細粒化による強化は転位の運動阻害が原因
   • ナノ結晶領域では逆Hall-Petch効果が現れることがある
4. EBSD（電子後方散乱回折）
   • 結晶方位マップ、粒界min布、集合組織の測定が可能
   • 方位差15°が大傾角/小傾角粒界の境界
   • 極点図により集合組織を可視化
5. Pythonによる組織解析
   • 対数正規min布によるGrain size distributionのモデリング
   • Hall-Petch関係の可視化と強度予測
   • Monte Carlo法による粒成長シミュレーション
   • 組織-特性相関の統計解析と回帰モデル構築

重要なポイント

• 結晶Grain sizeはMaterialの機械的性質を決定する最重要パラメータの1つ
• 細粒化は強度向上、粗大化は延性向上につながる（強度-延性トレードオフ）
• 粒界工学（Grain Boundary Engineering）：特殊粒界（低Σ値）の割合を増やして特性改善
• 集合組織によりMaterialは異方性を持つ（圧延方向で性質が異なる）
• 組織パラメータの定量化と統計解析がMI（Materials Informatics）の基盤

次の章へ

第2章では、相変態の基礎を学びます：

• 相図の読み方と活用
• 拡散型変態と無拡散型変態のメカニズム
• TTT図・CCT図による変態速度の理解
• マルテンサイト変態とベイナイト変態
• CALPHAD法による状態図計算の基礎
• Pythonによる相変態シミュレーション

演習問題

Easy（基礎確認）

Medium（応用）

Hard（発展）