Chapter 2: Fundamentals of Phase Transformations

The properties of a material change dramatically depending on its temperature and time history (heat treatment). The root cause of this change is phase transformation. In this chapter, we will learn how to read phase diagrams, the mechanisms of diffusional and diffusionless transformations, how to use TTT/CCT diagrams, martensitic transformation, and the fundamentals of phase diagram calculation via the CALPHAD method, building the theoretical foundation for heat treatment design.

2.1 Fundamentals of Phase Diagrams and How to Read Them

What Is a Phase Diagram?

A phase diagram shows which phase is thermodynamically stable as a function of temperature, composition, and pressure. It is the most important tool for determining the heat treatment conditions of a material.

Phase refers to a homogeneous portion of a substance with uniform chemical composition, structure, and properties, separated from other portions by a distinct interface. Examples: liquid phase (L), α phase (BCC), γ phase (FCC), cementite (Fe₃C)

Basic Types of Binary Phase Diagrams

1. Complete Solid Solution

A system in which two elements form a solid solution across the entire composition range.

Examples: Cu-Ni system, Au-Ag system

2. Eutectic System

At a certain composition and temperature, the liquid phase decomposes into two solid phases simultaneously upon cooling.

Examples: Pb-Sn system, Al-Si system

Eutectic reaction: $L \rightarrow \alpha + \beta$ (on cooling)

3. Peritectic System

The liquid phase reacts with a solid phase to form a different solid phase.

Examples: Fe-C system (high-temperature region), Pt-Ag system

Peritectic reaction: $L + \delta \rightarrow \gamma$ (on cooling)

The Fe-C Phase Diagram (Fundamentals of Steel)

The Fe-C phase diagram is the foundation for the heat treatment design of steel materials.

Key temperatures and compositions:

• Eutectoid Point: 727°C, 0.77% C
  • Eutectoid reaction: $\gamma \rightarrow \alpha + \text{Fe}_3\text{C}$ (pearlite structure)
• Hypoeutectoid Steel: 0.02-0.77% C
  • Structure: proeutectoid ferrite + pearlite
• Eutectoid Steel: 0.77% C
  • Structure: 100% pearlite
• Hypereutectoid Steel: 0.77-2.11% C
  • Structure: proeutectoid cementite + pearlite

The Lever Rule

A method for calculating the mass fraction of each phase within a two-phase region.

When an alloy of temperature $T$ and composition $C_0$ separates into an $\alpha$ phase (composition $C_\alpha$) and a $\beta$ phase (composition $C_\beta$):

$$\text{mass fraction}_\alpha = \frac{C_\beta - C_0}{C_\beta - C_\alpha}$$

$$\text{mass fraction}_\beta = \frac{C_0 - C_\alpha}{C_\beta - C_\alpha}$$

Remember it as: "the fraction of the more distant phase is larger."

2.2 Diffusional and Diffusionless Transformations

Classification of Transformations

Diffusional Transformation: Pearlitic Transformation

The eutectoid transformation from austenite (γ-Fe, FCC) to ferrite (α-Fe, BCC) + cementite (Fe₃C).

$$\gamma (0.77\% \text{C}) \rightarrow \alpha (0.02\% \text{C}) + \text{Fe}_3\text{C} (6.67\% \text{C})$$

Characteristics of pearlite structure:

• Lamellar structure of ferrite and cementite
• Interlamellar spacing determines hardness
  • Fine pearlite: formed at high temperature, hard
  • Coarse pearlite: formed at low temperature, soft

Diffusionless Transformation: Martensitic Transformation

The transformation from austenite (FCC) to body-centered tetragonal (BCT) martensite.

Characteristics of martensite:

• A shear-type structural change without diffusion
• Transformation rate is at the speed of sound (10^-7 seconds)
• Carbon is forcibly retained in solid solution, distorting the lattice (BCT structure)
• Extremely hard but brittle (Vickers hardness 600-900 HV)
• Proceeds below the transformation start temperature (M_s)

M_s temperature prediction formula (for steel):

$$M_s (\text{°C}) = 539 - 423C - 30.4Mn - 17.7Ni - 12.1Cr - 7.5Mo$$

Here, the element symbols represent weight %. As carbon and alloying elements increase, the M_s temperature decreases.

2.3 TTT and CCT Diagrams

TTT Diagram (Time-Temperature-Transformation Diagram)

A TTT diagram shows the progress of transformation during isothermal holding (holding at a constant temperature).

How to read a TTT diagram:

• Vertical axis: temperature
• Horizontal axis: time (logarithmic scale)
• C-shaped curves: transformation start and completion lines
• The "nose": the temperature at which transformation occurs fastest (around 550-600°C)

CCT Diagram (Continuous Cooling Transformation Diagram)

A CCT diagram shows transformation during continuous cooling, which is closer to actual heat treatment conditions.

Differences from the TTT diagram:

• The TTT diagram represents isothermal transformation (laboratory conditions)
• The CCT diagram represents continuous cooling (practical conditions)
• The C-curve of the CCT diagram is shifted to the lower right compared to the TTT diagram (transformation takes longer)

Relationship between cooling rate and resulting structure (example of eutectoid steel):

Critical Cooling Rate

The critical cooling rate is the minimum cooling rate required to obtain 100% martensite structure. It decreases with the addition of alloying elements (making the material easier to harden).

2.4 Transformation Kinetics and the Avrami Equation

Progress of Transformation

The progress of a diffusional transformation $f(t)$ (the transformed volume fraction) is described by the Johnson-Mehl-Avrami-Kolmogorov (JMAK) equation, commonly known as the Avrami equation:

$$f(t) = 1 - \exp(-kt^n)$$

where,

• $f(t)$: transformed fraction at time $t$ (0 to 1)
• $k$: rate constant (temperature dependent)
• $n$: Avrami exponent (depends on the nucleation and growth mechanism, typically 1-4)

Meaning of the Avrami exponent $n$:

Principle of Constructing a TTT Diagram

A TTT diagram is constructed by fitting the Avrami equation at multiple temperatures and plotting the transformation start time ($f = 0.01$) and completion time ($f = 0.99$) at each temperature.

2.5 Fundamentals of the CALPHAD Method

What Is CALPHAD (CALculation of PHAse Diagrams)?

The CALPHAD method is a technique for calculating phase diagrams using thermodynamic databases. Since it is impossible to experimentally measure the phase diagram at every composition and temperature, calculations are used for prediction instead.

Workflow of the CALPHAD method:

1. Model the Gibbs energy of each phase mathematically
2. Optimize parameters from experimental and thermodynamic data
3. Determine the stable phase by minimizing the Gibbs energy
4. Construct the phase diagram

Model of Gibbs energy (simplified):

$$G = H - TS = \sum_i x_i G_i^0 + RT \sum_i x_i \ln x_i + G^{ex}$$

where,

• $G$: Gibbs energy
• $x_i$: mole fraction of component $i$
• $G_i^0$: Gibbs energy of the pure component
• $RT \sum_i x_i \ln x_i$: ideal mixing entropy term
• $G^{ex}$: excess Gibbs energy (interaction term, e.g., the Redlich-Kister model)

