第5章: 産業応用と事例研究

5.1 塗料・コーティング

コーティング産業は、ナノ粒子分散技術の最大の応用分野の一つです。顔料分散の品質は、着色力、光沢、隠蔽力、耐久性に直接影響します。

顔料分散の基礎

例1: コーティング配合最適化

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

# ===================================
# 例1: コーティング配合最適化
# ===================================

class CoatingFormulator:
    """コーティング用途の顔料分散を最適化するクラス。"""

    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):
        """配合パラメータからコーティング特性を予測。"""

        # 業界相関に基づく簡略化モデル
        # 粒子サイズはミリング時間と小さいビーズで減少
        d50 = 500 * np.exp(-0.1 * milling_time) * (bead_size / 0.5) ** 0.3

        # 着色力は分散品質で向上
        # 最適な分散剤濃度で最大の強度を発揮
        color_strength = 100 * (1 - np.exp(-2 * dispersant_conc)) * \
                        np.exp(-0.5 * (dispersant_conc - 0.03) ** 2 / 0.01)

        # 光沢は粒子サイズとバインダー量に依存
        gloss = 95 * np.exp(-d50 / 500) * (1 - np.exp(-binder_conc / 0.3))

        # DLVOライクな相互作用からの安定性
        # 分散剤が高いほど安定性が向上（ある点まで）
        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):
        """多目的最適化関数。"""
        dispersant, binder, time, beads = params
        props = self.calculate_properties(dispersant, binder, time, beads)

        # 目標値からの偏差に対する重み付きペナルティ
        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

        # コスト項を追加（分散剤とミリング時間は高コスト）
        cost = 100 * dispersant + 0.5 * time + 50 * (0.5 - beads) ** 2

        return penalty + cost

    def optimize(self):
        """最適な配合パラメータを探索。"""
        # パラメータ境界: [分散剤%, バインダー%, ミリング時間h, ビーズサイズ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

# 例: 自動車用コーティングの最適化
targets = {
    'd50_nm': 150,
    'color_strength': 100,
    'gloss_GU': 85,
    'stability_months': 24
}

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

print("最適配合パラメータ:")
print(f"  分散剤: {optimal_params['dispersant_conc']*100:.1f}%")
print(f"  バインダー: {optimal_params['binder_conc']*100:.1f}%")
print(f"  ミリング時間: {optimal_params['milling_time_h']:.1f} 時間")
print(f"  ビーズサイズ: {optimal_params['bead_size_mm']:.2f} mm")
print("\n予測特性:")
for key, value in predicted_props.items():
    print(f"  {key}: {value:.1f}")

機能性ナノコーティング

従来の顔料に加えて、ナノ粒子は特殊な特性を持つ機能性コーティングを可能にします：

5.2 医薬品とドラッグデリバリー

ナノテクノロジーは、標的療法、バイオアベイラビリティの向上、徐放を可能にすることで、ドラッグデリバリーに革命をもたらしました。分散安定性は有効性と安全性の両方に重要です。

ナノ粒子ドラッグデリバリーシステム

例2: 医薬品ナノ粒子安定性モデル

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# 例2: 医薬品ナノ粒子安定性
# ===================================

class PharmaNanoparticle:
    """医薬品ナノ粒子製剤の安定性をモデル化するクラス。"""

    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):
        """アレニウス式を用いて分解速度を計算。"""
        R = 8.314e-3  # kJ/(mol·K)
        T = temp_C + 273.15
        T_ref = 298.15  # 25°C 基準

        k_ref = 0.001  # 基準速度定数 (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):
        """オストワルド熟成と凝集による粒子サイズ成長を予測。"""

        # オストワルド熟成: r³ - r₀³ = kt (LSW理論)
        k_ostwald = 0.1 * (temp_C / 25) ** 2 * (1 + ionic_strength)

        # 凝集の寄与（DLVOベース）
        if ionic_strength > 0.2:
            k_agg = 0.05 * (ionic_strength - 0.15)
        else:
            k_agg = 0

        # 複合成長
        size_cubed = self.initial_size ** 3 + k_ostwald * time_days
        size_from_ostwald = size_cubed ** (1/3)

        # 凝集の寄与を追加
        final_size = size_from_ostwald * (1 + k_agg * time_days / 100)

        return final_size

    def predict_pdi_change(self, time_days, temp_C):
        """時間経過によるPDI変化を予測。"""
        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):
        """複数温度での加速安定性試験をシミュレート。"""

        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):
        """許容基準に基づいて有効期限を予測。"""

        time = 0
        while time < 1000:  # 最大1000日
            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

