Polymer Chemistry

Code Examples

import numpy as np
from typing import List, Dict, Tuple
from scipy import stats

class Polymerization:
    def __init__(self, monomer: str, mechanism: str):
        self.monomer = monomer
        self.mechanism = mechanism

    def calculate_mn_step_growth(self, conversion: float, 
                                functionality: int) -> float:
        degree_polymerization = 1 / (1 - conversion)
        mn = 100 * degree_polymerization  # Monomer MW ~ 100 g/mol
        return mn

    def calculate_mn_chain_growth(self, initiator_conc: float,
                                 rate_constant: float,
                                 time: float) -> float:
        kp = rate_constant
        [I] = initiator_conc
        R_p = kp * np.sqrt(2 * 1e-5 * [I])  # Assume ki = 1e-5
        degree_polymerization = R_p * time / [I]
        return degree_polymerization * 100

    def predict_molecular_weight_distribution(self, mn: float, 
                                             dispersity: float) -> List[float]:
        mw_range = np.linspace(mn * 0.1, mn * 5, 100)
        from scipy.stats import lognorm
        sigma = np.sqrt(np.log(disperity))
        mu = np.log(mn) - sigma**2
        distribution = lognorm.pdf(mw_range, sigma, scale=np.exp(mu))
        return distribution

    def flory_stockmayer_theory(self, conversion: float,
                               r: float, rho_a: float, rho_b: float) -> Dict:
        p_a = conversion * rho_a / (rho_a + rho_b * r)
        p_b = r * p_a
        if p_a < 1 and p_b < 1:
            degree_polymerization = 1 / ((1 - p_a) * (1 - p_b))
            gel_point = 1 / np.sqrt((1 + r) * (1 + 1/r))
        else:
            degree_polymerization = float('inf')
            gel_point = conversion
        return {'DP': degree_polymerization, 'gel_point': gel_point}

    def copolymer_composition(self, f1: float, r1: float, r2: float) -> float:
        f2 = 1 - f1
        f1_star = (r1 * f1**2 + f1 * f2) / (r1 * f1**2 + 2 * f1 * f2 + r2 * f2**2)
        return f1_star

    def glass_transition_prediction(self, w1: float, w2: float,
                                   Tg1: float, Tg2: float) -> float:
        k = 1.0  # Typically 1 for many polymer blends
        Tg = (w1 * Tg1 + k * w2 * Tg2) / (w1 + k * w2)
        return Tg

    def calculate_degree_crystallinity(self, crystalline_fraction: float,
                                       density_crystalline: float,
                                       density_amorphous: float,
                                       measured_density: float) -> float:
        return (density_crystalline - measured_density) / \
               (density_crystalline - density_amorphous)

poly = Polymerization("styrene", "chain_growth")
mn = poly.calculate_mn_chain_growth(1e-4, 100, 60)
print(f"Number average MW: {mn:.0f} g/mol")

poly_step = Polymerization("ethylene glycol + terephthalic acid", "step_growth")
dp = poly_step.calculate_mn_step_growth(0.99, 2)
print(f"Degree of polymerization at 99% conversion: {dp:.0f}")

Best Practices

1. Control molecular weight through monomer-to-initiator ratio
2. Monitor conversion and molecular weight throughout polymerization
3. Remove impurities and inhibit premature polymerization
4. Use proper solvent and temperature for polymerization conditions
5. Characterize polymer using multiple techniques (GPC, NMR, DSC)
6. Consider copolymer composition drift in continuous processes
7. Account for chain transfer agents in molecular weight control
8. Optimize reaction conditions for desired tacticity
9. Consider polymer-solvent interactions in solution properties
10. Validate processing conditions with small-scale testing