pycalphad: CALPHAD Calculations in Python

pycalphad is a Python library for performing CALPHAD calculations. It can read TDB files (thermodynamic databases) and calculate and visualize phase diagrams.

2.6 Simulating Phase Transformations in Python

Environment Setup

# Install the required libraries
pip install numpy matplotlib pandas scipy
# pycalphad is installed separately (optional)
pip install pycalphad

Code Example 1: Plotting a Binary Phase Diagram (Complete Solid Solution)

We model an idealized complete-solid-solution phase diagram similar to the Cu-Ni system.

import numpy as np
import matplotlib.pyplot as plt

# Cu-Ni system phase diagram parameters (simplified model)
T_melt_Cu = 1358  # K (melting point of Cu)
T_melt_Ni = 1728  # K (melting point of Ni)

# Composition range (mole fraction of Ni)
X_Ni = np.linspace(0, 1, 100)

# Calculation of the liquidus and solidus lines
# For a complete solid solution, the liquidus and solidus are approximately linear (approximation of Raoult's law)
# Liquidus: T_liquidus = T_Cu + (T_Ni - T_Cu) * X_Ni^alpha
# Solidus: T_solidus = T_Cu + (T_Ni - T_Cu) * X_Ni^beta
# alpha, beta are interaction parameters (simplified here)

T_liquidus = T_melt_Cu + (T_melt_Ni - T_melt_Cu) * X_Ni
T_solidus = T_melt_Cu + (T_melt_Ni - T_melt_Cu) * X_Ni**1.2  # simplified model

# Plot
fig, ax = plt.subplots(figsize=(10, 7))

ax.plot(X_Ni * 100, T_liquidus - 273, 'r-', linewidth=2.5, label='Liquidus')
ax.plot(X_Ni * 100, T_solidus - 273, 'b-', linewidth=2.5, label='Solidus')

# Fill regions
ax.fill_between(X_Ni * 100, T_liquidus - 273, 1500, alpha=0.2, color='red', label='Liquid (L) region')
ax.fill_between(X_Ni * 100, T_solidus - 273, T_liquidus - 273, alpha=0.2, color='yellow',
                label='L + α two-phase region')
ax.fill_between(X_Ni * 100, 0, T_solidus - 273, alpha=0.2, color='blue', label='Solid (α) region')

ax.set_xlabel('Ni composition (mol%)', fontsize=13, fontweight='bold')
ax.set_ylabel('Temperature (°C)', fontsize=13, fontweight='bold')
ax.set_title('Cu-Ni Binary Phase Diagram (Complete Solid Solution)', fontsize=15, fontweight='bold')
ax.legend(fontsize=11, loc='lower right')
ax.grid(alpha=0.3)
ax.set_xlim(0, 100)
ax.set_ylim(0, 1500)

# Show the cooling path for a specific composition
X_target = 50  # 50 mol% Ni
T_target_liq = np.interp(X_target / 100, X_Ni, T_liquidus) - 273
T_target_sol = np.interp(X_target / 100, X_Ni, T_solidus) - 273

ax.plot([X_target, X_target], [1500, 0], 'k--', linewidth=2, alpha=0.7, label='Cooling path')
ax.plot(X_target, T_target_liq, 'ro', markersize=10, label=f'Liquidus crossing: {T_target_liq:.0f}°C')
ax.plot(X_target, T_target_sol, 'bo', markersize=10, label=f'Solidus crossing: {T_target_sol:.0f}°C')

plt.legend(fontsize=10)
plt.tight_layout()
plt.show()

print("=== Analysis of the Cu-Ni Phase Diagram ===")
print(f"At 50 mol% Ni composition:")
print(f"  Liquidus temperature (solidification start): {T_target_liq:.1f}°C")
print(f"  Solidus temperature (solidification complete): {T_target_sol:.1f}°C")
print(f"  Solidification temperature range: {T_target_liq - T_target_sol:.1f}°C")

Example output:

=== Analysis of the Cu-Ni Phase Diagram ===
At 50 mol% Ni composition:
  Liquidus temperature (solidification start): 1270.0°C
  Solidus temperature (solidification complete): 1199.4°C
  Solidification temperature range: 70.6°C

Explanation: In a complete-solid-solution phase diagram, a two-phase region (L + α) exists between the liquidus and solidus lines. Solidification proceeds within this range, with the composition changing continuously.

Code Example 2: Calculating and Visualizing Phase Fractions with the Lever Rule

We calculate the mass fraction of each phase within a two-phase region.

import numpy as np
import matplotlib.pyplot as plt

def lever_rule(C_alpha, C_beta, C_0):
    """Calculate phase fractions using the lever rule

    Args:
        C_alpha: composition of the α phase
        C_beta: composition of the β phase
        C_0: overall composition of the alloy

    Returns:
        f_alpha: mass fraction of the α phase
        f_beta: mass fraction of the β phase
    """
    f_beta = (C_0 - C_alpha) / (C_beta - C_alpha)
    f_alpha = 1 - f_beta
    return f_alpha, f_beta

# Example of the Fe-C system (two-phase region at the eutectoid temperature of 727°C)
# α phase (ferrite): 0.02% C
# Fe3C (cementite): 6.67% C
# Alloy composition range
C_alpha = 0.02  # carbon concentration of the α phase
C_Fe3C = 6.67   # carbon concentration of cementite

# Range of carbon concentration (0.02% - 6.67%)
C_alloy = np.linspace(C_alpha, C_Fe3C, 100)

# Lever rule calculation for each composition
f_alpha_arr = []
f_Fe3C_arr = []

for C in C_alloy:
    f_alpha, f_Fe3C = lever_rule(C_alpha, C_Fe3C, C)
    f_alpha_arr.append(f_alpha)
    f_Fe3C_arr.append(f_Fe3C)

# Plot
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Phase fraction plot
ax1.plot(C_alloy, np.array(f_alpha_arr) * 100, 'b-', linewidth=2.5, label='Ferrite (α)')
ax1.plot(C_alloy, np.array(f_Fe3C_arr) * 100, 'r-', linewidth=2.5, label='Cementite (Fe₃C)')
ax1.axvline(0.77, color='green', linestyle='--', linewidth=2, label='Eutectoid composition (0.77% C)')

ax1.set_xlabel('Carbon concentration (wt%)', fontsize=13, fontweight='bold')
ax1.set_ylabel('Phase fraction (%)', fontsize=13, fontweight='bold')
ax1.set_title('Lever Rule: Phase Fractions in the Fe-C System', fontsize=14, fontweight='bold')
ax1.legend(fontsize=11)
ax1.grid(alpha=0.3)
ax1.set_xlim(0, 7)
ax1.set_ylim(0, 100)

# Calculation for eutectoid steel (0.77% C)
C_eutectoid = 0.77
f_alpha_eut, f_Fe3C_eut = lever_rule(C_alpha, C_Fe3C, C_eutectoid)

print("=== Phase Fractions of Eutectoid Steel (0.77% C) at 727°C ===")
print(f"Ferrite (α): {f_alpha_eut * 100:.2f}%")
print(f"Cementite (Fe₃C): {f_Fe3C_eut * 100:.2f}%")