# 例: リポソームドキソルビシン製剤
liposome = PharmaNanoparticle(
    drug_name="ドキソルビシン",
    particle_type="PEG化リポソーム",
    initial_size_nm=85,
    pdi=0.08
)

# 加速安定性試験の実行
stability_results = liposome.accelerated_stability_study(
    temps=[5, 25, 40],
    duration_days=90
)

# 有効期限の予測（規格: <120 nm, PDI <0.2）
shelf_life = liposome.predict_shelf_life(
    max_size_nm=120,
    max_pdi=0.2,
    storage_temp=5
)

print(f"製剤: {liposome.particle_type} - {liposome.drug_name}")
print(f"初期値: {liposome.initial_size} nm, PDI {liposome.initial_pdi}")
print(f"5°Cでの予測有効期限: {shelf_life} 日 ({shelf_life/30:.1f} ヶ月)")

# 安定性データのプロット
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='規格')
axes[0].set_xlabel('時間（日）')
axes[0].set_ylabel('粒子サイズ (nm)')
axes[0].set_title('サイズ安定性')
axes[0].legend()

axes[1].axhline(y=0.2, color='gray', linestyle='--', label='規格')
axes[1].set_xlabel('時間（日）')
axes[1].set_ylabel('PDI')
axes[1].set_title('PDI安定性')
axes[1].legend()

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

5.3 電池材料

リチウムイオン電池は、電極スラリー特性の精密な制御が必要です。活物質、導電助剤、バインダーの分散は、電池性能に直接影響します。

電極スラリー成分

例3: 電池スラリー最適化

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# 例3: 電池電極スラリー
# ===================================

class BatterySlurryOptimizer:
    """リチウムイオン電池の電極スラリーを最適化するクラス。"""

    def __init__(self, electrode_type='cathode'):
        self.electrode_type = electrode_type
        self.viscosity_model = 'Cross'  # シェアシニングモデル

    def calculate_viscosity(self, solid_loading, shear_rate,
                           dispersant_conc=0, temp_C=25):
        """
        Crossモデルを用いてスラリー粘度を計算。
        η = η_∞ + (η_0 - η_∞) / (1 + (λγ̇)^n)
        """
        # パラメータは固形分濃度と配合に依存
        eta_0 = 10 * np.exp(5 * solid_loading)  # ゼロせん断粘度
        eta_inf = 0.5  # 無限せん断粘度
        lambda_param = 10 * (1 - 0.5 * dispersant_conc / 0.02)
        n = 0.6

        # 温度補正
        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):
        """コーティングプロセスウィンドウを決定。"""

        # コーティングせん断速度（〜1000 s⁻¹）での粘度を計算
        eta_coating = self.calculate_viscosity(solid_loading, 1000)

        # 静止時（〜0.1 s⁻¹）の粘度（レベリング用）
        eta_rest = self.calculate_viscosity(solid_loading, 0.1)

        # チキソトロピー比は加工性を示す
        thixotropic_ratio = eta_rest / eta_coating

        # コーティング品質指標
        results = {
            'viscosity_coating_Pa_s': eta_coating,
            'viscosity_rest_Pa_s': eta_rest,
            'thixotropic_ratio': thixotropic_ratio,
            'coating_quality': '良好' if 5 < thixotropic_ratio < 20 else '不良',
            'leveling': '良好' if eta_rest < 50 else '不良',
            'edge_definition': '良好' if thixotropic_ratio > 8 else '不良'
        }

        return results

    def optimize_formulation(self, target_capacity_mAh_g=180):
        """最適な固形分濃度と混合パラメータを探索。"""

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

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

            # 固形分濃度に基づく容量推定（簡略化）
            # 高い固形分濃度 = 高容量だが加工課題
            if coating['coating_quality'] == '良好':
                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):
        """電極スラリーの混合プロトコルを生成。"""

        if self.electrode_type == 'cathode':
            protocol = {
                'step1': {
                    'description': 'NMPにPVDFを溶解',
                    'time_min': 30,
                    'speed_rpm': 500,
                    'temperature_C': 25
                },
                'step2': {
                    'description': '導電助剤を添加、混合',
                    'time_min': 60,
                    'speed_rpm': 1000,
                    'temperature_C': 25
                },
                'step3': {
                    'description': '活物質を徐々に添加',
                    'time_min': 120,
                    'speed_rpm': 1500,
                    'temperature_C': 25
                },
                'step4': {
                    'description': '高せん断混合',
                    'time_min': 30,
                    'speed_rpm': 3000,
                    'temperature_C': '<40'
                },
                'step5': {
                    'description': '脱泡',
                    'time_min': 30,
                    'pressure_mbar': 50,
                    'speed_rpm': 100
                }
            }
        else:  # 負極
            protocol = {
                'step1': {
                    'description': '水にCMCを溶解',
                    'time_min': 60,
                    'speed_rpm': 500,
                    'temperature_C': 25
                },
                'step2': {
                    'description': 'グラファイトを添加、遊星混合',
                    'time_min': 90,
                    'speed_rpm': 1000,
                    'temperature_C': 25
                },
                'step3': {
                    'description': 'SBRラテックスを添加',
                    'time_min': 30,
                    'speed_rpm': 500,
                    'temperature_C': 25
                },
                'step4': {
                    'description': '脱泡',
                    'time_min': 30,
                    'pressure_mbar': 50,
                    'speed_rpm': 100
                }
            }

        return protocol

