## Smith-Ewart

### Quick Start

Emulsion polymerization (EP) takes many forms. Here we have large (1-10μm) "droplets" of monomer being converted into polymer inside small particles that start off as micelles or seeds and which grown to a few 100nm. It's a complex process, here summed up with a few standard parameters.

This is a working prototype. It needs linking to real quantities.

### Credits

I believe that HLD-NAC should be routinely used in the EP community. The challenge is how to relate it to classical theories such as Smith-Ewart. All I know is that without HLD-NAC, EP is more difficult than it should be.

### Smith-Ewart

_{max}min

```
//One universal basic required here to get things going once loaded
window.onload = function () {
//restoreDefaultValues(); //Un-comment this if you want to start with defaults
Main();
};
//Any global variables go here
//Main is hard wired as THE place to start calculating when input changes
//It does no calculations itself, it merely sets them up, sends off variables, gets results and, if necessary, plots them.
function Main() {
saveSettings();
//Send all the inputs as a structured object
//If you need to convert to, say, SI units, do it here!
const inputs = {
rho:sliders.Sliderho.value*Math.pow(10,sliders.Sliderhopower.value),
k: sliders.Slidek.value*Math.pow(10,sliders.Slidekpower.value),
c: sliders.Slidec.value*Math.pow(10,sliders.Slidecpower.value),
tmax: sliders.Slidetmax.value,
}
//Send inputs off to CalcIt where the names are instantly available
//Get all the resonses as an object, result
const result = CalcIt(inputs)
//Set all the text box outputs
document.getElementById('nbar').value = result.nbar
document.getElementById('Data').value = result.Data
//Do all relevant plots by calling plotIt - if there's no plot, nothing happens
//plotIt is part of the app infrastructure in app.new.js
if (result.plots) {
for (let i = 0; i < result.plots.length; i++) {
plotIt(result.plots[i], result.canvas[i]);
}
}
//You might have some other stuff to do here, but for most apps that's it for CalcIt!
}
//Here's the app calculation
//The inputs are just the names provided - their order in the curly brackets is unimportant!
//By convention the input values are provided with the correct units within Main
function CalcIt({ rho, k, c, tmax }) {
let l=(k*(k+2*c)+4*rho*c)/(k+2*c)
let w=(2*rho*(k*k+k*(3*c+rho)+c*c+3*rho*c))/(2*k*k*k+k*k*(6*c+2*rho)+k*(4*c*c+10*rho*c+rho*rho)+8*rho*c*c+4*rho*rho*c)
let t=0,PA=0,Plot=[],Plot1=[],Plot2=[],Plot3=[]
for (t=0;t<=tmax;t+=tmax/100){
PA=w/l*(l*t*60+Math.exp(-l*t*60)-1)
Plot.push({x:t,y:PA})
}
const Data="λ = "+l.toExponential(2)+", ω = "+w.toExponential(2)+" t_e = "+(3/l/60).toFixed(1)+" min"
// k=1
// for (t=-3;t<=3;t+=0.1){
// rho=Math.pow(10,t)
// c=0.0
// w=(2*rho*(k*k+k*(3*c+rho)+c*c+3*rho*c))/(2*k*k*k+k*k*(6*c+2*rho)+k*(4*c*c+10*rho*c+rho*rho)+8*rho*c*c+4*rho*rho*c)
// Plot.push({x:t,y:Math.log10(w)})
// c=rho/100
// w=(2*rho*(k*k+k*(3*c+rho)+c*c+3*rho*c))/(2*k*k*k+k*k*(6*c+2*rho)+k*(4*c*c+10*rho*c+rho*rho)+8*rho*c*c+4*rho*rho*c)
// Plot1.push({x:t,y:Math.log10(w)})
// c=rho/1
// w=(2*rho*(k*k+k*(3*c+rho)+c*c+3*rho*c))/(2*k*k*k+k*k*(6*c+2*rho)+k*(4*c*c+10*rho*c+rho*rho)+8*rho*c*c+4*rho*rho*c)
// Plot2.push({x:t,y:Math.log10(w)})
// c=rho/0.2
// w=(2*rho*(k*k+k*(3*c+rho)+c*c+3*rho*c))/(2*k*k*k+k*k*(6*c+2*rho)+k*(4*c*c+10*rho*c+rho*rho)+8*rho*c*c+4*rho*rho*c)
// Plot3.push({x:t,y:Math.log10(w)})
// }
//Now set up all the graphing data detail by detail.
let plotData = [Plot]//,Plot1,Plot2,Plot3]
let lineLabels = ["P/A over time"]//,"Plot1","Plot2","Plot3"] //An array of labels for each dataset
const prmap = {
plotData: plotData,
lineLabels: lineLabels,
xLabel: "t& m", //Label for the x axis, with an & to separate the units
yLabel: "P/A& ", //Label for the y axis, with an & to separate the units
y2Label: null, //Label for the y2 axis, null if not needed
yAxisL1R2: [], //Array to say which axis each dataset goes on. Blank=Left=1
logX: false, //Is the x-axis in log form?
xTicks: undefined, //We can define a tick function if we're being fancy
logY: false, //Is the y-axis in log form?
yTicks: undefined, //We can define a tick function if we're being fancy
legendPosition: 'top', //Where we want the legend - top, bottom, left, right
xMinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
yMinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
y2MinMax: [,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
xSigFigs: 'F2', //These are the sig figs for the Tooltip readout. A wide choice!
ySigFigs: 'F1', //F for Fixed, P for Precision, E for exponential
};
//Now we return everything - text boxes, plot and the name of the canvas, which is 'canvas' for a single plot
return {
// Vt: Vt.toFixed(1),
// Vimpact: Vimpact.toFixed(1),
// maxDepth: (-maxDepth*100).toFixed(1),
// floatDepth: (floatDepth*100).toFixed(1),
// rhofoam: (rhofoam/1000).toFixed(2),
// thetar: thetar.toFixed(0),
nbar: w.toFixed(3),
Data: Data,
plots: [prmap],
canvas: ['canvas'],
};
}
```