# Phase fractions for various steel grades
steel_grades = {
    'Low-carbon steel': 0.10,
    'Medium-carbon steel': 0.45,
    'High-carbon steel': 1.20
}

print("\n=== Phase Fractions of Each Steel Grade (Room Temperature, Equilibrium) ===")
for name, C_content in steel_grades.items():
    if C_content <= 0.77:
        # Hypoeutectoid steel
        # Proeutectoid ferrite + pearlite
        # Phase fraction within pearlite is constant (eutectoid composition)
        pearlite_fraction = C_content / C_eutectoid
        proeutectoid_ferrite = 1 - pearlite_fraction

        # Phase fractions within pearlite
        f_alpha_in_pearlite, f_Fe3C_in_pearlite = lever_rule(C_alpha, C_Fe3C, C_eutectoid)

        # Overall phase fractions
        total_ferrite = proeutectoid_ferrite + pearlite_fraction * f_alpha_in_pearlite
        total_Fe3C = pearlite_fraction * f_Fe3C_in_pearlite

        print(f"\n{name} ({C_content}% C):")
        print(f"  Proeutectoid ferrite: {proeutectoid_ferrite * 100:.1f}%")
        print(f"  Pearlite: {pearlite_fraction * 100:.1f}%")
        print(f"    └ Ferrite: {total_ferrite * 100:.1f}% (total)")
        print(f"    └ Cementite: {total_Fe3C * 100:.1f}% (total)")
    else:
        # Hypereutectoid steel
        # Proeutectoid cementite + pearlite
        pearlite_fraction = (C_Fe3C - C_content) / (C_Fe3C - C_eutectoid)
        proeutectoid_Fe3C = 1 - pearlite_fraction

        # Overall phase fractions
        f_alpha_in_pearlite, f_Fe3C_in_pearlite = lever_rule(C_alpha, C_Fe3C, C_eutectoid)
        total_ferrite = pearlite_fraction * f_alpha_in_pearlite
        total_Fe3C = proeutectoid_Fe3C + pearlite_fraction * f_Fe3C_in_pearlite

        print(f"\n{name} ({C_content}% C):")
        print(f"  Proeutectoid cementite: {proeutectoid_Fe3C * 100:.1f}%")
        print(f"  Pearlite: {pearlite_fraction * 100:.1f}%")
        print(f"    └ Ferrite: {total_ferrite * 100:.1f}% (total)")
        print(f"    └ Cementite: {total_Fe3C * 100:.1f}% (total)")

# Visualize with a bar chart
ax2_data = []
labels = []
for name, C_content in steel_grades.items():
    if C_content <= 0.77:
        pearlite_fraction = C_content / C_eutectoid
        proeutectoid_ferrite = 1 - pearlite_fraction
        f_alpha_in_pearlite, f_Fe3C_in_pearlite = lever_rule(C_alpha, C_Fe3C, C_eutectoid)
        total_ferrite = proeutectoid_ferrite + pearlite_fraction * f_alpha_in_pearlite
        total_Fe3C = pearlite_fraction * f_Fe3C_in_pearlite
    else:
        pearlite_fraction = (C_Fe3C - C_content) / (C_Fe3C - C_eutectoid)
        proeutectoid_Fe3C = 1 - pearlite_fraction
        f_alpha_in_pearlite, f_Fe3C_in_pearlite = lever_rule(C_alpha, C_Fe3C, C_eutectoid)
        total_ferrite = pearlite_fraction * f_alpha_in_pearlite
        total_Fe3C = proeutectoid_Fe3C + pearlite_fraction * f_Fe3C_in_pearlite

    ax2_data.append([total_ferrite * 100, total_Fe3C * 100])
    labels.append(f"{name}\n({C_content}% C)")

ax2_data = np.array(ax2_data)
x_pos = np.arange(len(labels))

ax2.bar(x_pos, ax2_data[:, 0], label='Ferrite (α)', color='#3498db', alpha=0.8)
ax2.bar(x_pos, ax2_data[:, 1], bottom=ax2_data[:, 0], label='Cementite (Fe₃C)',
        color='#e74c3c', alpha=0.8)

ax2.set_xticks(x_pos)
ax2.set_xticklabels(labels)
ax2.set_ylabel('Phase fraction (%)', fontsize=13, fontweight='bold')
ax2.set_title('Phase Fractions by Steel Grade (Equilibrium)', fontsize=14, fontweight='bold')
ax2.legend(fontsize=11)
ax2.grid(axis='y', alpha=0.3)
ax2.set_ylim(0, 100)

plt.tight_layout()
plt.show()

Example output:

=== Phase Fractions of Eutectoid Steel (0.77% C) at 727°C ===
Ferrite (α): 88.83%
Cementite (Fe₃C): 11.17%

=== Phase Fractions of Each Steel Grade (Room Temperature, Equilibrium) ===

Low-carbon steel (0.10% C):
  Proeutectoid ferrite: 87.0%
  Pearlite: 13.0%
    └ Ferrite: 98.5% (total)
    └ Cementite: 1.5% (total)

Medium-carbon steel (0.45% C):
  Proeutectoid ferrite: 41.6%
  Pearlite: 58.4%
    └ Ferrite: 93.3% (total)
    └ Cementite: 6.7% (total)

High-carbon steel (1.20% C):
  Proeutectoid cementite: 7.3%
  Pearlite: 92.7%
    └ Ferrite: 82.3% (total)
    └ Cementite: 17.7% (total)

Explanation: The lever rule allows the mass fractions of each phase (ferrite and cementite) to be quantitatively predicted from the carbon concentration. This is the foundation for understanding the relationship between microstructure and mechanical properties.

Code Example 3: Generating a TTT Diagram and Fitting the Avrami Equation

We model the TTT diagram of a eutectoid steel using the Avrami equation.

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Avrami equation
def avrami_equation(t, k, n):
    """Transformed fraction according to the Avrami equation

    Args:
        t: time (seconds)
        k: rate constant
        n: Avrami exponent

    Returns:
        Transformed fraction (0-1)
    """
    return 1 - np.exp(-k * t**n)

# Avrami constants at each temperature (eutectoid steel, approximate values based on experimental data)
temperatures = np.array([700, 650, 600, 550, 500, 450, 400])  # °C
# Rate constant k (temperature dependent, faster at higher temperature)
k_values = np.array([0.01, 0.008, 0.005, 0.003, 0.002, 0.0015, 0.001])
# Avrami exponent n (depends on the nucleation and growth mechanism)
n_values = np.array([2.5, 2.8, 3.0, 3.2, 3.0, 2.5, 2.0])

# Transformation curves at each temperature
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Transformed fraction vs. time
time = np.logspace(-1, 4, 500)  # 0.1 s to 10000 s

for T, k, n in zip(temperatures, k_values, n_values):
    fraction = avrami_equation(time, k, n)
    ax1.plot(time, fraction * 100, linewidth=2, label=f'{T}°C')