# 例: NMC811正極スラリーの最適化
cathode_optimizer = BatterySlurryOptimizer('cathode')

# 最適な配合を探索
optimization_results = cathode_optimizer.optimize_formulation(target_capacity_mAh_g=200)

# 結果のプロット
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]

# コーティング品質で色分け
colors = ['green' if r['coating_quality'] == '良好' else 'red'
          for r in optimization_results]

axes[0].scatter(solids, capacities, c=colors, s=100)
axes[0].set_xlabel('固形分濃度（重量分率）')
axes[0].set_ylabel('有効容量 (mAh/g)')
axes[0].set_title('容量 vs 固形分濃度')
axes[0].axhline(y=190, color='gray', linestyle='--', label='目標')
axes[0].legend()

axes[1].scatter(solids, viscosities, c=colors, s=100)
axes[1].set_xlabel('固形分濃度（重量分率）')
axes[1].set_ylabel('コーティング粘度 (Pa·s)')
axes[1].set_title('粘度 vs 固形分濃度')
axes[1].axhline(y=5, color='gray', linestyle='--', label='加工可能上限')
axes[1].legend()

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

# 混合プロトコルの生成
protocol = cathode_optimizer.mixing_protocol(solid_loading=0.60)
print("\nNMC811正極スラリーの混合プロトコル:")
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 触媒

不均一系触媒は、担体上に分散した高比表面積ナノ粒子に依存しています。触媒活性には、粒子サイズ、分布、および調製中の分散安定性が重要です。

担持触媒の調製

例4: 触媒粒子サイズ分布

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

# ===================================
# 例4: 触媒ナノ粒子解析
# ===================================

class CatalystDesigner:
    """担持触媒ナノ粒子の設計と解析を行うクラス。"""

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

        # 金属特性
        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):
        """金属分散度（表面原子の割合）を計算。"""
        # 立方体近似: D ≈ 6 * v_m / (d * a_m)
        # 球状粒子の簡略化公式
        if self.metal in self.metal_props:
            # fcc金属の経験的相関
            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):
        """反応速度からターンオーバー頻度を計算。"""
        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'):
        """サイズ依存触媒活性をモデル化。"""

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

            if reaction_type == 'structure_insensitive':
                # 活性は表面積のみに比例
                activity = dispersion
            elif reaction_type == 'structure_sensitive':
                # 最適サイズが存在（多くの反応で約3-5 nm）
                optimal_size = 4.0
                activity = dispersion * np.exp(-0.5 * ((size - optimal_size) / 2) ** 2)
            elif reaction_type == 'demanding':
                # 特定のサイトが必要、大きな粒子が有利
                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):
        """触媒調製をシミュレートし、粒子サイズを予測。"""

        # 調製条件に基づく粒子サイズの推定
        if method == 'impregnation':
            # サイズは担持量と担体面積に依存
            d_mean = 2.5 + 10 * self.loading / support_area_m2_g
            sigma = 0.4  # 対数正規分布のσ

        elif method == 'deposition_precipitation':
            # より良いサイズ制御
            d_mean = 3.0
            sigma = 0.3

        elif method == 'colloidal':
            # 最良のサイズ制御
            d_mean = 3.5
            sigma = 0.2

        # 温度効果（焼結）
        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):
        """粒子サイズ分布を生成。"""
        sizes = lognorm.rvs(sigma, scale=d_mean, size=n_particles)
        return sizes

