Chapter 5: Industrial Applications and Case Studies

5.1 Paints and Coatings

The coatings industry represents one of the largest applications of nanoparticle dispersion technology. Pigment dispersion quality directly affects color strength, gloss, hiding power, and durability.

Pigment Dispersion Fundamentals

Example 1: Coating Formulation Optimizer

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

# ===================================
# Example 1: Coating Formulation Optimizer
# ===================================

class CoatingFormulator:
    """Optimize pigment dispersion for coating applications."""

    def __init__(self, pigment_type, target_properties):
        self.pigment_type = pigment_type
        self.targets = target_properties
        self.formulation_history = []

    def calculate_properties(self, dispersant_conc, binder_conc,
                             milling_time, bead_size):
        """Predict coating properties from formulation parameters."""

        # Simplified models based on industry correlations
        # Particle size decreases with milling time and smaller beads
        d50 = 500 * np.exp(-0.1 * milling_time) * (bead_size / 0.5) ** 0.3

        # Color strength increases with dispersion quality
        # Optimal dispersant concentration gives maximum strength
        color_strength = 100 * (1 - np.exp(-2 * dispersant_conc)) * \
                        np.exp(-0.5 * (dispersant_conc - 0.03) ** 2 / 0.01)

        # Gloss depends on particle size and binder level
        gloss = 95 * np.exp(-d50 / 500) * (1 - np.exp(-binder_conc / 0.3))

        # Stability from DLVO-like interactions
        # Higher dispersant improves stability up to a point
        stability = min(36, 12 * dispersant_conc / 0.02) if dispersant_conc < 0.04 \
                   else 36 - 200 * (dispersant_conc - 0.04)

        return {
            'd50_nm': max(50, d50),
            'color_strength': min(105, color_strength),
            'gloss_GU': min(95, gloss),
            'stability_months': max(1, stability)
        }

    def objective_function(self, params):
        """Multi-objective optimization function."""
        dispersant, binder, time, beads = params
        props = self.calculate_properties(dispersant, binder, time, beads)

        # Weighted penalty for deviation from targets
        penalty = 0
        if 'd50_nm' in self.targets:
            penalty += 10 * (props['d50_nm'] - self.targets['d50_nm']) ** 2
        if 'color_strength' in self.targets:
            penalty += 5 * (self.targets['color_strength'] - props['color_strength']) ** 2
        if 'gloss_GU' in self.targets:
            penalty += 2 * (self.targets['gloss_GU'] - props['gloss_GU']) ** 2
        if 'stability_months' in self.targets:
            penalty += 20 * max(0, self.targets['stability_months'] - props['stability_months']) ** 2

        # Add cost term (dispersant and milling time are expensive)
        cost = 100 * dispersant + 0.5 * time + 50 * (0.5 - beads) ** 2

        return penalty + cost

    def optimize(self):
        """Find optimal formulation parameters."""
        # Parameter bounds: [dispersant%, binder%, milling_time_h, bead_size_mm]
        bounds = [(0.01, 0.08), (0.15, 0.45), (1, 24), (0.1, 1.0)]
        x0 = [0.03, 0.30, 8, 0.5]

        result = minimize(self.objective_function, x0,
                         method='L-BFGS-B', bounds=bounds)

        optimal = {
            'dispersant_conc': result.x[0],
            'binder_conc': result.x[1],
            'milling_time_h': result.x[2],
            'bead_size_mm': result.x[3]
        }

        properties = self.calculate_properties(*result.x)

        return optimal, properties

# Example: Automotive coating optimization
targets = {
    'd50_nm': 150,
    'color_strength': 100,
    'gloss_GU': 85,
    'stability_months': 24
}

formulator = CoatingFormulator('TiO2', targets)
optimal_params, predicted_props = formulator.optimize()

print("Optimal Formulation Parameters:")
print(f"  Dispersant: {optimal_params['dispersant_conc']*100:.1f}%")
print(f"  Binder: {optimal_params['binder_conc']*100:.1f}%")
print(f"  Milling Time: {optimal_params['milling_time_h']:.1f} hours")
print(f"  Bead Size: {optimal_params['bead_size_mm']:.2f} mm")
print("\nPredicted Properties:")
for key, value in predicted_props.items():
    print(f"  {key}: {value:.1f}")

Functional Nanocoatings

Beyond traditional pigments, nanoparticles enable functional coatings with special properties:

5.2 Pharmaceuticals and Drug Delivery

Nanotechnology has revolutionized drug delivery by enabling targeted therapy, improved bioavailability, and controlled release. Dispersion stability is critical for both efficacy and safety.

Nanoparticle Drug Delivery Systems

Example 2: Pharmaceutical Nanoparticle Stability Model

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# Example 2: Pharmaceutical NP Stability
# ===================================