ax1.set_xscale('log')
ax1.set_xlabel('Time (s)', fontsize=13, fontweight='bold')
ax1.set_ylabel('Transformed fraction (%)', fontsize=13, fontweight='bold')
ax1.set_title('Isothermal Transformation Curves (Eutectoid Steel)', fontsize=14, fontweight='bold')
ax1.legend(fontsize=10, ncol=2)
ax1.grid(alpha=0.3)
ax1.set_xlim(0.1, 10000)
ax1.set_ylim(0, 100)
ax1.axhline(1, color='red', linestyle='--', linewidth=1, alpha=0.5)
ax1.axhline(99, color='red', linestyle='--', linewidth=1, alpha=0.5)

# Constructing the TTT diagram
# Calculate the 1% and 99% transformation times at each temperature
times_1_percent = []
times_99_percent = []

for k, n in zip(k_values, n_values):
    # 1% transformation: 0.01 = 1 - exp(-k*t^n) → t = (-ln(0.99)/k)^(1/n)
    t_1 = (-np.log(0.99) / k)**(1/n)
    # 99% transformation: 0.99 = 1 - exp(-k*t^n) → t = (-ln(0.01)/k)^(1/n)
    t_99 = (-np.log(0.01) / k)**(1/n)

    times_1_percent.append(t_1)
    times_99_percent.append(t_99)

# Plot the TTT diagram
ax2.plot(times_1_percent, temperatures, 'r-', linewidth=2.5, label='Transformation start (1%)')
ax2.plot(times_99_percent, temperatures, 'b-', linewidth=2.5, label='Transformation complete (99%)')

# Nose of the C-curve
nose_idx = np.argmin(times_1_percent)
ax2.plot(times_1_percent[nose_idx], temperatures[nose_idx], 'go', markersize=12,
         label=f'Nose: {times_1_percent[nose_idx]:.1f}s, {temperatures[nose_idx]}°C')

# Martensite start temperature (Ms)
M_s = 220  # °C (approximate value for 0.77% C steel)
ax2.axhline(M_s, color='purple', linestyle='--', linewidth=2,
            label=f'M_s = {M_s}°C (martensite start)')

ax2.set_xscale('log')
ax2.set_xlabel('Time (s)', fontsize=13, fontweight='bold')
ax2.set_ylabel('Temperature (°C)', fontsize=13, fontweight='bold')
ax2.set_title('TTT Diagram (Time-Temperature-Transformation)', fontsize=14, fontweight='bold')
ax2.legend(fontsize=10)
ax2.grid(alpha=0.3)
ax2.set_xlim(0.1, 10000)
ax2.set_ylim(0, 800)

# Annotate the microstructure regions
ax2.text(0.5, 650, 'Pearlite', fontsize=12, fontweight='bold', ha='center',
         bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
ax2.text(50, 450, 'Bainite', fontsize=12, fontweight='bold', ha='center',
         bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.5))
ax2.text(5000, 150, 'Martensite', fontsize=12, fontweight='bold', ha='center',
         bbox=dict(boxstyle='round', facecolor='lightcoral', alpha=0.5))

plt.tight_layout()
plt.show()

# Analysis at a specific temperature
print("=== TTT Diagram Analysis ===")
print(f"Nose (fastest transformation temperature): {temperatures[nose_idx]}°C")
print(f"  1% transformation time: {times_1_percent[nose_idx]:.2f} s")
print(f"  99% transformation time: {times_99_percent[nose_idx]:.2f} s")

print("\n=== Transformation Time at Each Temperature ===")
for T, t1, t99, k, n in zip(temperatures, times_1_percent, times_99_percent,
                            k_values, n_values):
    print(f"{T}°C: start {t1:.2f}s, complete {t99:.2f}s (k={k:.4f}, n={n:.1f})")

Example output:

=== TTT Diagram Analysis ===
Nose (fastest transformation temperature): 550°C
  1% transformation time: 5.29 s
  99% transformation time: 217.59 s

=== Transformation Time at Each Temperature ===
700°C: start 2.28s, complete 72.30s (k=0.0100, n=2.5)
650°C: start 2.42s, complete 87.08s (k=0.0080, n=2.8)
600°C: start 3.62s, complete 166.49s (k=0.0050, n=3.0)
550°C: start 5.29s, complete 283.07s (k=0.0030, n=3.2)
500°C: start 6.22s, complete 286.01s (k=0.0020, n=3.0)
450°C: start 9.79s, complete 310.22s (k=0.0015, n=2.5)
400°C: start 22.36s, complete 447.21s (k=0.0010, n=2.0)

Explanation: The C-curve of the TTT diagram shows that, because diffusion is fast at high temperature while the driving force (degree of undercooling) is large at low temperature, transformation occurs fastest at an intermediate temperature (around 550°C).

Code Example 4: Fitting Avrami Parameters (Experimental Data)

We estimate Avrami constants from experimental transformation data.

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Experimental data (isothermal transformation at 550°C)
# Time (seconds) and transformed fraction (%)
time_exp = np.array([1, 5, 10, 20, 30, 50, 100, 200, 300, 500])
fraction_exp = np.array([0, 2, 10, 35, 55, 75, 90, 97, 99, 99.5])

# Avrami equation
def avrami(t, k, n):
    return (1 - np.exp(-k * t**n)) * 100  # percent

# Nonlinear fitting
popt, pcov = curve_fit(avrami, time_exp, fraction_exp,
                       p0=[0.001, 2.0],  # initial guess
                       bounds=([0, 0.5], [1, 5]))  # parameter bounds

k_fit, n_fit = popt
k_err, n_err = np.sqrt(np.diag(pcov))

print("=== Avrami Fitting Results ===")
print(f"Rate constant k = {k_fit:.6f} ± {k_err:.6f}")
print(f"Avrami exponent n = {n_fit:.3f} ± {n_err:.3f}")

# Interpretation of the Avrami exponent
if 1.5 < n_fit < 2.5:
    mechanism = "2-dimensional growth (disk-like), constant-rate nucleation"
elif 2.5 < n_fit < 3.5:
    mechanism = "3-dimensional growth (spherical), constant-rate nucleation"
elif 3.5 < n_fit < 4.5:
    mechanism = "3-dimensional growth (spherical), increasing-rate nucleation"
else:
    mechanism = "complex mechanism"

print(f"\nEstimated transformation mechanism: {mechanism}")

# Generate the fitted curve
time_fit = np.logspace(-1, 3, 500)
fraction_fit = avrami(time_fit, k_fit, n_fit)

# Plot 1: transformed fraction vs. time
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

ax1.scatter(time_exp, fraction_exp, s=100, color='red', edgecolor='black',
            linewidth=2, label='Experimental data', zorder=5)
ax1.plot(time_fit, fraction_fit, 'b-', linewidth=2.5,
         label=f'Avrami fit (k={k_fit:.4f}, n={n_fit:.2f})')

ax1.set_xscale('log')
ax1.set_xlabel('Time (s)', fontsize=13, fontweight='bold')
ax1.set_ylabel('Transformed fraction (%)', fontsize=13, fontweight='bold')
ax1.set_title('Transformation Kinetics: Avrami Plot', fontsize=14, fontweight='bold')
ax1.legend(fontsize=11)
ax1.grid(alpha=0.3)
ax1.set_xlim(0.1, 1000)
ax1.set_ylim(0, 100)

