## Interlayer Strain

### Quick Start

A mismatch of modulus between a hard coating and a soft substrate can create catastrophic extra strains in the coating, causing easy cracking. This is especially a problem for the SiOx and AlOx barrier coatings onto polymer substrates.

### Credits

The app was inspired by an article^{1} in the Q2 2023 Converting Quarterly magazine from Neil Morrison and colleagues from Applied Materials.

### Interlayer Strain

_{b}GPa

_{f}GPa

_{b}

_{f}

_{f}J/m²

_{b}nm

```
//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();
};
//Main() is hard wired as THE place to start calculating when inputs change
//It does no calculations itself, it merely sets them up, sends off variables, gets results and, if necessary, plots them.
function Main() {
//Save settings every time you calculate, so they're always ready on a reload
saveSettings();
//Send all the inputs as a structured object
//If you need to convert to, say, SI units, do it here!
const inputs = {
E1: sliders.SlideE1.value * 1e9, // GPa to Pa
E2: sliders.SlideE2.value * 1e9,
nu1: sliders.Slidenu1.value,
nu2: sliders.Slidenu2.value,
Gf: sliders.SlideGf.value,
h1: sliders.Slideh1.value * 1e-9, //nm to m
};
//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
//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]);
}
}
document.getElementById('alpha').value = result.alpha;
document.getElementById('gata').value = result.gata;
document.getElementById('COS').value = result.COS;
//You might have some other stuff to do here, but for most apps that's it for Main!
}
//Here's the app calculation
function CalcIt({ E1, E2, nu1,nu2, Gf, h1 }) {
let aPts = [], vPts = [], alpha, g
//Poisson corrections
E1/=(1-nu1*nu1); E2/=(1-nu2*nu2); Gf/=(1-nu1*nu1)
for (alpha = 0; alpha <= 1.01; alpha += 0.01) { //Extend the range for calcs of wide distributions
//An ad hoc fitting formula
if (alpha < 0.6) {
g = 1.264 + 0.4 * alpha + 2.1 * alpha * alpha
} else {
g = 1.29/Math.pow(1-alpha,0.621)
}
aPts.push({ x: alpha, y: g })
acalc = (E1 - E2) / (E1 + E2)
vPts.push({ x: acalc, y: 0 }); vPts.push({ x: acalc, y: 20 })
}
const gata = 1.29/Math.pow(1-acalc,0.621)
const COS = 100 * Math.sqrt(2 * Gf / (Math.PI * h1 * E1 * gata)) //Converted to %
const plotData = [aPts, vPts]
//Now set up all the graphing data detail by detail.
const prmap = {
plotData: plotData, //An array of 1 or more datasets
lineLabels: ["Data", "alpha"], //An array of labels for each dataset
colors: ["blue", "orange"], //An array of colors for each dataset
hideLegend: true,
borderWidth: [2, 1],
xLabel: 'α&', //Label for the x axis, with an & to separate the units
yLabel: 'g(α;β)&', //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: null, //We can define a tick function if we're being fancy
logY: false, //Is the y-axis in log form?
yTicks: null, //We can define a tick function if we're being fancy
legendPosition: 'top', //Where we want the legend - top, bottom, left, right
xMinMax: [0, 1], //Set min and max, e.g. [-10,100], leave one or both blank for auto
yMinMax: [0, 20], //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: 'P3', //These are the sig figs for the Tooltip readout. A wide choice!
ySigFigs: 'P3', //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 {
plots: [prmap],
canvas: ['canvas'],
alpha: acalc.toFixed(3),
gata: gata.toFixed(1),
COS: COS.toPrecision(3),
};
}
```

### Cracked barrier films

SiOx and AlOx barriers are wonderful, clear barriers when coated onto polymer substrates, provided that they remain intact. Stresses in the films during handling can easily break the strong-but-brittle coatings.

An under-appreciated problem is that the strains imposed on the thin coatings depend strongly on the difference in modulus between the barrier and the substrate. This is captured in the Dundurs parameters α and β For this app we assume Dundurs β = 0 (that is when Poisson ratios are equal) because over the relevant range the β effects are small. If the modulus of the barrier is E_{b} and that of the film is E_{b}, then α is given by the following where the modulus values are corrected to "reduced modulus" using their respective Poisson ratios to divide by 1-ν². In the absence of any knowledge, assume ν = 0.3, though some inorganic coatings are closer to 0.2 and some "rubbery" interlayers are near 0.48 (where 0.5 is a pure rubber).

`α = (E_b-E_f)/(E_b+E_f)`

Given that a typical barrier modulus is 50 GPa and a typical film's is 2 GPa, α can easily be larger than 0.9, well on the way to a maximum of 1.

Citing a classic paper by Beuth^{2} and invoking the barrier film thickness h_{b} and "fracture energy-release rate", G_{b}, there is a Crack Onset Strain value, COS, based on a parameter g(α;β), the "Elastic Contrast Function" which is derived via a complex formula and is shown (for the case of β=0) in the graph. For more on COS see the Fragmentation app. You want COS to be as high as possible - so that cracks appear at higher strains:

`COS = ((2G_b(1-ν^2))/(πh_fE_fg(α;β)))^0.5`

Given that we want COS to be as large as possible, what do we do?

It seems intuitive to increase the barrier thickness to increase the "strength" but COS gets smaller, so thinner barriers are better. A high modulus E_{b} makes things doubly worse because it directly makes COS smaller and indirectly increases α,

Because g(α;β) rapidly gets larger in the region of the typical α values for barrier coatings on polymer films, and because COS gets smaller, we must try to keep α as small as possible to get the largest-possible COS and, therefore, the largest resistance to strains caused by handling the barrier film.

For a given barrier, all we can do to reduce α is increase E_{f} or, rather the value of the part of the film in immediate contact with the barrier. So if you have a sub 1 GPa PE/PP film but provide, between the film and the barrier, a thin "buffer" layer of EVOH or PVOH with a higher modulus, you increase the resistance to cracks.

As the paper shows, once you've optimized the buffer polymer and have the thinnest possible barrier, the remaining thing to do is increase G_{f} by, for example, using plasma-assisted coating to give a high density barrier layer. But even this has problems. The fracture energy-release rate goes up, which helps COS but so does E_{f} which somewhat reduces the gains made from the larger G_{f}. That's why we have apps to explore these subtle effects.

### Data from the paper

Not all relevant details are provided in the paper, but the key ones are that G_{f} = 0.94 J/m² rising to 24.4 J/m² when plasma assisted. At the same time E_{f} goes from 50 GPa to 95 GPa. Using an estimate of h_{f} = 10 nm and a modulus of 2.3 GPa for an EVOH buffer layer we find a COS of 1.4% for the standard AlOx, as per the paper. With the values for the plasma enhanced AlOx we reach a COS of 4%, higher than the 2% in the paper, but in the right direction.

^{1}NA Morrison et al, *High-performance AlOx thin films for next-generation sustainable flexible packaging: Part 2*, Converting Quarterly, Q2 2023, Association of Roll-to-Roll Converters.

^{2}JL Beuth, JR, *Cracking of Thin Bonded Films on Residual Tension*, Jilt. J. Solids Structures, 29, 1657-1675, 1992