class PharmaNanoparticle:
    """Model stability of pharmaceutical nanoparticle formulations."""

    def __init__(self, drug_name, particle_type, initial_size_nm, pdi):
        self.drug_name = drug_name
        self.particle_type = particle_type
        self.initial_size = initial_size_nm
        self.initial_pdi = pdi
        self.stability_data = []

    def arrhenius_rate(self, temp_C, Ea_kJ=80):
        """Calculate degradation rate using Arrhenius equation."""
        R = 8.314e-3  # kJ/(mol·K)
        T = temp_C + 273.15
        T_ref = 298.15  # 25°C reference

        k_ref = 0.001  # Reference rate constant (day^-1)
        k = k_ref * np.exp(-Ea_kJ / R * (1/T - 1/T_ref))
        return k

    def predict_size_growth(self, time_days, temp_C, ionic_strength=0.15):
        """Predict particle size growth due to Ostwald ripening and aggregation."""

        # Ostwald ripening: r³ - r₀³ = kt (LSW theory)
        k_ostwald = 0.1 * (temp_C / 25) ** 2 * (1 + ionic_strength)

        # Aggregation contribution (DLVO-based)
        if ionic_strength > 0.2:
            k_agg = 0.05 * (ionic_strength - 0.15)
        else:
            k_agg = 0

        # Combined growth
        size_cubed = self.initial_size ** 3 + k_ostwald * time_days
        size_from_ostwald = size_cubed ** (1/3)

        # Add aggregation contribution
        final_size = size_from_ostwald * (1 + k_agg * time_days / 100)

        return final_size

    def predict_pdi_change(self, time_days, temp_C):
        """Predict PDI broadening over time."""
        k_pdi = self.arrhenius_rate(temp_C, Ea_kJ=60)
        pdi = self.initial_pdi + k_pdi * time_days * 0.1
        return min(1.0, pdi)

    def accelerated_stability_study(self, temps=[5, 25, 40],
                                    duration_days=90,
                                    sampling_interval=7):
        """Simulate accelerated stability study at multiple temperatures."""

        results = {}
        for temp in temps:
            times = np.arange(0, duration_days + 1, sampling_interval)
            sizes = [self.predict_size_growth(t, temp) for t in times]
            pdis = [self.predict_pdi_change(t, temp) for t in times]

            results[temp] = {
                'time_days': times,
                'size_nm': sizes,
                'pdi': pdis
            }

        return results

    def predict_shelf_life(self, max_size_nm, max_pdi, storage_temp=5):
        """Predict shelf life based on acceptance criteria."""

        time = 0
        while time < 1000:  # Max 1000 days
            size = self.predict_size_growth(time, storage_temp)
            pdi = self.predict_pdi_change(time, storage_temp)

            if size > max_size_nm or pdi > max_pdi:
                break
            time += 1

        return time

# Example: Liposomal doxorubicin formulation
liposome = PharmaNanoparticle(
    drug_name="Doxorubicin",
    particle_type="PEGylated Liposome",
    initial_size_nm=85,
    pdi=0.08
)

# Run accelerated stability study
stability_results = liposome.accelerated_stability_study(
    temps=[5, 25, 40],
    duration_days=90
)

# Predict shelf life (specification: <120 nm, PDI <0.2)
shelf_life = liposome.predict_shelf_life(
    max_size_nm=120,
    max_pdi=0.2,
    storage_temp=5
)

print(f"Formulation: {liposome.particle_type} - {liposome.drug_name}")
print(f"Initial: {liposome.initial_size} nm, PDI {liposome.initial_pdi}")
print(f"Predicted Shelf Life at 5°C: {shelf_life} days ({shelf_life/30:.1f} months)")

# Plot stability data
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

colors = {5: 'blue', 25: 'orange', 40: 'red'}
for temp, data in stability_results.items():
    axes[0].plot(data['time_days'], data['size_nm'],
                 color=colors[temp], label=f'{temp}°C')
    axes[1].plot(data['time_days'], data['pdi'],
                 color=colors[temp], label=f'{temp}°C')

axes[0].axhline(y=120, color='gray', linestyle='--', label='Specification')
axes[0].set_xlabel('Time (days)')
axes[0].set_ylabel('Particle Size (nm)')
axes[0].set_title('Size Stability')
axes[0].legend()

axes[1].axhline(y=0.2, color='gray', linestyle='--', label='Specification')
axes[1].set_xlabel('Time (days)')
axes[1].set_ylabel('PDI')
axes[1].set_title('PDI Stability')
axes[1].legend()

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

5.3 Battery Materials

Lithium-ion batteries require precise control of electrode slurry properties. The dispersion of active materials, conductive additives, and binders directly impacts battery performance.

Electrode Slurry Components

Example 3: Battery Slurry Optimization

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# Example 3: Battery Electrode Slurry
# ===================================