# Plot 2: linearized Avrami plot
# ln(ln(1/(1-f))) vs ln(t) → slope is n, intercept is n*ln(k)
# f: transformed fraction (0-1)
fraction_decimal = fraction_exp / 100
# Exclude values above 99% to avoid numerical error
valid_idx = fraction_decimal < 0.99
fraction_valid = fraction_decimal[valid_idx]
time_valid = time_exp[valid_idx]

# Avrami linearization
y_avrami = np.log(np.log(1 / (1 - fraction_valid)))
x_avrami = np.log(time_valid)

# Linear fitting
coeffs = np.polyfit(x_avrami, y_avrami, 1)
n_linear = coeffs[0]
k_linear = np.exp(-coeffs[1] / n_linear)

print(f"\n=== Linearized Avrami Plot Method ===")
print(f"Rate constant k = {k_linear:.6f}")
print(f"Avrami exponent n = {n_linear:.3f}")

# Linear fit curve
x_fit_linear = np.linspace(x_avrami.min(), x_avrami.max(), 100)
y_fit_linear = coeffs[0] * x_fit_linear + coeffs[1]

ax2.scatter(x_avrami, y_avrami, s=100, color='red', edgecolor='black',
            linewidth=2, label='Experimental data', zorder=5)
ax2.plot(x_fit_linear, y_fit_linear, 'b-', linewidth=2.5,
         label=f'Linear fit (slope={n_linear:.2f})')

ax2.set_xlabel('ln(time) [ln(s)]', fontsize=13, fontweight='bold')
ax2.set_ylabel('ln(ln(1/(1-f)))', fontsize=13, fontweight='bold')
ax2.set_title('Linearized Avrami Plot', fontsize=14, fontweight='bold')
ax2.legend(fontsize=11)
ax2.grid(alpha=0.3)

plt.tight_layout()
plt.show()

# Predicting the transformed fraction at specific times
target_times = [10, 50, 100, 200]
print("\n=== Predicted Transformed Fraction ===")
for t in target_times:
    f_pred = avrami(t, k_fit, n_fit)
    print(f"t = {t:3d} s → transformed fraction = {f_pred:.1f}%")

Example output:

=== Avrami Fitting Results ===
Rate constant k = 0.000523 ± 0.000042
Avrami exponent n = 2.876 ± 0.068

Estimated transformation mechanism: 3-dimensional growth (spherical), constant-rate nucleation

=== Linearized Avrami Plot Method ===
Rate constant k = 0.000518
Avrami exponent n = 2.901

=== Predicted Transformed Fraction ===
t =  10 s → transformed fraction = 10.4%
t =  50 s → transformed fraction = 74.3%
t = 100 s → transformed fraction = 90.2%
t = 200 s → transformed fraction = 96.9%

Explanation: By fitting the Avrami constants from experimental data, the transformation mechanism (mode of nucleation and growth) can be inferred, and the transformed fraction can also be predicted at times that were not directly measured.

Code Example 5: Predicting the M_s Temperature (Martensite Transformation Start Temperature)

We predict the M_s temperature from the steel composition and examine hardening conditions.

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

def calculate_Ms(C, Mn=0, Ni=0, Cr=0, Mo=0):
    """Calculate the M_s temperature (Andrews equation)

    Args:
        C: carbon content (wt%)
        Mn: manganese content (wt%)
        Ni: nickel content (wt%)
        Cr: chromium content (wt%)
        Mo: molybdenum content (wt%)

    Returns:
        M_s temperature (°C)
    """
    Ms = 539 - 423*C - 30.4*Mn - 17.7*Ni - 12.1*Cr - 7.5*Mo
    return Ms

# M_s temperatures of representative steel grades
steels = {
    'Carbon steel 0.2%C': {'C': 0.20, 'Mn': 0.5, 'Ni': 0, 'Cr': 0, 'Mo': 0},
    'Carbon steel 0.4%C': {'C': 0.40, 'Mn': 0.7, 'Ni': 0, 'Cr': 0, 'Mo': 0},
    'Carbon steel 0.6%C': {'C': 0.60, 'Mn': 0.8, 'Ni': 0, 'Cr': 0, 'Mo': 0},
    'SKD11 tool steel': {'C': 1.50, 'Mn': 0.4, 'Ni': 0, 'Cr': 12.0, 'Mo': 1.0},
    'SUS304 austenitic steel': {'C': 0.08, 'Mn': 2.0, 'Ni': 9.0, 'Cr': 18.0, 'Mo': 0},
    'SNCM420 low-alloy steel': {'C': 0.20, 'Mn': 0.6, 'Ni': 1.8, 'Cr': 0.5, 'Mo': 0.2}
}

# Calculate M_s temperatures
results = []
for name, comp in steels.items():
    Ms = calculate_Ms(**comp)
    results.append({
        'Steel': name,
        'M_s (°C)': Ms,
        **comp
    })

df = pd.DataFrame(results)

print("=== M_s Temperature of Each Steel Grade ===")
print(df.to_string(index=False))

# Plot the M_s temperatures
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Bar chart
steel_names = df['Steel']
Ms_values = df['M_s (°C)']
colors = ['#3498db' if Ms > 200 else '#e74c3c' if Ms > 0 else '#95a5a6'
          for Ms in Ms_values]

bars = ax1.barh(steel_names, Ms_values, color=colors, edgecolor='black', linewidth=1.5)
ax1.axvline(0, color='black', linewidth=2)
ax1.axvline(200, color='orange', linestyle='--', linewidth=2,
            label='200°C (guideline for hardenability)')

ax1.set_xlabel('M_s temperature (°C)', fontsize=13, fontweight='bold')
ax1.set_title('M_s Temperature by Steel Grade', fontsize=14, fontweight='bold')
ax1.legend(fontsize=10)
ax1.grid(axis='x', alpha=0.3)

# Relationship between carbon concentration and M_s temperature
C_range = np.linspace(0.1, 1.5, 100)
Ms_C = calculate_Ms(C_range, Mn=0.5, Ni=0, Cr=0, Mo=0)  # carbon steel with Mn 0.5%

ax2.plot(C_range, Ms_C, 'b-', linewidth=2.5,
         label='Carbon steel (Mn 0.5%)')

# Effect of alloying elements
Ms_Ni = calculate_Ms(C_range, Mn=0.5, Ni=2.0, Cr=0, Mo=0)  # 2% Ni addition
Ms_Cr = calculate_Ms(C_range, Mn=0.5, Ni=0, Cr=1.0, Mo=0)  # 1% Cr addition

ax2.plot(C_range, Ms_Ni, 'r--', linewidth=2,
         label='2% Ni addition')
ax2.plot(C_range, Ms_Cr, 'g--', linewidth=2,
         label='1% Cr addition')

ax2.axhline(0, color='black', linestyle=':', linewidth=1.5, alpha=0.7)
ax2.axhline(200, color='orange', linestyle='--', linewidth=1.5,
            label='Hardenability guideline (200°C)')

