## Calendering

### Quick Start

Calendering (sometimes 'calendaring') is a tricky process to understand in terms of rheology, pressures, thicknesses. The equations are complex and have plenty of approximations, but they capture the essence surprisingly well

### Credits

The approach is from a paper of the well-known calendering expert Prof Mitsoulis^{1}.

### Calendering

_{0}Gap μm

_{0}Pa.s

_{in}μm : H

_{in}/H

_{0}

_{out}μm : H

_{out}/H

_{0}

_{max}bar

```
//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 = {
R: sliders.SlideR.value/1000, //mm to m
U: sliders.SlideU.value/60, //m/min to m/s
l: sliders.Slidel.value,
H0: sliders.SlideH0.value/2e6, //μm to m and half gap used in calcs
eta: sliders.Slideeta.value,
n: sliders.Sliden.value,
//Wi: sliders.SlideWi.value,
// HumType: document.getElementById("Hum").value,
// Wisotherm: document.getElementById('Wisotherm').checked,
};
//Send inputs off to CalcIt where the names are instantly available
//Get all the resonses as an object, result
const result = CalcIt(inputs);
document.getElementById('Pmax').value = result.Pmax;
document.getElementById('F').value = result.F;
document.getElementById('Hout').value = result.Hout;
document.getElementById('Hin').value = result.Hin;
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 Main!
}
//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({R,U,l,H0,eta,n}) {
const l2=l*l,n2n=-Math.pow((2*n+1)/n,n),sqr=Math.sqrt(2*R/H0),dx=0.01, xfact=1e3*Math.sqrt(2*R*H0)
let dP=0, x2=0, P=0, PMax=0, xf=0, F=0, pPlot=[]
pPlot.push({x:l*xfact,y:0})
//const dP0=-n2n*sqr*((l2-0)*Math.pow(Math.abs(l2-0),n-1))/(Math.pow((1+0),n)*Math.pow(1+0,n+1))
const Pconv=1e-5*eta/Math.pow(H0/U,n)
for (let x=l-dx;x >-10*l; x-=dx){
x2=x*x
dP=n2n*sqr*((l2-x2)*Math.pow(Math.abs(l2-x2),n-1))/(Math.pow((1+x2),n)*Math.pow(1+x2,n+1))
P-=dP*dx
F+=P*dx
PMax=Math.max(P,PMax)
//pPlot.push({x:x,y:dP/dP0})
pPlot.push({x:x*xfact,y:Math.max(0,P*Pconv)})
xf=x
if (P < 0) break
}
PMax*=Pconv
F*=Pconv*1e5*Math.sqrt(2*R*H0) //Back to Pa rather than bar, real length
F/=1000 //to kN/m
const Hout=2e6*H0*(1+l2)
const Hin=2e6*H0*(1+xf*xf)
//console.log(pPlot)
//Now set up all the graphing data detail by detail.
let plotData = [pPlot], lineLabels = ["Pressure"], myColors = ['blue', 'green']
const yLabel="Pressure&bar"
const prmap = {
plotData: plotData, //An array of 1 or more datasets
lineLabels: lineLabels, //An array of labels for each dataset
colors: myColors, //An array of colors for each dataset
borderWidth: [2, 1], //An array of line widths for each dataset
hideLegend: true, //Set to true if you don't want to see any labels/legnds.
xLabel: 'x&mm', //Label for the x axis, with an & to separate the units
yLabel: yLabel, //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: 'F1', //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 {
Pmax:PMax.toFixed(1),
F:F.toFixed(1),
Hout:Hout.toFixed(1)+" : "+(0.5e-6*Hout/H0).toFixed(2),
Hin:Hin.toFixed(1)+" : "+(0.5e-6*Hin/H0).toFixed(2),
plots: [prmap],
canvas: ['canvas'],
};
}
```

Calculating what happens to a material as it passes through a calendering nip is super-complicated. This app uses a well-known approximation from calendering expert Prof Mitsoulis and applies only to pseudoplastic materials that start off with a low-shear viscosity η_{0} and change with shear according to a power law exponent n. Newtonian fluids have n=1, the shear-thinning fluids used for calendering have n < 1. Although the paper can deal with Bingham fluids with yield stresses, that's too complex for this app and in any case makes surprisingly little difference compared to the effects of n.

You have rollers of radius R moving at speed U and there is a gap, H_{0} (you enter the full gap, in the papers and the code H_{0} is the half gap). You would reasonably expect to provide the thickness H_{in} and the resulting thickness H_{out}, but instead you provide the parameter λ which has a maximum ~0.45. This is the "non-dimensional length from the nip gap to where the roller separates from the material". This is done because if you start with λ as an input, the calculations are relatively easy. Doing the real calculation to get λ (needed for the pressure calculations) from the expected inputs is much harder.

To simulate your own setup you need to play with the nip gap and λ to get your H_{out}. Whether the calculated H_{in} matches reality is a bit complex as you might, for example, have a rolling nip input which this model cannot simulate.

### Outputs

The graph shows pressure versus distance x where x = 0 is the narrow point of the nip. The dimensional version of λ, the maximum plotted value of x, can be read from the graph using the mouse. The maximum pressure is at the point where x = -λ, not at x = 0! The nominal contact point of the incoming material with the roller is the upstream most negative plotted value.

Also calculated are the maximum pressure, P_{max}, the force per unit width, F, the absolute in and out thicknesses plus their ratio (often quoted in papers) to the gap. Note that P_{max} and F can reach unrealistic values - don't go too fast with narrow gaps and super-viscous materials!

### Validation

The academic papers have all their inputs and outputs in non-dimensional form, which makes a lot of sense. But we want them in real units. Before plotting the real outputs I checked the non-dimensional outputs as much as possible against the examples in the paper and they are accurate. I have not found a way to check if the real P and F values are correct - I welcome feedback/correction. Also, remember that this is using a simple pseudoplastic material, not a viscoplastic material with a yield stress that the paper also considers but which required a *modified regula falsi method* numerical solver which is beyond me.

^{1}

Souzanna Sofou and Evan Mitsoulis, Calendering of pseudoplastic and viscoplastic sheets of finite thickness, J Plastic Film & Sheeting, 2004, 20, 185-222