class BatterySlurryOptimizer:
    """Optimize electrode slurry for Li-ion batteries."""

    def __init__(self, electrode_type='cathode'):
        self.electrode_type = electrode_type
        self.viscosity_model = 'Cross'  # Shear-thinning model

    def calculate_viscosity(self, solid_loading, shear_rate,
                           dispersant_conc=0, temp_C=25):
        """
        Calculate slurry viscosity using Cross model.
        η = η_∞ + (η_0 - η_∞) / (1 + (λγ̇)^n)
        """
        # Parameters depend on solid loading and formulation
        eta_0 = 10 * np.exp(5 * solid_loading)  # Zero-shear viscosity
        eta_inf = 0.5  # Infinite-shear viscosity
        lambda_param = 10 * (1 - 0.5 * dispersant_conc / 0.02)
        n = 0.6

        # Temperature correction
        T_factor = np.exp(2000 * (1/(temp_C + 273) - 1/298))

        eta = eta_inf + (eta_0 - eta_inf) / (1 + (lambda_param * shear_rate) ** n)

        return eta * T_factor

    def coating_window(self, solid_loading, target_thickness_um=100):
        """Determine coating process window."""

        # Calculate viscosity at coating shear rate (~1000 s⁻¹)
        eta_coating = self.calculate_viscosity(solid_loading, 1000)

        # Calculate viscosity at rest (~0.1 s⁻¹) for leveling
        eta_rest = self.calculate_viscosity(solid_loading, 0.1)

        # Thixotropic ratio indicates processing behavior
        thixotropic_ratio = eta_rest / eta_coating

        # Coating quality indicators
        results = {
            'viscosity_coating_Pa_s': eta_coating,
            'viscosity_rest_Pa_s': eta_rest,
            'thixotropic_ratio': thixotropic_ratio,
            'coating_quality': 'Good' if 5 < thixotropic_ratio < 20 else 'Poor',
            'leveling': 'Good' if eta_rest < 50 else 'Poor',
            'edge_definition': 'Good' if thixotropic_ratio > 8 else 'Poor'
        }

        return results

    def optimize_formulation(self, target_capacity_mAh_g=180):
        """Find optimal solid loading and mixing parameters."""

        results = []
        solid_loadings = np.linspace(0.45, 0.75, 20)

        for solid in solid_loadings:
            coating = self.coating_window(solid)

            # Estimate capacity based on loading (simplified)
            # Higher solid loading = higher capacity but processing challenges
            if coating['coating_quality'] == 'Good':
                capacity = target_capacity_mAh_g * (solid / 0.6)
                efficiency = 0.95 if solid < 0.65 else 0.90
            else:
                capacity = target_capacity_mAh_g * (solid / 0.6) * 0.85
                efficiency = 0.85

            results.append({
                'solid_loading': solid,
                'capacity_mAh_g': capacity * efficiency,
                'viscosity_Pa_s': coating['viscosity_coating_Pa_s'],
                'coating_quality': coating['coating_quality'],
                'processability': 1/coating['viscosity_coating_Pa_s'] * coating['thixotropic_ratio']
            })

        return results

    def mixing_protocol(self, solid_loading, batch_size_kg=10):
        """Generate mixing protocol for electrode slurry."""

        if self.electrode_type == 'cathode':
            protocol = {
                'step1': {
                    'description': 'Dissolve PVDF in NMP',
                    'time_min': 30,
                    'speed_rpm': 500,
                    'temperature_C': 25
                },
                'step2': {
                    'description': 'Add conductive additive, mix',
                    'time_min': 60,
                    'speed_rpm': 1000,
                    'temperature_C': 25
                },
                'step3': {
                    'description': 'Add active material gradually',
                    'time_min': 120,
                    'speed_rpm': 1500,
                    'temperature_C': 25
                },
                'step4': {
                    'description': 'High-shear mixing',
                    'time_min': 30,
                    'speed_rpm': 3000,
                    'temperature_C': '<40'
                },
                'step5': {
                    'description': 'Deaeration',
                    'time_min': 30,
                    'pressure_mbar': 50,
                    'speed_rpm': 100
                }
            }
        else:  # Anode
            protocol = {
                'step1': {
                    'description': 'Dissolve CMC in water',
                    'time_min': 60,
                    'speed_rpm': 500,
                    'temperature_C': 25
                },
                'step2': {
                    'description': 'Add graphite, planetary mixing',
                    'time_min': 90,
                    'speed_rpm': 1000,
                    'temperature_C': 25
                },
                'step3': {
                    'description': 'Add SBR latex',
                    'time_min': 30,
                    'speed_rpm': 500,
                    'temperature_C': 25
                },
                'step4': {
                    'description': 'Deaeration',
                    'time_min': 30,
                    'pressure_mbar': 50,
                    'speed_rpm': 100
                }
            }

        return protocol

# Example: Cathode slurry optimization for NMC811
cathode_optimizer = BatterySlurryOptimizer('cathode')

# Find optimal formulation
optimization_results = cathode_optimizer.optimize_formulation(target_capacity_mAh_g=200)

# Plot results
fig, axes = plt.subplots(1, 2, figsize=(12, 5))

solids = [r['solid_loading'] for r in optimization_results]
capacities = [r['capacity_mAh_g'] for r in optimization_results]
viscosities = [r['viscosity_Pa_s'] for r in optimization_results]

# Color by coating quality
colors = ['green' if r['coating_quality'] == 'Good' else 'red'
          for r in optimization_results]

axes[0].scatter(solids, capacities, c=colors, s=100)
axes[0].set_xlabel('Solid Loading (wt fraction)')
axes[0].set_ylabel('Effective Capacity (mAh/g)')
axes[0].set_title('Capacity vs Solid Loading')
axes[0].axhline(y=190, color='gray', linestyle='--', label='Target')
axes[0].legend()