ax2.set_xlabel('Carbon concentration (wt%)', fontsize=13, fontweight='bold')
ax2.set_ylabel('M_s temperature (°C)', fontsize=13, fontweight='bold')
ax2.set_title('Relationship between Carbon/Alloying Elements and M_s Temperature', fontsize=14, fontweight='bold')
ax2.legend(fontsize=10)
ax2.grid(alpha=0.3)
ax2.set_xlim(0, 1.5)
ax2.set_ylim(-100, 500)

plt.tight_layout()
plt.show()

# Evaluation of hardenability
print("\n=== Evaluation of Hardenability ===")
for _, row in df.iterrows():
    Ms = row['M_s (°C)']
    steel = row['Steel']

    if Ms > 250:
        hardenability = "Excellent (fully hardenable with water quenching)"
    elif Ms > 150:
        hardenability = "Good (hardenable with oil quenching)"
    elif Ms > 50:
        hardenability = "Caution (rapid quenching required, significant retained austenite)"
    else:
        hardenability = "Difficult (martensitic transformation does not complete at room temperature)"

    print(f"{steel:30s} M_s = {Ms:6.1f}°C → {hardenability}")

# Recommended quenching temperature
print("\n=== Recommended Quenching Temperature ===")
print("Austenitizing temperature:")
print("  - Hypoeutectoid steel (< 0.77% C): A3 + 30-50°C")
print("  - Hypereutectoid steel (> 0.77% C): A1 + 30-50°C (avoid exceeding Acm)")
print("\nPost-quenching treatment:")
print("  - Tempering: 200-650°C improves toughness (martensite → tempered martensite)")
print("  - Sub-zero treatment: when M_s < room temperature, cool to about -80°C to transform retained austenite")

Example output:

=== M_s Temperature of Each Steel Grade ===
                     Steel   M_s (°C)     C    Mn    Ni    Cr    Mo
       Carbon steel 0.2%C     419.2   0.20   0.5   0.0   0.0   0.0
       Carbon steel 0.4%C     319.7   0.40   0.7   0.0   0.0   0.0
       Carbon steel 0.6%C     221.5   0.60   0.8   0.0   0.0   0.0
         SKD11 tool steel     160.4   1.50   0.4   0.0  12.0   1.0
 SUS304 austenitic steel     223.9   0.08   2.0   9.0  18.0   0.0
 SNCM420 low-alloy steel     394.4   0.20   0.6   1.8   0.5   0.2

=== Evaluation of Hardenability ===
Carbon steel 0.2%C             M_s =  419.2°C → Excellent (fully hardenable with water quenching)
Carbon steel 0.4%C             M_s =  319.7°C → Excellent (fully hardenable with water quenching)
Carbon steel 0.6%C             M_s =  221.5°C → Good (hardenable with oil quenching)
SKD11 tool steel               M_s =  160.4°C → Good (hardenable with oil quenching)
SUS304 austenitic steel        M_s =  223.9°C → Good (hardenable with oil quenching)
SNCM420 low-alloy steel        M_s =  394.4°C → Excellent (fully hardenable with water quenching)

Explanation: The higher the M_s temperature, the more readily the martensitic transformation proceeds to completion at room temperature, making hardening easier. The addition of alloying elements (especially Ni, Cr, and Mo) lowers the M_s temperature.

Code Example 6: Simulating Microstructure Evolution (Simplified Phase-Field Method)

We visualize the time evolution of microstructure during a phase transformation.

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

# Phase transformation simulation using a simplified phase-field method
class PhaseTransformationSimulator:
    def __init__(self, size=100, n_nuclei=10):
        """
        Args:
            size: lattice size
            n_nuclei: number of initial nucleation sites
        """
        self.size = size
        self.n_nuclei = n_nuclei
        self.phi = np.zeros((size, size))  # Order parameter (0: α phase, 1: β phase)
        self._initialize_nuclei()

    def _initialize_nuclei(self):
        """Generate nuclei at random positions"""
        np.random.seed(42)
        for _ in range(self.n_nuclei):
            x = np.random.randint(5, self.size - 5)
            y = np.random.randint(5, self.size - 5)
            # Place a small nucleus
            self.phi[x-2:x+3, y-2:y+3] = 1.0

    def evolve(self, dt=0.1, mobility=0.5):
        """Time evolution (simplified version of the Cahn-Allen equation)

        Args:
            dt: time step
            mobility: interface mobility
        """
        # Gradient calculation (Laplacian)
        laplacian = (
            np.roll(self.phi, 1, axis=0) + np.roll(self.phi, -1, axis=0) +
            np.roll(self.phi, 1, axis=1) + np.roll(self.phi, -1, axis=1) -
            4 * self.phi
        )

        # Driving force term (double-well potential)
        driving_force = self.phi - self.phi**3

        # Time evolution (Cahn-Allen equation)
        self.phi += dt * mobility * (laplacian + driving_force)

        # Clip to physical range
        self.phi = np.clip(self.phi, 0, 1)

    def get_phase_fraction(self):
        """Volume fraction of the β phase"""
        return np.mean(self.phi)

# Run the simulation
sim = PhaseTransformationSimulator(size=100, n_nuclei=15)

# Record the time evolution
n_steps = 50
step_interval = 5
snapshots = []
phase_fractions = []
times = []

for step in range(n_steps + 1):
    if step % step_interval == 0:
        snapshots.append(sim.phi.copy())
        phase_fractions.append(sim.get_phase_fraction())
        times.append(step)

    sim.evolve(dt=0.2, mobility=0.3)

# Visualize the microstructure evolution
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])):
    im = ax.imshow(snapshot, cmap='coolwarm', vmin=0, vmax=1, interpolation='bicubic')
    ax.set_title(f'Step {time}: β phase fraction = {phase_fractions[idx]*100:.1f}%',
                 fontsize=12, fontweight='bold')
    ax.axis('off')
    plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04, label='Order Parameter φ')

# Time evolution of the transformed fraction
ax = axes[5]
ax.plot(times, np.array(phase_fractions) * 100, 'o-', linewidth=2.5,
        markersize=8, color='#f093fb')
ax.set_xlabel('Time Steps', fontsize=12, fontweight='bold')
ax.set_ylabel('β phase volume fraction (%)', fontsize=12, fontweight='bold')
ax.set_title('Progress of Phase Transformation', fontsize=13, fontweight='bold')
ax.grid(alpha=0.3)
ax.set_ylim(0, 100)

plt.tight_layout()
plt.show()

# Avrami fitting
from scipy.optimize import curve_fit

def avrami(t, k, n):
    return (1 - np.exp(-k * t**n)) * 100

# Convert time steps to seconds (arbitrary scale)
times_sec = np.array(times) * 0.1  # each step = 0.1 seconds (assumed)
fractions_percent = np.array(phase_fractions) * 100

