Chapter 2: Synthesis Strategies

2.1 Overview of Synthesis Approaches

Nanomaterial synthesis methods can be broadly classified into two categories: top-down approaches that break down bulk materials into nanoscale structures, and bottom-up approaches that build up nanostructures from atomic or molecular precursors.

2.2 Top-Down Methods

2.2.1 Mechanical Milling

Ball milling is a widely used technique that uses high-energy collisions to reduce particle size. The process involves placing powder in a rotating or vibrating container with hard balls (steel, ceramic, or tungsten carbide).

import numpy as np
import matplotlib.pyplot as plt

def particle_size_evolution(t, d0, d_min, k):
    """
    Model particle size reduction during ball milling.

    Uses first-order kinetics: d(t) = d_min + (d0 - d_min) * exp(-k*t)

    Parameters:
    -----------
    t : float or array
        Milling time (hours)
    d0 : float
        Initial particle size (nm)
    d_min : float
        Minimum achievable size (nm)
    k : float
        Rate constant (1/hour)

    Returns:
    --------
    float or array : Particle size at time t
    """
    return d_min + (d0 - d_min) * np.exp(-k * t)

def milling_energy(speed_rpm, ball_mass, ball_diameter, time_hours):
    """
    Estimate cumulative milling energy.

    Parameters:
    -----------
    speed_rpm : float
        Rotation speed (rpm)
    ball_mass : float
        Mass of balls (kg)
    ball_diameter : float
        Ball diameter (m)
    time_hours : float
        Milling time (hours)

    Returns:
    --------
    float : Cumulative energy (kJ)
    """
    omega = speed_rpm * 2 * np.pi / 60  # rad/s
    r = ball_diameter / 2
    # Simplified kinetic energy estimate
    energy_per_impact = 0.5 * ball_mass * (omega * r)**2
    impacts_per_second = speed_rpm / 60 * 10  # Approximate
    time_seconds = time_hours * 3600

    return energy_per_impact * impacts_per_second * time_seconds / 1000  # kJ

# Simulation of milling process
time = np.linspace(0, 20, 100)  # hours

# Different milling conditions
conditions = [
    {"d0": 50000, "d_min": 20, "k": 0.3, "label": "High-energy (SPEX)"},
    {"d0": 50000, "d_min": 50, "k": 0.15, "label": "Planetary mill"},
    {"d0": 50000, "d_min": 100, "k": 0.08, "label": "Attritor"},
]

plt.figure(figsize=(12, 5))

# Plot 1: Size evolution
plt.subplot(1, 2, 1)
for cond in conditions:
    sizes = particle_size_evolution(time, cond["d0"], cond["d_min"], cond["k"])
    plt.semilogy(time, sizes, linewidth=2, label=cond["label"])

plt.xlabel('Milling Time (hours)')
plt.ylabel('Particle Size (nm)')
plt.title('Particle Size Reduction During Ball Milling')
plt.legend()
plt.grid(True, alpha=0.3)
plt.ylim(10, 100000)

# Plot 2: Size distribution evolution
plt.subplot(1, 2, 2)
# Simulate log-normal distributions at different times
from scipy.stats import lognorm

sizes_x = np.logspace(1, 5, 200)  # 10 nm to 100 μm
times_plot = [0, 2, 5, 10, 20]

for t in times_plot:
    mean_size = particle_size_evolution(t, 50000, 50, 0.3)
    sigma = 0.5 + 0.3 * np.exp(-0.1 * t)  # Narrower distribution with time
    dist = lognorm.pdf(sizes_x, sigma, scale=mean_size)
    plt.semilogx(sizes_x, dist, linewidth=2, label=f't = {t} h')

plt.xlabel('Particle Size (nm)')
plt.ylabel('Probability Density')
plt.title('Size Distribution Evolution')
plt.legend()
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('ball_milling.png', dpi=150)
plt.show()
        

2.2.2 Lithography

Lithographic techniques use patterns to selectively remove or deposit material, achieving precise nanoscale features:

• Photolithography: UV light through masks, resolution ~50 nm with deep UV
• Electron beam lithography (EBL): Direct writing with electrons, resolution ~5 nm
• Nanoimprint lithography (NIL): Mechanical molding, resolution ~10 nm, high throughput
• Focused ion beam (FIB): Ion milling for direct patterning, resolution ~10 nm

2.2.3 Laser Ablation

Pulsed laser ablation in liquid (PLAL) produces colloidal nanoparticles by focusing high-energy laser pulses on a solid target immersed in liquid:

2.3 Bottom-Up Methods: Gas Phase

2.3.1 Chemical Vapor Deposition (CVD)

CVD deposits thin films and nanomaterials from gaseous precursors through chemical reactions at heated surfaces. It's essential for graphene, carbon nanotubes, and semiconductor nanowires.

import numpy as np
import matplotlib.pyplot as plt

def cvd_growth_rate(T, P, Ea, A, reaction_order=1):
    """
    Calculate CVD growth rate using Arrhenius kinetics.

    Parameters:
    -----------
    T : float or array
        Temperature (K)
    P : float
        Precursor partial pressure (Torr)
    Ea : float
        Activation energy (eV)
    A : float
        Pre-exponential factor (nm/min/Torr^n)
    reaction_order : float
        Pressure dependence order

    Returns:
    --------
    float or array : Growth rate (nm/min)
    """
    kB = 8.617e-5  # eV/K

    # Arrhenius equation
    rate = A * P**reaction_order * np.exp(-Ea / (kB * T))

    return rate

def cvd_regime_analysis(T, P):
    """
    Determine CVD growth regime (reaction-limited vs transport-limited).
    """
    # Simplified model
    Ea_reaction = 1.2  # eV (surface reaction)
    Ea_transport = 0.1  # eV (gas diffusion)

    kB = 8.617e-5
    k_reaction = np.exp(-Ea_reaction / (kB * T))
    k_transport = np.exp(-Ea_transport / (kB * T))

    if k_reaction < k_transport:
        return "Reaction-limited", k_reaction
    else:
        return "Transport-limited", k_transport

# Example: Graphene CVD on copper
temperatures = np.linspace(800, 1100, 100) + 273  # K
pressures = [0.1, 1, 10, 100]  # Torr

# Parameters for graphene growth
Ea = 1.5  # eV
A = 1e6  # Pre-exponential factor

plt.figure(figsize=(12, 5))

# Plot 1: Temperature dependence (Arrhenius plot)
plt.subplot(1, 2, 1)
for P in [0.1, 1, 10]:
    rates = cvd_growth_rate(temperatures, P, Ea, A)
    plt.semilogy(1000/temperatures, rates, linewidth=2, label=f'P = {P} Torr')

plt.xlabel('1000/T (1/K)')
plt.ylabel('Growth Rate (nm/min)')
plt.title('Arrhenius Plot: CVD Growth Rate')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot 2: Temperature dependence (linear T)
plt.subplot(1, 2, 2)
for P in [0.1, 1, 10]:
    rates = cvd_growth_rate(temperatures, P, Ea, A)
    plt.plot(temperatures - 273, rates, linewidth=2, label=f'P = {P} Torr')

plt.xlabel('Temperature (°C)')
plt.ylabel('Growth Rate (nm/min)')
plt.title('CVD Growth Rate vs Temperature')
plt.legend()
plt.grid(True, alpha=0.3)
plt.yscale('log')

plt.tight_layout()
plt.savefig('cvd_growth.png', dpi=150)
plt.show()

# Print growth regime analysis
print("\nCVD Growth Regime Analysis:")
print("-" * 50)
for T_C in [700, 800, 900, 1000]:
    T_K = T_C + 273
    regime, k = cvd_regime_analysis(T_K, 1)
    rate = cvd_growth_rate(T_K, 1, Ea, A)
    print(f"T = {T_C}°C: {regime}, Rate = {rate:.2e} nm/min")
        

2.3.2 Atomic Layer Deposition (ALD)

ALD is a variant of CVD that uses sequential, self-limiting surface reactions to deposit films one atomic layer at a time. This provides exceptional thickness control (±0.1 Å) and conformal coating on complex geometries.

import numpy as np
import matplotlib.pyplot as plt