axes[1].scatter(solids, viscosities, c=colors, s=100)
axes[1].set_xlabel('Solid Loading (wt fraction)')
axes[1].set_ylabel('Coating Viscosity (Pa·s)')
axes[1].set_title('Viscosity vs Solid Loading')
axes[1].axhline(y=5, color='gray', linestyle='--', label='Max processable')
axes[1].legend()

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

# Generate mixing protocol
protocol = cathode_optimizer.mixing_protocol(solid_loading=0.60)
print("\nMixing Protocol for NMC811 Cathode Slurry:")
for step, details in protocol.items():
    print(f"\n{step}: {details['description']}")
    for key, value in details.items():
        if key != 'description':
            print(f"  {key}: {value}")

5.4 Catalysts

Heterogeneous catalysts rely on high surface area nanoparticles dispersed on supports. Particle size, distribution, and dispersion stability during preparation are critical for catalytic activity.

Supported Catalyst Preparation

Example 4: Catalyst Particle Size Distribution

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

# ===================================
# Example 4: Catalyst Nanoparticle Analysis
# ===================================

class CatalystDesigner:
    """Design and analyze supported catalyst nanoparticles."""

    def __init__(self, metal, support, loading_wt_pct):
        self.metal = metal
        self.support = support
        self.loading = loading_wt_pct

        # Metal properties
        self.metal_props = {
            'Pt': {'density': 21.45, 'molar_mass': 195.08, 'surface_atoms_per_nm2': 12.5},
            'Pd': {'density': 12.02, 'molar_mass': 106.42, 'surface_atoms_per_nm2': 12.7},
            'Au': {'density': 19.30, 'molar_mass': 196.97, 'surface_atoms_per_nm2': 11.5},
            'Ni': {'density': 8.91, 'molar_mass': 58.69, 'surface_atoms_per_nm2': 15.4},
            'Cu': {'density': 8.96, 'molar_mass': 63.55, 'surface_atoms_per_nm2': 14.6}
        }

    def calculate_dispersion(self, particle_size_nm):
        """Calculate metal dispersion (fraction of surface atoms)."""
        # Cubic approximation: D ≈ 6 * v_m / (d * a_m)
        # Simplified formula for spherical particles
        if self.metal in self.metal_props:
            # Empirical correlation for fcc metals
            d = particle_size_nm
            dispersion = min(1.0, 1.1 / d)
            return dispersion
        return 0.5

    def calculate_TOF(self, rate_mol_s_g, particle_size_nm):
        """Calculate turnover frequency from reaction rate."""
        dispersion = self.calculate_dispersion(particle_size_nm)

        props = self.metal_props.get(self.metal, {'molar_mass': 100})
        n_surface = (self.loading / 100) / props['molar_mass'] * dispersion

        if n_surface > 0:
            tof = rate_mol_s_g / n_surface
        else:
            tof = 0

        return tof

    def size_activity_relationship(self, sizes_nm, reaction_type='structure_sensitive'):
        """Model size-dependent catalytic activity."""

        activities = []
        for size in sizes_nm:
            dispersion = self.calculate_dispersion(size)

            if reaction_type == 'structure_insensitive':
                # Activity proportional to surface area only
                activity = dispersion
            elif reaction_type == 'structure_sensitive':
                # Optimal size exists (e.g., around 3-5 nm for many reactions)
                optimal_size = 4.0
                activity = dispersion * np.exp(-0.5 * ((size - optimal_size) / 2) ** 2)
            elif reaction_type == 'demanding':
                # Requires specific sites, larger particles better
                activity = dispersion * (1 - np.exp(-size / 3))

            activities.append(activity)

        return np.array(activities)

    def simulate_preparation(self, method='impregnation',
                            support_area_m2_g=200,
                            calcination_temp_C=500):
        """Simulate catalyst preparation and predict particle size."""

        # Estimate particle size based on preparation conditions
        if method == 'impregnation':
            # Size depends on loading and support area
            d_mean = 2.5 + 10 * self.loading / support_area_m2_g
            sigma = 0.4  # Log-normal sigma

        elif method == 'deposition_precipitation':
            # Better size control
            d_mean = 3.0
            sigma = 0.3

        elif method == 'colloidal':
            # Best size control
            d_mean = 3.5
            sigma = 0.2

        # Temperature effect (sintering)
        if calcination_temp_C > 400:
            d_mean *= 1 + 0.002 * (calcination_temp_C - 400)
            sigma *= 1 + 0.001 * (calcination_temp_C - 400)

        return d_mean, sigma

    def generate_size_distribution(self, d_mean, sigma, n_particles=1000):
        """Generate particle size distribution."""
        sizes = lognorm.rvs(sigma, scale=d_mean, size=n_particles)
        return sizes

# Example: Pt/Al2O3 catalyst for hydrogenation
catalyst = CatalystDesigner('Pt', 'Al2O3', loading_wt_pct=1.0)

# Compare preparation methods
methods = ['impregnation', 'deposition_precipitation', 'colloidal']
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