# 例: 水素化反応用Pt/Al2O3触媒
catalyst = CatalystDesigner('Pt', 'Al2O3', loading_wt_pct=1.0)

# 調製法の比較
methods = ['impregnation', 'deposition_precipitation', 'colloidal']
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

colors = ['blue', 'green', 'red']
method_names = {'impregnation': '含浸法',
                'deposition_precipitation': '析出沈殿法',
                'colloidal': 'コロイド法'}

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_names[method]} (d={d_mean:.1f} nm)')

    print(f"\n{method_names[method]}:")
    print(f"  平均サイズ: {d_mean:.2f} nm")
    print(f"  分散度: {catalyst.calculate_dispersion(d_mean)*100:.1f}%")

axes[0, 0].set_xlabel('粒子サイズ (nm)')
axes[0, 0].set_ylabel('カウント')
axes[0, 0].set_title('調製法別サイズ分布')
axes[0, 0].legend()

# サイズ-活性関係
sizes = np.linspace(1, 15, 100)
reaction_names = {'structure_insensitive': '構造非感受性',
                  'structure_sensitive': '構造感受性',
                  'demanding': '要求性'}
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_names[reaction])

axes[0, 1].set_xlabel('粒子サイズ (nm)')
axes[0, 1].set_ylabel('相対活性')
axes[0, 1].set_title('サイズ-活性関係')
axes[0, 1].legend()

# 焼成温度の影響
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('焼成温度 (°C)')
axes[1, 0].set_ylabel('平均粒子サイズ (nm)')
axes[1, 0].set_title('焼結効果')

axes[1, 1].set_xlabel('焼成温度 (°C)')
axes[1, 1].set_ylabel('金属分散度 (%)')
axes[1, 1].set_title('分散度 vs 温度')

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

5.5 ナノコンポジット

ポリマーナノコンポジットは、ポリマーの加工性とナノフィラーの優れた特性を組み合わせます。均一な分散を達成することが主要な課題です。

フィラーの種類と機能

例5: ナノコンポジット物性予測

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# 例5: ナノコンポジット物性
# ===================================