class ALDProcess:
    """Simulate ALD film growth."""

    def __init__(self, gpc, nucleation_delay=0):
        """
        Parameters:
        -----------
        gpc : float
            Growth per cycle (Angstroms)
        nucleation_delay : int
            Number of cycles before steady-state growth
        """
        self.gpc = gpc
        self.nucleation_delay = nucleation_delay

    def thickness(self, cycles):
        """Calculate film thickness after n cycles."""
        if cycles <= self.nucleation_delay:
            # Substrate-inhibited growth
            effective_cycles = cycles * (cycles / (2 * self.nucleation_delay))
        else:
            # Steady-state growth
            delay_contribution = self.nucleation_delay / 2
            linear_contribution = cycles - self.nucleation_delay
            effective_cycles = delay_contribution + linear_contribution

        return effective_cycles * self.gpc  # Angstroms

    def time_per_cycle(self, pulse_times, purge_times):
        """
        Calculate cycle time.

        Parameters:
        -----------
        pulse_times : list
            [precursor_A_time, precursor_B_time] in seconds
        purge_times : list
            [purge_A_time, purge_B_time] in seconds
        """
        return sum(pulse_times) + sum(purge_times)

# Example: Al2O3 ALD using TMA and H2O
al2o3_ald = ALDProcess(gpc=1.1, nucleation_delay=5)  # 1.1 Å/cycle

# Calculate growth curve
cycles = np.arange(0, 101)
thicknesses = [al2o3_ald.thickness(c) for c in cycles]

# Compare different materials
materials = {
    'Al2O3 (TMA/H2O)': ALDProcess(gpc=1.1, nucleation_delay=5),
    'TiO2 (TDMAT/H2O)': ALDProcess(gpc=0.5, nucleation_delay=10),
    'HfO2 (TEMAH/H2O)': ALDProcess(gpc=1.0, nucleation_delay=8),
    'ZnO (DEZ/H2O)': ALDProcess(gpc=1.8, nucleation_delay=3),
}

plt.figure(figsize=(12, 5))

# Plot 1: Thickness vs cycles
plt.subplot(1, 2, 1)
for name, process in materials.items():
    thicknesses = [process.thickness(c) for c in cycles]
    plt.plot(cycles, np.array(thicknesses)/10, linewidth=2, label=name)

plt.xlabel('Number of ALD Cycles')
plt.ylabel('Film Thickness (nm)')
plt.title('ALD Film Growth')
plt.legend()
plt.grid(True, alpha=0.3)

# Plot 2: Recipe design tool
plt.subplot(1, 2, 2)
target_thickness = 10  # nm
gpcs = np.linspace(0.5, 2.5, 100)
cycles_needed = target_thickness * 10 / gpcs  # Convert nm to Å

cycle_time = 10  # seconds per cycle
total_time = cycles_needed * cycle_time / 60  # minutes

plt.plot(gpcs, cycles_needed, 'b-', linewidth=2, label='Cycles needed')
plt.xlabel('Growth per Cycle (Å/cycle)')
plt.ylabel('Number of Cycles')
plt.title(f'Cycles Required for {target_thickness} nm Film')
plt.grid(True, alpha=0.3)

ax2 = plt.twinx()
ax2.plot(gpcs, total_time, 'r--', linewidth=2, label='Deposition time')
ax2.set_ylabel('Deposition Time (minutes)', color='red')
ax2.tick_params(axis='y', labelcolor='red')

plt.tight_layout()
plt.savefig('ald_growth.png', dpi=150)
plt.show()

# Print recipe calculation
print("\nALD Recipe Calculator:")
print("-" * 50)
target = 5  # nm
for name, process in materials.items():
    cycles_req = int(np.ceil(target * 10 / process.gpc))
    time_min = cycles_req * 10 / 60  # 10 s/cycle
    print(f"{name}:")
    print(f"  Cycles: {cycles_req}, Time: {time_min:.1f} min")
        

2.4 Bottom-Up Methods: Solution Phase

2.4.1 Sol-Gel Synthesis

The sol-gel process involves the transition from a colloidal solution (sol) to a gel network through hydrolysis and condensation reactions. It's widely used for oxide nanoparticles and thin films.

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