colors = ['blue', 'green', 'red']
for method, color in zip(methods, colors):
    d_mean, sigma = catalyst.simulate_preparation(
        method=method,
        support_area_m2_g=200,
        calcination_temp_C=450
    )
    sizes = catalyst.generate_size_distribution(d_mean, sigma)

    axes[0, 0].hist(sizes, bins=30, alpha=0.5, color=color,
                    label=f'{method} (d={d_mean:.1f} nm)')

    print(f"\n{method}:")
    print(f"  Mean size: {d_mean:.2f} nm")
    print(f"  Dispersion: {catalyst.calculate_dispersion(d_mean)*100:.1f}%")

axes[0, 0].set_xlabel('Particle Size (nm)')
axes[0, 0].set_ylabel('Count')
axes[0, 0].set_title('Size Distribution by Preparation Method')
axes[0, 0].legend()

# Size-activity relationship
sizes = np.linspace(1, 15, 100)
for reaction, style in [('structure_insensitive', '-'),
                        ('structure_sensitive', '--'),
                        ('demanding', ':')]:
    activity = catalyst.size_activity_relationship(sizes, reaction)
    axes[0, 1].plot(sizes, activity, style, linewidth=2, label=reaction)

axes[0, 1].set_xlabel('Particle Size (nm)')
axes[0, 1].set_ylabel('Relative Activity')
axes[0, 1].set_title('Size-Activity Relationships')
axes[0, 1].legend()

# Effect of calcination temperature
calc_temps = [350, 450, 550, 650]
for temp in calc_temps:
    d_mean, sigma = catalyst.simulate_preparation(
        method='impregnation',
        calcination_temp_C=temp
    )
    disp = catalyst.calculate_dispersion(d_mean)
    axes[1, 0].scatter(temp, d_mean, s=100, label=f'{temp}°C')
    axes[1, 1].scatter(temp, disp * 100, s=100)

axes[1, 0].set_xlabel('Calcination Temperature (°C)')
axes[1, 0].set_ylabel('Mean Particle Size (nm)')
axes[1, 0].set_title('Sintering Effect')

axes[1, 1].set_xlabel('Calcination Temperature (°C)')
axes[1, 1].set_ylabel('Metal Dispersion (%)')
axes[1, 1].set_title('Dispersion vs Temperature')

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

5.5 Nanocomposites

Polymer nanocomposites combine the processability of polymers with the exceptional properties of nanofillers. Achieving uniform dispersion is the primary challenge.

Filler Types and Functions

Example 5: Nanocomposite Property Prediction

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# Example 5: Nanocomposite Properties
# ===================================

class NanocompositeDesigner:
    """Predict properties of polymer nanocomposites."""

    def __init__(self, polymer_matrix, filler_type):
        self.matrix = polymer_matrix
        self.filler = filler_type

        # Matrix properties
        self.matrix_props = {
            'PP': {'E': 1.5, 'sigma': 35, 'epsilon': 400, 'Tg': -10},
            'PA6': {'E': 2.8, 'sigma': 80, 'epsilon': 50, 'Tg': 50},
            'HDPE': {'E': 1.0, 'sigma': 25, 'epsilon': 800, 'Tg': -120},
            'Epoxy': {'E': 3.0, 'sigma': 70, 'epsilon': 5, 'Tg': 120}
        }

        # Filler properties
        self.filler_props = {
            'MMT': {'E': 178, 'aspect_ratio': 100, 'surface_area': 750},
            'CNT': {'E': 1000, 'aspect_ratio': 1000, 'surface_area': 200},
            'Graphene': {'E': 1000, 'aspect_ratio': 500, 'surface_area': 2630},
            'SiO2': {'E': 70, 'aspect_ratio': 1, 'surface_area': 200},
            'TiO2': {'E': 230, 'aspect_ratio': 1, 'surface_area': 50}
        }

    def halpin_tsai_modulus(self, vol_frac, dispersion_factor=1.0):
        """
        Calculate composite modulus using Halpin-Tsai equation.
        E_c = E_m * (1 + ξηφ) / (1 - ηφ)
        """
        E_m = self.matrix_props[self.matrix]['E']
        E_f = self.filler_props[self.filler]['E']
        AR = self.filler_props[self.filler]['aspect_ratio']

        # Shape factor
        xi = 2 * AR * dispersion_factor

        # Efficiency factor
        eta = (E_f / E_m - 1) / (E_f / E_m + xi)

        # Composite modulus
        E_c = E_m * (1 + xi * eta * vol_frac) / (1 - eta * vol_frac)

        return E_c

    def percolation_conductivity(self, vol_frac, phi_c=0.01, sigma_f=1e4):
        """Calculate electrical conductivity using percolation theory."""
        if vol_frac < phi_c:
            return 1e-14  # Insulating
        else:
            t = 2.0  # Universal exponent for 3D
            sigma = sigma_f * (vol_frac - phi_c) ** t
            return min(sigma, sigma_f)

    def barrier_improvement(self, vol_frac, dispersion_factor=1.0):
        """Calculate gas barrier improvement using Nielsen model."""
        AR = self.filler_props[self.filler]['aspect_ratio']

        # Effective aspect ratio depends on dispersion
        AR_eff = AR * dispersion_factor

        # Tortuosity factor
        tau = 1 + AR_eff * vol_frac / 2

        # Relative permeability (1 = no improvement)
        P_rel = (1 - vol_frac) / tau

        # Barrier improvement factor
        BIF = 1 / P_rel

        return BIF

    def dispersion_quality_model(self, mixing_energy_kJ_kg,
                                  surfactant_conc=0,
                                  compatibility='poor'):
        """Estimate dispersion quality from processing parameters."""

        # Base dispersion from mixing energy
        base_dispersion = 1 - np.exp(-mixing_energy_kJ_kg / 500)

        # Surfactant/compatibilizer effect
        surfactant_boost = 0.3 * surfactant_conc / 0.02

        # Compatibility factor
        compat_factor = {'poor': 0.5, 'moderate': 0.75, 'good': 1.0}

        dispersion = base_dispersion * compat_factor.get(compatibility, 0.5) + surfactant_boost

        return min(1.0, max(0.1, dispersion))

    def predict_properties(self, wt_frac, processing_params):
        """Predict composite properties for given formulation."""

        # Convert weight fraction to volume fraction
        rho_m = 1.0  # g/cm³ approximate
        rho_f = 2.5  # g/cm³ approximate for most fillers
        vol_frac = (wt_frac / rho_f) / (wt_frac / rho_f + (1 - wt_frac) / rho_m)

        # Calculate dispersion quality
        disp = self.dispersion_quality_model(**processing_params)

        # Calculate properties
        properties = {
            'vol_frac': vol_frac,
            'dispersion': disp,
            'modulus_GPa': self.halpin_tsai_modulus(vol_frac, disp),
            'modulus_improvement': self.halpin_tsai_modulus(vol_frac, disp) / \
                                  self.matrix_props[self.matrix]['E'],
            'barrier_factor': self.barrier_improvement(vol_frac, disp),
        }

        if self.filler in ['CNT', 'Graphene']:
            properties['conductivity_S_m'] = self.percolation_conductivity(vol_frac)

        return properties