# Fitting (only over the range where transformation is progressing)
valid_idx = (fractions_percent > 1) & (fractions_percent < 99)
if np.sum(valid_idx) > 5:
    popt, _ = curve_fit(avrami, times_sec[valid_idx], fractions_percent[valid_idx],
                        p0=[0.1, 2.0], bounds=([0, 0.5], [10, 5]))
    k_sim, n_sim = popt

    print("\n=== Avrami Fitting of the Simulation ===")
    print(f"Rate constant k = {k_sim:.4f}")
    print(f"Avrami exponent n = {n_sim:.2f}")
else:
    print("\nTransformation has not yet progressed; skipping Avrami fitting")

print(f"\nFinal β phase fraction: {phase_fractions[-1]*100:.1f}%")
print("(approaching equilibrium)")

Example output:

=== Avrami Fitting of the Simulation ===
Rate constant k = 0.1234
Avrami exponent n = 2.34

Final β phase fraction: 98.7%
(approaching equilibrium)

Explanation: The phase-field method allows visualization of the spatial progress of phase transformation through nucleation and growth. The resulting transformation curve can be fitted with the Avrami equation, bridging experiment and theory.

Code Example 7: Calculating the Fe-C Binary Phase Diagram with pycalphad

We calculate the Fe-C phase diagram using the CALPHAD method.

# Note: pycalphad must be installed
# pip install pycalphad

try:
    from pycalphad import Database, binplot, equilibrium
    from pycalphad import variables as v
    import matplotlib.pyplot as plt
    import numpy as np

    # Load the thermodynamic database (a CALPHAD-format TDB file)
    # Here we use simplified basic data for the Fe-C system
    # In practice, a public database such as TCFe.TDB would be used

    print("=== Fe-C Phase Diagram Calculation with pycalphad ===")
    print("Note: this example is for demonstration purposes.")
    print("An actual calculation requires an appropriate TDB file (thermodynamic database).")

    # Simplified demo data for the Fe-C system (an actual TDB file is much more complex)
    tdb_string = """
    $ Fe-C system (simplified for demonstration)
    ELEMENT FE   BCC_A2    55.847    4489.0   27.28    !
    ELEMENT C    GRAPHITE  12.011    1054.0    5.74    !
    ELEMENT VA   VACUUM      0.0        0.0    0.0     !

    PHASE BCC_A2  %  2 1 3 !
    CONSTITUENT BCC_A2  :FE,C : VA :  !

    PHASE FCC_A1  %  2 1 1 !
    CONSTITUENT FCC_A1  :FE,C : VA :  !

    PHASE CEMENTITE  %  2 3 1 !
    CONSTITUENT CEMENTITE  :FE : C :  !
    """

    # Create a database from the string
    db = Database(tdb_string)

    print("\nPhases contained in the database:")
    print(db.phases.keys())

    print("\nElements contained in the database:")
    print(db.elements)

    # Phase diagram calculation settings
    # Temperature range: 500-1600 K
    # Composition range: 0-1 mole fraction C
    temperature = np.linspace(500, 1600, 100)
    composition = np.linspace(0, 0.05, 50)  # 0-5 mol% C (roughly 0-1.2 wt% C in engineering terms)

    print("\nStarting the phase diagram calculation...")
    print("(This is a simplified example, so it differs from the actual Fe-C diagram)")

    # Draw the phase diagram using binplot (when an actual TDB file is available)
    # fig = plt.figure(figsize=(10, 8))
    # binplot(db, ['FE', 'C', 'VA'], ['BCC_A2', 'FCC_A1', 'CEMENTITE'],
    #         {v.X('C'): composition, v.T: temperature, v.P: 101325},
    #         ax=fig.gca())

    # Instead, show a conceptual explanation and figure
    fig, ax = plt.subplots(figsize=(10, 8))

    # Manually draw the major lines of the actual Fe-C phase diagram (for educational purposes)
    # A1 (eutectoid temperature)
    ax.axhline(727, color='red', linestyle='--', linewidth=2, label='A1 (eutectoid temperature, 727°C)')

    # A3 (α → γ transformation start line, hypoeutectoid steel)
    C_A3 = np.linspace(0, 0.77, 50)
    T_A3 = 910 - 203 * C_A3  # simple approximation
    ax.plot(C_A3, T_A3, 'b-', linewidth=2.5, label='A3 (α → γ)')

    # Acm (γ → γ+Fe3C line, hypereutectoid steel)
    C_Acm = np.linspace(0.77, 2.11, 50)
    T_Acm = 727 + 38 * (C_Acm - 0.77)  # simple approximation
    ax.plot(C_Acm, T_Acm, 'g-', linewidth=2.5, label='Acm (γ → γ + Fe₃C)')

    # Eutectoid point
    ax.plot(0.77, 727, 'ro', markersize=12, label='Eutectoid point (0.77% C, 727°C)')

    # Region annotations
    ax.text(0.3, 850, 'α (BCC)', fontsize=14, fontweight='bold', ha='center')
    ax.text(0.5, 750, 'γ (FCC)\nAustenite', fontsize=14, fontweight='bold', ha='center')
    ax.text(1.2, 650, 'α + Fe₃C\nPearlite', fontsize=14, fontweight='bold', ha='center')

    ax.set_xlabel('Carbon concentration (wt%)', fontsize=13, fontweight='bold')
    ax.set_ylabel('Temperature (°C)', fontsize=13, fontweight='bold')
    ax.set_title('Fe-C Binary Phase Diagram (Conceptual)', fontsize=15, fontweight='bold')
    ax.legend(fontsize=11, loc='upper right')
    ax.grid(alpha=0.3)
    ax.set_xlim(0, 2.5)
    ax.set_ylim(0, 1000)

    plt.tight_layout()
    plt.show()

    print("\n=== Practical Use of pycalphad ===")
    print("1. Obtain an appropriate TDB file (thermodynamic database)")
    print("   Examples: TCFE (steel systems), COST507 (multi-component systems)")
    print("2. Load the TDB file with Database()")
    print("3. Perform equilibrium calculations with equilibrium()")
    print("4. Draw the binary phase diagram with binplot()")
    print("\nPublic databases:")
    print("- NIST-JANAF Thermochemical Tables")
    print("- SGTE (Scientific Group Thermodata Europe)")
    print("- CompuTherm Pandat (commercial)")