def sol_gel_kinetics(y, t, k_h, k_c, water_ratio):
    """
    Model sol-gel hydrolysis and condensation kinetics.

    Parameters:
    -----------
    y : array
        [M(OR)4, M(OR)3(OH), M-O-M, ROH]
    t : float
        Time
    k_h : float
        Hydrolysis rate constant
    k_c : float
        Condensation rate constant
    water_ratio : float
        H2O/M(OR)4 molar ratio

    Returns:
    --------
    array : Derivatives [d/dt for each species]
    """
    M_OR4, M_OR3_OH, M_O_M, ROH = y

    # Available water (decreases with hydrolysis)
    H2O = max(0, water_ratio - (1 - M_OR4) - 0.5 * M_O_M)

    # Reaction rates
    r_hydrolysis = k_h * M_OR4 * H2O
    r_condensation = k_c * M_OR3_OH**2

    # Mass balances
    dM_OR4 = -r_hydrolysis
    dM_OR3_OH = r_hydrolysis - 2 * r_condensation
    dM_O_M = r_condensation
    dROH = r_hydrolysis + r_condensation

    return [dM_OR4, dM_OR3_OH, dM_O_M, dROH]

# Simulation parameters
t = np.linspace(0, 100, 1000)  # time units
y0 = [1.0, 0.0, 0.0, 0.0]  # Initial: 100% M(OR)4

# Compare different water ratios
water_ratios = [2, 4, 8, 16]
k_h = 0.1  # Hydrolysis rate constant
k_c = 0.05  # Condensation rate constant

plt.figure(figsize=(12, 8))

for i, r_w in enumerate(water_ratios):
    solution = odeint(sol_gel_kinetics, y0, t, args=(k_h, k_c, r_w))

    plt.subplot(2, 2, i+1)
    plt.plot(t, solution[:, 0], 'b-', label='M(OR)₄', linewidth=2)
    plt.plot(t, solution[:, 1], 'g-', label='M(OR)₃(OH)', linewidth=2)
    plt.plot(t, solution[:, 2], 'r-', label='M-O-M', linewidth=2)

    plt.xlabel('Time (a.u.)')
    plt.ylabel('Concentration')
    plt.title(f'H₂O/M ratio = {r_w}')
    plt.legend(loc='right')
    plt.grid(True, alpha=0.3)
    plt.ylim(0, 1.1)

plt.tight_layout()
plt.savefig('sol_gel_kinetics.png', dpi=150)
plt.show()

# Gel time estimation
def estimate_gel_time(water_ratio, k_h, k_c, threshold=0.5):
    """Estimate gelation time (when M-O-M > threshold)."""
    t = np.linspace(0, 1000, 10000)
    y0 = [1.0, 0.0, 0.0, 0.0]
    solution = odeint(sol_gel_kinetics, y0, t, args=(k_h, k_c, water_ratio))

    # Find when M-O-M exceeds threshold
    gel_idx = np.where(solution[:, 2] > threshold)[0]
    if len(gel_idx) > 0:
        return t[gel_idx[0]]
    return np.inf

print("\nGel Time vs Water Ratio:")
print("-" * 40)
for r in [1, 2, 4, 8, 16, 32]:
    gel_time = estimate_gel_time(r, 0.1, 0.05)
    print(f"H₂O/M = {r:2d}: Gel time = {gel_time:.1f}")
        

2.4.2 Hydrothermal and Solvothermal Synthesis

Hydrothermal synthesis uses aqueous solutions at elevated temperatures (100-300°C) and pressures in sealed vessels (autoclaves). This enables crystalline nanoparticle formation at relatively low temperatures.

2.4.3 Colloidal Synthesis (Hot Injection Method)

The hot injection method is the gold standard for synthesizing monodisperse quantum dots. Rapid injection of precursors into a hot solvent separates nucleation and growth temporally, enabling excellent size control.

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint

def lamer_model(y, t, k_nucleation, k_growth, C_star, injection_rate=0):
    """
    LaMer nucleation and growth model.

    Parameters:
    -----------
    y : array
        [C (monomer concentration), N (number of nuclei), r (mean radius)]
    t : float
        Time
    k_nucleation : float
        Nucleation rate constant
    k_growth : float
        Growth rate constant
    C_star : float
        Critical supersaturation for nucleation

    Returns:
    --------
    array : Time derivatives
    """
    C, N, r = y

    # Nucleation rate (only above critical supersaturation)
    if C > C_star:
        dN = k_nucleation * (C - C_star)**3
    else:
        dN = 0

    # Growth rate (diffusion-limited)
    if r > 0 and N > 0:
        dr = k_growth * (C - 1) / r  # Gibbs-Thomson effect
    else:
        dr = 0

    # Monomer consumption
    if N > 0 and r > 0:
        dC = injection_rate - 4 * np.pi * r**2 * N * dr - dN * (4/3) * np.pi * r**3
    else:
        dC = injection_rate - dN * 0.1  # Nuclei consume some monomer

    return [dC, dN, dr]

# Hot injection simulation
def simulate_hot_injection():
    """Simulate hot injection synthesis."""

    # Pre-injection: build up concentration
    t1 = np.linspace(0, 1, 100)
    # Post-injection
    t2 = np.linspace(1, 10, 500)

    # Parameters
    k_nuc = 100  # Nucleation rate constant
    k_growth = 0.5  # Growth rate constant
    C_star = 5  # Critical supersaturation

    # Stage 1: Concentration buildup
    C_pre = np.linspace(0, 8, 100)  # Ramping up

    # Stage 2 & 3: Hot injection and growth
    y0 = [8.0, 0.1, 0.5]  # Initial after injection
    solution = odeint(lamer_model, y0, t2, args=(k_nuc, k_growth, C_star))

    # Combine results
    t_full = np.concatenate([t1, t2])
    C_full = np.concatenate([C_pre, solution[:, 0]])
    N_full = np.concatenate([np.zeros(100), solution[:, 1]])
    r_full = np.concatenate([np.zeros(100), solution[:, 2]])

    return t_full, C_full, N_full, r_full

t, C, N, r = simulate_hot_injection()

# Plot LaMer diagram
fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# Plot 1: Concentration vs time (LaMer diagram)
ax1 = axes[0]
ax1.plot(t, C, 'b-', linewidth=2)
ax1.axhline(y=5, color='r', linestyle='--', label='C* (nucleation threshold)')
ax1.axhline(y=1, color='g', linestyle='--', label='C_eq (equilibrium)')
ax1.axvline(x=1, color='gray', linestyle=':', alpha=0.7, label='Injection')
ax1.fill_between(t, 5, C, where=C>5, alpha=0.3, color='red', label='Nucleation zone')
ax1.set_xlabel('Time (a.u.)')
ax1.set_ylabel('Monomer Concentration')
ax1.set_title('LaMer Diagram')
ax1.legend(loc='upper right')
ax1.grid(True, alpha=0.3)

# Plot 2: Number of nuclei
ax2 = axes[1]
ax2.plot(t, N, 'g-', linewidth=2)
ax2.axvline(x=1, color='gray', linestyle=':', alpha=0.7)
ax2.set_xlabel('Time (a.u.)')
ax2.set_ylabel('Number of Nuclei (a.u.)')
ax2.set_title('Nucleation Burst')
ax2.grid(True, alpha=0.3)

# Plot 3: Particle size
ax3 = axes[2]
ax3.plot(t, r, 'r-', linewidth=2)
ax3.axvline(x=1, color='gray', linestyle=':', alpha=0.7)
ax3.set_xlabel('Time (a.u.)')
ax3.set_ylabel('Mean Particle Radius (a.u.)')
ax3.set_title('Particle Growth')
ax3.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('hot_injection_synthesis.png', dpi=150)
plt.show()
        

2.5 Green Synthesis Methods

Green synthesis methods minimize environmental impact by using non-toxic solvents, renewable precursors, and mild reaction conditions:

• Biosynthesis: Using plant extracts, bacteria, or fungi as reducing agents
• Microwave-assisted: Rapid, energy-efficient heating
• Sonochemical: Ultrasound-driven reactions at ambient conditions
• Ionic liquid synthesis: Non-volatile, recyclable solvents

2.6 Summary

Exercises