# Example: PP/Nanoclay nanocomposite
composite = NanocompositeDesigner('PP', 'MMT')

# Compare dispersion quality effects
loadings = np.linspace(0.01, 0.10, 20)  # 1-10 wt%

fig, axes = plt.subplots(1, 3, figsize=(15, 5))

for disp_quality, color in [('poor', 'red'), ('moderate', 'orange'), ('good', 'green')]:
    moduli = []
    barriers = []

    for wt in loadings:
        props = composite.predict_properties(wt, {
            'mixing_energy_kJ_kg': 300 if disp_quality == 'poor' else 600 if disp_quality == 'moderate' else 1000,
            'surfactant_conc': 0 if disp_quality == 'poor' else 0.01 if disp_quality == 'moderate' else 0.02,
            'compatibility': disp_quality
        })
        moduli.append(props['modulus_improvement'])
        barriers.append(props['barrier_factor'])

    axes[0].plot(loadings * 100, moduli, color=color, linewidth=2, label=f'{disp_quality} dispersion')
    axes[1].plot(loadings * 100, barriers, color=color, linewidth=2, label=f'{disp_quality} dispersion')

axes[0].set_xlabel('Filler Loading (wt%)')
axes[0].set_ylabel('Modulus Improvement Factor')
axes[0].set_title('Mechanical Reinforcement')
axes[0].legend()
axes[0].axhline(y=1, color='gray', linestyle='--')

axes[1].set_xlabel('Filler Loading (wt%)')
axes[1].set_ylabel('Barrier Improvement Factor')
axes[1].set_title('Gas Barrier Enhancement')
axes[1].legend()
axes[1].axhline(y=1, color='gray', linestyle='--')

# CNT percolation
cnt_composite = NanocompositeDesigner('Epoxy', 'CNT')
cnt_loadings = np.linspace(0.001, 0.05, 100)
conductivities = [cnt_composite.percolation_conductivity(v) for v in cnt_loadings]

axes[2].semilogy(cnt_loadings * 100, conductivities, 'b-', linewidth=2)
axes[2].axvline(x=1.0, color='red', linestyle='--', label='Percolation threshold')
axes[2].set_xlabel('CNT Loading (vol%)')
axes[2].set_ylabel('Electrical Conductivity (S/m)')
axes[2].set_title('Percolation Behavior (CNT/Epoxy)')
axes[2].legend()

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

5.6 Scale-Up Challenges

Transitioning nanoparticle dispersion processes from laboratory to industrial scale presents unique challenges related to mixing, heat transfer, and process control.

Scale-Up Considerations

Example 6: Scale-Up Analysis Tool

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# Example 6: Scale-Up Analysis
# ===================================