class NanocompositeDesigner:
    """ポリマーナノコンポジットの物性を予測するクラス。"""

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

        # マトリックス特性
        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}
        }

        # フィラー特性
        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):
        """
        Halpin-Tsai式を用いて複合材弾性率を計算。
        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']

        # 形状係数
        xi = 2 * AR * dispersion_factor

        # 効率係数
        eta = (E_f / E_m - 1) / (E_f / E_m + xi)

        # 複合材弾性率
        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):
        """パーコレーション理論を用いて電気伝導率を計算。"""
        if vol_frac < phi_c:
            return 1e-14  # 絶縁性
        else:
            t = 2.0  # 3Dの普遍指数
            sigma = sigma_f * (vol_frac - phi_c) ** t
            return min(sigma, sigma_f)

    def barrier_improvement(self, vol_frac, dispersion_factor=1.0):
        """Nielsenモデルを用いてガスバリア性向上を計算。"""
        AR = self.filler_props[self.filler]['aspect_ratio']

        # 有効アスペクト比は分散状態に依存
        AR_eff = AR * dispersion_factor

        # 屈曲度因子
        tau = 1 + AR_eff * vol_frac / 2

        # 相対透過率（1 = 向上なし）
        P_rel = (1 - vol_frac) / tau

        # バリア向上係数
        BIF = 1 / P_rel

        return BIF

    def dispersion_quality_model(self, mixing_energy_kJ_kg,
                                  surfactant_conc=0,
                                  compatibility='poor'):
        """加工パラメータから分散品質を推定。"""

        # 混合エネルギーからの基本分散度
        base_dispersion = 1 - np.exp(-mixing_energy_kJ_kg / 500)

        # 界面活性剤/相溶化剤効果
        surfactant_boost = 0.3 * surfactant_conc / 0.02

        # 相溶性因子
        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):
        """与えられた配合の複合材物性を予測。"""

        # 重量分率を体積分率に変換
        rho_m = 1.0  # g/cm³ 近似
        rho_f = 2.5  # g/cm³ ほとんどのフィラーの近似
        vol_frac = (wt_frac / rho_f) / (wt_frac / rho_f + (1 - wt_frac) / rho_m)

        # 分散品質を計算
        disp = self.dispersion_quality_model(**processing_params)

        # 物性を計算
        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

# 例: PP/ナノクレイナノコンポジット
composite = NanocompositeDesigner('PP', 'MMT')

# 分散品質効果の比較
loadings = np.linspace(0.01, 0.10, 20)  # 1-10 wt%

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

disp_names = {'poor': '不良', 'moderate': '中程度', 'good': '良好'}
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_names[disp_quality]}分散')
    axes[1].plot(loadings * 100, barriers, color=color, linewidth=2, label=f'{disp_names[disp_quality]}分散')

axes[0].set_xlabel('フィラー添加量 (wt%)')
axes[0].set_ylabel('弾性率向上係数')
axes[0].set_title('機械的強化')
axes[0].legend()
axes[0].axhline(y=1, color='gray', linestyle='--')

axes[1].set_xlabel('フィラー添加量 (wt%)')
axes[1].set_ylabel('バリア向上係数')
axes[1].set_title('ガスバリア性向上')
axes[1].legend()
axes[1].axhline(y=1, color='gray', linestyle='--')

# CNTパーコレーション
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='パーコレーション閾値')
axes[2].set_xlabel('CNT添加量 (vol%)')
axes[2].set_ylabel('電気伝導率 (S/m)')
axes[2].set_title('パーコレーション挙動（CNT/エポキシ）')
axes[2].legend()

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

5.6 スケールアップの課題

ナノ粒子分散プロセスを実験室から工業スケールに移行する際には、混合、熱伝達、プロセス制御に関連する独自の課題があります。

スケールアップの考慮事項

例6: スケールアップ解析ツール

import numpy as np
import matplotlib.pyplot as plt

# ===================================
# 例6: スケールアップ解析
# ===================================

class ScaleUpAnalyzer:
    """ナノ粒子分散プロセスのスケールアップ課題を解析するクラス。"""

    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):
        """
        スケールアップの動力要件を計算。
        幾何学的相似: P/V = 一定 (指数 = 1.0)
        先端速度相似: P ∝ V^0.67
        """
        power_ratio = (target_volume_L / lab_volume_L) ** scaling_exponent
        target_power = lab_power_W * power_ratio

        # 比動力 (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'):
        """無次元解析に基づいて混合時間をスケーリング。"""

        if mixing_type == 'turbulent':
            # 混合時間 ∝ V^(1/3) (N*D²一定時)
            time_ratio = (target_volume_L / lab_volume_L) ** (1/3)
        elif mixing_type == 'laminar':
            # 混合時間 ∝ 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):
        """スケールにおける除熱課題を解析。"""

        # 表面積対体積比はスケールで減少
        # 円筒形状（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  # 表面積対体積 (m²/L)
        target_SA_V = 6 / target_diameter

        # 最大温度上昇
        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': '高' if delta_T_target > 20 else
                                '中' if delta_T_target > 10 else '低'
        }

    def cost_analysis(self, lab_params, production_volume_L_day):
        """スケールでの生産コストを推定。"""

        # 設備コスト（簡略化モデル）
        equipment_cost = 50000 * (production_volume_L_day / 100) ** 0.6

        # 運転コスト
        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時間運転

        # 材料コスト（界面活性剤、分散剤）
        material_cost_L = 5.0  # $/L
        material_cost_day = material_cost_L * production_volume_L_day * 0.02  # 2%添加剤

        # 人件費
        labor_cost_day = 200  # $/日

        total_operating_day = energy_cost_day + material_cost_day + labor_cost_day

        # リットルあたりのコスト
        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):
        """生産の環境影響を評価。"""

        # エネルギーからのCO2排出量（系統電力を仮定）
        co2_kg_kWh = 0.5  # kg CO2/kWh（地域により異なる）
        energy_daily = production_volume_L_day * energy_kWh_L
        co2_daily = energy_daily * co2_kg_kWh

        # 溶媒の考慮
        solvent_impact = {
            'water': {'voc': 0, 'toxicity': 'なし', 'recyclability': '容易'},
            'NMP': {'voc': '低', 'toxicity': '中程度', 'recyclability': '中程度'},
            'ethanol': {'voc': '中程度', 'toxicity': '低', 'recyclability': '容易'},
            'toluene': {'voc': '高', 'toxicity': '高', 'recyclability': '中程度'}
        }

        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': '良好' if solvent_type == 'water' and energy_kWh_L < 0.3 else
                                   '中程度' if solvent_type in ['water', 'ethanol'] else '不良'
        }

# 例: コーティング分散のスケールアップ解析
analyzer = ScaleUpAnalyzer('bead_mill')

# 実験室パラメータ
lab_params = {
    'volume_L': 0.5,
    'power_W': 500,
    'time_min': 30
}

# スケールアップ目標
scales = [0.5, 5, 50, 500, 5000]  # L

print("ナノ粒子分散のスケールアップ解析")
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"\nスケール: {scale} L")
    print(f"  動力: {power['target_power_kW']:.1f} kW ({power['target_specific_power_W_L']:.0f} W/L)")
    print(f"  時間: {time['target_time_min']:.0f} 分")
    print(f"  ΔT: {heat['target_delta_T_C']:.1f}°C ({heat['cooling_challenge']})")

# 結果のプロット
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('バッチ体積 (L)')
axes[0, 0].set_ylabel('所要動力 (kW)')
axes[0, 0].set_title('動力のスケールアップ')
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('バッチ体積 (L)')
axes[0, 1].set_ylabel('比動力 (W/L)')
axes[0, 1].set_title('比動力 vs スケール')
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('バッチ体積 (L)')
axes[1, 0].set_ylabel('処理時間（分）')
axes[1, 0].set_title('時間のスケールアップ')
axes[1, 0].grid(True, alpha=0.3)

colors = ['green' if r['cooling_challenge'] == '低' else
          'orange' if r['cooling_challenge'] == '中' 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('バッチ体積 (L)')
axes[1, 1].set_ylabel('温度上昇 (°C)')
axes[1, 1].set_title('熱伝達の課題')
axes[1, 1].axhline(y=10, color='orange', linestyle='--', label='中程度')
axes[1, 1].axhline(y=20, color='red', linestyle='--', label='高')
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()

# 生産スケールのコスト分析
print("\n" + "=" * 60)
print("生産コスト分析（500 L/日）")
costs = analyzer.cost_analysis(lab_params, 500)
for key, value in costs.items():
    if 'USD' in key:
        print(f"  {key}: ${value:.2f}")

# 環境評価
print("\n環境評価:")
env = analyzer.environmental_assessment(500, 'water', 0.4)
print(f"  エネルギー: {env['energy_kWh_day']:.0f} kWh/日")
print(f"  CO2: {env['co2_emissions_kg_day']:.1f} kg/日")
print(f"  評価: {env['environmental_rating']}")

まとめと重要ポイント

結論

ナノ粒子分散技術の産業応用を成功させるには、以下が必要です：

1. 基礎の理解（第1-2章）：凝集を駆動する力を知る
2. 適切な技術の選択（第3章）：分散法を応用に合わせる
3. 安定性の検証（第4章）：複数の特性評価技術を使用する
4. スケールアップ課題への対処（本章）：最初から製造を計画する

この分野は、特性評価技術の進歩、機械学習最適化、持続可能な処理方法により進化し続けています。成功には、性能目標とコスト、安全性、環境配慮のバランスが必要です。

演習問題

参考文献