## Flow Profile

### Quick Start

I had no idea that from a velocity flow profile you could extract the basic shear thinning and yield stress values of fluids. Nor did I know that via ultrasonics you can do these measurements in real time in a stainless pipe and so monitor the complex rheology of your fluid during production.

In real life, you extract rheological parameters from the velocity profile, here you see how the profile changes with the parameters.

### Credits

I am grateful to Michael Kotzé at INCIPIENTUS Ultrasound Flow Technologies. Their ultrasound technique measures these flow profiles on-line, giving you real-time shear dependence and yield stress values.

### Flow Profile

_{0}Pa

```
//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 = {
P: sliders.SlideP.value * 1000, //From kPa
R: sliders.SlideR.value / 1000, //From mm
L: sliders.SlideL.value / 100, //From cm
n: sliders.Sliden.value,
K: sliders.SlideK.value,
t0: sliders.Slidet0.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('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({ P, R, L, n, K, t0 }) {
const Rs = 2 * L * t0 / P
n=Math.min(n,0.99)
let r = 0, y = 0, v = 0, gamma, Plot = [], Plotv = []
for (r = 0; r <= 2 * R; r += 2 * R / 100) {
y = Math.abs(R - r)
v = (n / (1 + n)) * Math.pow(P / (2 * L * K), 1 / n) * (Math.pow(R - Rs, 1 + 1 / n) - Math.pow(y - Rs, 1 + 1 / n))
if (!isNaN(v)) Plot.push({ x: r * 1000, y: v })
gamma = Math.pow(P / (2 * L * K), 1 / n) * Math.pow(y - Rs, 1 / n)
Plotv.push({ x: r * 1000, y: Math.max(gamma,0) })
}
//Tidy up the end points
Plot.push({ x: 2 * R * 1000, y: 0 })
Plotv.push({ x: 2 * R * 1000, y: Plotv[0].y })
const vs = (n / (1 + n)) * Math.pow(P / (2 * L * K), 1 / n) * (Math.pow(R - Rs, 1 + 1 / n))
const Q = Math.PI * vs * Rs * Rs + Math.PI * n * R * R * Math.pow(R - Rs, 1 + 1 / n) / (n + 1) * Math.pow(P / (2 * L * K), 1 / n) * (1 - 2 * n / (3 * n + 1) * Math.pow(1 - Rs / R, 2) - 2 * n * Rs / ((2 * n + 1) * R) * (1 - Rs / R) - Math.pow(Rs / R, 2))
const wallShear = Math.pow(P / (2 * L * K), 1 / n) * Math.pow(R - Rs, 1 / n)
const wallVisc = 1000 * K * Math.pow(P / (2 * L * K), 1 - 1 / n) * R / Math.pow(R - Rs, 1 / n)
const Data = "R* = " + (Rs * 1000).toPrecision(3) + " mm, v* = " + vs.toPrecision(3) + " m/s, Q = " + (1000 * Q).toPrecision(3) + " l/s\nγ̇ _wall = " + wallShear.toPrecision(3) + " /s, η_wall = " + wallVisc.toPrecision(3) + " mPa.s"
//Now set up all the graphing data detail by detail.
let plotData = [Plot, Plotv,]
let lineLabels = ["Velocity", "Shear Rate"]//,"Plot1","Plot2","Plot3"] //An array of labels for each dataset
const prmap = {
plotData: plotData,
lineLabels: lineLabels,
xLabel: "x& mm", //Label for the x axis, with an & to separate the units
yLabel: "v& m/s", //Label for the y axis, with an & to separate the units
y2Label: "γ̇ & /s", //Label for the y2 axis, null if not needed
yAxisL1R2: [1, 2], //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: [0,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
y2MinMax: [0,], //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 {
Data: Data,
plots: [prmap],
canvas: ['canvas'],
};
}
```

A complex fluid with Herschel Bulkley characteristics is flowing through a pipe of radius R. There is a relative pressure ΔP measured over a length L. You have a flow meter measuring the average flow, Q.

The Herschel Bulkley parameters, n, K and the yield stress τ_{0} describe the stress τ which depends on the shear rate γ̇ :

`τ=τ_0+Kγ̇ ^n`

If you set τ_{0}=0 and n=1, you have a Newtonian fluid which gives the familiar parabolic velocity profile. As you increase τ_{0} and decrease n you start to shift to a flat central flow profile. *Note that a power-law fluid (i.e. τ _{0}=0) can give a similar shape, so a single curve can often be fitted adequately with various combinations of n, K & τ_{0}. By using a range of ΔP values a more reliable set of values can be extracted.* Again, the point of the app is to explore this world of velocity profiles as many of us are unaware of them.

The output of the app, in addition to the velocity and shear rate profiles, gives some key parameters. R* is the distance from the wall where the flow goes flat, v* is the velocity at which that happens (these values lose meaning at high n values), Q is the calculated flow, γ̇ _{wall} is the wall shear stress, η_{wall} is the viscosity at the wall.

Although it is possible to calculate the viscosity profile, it is relatively meaningless and numerically goes to infinity at the centre!

### The Calculations

The key paper is from Wiklund at al^{1}, with the following equations. The velocity, v at distance r from the centre of flow, is given by

`v=(nR)/(1+n)((RΔP)/(2LK))^(1/n)(1-(r/R)^(1+1/n))`

The shear rate, γ̇ , is given by:

`γ̇ =((rΔP)/(2LK))^(1/n)`

The viscosity (not plotted here), η, is given by:

`η=K((rΔP)/(2LK))^(1-1/n)`

The values of γ̇ and η at the walls are calculated with r=R.

The formula for the flow Q is complicated, and can be readily found by clicking the Show Code button and looking for the line starting with "const Q ="

### Implications for Production

Most of us will measure "the viscosity" of each batch of a viscous solution before taking it into production. But if the shear thinning or yield stress behaviour was different, a single measurement might not show up a problem. And few of us have a near-line rheometer to check. Also, during a run, the rheological behaviour might change, something that a simple in-line viscometer might pick up, but, again might miss - and most of us don't have in-line viscometers. Having the ability to detect in real time changes in shear and yield behaviour would be very powerful. Having the ability to do this as the fluid passes through a stainless steel pipe, only making brief contact with the pressure sensors before and after the flow profile measurement, is a powerful way to improve process control.

^{1}Johan Wiklund, Mattias Johansson, Jeelani Shaik, Peter Fischer, Erich Windhab, Mats Stading and Anne-Marie Hermansson, *In-Line Ultrasound Based Rheometry of Industrial and Model Suspensions Flowing Through Pipes*, Third International Symposium on Ultrasonic Doppler Methods for Fluid Mechanics and Fluid Engineering EPFL, Lausanne, Switzerland, September 9 - 11, 2002.