class ScaleUpAnalyzer:
    """Analyze scale-up challenges for nanoparticle dispersion processes."""

    def __init__(self, process_type='ultrasonication'):
        self.process_type = process_type

    def power_scaling(self, lab_volume_L, lab_power_W, target_volume_L,
                      scaling_exponent=0.67):
        """
        Calculate power requirement for scale-up.
        For geometric similarity: P/V = constant (exponent = 1.0)
        For tip speed similarity: P ∝ V^0.67
        """
        power_ratio = (target_volume_L / lab_volume_L) ** scaling_exponent
        target_power = lab_power_W * power_ratio

        # Specific power (W/L)
        lab_specific = lab_power_W / lab_volume_L
        target_specific = target_power / target_volume_L

        return {
            'target_power_W': target_power,
            'target_power_kW': target_power / 1000,
            'lab_specific_power_W_L': lab_specific,
            'target_specific_power_W_L': target_specific,
            'power_ratio': power_ratio
        }

    def mixing_time_scaling(self, lab_time_min, lab_volume_L,
                            target_volume_L, mixing_type='turbulent'):
        """Scale mixing time based on dimensionless analysis."""

        if mixing_type == 'turbulent':
            # Blend time ∝ V^(1/3) at constant N*D²
            time_ratio = (target_volume_L / lab_volume_L) ** (1/3)
        elif mixing_type == 'laminar':
            # Blend time ∝ V^(2/3)
            time_ratio = (target_volume_L / lab_volume_L) ** (2/3)
        else:
            time_ratio = 1.0

        target_time = lab_time_min * time_ratio

        return {
            'target_time_min': target_time,
            'time_ratio': time_ratio,
            'productivity_factor': target_volume_L / target_time
        }

    def heat_transfer_analysis(self, lab_volume_L, target_volume_L,
                               heat_generation_W_L, cooling_capacity_W_m2_K):
        """Analyze heat removal challenges at scale."""

        # Surface area to volume ratio decreases with scale
        # Assuming cylindrical geometry with H/D = 1
        lab_diameter = (4 * lab_volume_L / np.pi) ** (1/3)
        target_diameter = (4 * target_volume_L / np.pi) ** (1/3)

        lab_SA_V = 6 / lab_diameter  # Surface area to volume (m²/L)
        target_SA_V = 6 / target_diameter

        # Maximum temperature rise
        delta_T_lab = heat_generation_W_L / (lab_SA_V * cooling_capacity_W_m2_K)
        delta_T_target = heat_generation_W_L / (target_SA_V * cooling_capacity_W_m2_K)

        return {
            'lab_SA_V_m2_L': lab_SA_V,
            'target_SA_V_m2_L': target_SA_V,
            'SA_V_ratio': target_SA_V / lab_SA_V,
            'lab_delta_T_C': delta_T_lab,
            'target_delta_T_C': delta_T_target,
            'cooling_challenge': 'High' if delta_T_target > 20 else
                                'Moderate' if delta_T_target > 10 else 'Low'
        }

    def cost_analysis(self, lab_params, production_volume_L_day):
        """Estimate production costs at scale."""

        # Capital costs (simplified model)
        equipment_cost = 50000 * (production_volume_L_day / 100) ** 0.6

        # Operating costs
        energy_cost_kWh = 0.10  # $/kWh
        power_kW = lab_params['power_W'] * (production_volume_L_day / lab_params['volume_L']) ** 0.67 / 1000
        energy_cost_day = power_kW * 8 * energy_cost_kWh  # 8 hour operation

        # Material costs (surfactant, dispersant)
        material_cost_L = 5.0  # $/L
        material_cost_day = material_cost_L * production_volume_L_day * 0.02  # 2% additives

        # Labor
        labor_cost_day = 200  # $/day

        total_operating_day = energy_cost_day + material_cost_day + labor_cost_day

        # Cost per liter
        cost_per_L = total_operating_day / production_volume_L_day

        return {
            'equipment_cost_USD': equipment_cost,
            'energy_cost_day_USD': energy_cost_day,
            'material_cost_day_USD': material_cost_day,
            'labor_cost_day_USD': labor_cost_day,
            'total_operating_day_USD': total_operating_day,
            'cost_per_L_USD': cost_per_L
        }

    def environmental_assessment(self, production_volume_L_day,
                                 solvent_type='water',
                                 energy_kWh_L=0.5):
        """Assess environmental impact of production."""

        # CO2 emissions from energy (assuming grid electricity)
        co2_kg_kWh = 0.5  # kg CO2 per kWh (varies by region)
        energy_daily = production_volume_L_day * energy_kWh_L
        co2_daily = energy_daily * co2_kg_kWh

        # Solvent considerations
        solvent_impact = {
            'water': {'voc': 0, 'toxicity': 'None', 'recyclability': 'Easy'},
            'NMP': {'voc': 'Low', 'toxicity': 'Moderate', 'recyclability': 'Moderate'},
            'ethanol': {'voc': 'Moderate', 'toxicity': 'Low', 'recyclability': 'Easy'},
            'toluene': {'voc': 'High', 'toxicity': 'High', 'recyclability': 'Moderate'}
        }

        return {
            'energy_kWh_day': energy_daily,
            'co2_emissions_kg_day': co2_daily,
            'co2_emissions_kg_L': co2_daily / production_volume_L_day,
            'solvent_profile': solvent_impact.get(solvent_type, {}),
            'environmental_rating': 'Good' if solvent_type == 'water' and energy_kWh_L < 0.3 else
                                   'Moderate' if solvent_type in ['water', 'ethanol'] else 'Poor'
        }