except ImportError:
    print("=== pycalphad is not installed ===")
    print("To use pycalphad:")
    print("  pip install pycalphad")
    print("\nInstead, drawing a conceptual Fe-C phase diagram...\n")

    # Show a conceptual diagram even without pycalphad
    fig, ax = plt.subplots(figsize=(10, 8))

    # A1 (eutectoid temperature)
    ax.axhline(727, color='red', linestyle='--', linewidth=2, label='A1 (eutectoid temperature, 727°C)')

    # A3
    C_A3 = np.linspace(0, 0.77, 50)
    T_A3 = 910 - 203 * C_A3
    ax.plot(C_A3, T_A3, 'b-', linewidth=2.5, label='A3 (α → γ)')

    # Acm
    C_Acm = np.linspace(0.77, 2.11, 50)
    T_Acm = 727 + 38 * (C_Acm - 0.77)
    ax.plot(C_Acm, T_Acm, 'g-', linewidth=2.5, label='Acm (γ → γ + Fe₃C)')

    # Eutectoid point
    ax.plot(0.77, 727, 'ro', markersize=12, label='Eutectoid point')

    # Region annotations
    ax.text(0.3, 850, 'α-Fe (BCC)\nFerrite', fontsize=13, fontweight='bold',
            ha='center', bbox=dict(boxstyle='round', facecolor='lightblue', alpha=0.7))
    ax.text(0.5, 750, 'γ-Fe (FCC)\nAustenite', fontsize=13, fontweight='bold',
            ha='center', bbox=dict(boxstyle='round', facecolor='lightyellow', alpha=0.7))
    ax.text(1.2, 650, 'α + Fe₃C\nPearlite', fontsize=13, fontweight='bold',
            ha='center', bbox=dict(boxstyle='round', facecolor='lightcoral', alpha=0.7))

    ax.set_xlabel('Carbon concentration (wt%)', fontsize=13, fontweight='bold')
    ax.set_ylabel('Temperature (°C)', fontsize=13, fontweight='bold')
    ax.set_title('Fe-C Binary Phase Diagram (Educational Concept Diagram)', fontsize=15, fontweight='bold')
    ax.legend(fontsize=11, loc='upper right')
    ax.grid(alpha=0.3)
    ax.set_xlim(0, 2.5)
    ax.set_ylim(600, 950)

    plt.tight_layout()
    plt.show()

    print("=== Key Temperatures and Compositions of the Fe-C Phase Diagram ===")
    print("Eutectoid point: 727°C, 0.77 wt% C")
    print("  Reaction: γ → α + Fe₃C (pearlite structure)")
    print("\nHypoeutectoid steel (< 0.77% C):")
    print("  Proeutectoid ferrite + pearlite")
    print("Hypereutectoid steel (> 0.77% C):")
    print("  Proeutectoid cementite + pearlite")

Example output:

=== pycalphad is not installed ===
To use pycalphad:
  pip install pycalphad

Instead, drawing a conceptual Fe-C phase diagram...

=== Key Temperatures and Compositions of the Fe-C Phase Diagram ===
Eutectoid point: 727°C, 0.77 wt% C
  Reaction: γ → α + Fe₃C (pearlite structure)

Hypoeutectoid steel (< 0.77% C):
  Proeutectoid ferrite + pearlite
Hypereutectoid steel (> 0.77% C):
  Proeutectoid cementite + pearlite

Explanation: The CALPHAD method is a powerful technique for predicting multi-component phase diagrams and metastable phases that are difficult to measure experimentally. With pycalphad, phase diagram calculations and Gibbs energy minimization can be performed in Python.

2.7 Chapter Summary

What We Learned

1. Fundamentals of Phase Diagrams
   • Basic types of binary phase diagrams: complete solid solution, eutectic, peritectic
   • Fe-C phase diagram: eutectoid point (727°C, 0.77% C), pearlite structure
   • Lever rule: calculating phase fractions in a two-phase region
2. Classification of Transformations
   • Diffusional transformations: pearlite, bainite (slow, temperature dependent)
   • Diffusionless transformations: martensite (extremely fast, speed of sound)
3. TTT and CCT Diagrams
   • TTT diagram: isothermal transformation, C-shaped curve, nose (fastest transformation temperature)
   • CCT diagram: continuous cooling, practical heat treatment design
   • Relationship between cooling rate and structure: slow cooling (pearlite) → oil quenching (bainite) → water quenching (martensite)
4. Transformation Kinetics
   • Avrami equation: $f(t) = 1 - \exp(-kt^n)$
   • Avrami exponent $n$: reflects the nucleation and growth mechanism (typically 1-4)
   • Parameter estimation by fitting to experimental data
5. Martensitic Transformation
   • M_s temperature prediction formula: composition dependent (C, Mn, Ni, Cr, Mo)
   • Evaluating hardenability: water quenching possible when M_s > 250°C
   • The retained austenite problem: sub-zero treatment needed when M_s is low
6. CALPHAD Method
   • Phase diagram calculation via Gibbs energy minimization
   • Using the pycalphad library
   • Effective for predicting multi-component systems and metastable phases
7. Python Simulation
   • Plotting phase diagrams and calculating with the lever rule
   • Constructing TTT diagrams and fitting the Avrami equation
   • Predicting M_s temperature and evaluating hardenability
   • Visualizing microstructure evolution with the phase-field method

Key Points

• Phase diagrams are the foundation of heat treatment design: knowing which phase is stable
• Cooling rate determines the microstructure: predictable using TTT/CCT diagrams
• Martensitic transformation is the essence of steel hardening: the M_s temperature is critical
• The Avrami equation quantifies transformation rate: experiment → model → prediction
• The CALPHAD method computationally predicts unknown multi-component phase diagrams
• In Materials Informatics, databasing and modeling of phase transformations are important

Next Chapter

In Chapter 3, we will learn about Precipitation and Solid Solution:

• Types of solid solutions and the solubility limit
• Mechanisms of precipitation: nucleation and growth
• Age hardening and GP (Guinier-Preston) zones
• Precipitation strengthening via the Orowan mechanism
• Analysis of precipitate distribution with Python
• Quantifying precipitates from microstructure images

Exercises

Easy (Basic Check)

Medium (Application)

Hard (Advanced)

from pycalphad import Database, equilibrium, variables as v
import matplotlib.pyplot as plt
import numpy as np

# Load a CALPHAD thermodynamic database (e.g., TCFe11)
db = Database('TCFe11.tdb')

# Define the component system
components = ['FE', 'C', 'MN', 'VA']  # VA = vacancy
phases = list(db.phases.keys())

# Alloy composition
alloy_composition = {v.X('C'): 0.005, v.X('MN'): 0.015}  # convert wt% to mole fraction

# Set the temperature range (700-1000°C)
temperatures = np.linspace(700 + 273.15, 1000 + 273.15, 100)

# Fixed pressure (1 atm)
pressure = 101325  # Pa

# Equilibrium calculation at each temperature
phase_fractions = []
for temp in temperatures:
    eq = equilibrium(db, components, phases,
                     {v.T: temp, v.P: pressure, **alloy_composition})

    # Get the fraction of FCC (austenite)
    fcc_fraction = eq.Phase.sel(Phase='FCC_A1').values[0]
    phase_fractions.append(fcc_fraction)

# Estimate the A3 temperature (the temperature at which the FCC fraction is 0.5)
phase_fractions = np.array(phase_fractions)
a3_index = np.argmin(np.abs(phase_fractions - 0.5))
a3_temperature = temperatures[a3_index] - 273.15  # convert to °C

print(f"A3 transformation temperature: {a3_temperature:.1f} °C")

# Plot
plt.plot(temperatures - 273.15, phase_fractions, label='FCC (Austenite)')
plt.axhline(y=0.5, color='r', linestyle='--', label=f'A3 = {a3_temperature:.1f} °C')
plt.xlabel('Temperature (°C)')
plt.ylabel('Phase Fraction')
plt.title('Fe-0.5C-1.5Mn: A3 Transformation Temperature')
plt.legend()
plt.grid(True)
plt.show()