For some reason, either deliberate seeds or via the statistics of surfactants and monomers, we have some particles containing growing polymer chains with one radical chain end, and slightly water soluble monomer migrates from the large drops and continues the reaction. The initiator is water soluble, and although it can initiate bad reactions in the large droplets, the relatively small surface area to volume ratio of the big drops means little reaction in practice ... unless the droplets get accidentally split up by a combination of over-stirring in the reaction vessel and a low interfacial rigidity from the surfactant system being used.

Looking only at the growing polymer particles we have 3 factors that affect the polymerization.

**ρ**. This is the**Entry Rate**of radicals into the particle. That particle might contain no radicals so this kicks off polymerization that might consume all the monomer that migrates into it, giving a high MWt. Or the new radical might cause a second polymer chain to grow. What is of interest is n̄, the average number of radicals per particle. If this is low then we have a desirable high MWt polymer, but a relatively low reaction rate.**k**. This is the**Exit Rate**. Obviously a high exit rate increases the MWt and decreases the reaction rate.**c**. This is the bimolecular**Termination Rate**. You have to hope that this is low as it is not a helpful attribute.

Smith & Ewart were able to show that just from these 3 constants it was possible to know n̄ via a relatively simple recursion formula which happens to be relatively hard to solve. They could identify a few special cases (ratios of ρ, k & c) where n̄ was easy to calculate, and adding the assumption that this value is reached rather rapidly, the whole polymerization could be characterized. Here we use a general solution^{1} with no restrictions on the 3 parameters. Remarkably it requires only two parameters, λ and ω. Although this app doesn't calculate how n̄ rises from zero to its equilbrium value, there is a characteristic time, `t_e=3/λ` which gives you an idea of how long this is relative to the consumption of all the monomer from the starting droplets.

The calculation is of P/A where P is the extent of polymerization and A is a scaling constant. The dependence on time t is given by

`P/A=ω/λ[λt+e^(-λt)-1]`

The time to equilibrium is taken as being when the exponential term becomes `e^(-3)`

The values of λ and ω come from some complex eigenvector calculations based on the 3 parameters. Click on the Code button to see the formulae.

How does this all relate to your real quantities of monomer, surfactant and initiator? Hopefully someone can help me here. I know the formulae but I don't know which parameters are useful for real-world formulators.

^{1}Brian S Hawk,Donald H Napper and Robert Gilbert, *General Solution to the Smith-Ewart Equations for Emulsion Polymerization Kinetics*, J. Chem. Soc., Faraday Trans. 1, 1977,73, 690-698.