# Example: Scale-up analysis for coating dispersion
analyzer = ScaleUpAnalyzer('bead_mill')

# Lab parameters
lab_params = {
    'volume_L': 0.5,
    'power_W': 500,
    'time_min': 30
}

# Scale-up targets
scales = [0.5, 5, 50, 500, 5000]  # L

print("Scale-Up Analysis for Nanoparticle Dispersion")
print("=" * 60)

results = []
for scale in scales:
    power = analyzer.power_scaling(lab_params['volume_L'],
                                    lab_params['power_W'], scale)
    time = analyzer.mixing_time_scaling(lab_params['time_min'],
                                         lab_params['volume_L'], scale)
    heat = analyzer.heat_transfer_analysis(lab_params['volume_L'], scale,
                                           1000, 500)  # W/L, W/m²K

    results.append({
        'scale_L': scale,
        'power_kW': power['target_power_kW'],
        'specific_power_W_L': power['target_specific_power_W_L'],
        'time_min': time['target_time_min'],
        'delta_T_C': heat['target_delta_T_C'],
        'cooling_challenge': heat['cooling_challenge']
    })

    print(f"\nScale: {scale} L")
    print(f"  Power: {power['target_power_kW']:.1f} kW ({power['target_specific_power_W_L']:.0f} W/L)")
    print(f"  Time: {time['target_time_min']:.0f} min")
    print(f"  ΔT: {heat['target_delta_T_C']:.1f}°C ({heat['cooling_challenge']})")

# Plot results
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

scales_arr = np.array([r['scale_L'] for r in results])
powers = np.array([r['power_kW'] for r in results])
specific_powers = np.array([r['specific_power_W_L'] for r in results])
times = np.array([r['time_min'] for r in results])
delta_Ts = np.array([r['delta_T_C'] for r in results])

axes[0, 0].loglog(scales_arr, powers, 'bo-', linewidth=2, markersize=10)
axes[0, 0].set_xlabel('Batch Volume (L)')
axes[0, 0].set_ylabel('Power Requirement (kW)')
axes[0, 0].set_title('Power Scale-Up')
axes[0, 0].grid(True, alpha=0.3)

axes[0, 1].semilogx(scales_arr, specific_powers, 'go-', linewidth=2, markersize=10)
axes[0, 1].set_xlabel('Batch Volume (L)')
axes[0, 1].set_ylabel('Specific Power (W/L)')
axes[0, 1].set_title('Specific Power vs Scale')
axes[0, 1].grid(True, alpha=0.3)

axes[1, 0].semilogx(scales_arr, times, 'ro-', linewidth=2, markersize=10)
axes[1, 0].set_xlabel('Batch Volume (L)')
axes[1, 0].set_ylabel('Processing Time (min)')
axes[1, 0].set_title('Time Scale-Up')
axes[1, 0].grid(True, alpha=0.3)

colors = ['green' if r['cooling_challenge'] == 'Low' else
          'orange' if r['cooling_challenge'] == 'Moderate' else 'red'
          for r in results]
axes[1, 1].scatter(scales_arr, delta_Ts, c=colors, s=200)
axes[1, 1].set_xscale('log')
axes[1, 1].set_xlabel('Batch Volume (L)')
axes[1, 1].set_ylabel('Temperature Rise (°C)')
axes[1, 1].set_title('Heat Transfer Challenge')
axes[1, 1].axhline(y=10, color='orange', linestyle='--', label='Moderate')
axes[1, 1].axhline(y=20, color='red', linestyle='--', label='High')
axes[1, 1].legend()
axes[1, 1].grid(True, alpha=0.3)

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

# Cost analysis for production scale
print("\n" + "=" * 60)
print("Production Cost Analysis (500 L/day)")
costs = analyzer.cost_analysis(lab_params, 500)
for key, value in costs.items():
    if 'USD' in key:
        print(f"  {key}: ${value:.2f}")

# Environmental assessment
print("\nEnvironmental Assessment:")
env = analyzer.environmental_assessment(500, 'water', 0.4)
print(f"  Energy: {env['energy_kWh_day']:.0f} kWh/day")
print(f"  CO2: {env['co2_emissions_kg_day']:.1f} kg/day")
print(f"  Rating: {env['environmental_rating']}")

Summary and Key Takeaways

Conclusion

Successful industrial application of nanoparticle dispersion technology requires:

1. Understanding fundamentals (Chapters 1-2): Know the forces driving agglomeration
2. Selecting appropriate techniques (Chapter 3): Match dispersion method to application
3. Validating stability (Chapter 4): Use multiple characterization techniques
4. Addressing scale-up challenges (this chapter): Plan for manufacturing from the start

The field continues to evolve with advances in characterization techniques, machine learning optimization, and sustainable processing methods. Success requires balancing performance targets with cost, safety, and environmental considerations.

Exercises

Further Reading