Powder Dissolution

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 = {
        Gel: sliders.SlideGel.value,
        RPM: sliders.SlideRPM.value, //keep in RPM
        R: sliders.SlideR.value, //keep in μm
        tmax:sliders.Slidetmax.value, //keep in min
        MWtMc: sliders.SlideMWtMc.value, //A relative value
    };


    //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('fg').value = result.fg;
    document.getElementById('k').value = result.k;
    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({ RPM, R, Gel, tmax, MWtMc }) {
    let Sol = [], t = 0
    const tstep = tmax / 200
    //A balance between radius and gel speed
    const fg = Math.min(1,Math.max(0.05, (1 - (Gel / 10)*(200/R))))
    const fg1 = 1 - fg, k = 60 * 2 / MWtMc * RPM / 1000 , Rl = 1500 //1.5mm lump
    let C = 0
    Sol.push({ x: 0, y: 0 })
    for (t = tstep; t <= tmax; t += tstep) {
        if (k * t / R < 1) { C = fg * (1 - Math.pow(1 - k * t / R, 3)) } else { C = fg }
        if (k * t / Rl < 1) { C += fg1 * (1 - Math.pow(1 - k * t / Rl, 3)) } else { C += fg1 }
        Sol.push({ x: t, y: C })
    }
    Sol[Sol.length-1].x=Math.round(tmax) //Fix rounding errors in graphics
    //Now set up all the graphing data detail by detail.
    let plotData = [Sol]

    const prmap = {
        plotData: plotData, //An array of 1 or more datasets
        lineLabels: [], //An array of labels for each dataset
        colors: ["orange"], //An array of colors for each dataset
        borderWidth: [2,], //An array of line widths for each dataset
        hideLegend: true, //Set to true if you don't want to see any labels/legnds.
        xLabel: 't&min', //Label for the x axis, with an & to separate the units
        yLabel: 'C&mg/ml', //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: [0,], //Set min and max, e.g. [-10,100], leave one or both blank for auto
        yMinMax: [0, 1], //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: 'F2', //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 {
        // Tmg: Tmg.toFixed(0)+ " : "+(Cd*1000).toPrecision(3),
        fg: fg.toFixed(2),
        k: k.toPrecision(3),
        plots: [prmap],
        canvas: ['canvas'],
    };
}

                        

It should be simple

Take some powder (typically some food powder) and throw it into a solvent (typically water, but see the Real Polymers section below) with some stirring. Common sense says, and science confirms, that smaller powder particles dissolve faster (t ~ 1/Radius) and that faster stirring also helps(t ~ 1/RPM).

Yet we often find that finer powders take longer to dissolve, because they instantly form lumps that are then equivalent to large particles, which take longer. There is a fraction of particles, f_Powder that are free and fast-dissolving and a fraction of lumps, `f_(Lump)=1-f_(Powder)` that are assumed here (as is found in practice) to have a "mm sized" radius (chosen to be 1.5mm in the app) which automatically leads to slower dissolution.

Because the distance between powder particles (when close packed or when added to a solvent) is always smaller for smaller particles, the chances of lumps forming increases with smaller powders. As the Parker paper says: "The practical point is that grinding polymer powders more and more finely to reduce the dissolution time eventually becomes counterproductive because it leads to increased lump formation."

The chances of powder particles sticking together depends on the speed of a sticky gel phase expanding around them. If this is fast, then the lumps form before dissolution, if slow then the lumps don't form so easily. As is commonly observed, lump formation is either near-instant or not at all. In the app, the Gel Speed slider captures this behaviour from 0 (no gelling) to 10 (rapid).

"Add the Powder to the Solvent, not the Solvent to the Powder"

We all know that the chances of creating a sticky mess are far worse if you add the solvent to the powder, so we often try to add the powder gently to the solvent, with good stirring. This makes sense. Dumping powder into solvent might give 1.5mm lumps, but dumping solvent into powder might give cm-sized lumps. Although it's helpful, the method is not fool-proof. A slight slip, tipping in a bit too much, can create a local high concentration of powder particles and you get a lump which takes a long time to dissolve.

"Dispersants"

The Parker paper talks of "dispersants". They don't mean classical surfactants. Instead they mean grains of non-sticky particles (typically sugar), with particle size similar to the powder, mixed in so that polymer-polymer contacts are greatly reduced. Sugars in instant foods aren't therefore just to give cheap bulk and sweetness, they make it easier to simply mix and consume. However, as they noted from an experiment, presumably out of curiosity: "when a small amount of solid surfactant is mixed with the powder before addition [and] the powder bed hits the water, the grains 'explode' in all directions and lump formation is eliminated". They attribute this to a Marangoni effect.

In the app, adding a non-gelling dispersant like sugar is done by reducing the Gel Speed input.

Polymer dependent

We also find that the polymer (e.g. starch) that makes up the powder has a big effect on the dissolution time. Short polymers are easily dissolved away from the surface. Larger ones are self-tangled. Classic reptation (the word comes from "reptile") theory tells us that there is a "repatation time" needed for the polymer chains to disentangle. They are caught in tubes created by other polymer chains. For dissolution of polymers it can also be the case that it's not so much disentangling but sliding out of the tube (a slower process) that governs the speed. Whichever is the true explanation, polymers have a critical entanglement molecular weight, M_c, that controls their behaviour. Below it, dissolution is rapid, above it, it gets much slower.

Putting things together

Rather than pretending we know all the parameters for our own system, the app explores the general trends identified in the two papers.

• Smaller individual powder particles dissolve faster
• Faster stirring gives faster dissolution
• MWts above M_c slow things down
• We can combine these effects into a rate constant k controlled by radius, RPM, MWt/M_c
• Smaller particles decrease f_Powder and increase f_Lump
• Fast gel creation/expansion decreases f_Powder and increase f_Lump
• Although we can produce fancy formulae for polydispersed powder sizes, a simple 2-parameter model does a good job.

The calculation

From the above we have a simple formula that well describes the observed phenomena. Where we have a powder radius R_P and lump radius R_L, the dissolved concentration C goes from 0 to 1 via:

`C=f_(Powder)[1-(1-(kt)/R_P)^3]+f_(Lump)[1-(1-(kt)/R_L)^3]`

The value of f_Powder in the calculation is an ad hoc combination of Radius and Gel Speed terms that covers the real-world behaviour range.

Real Polymers

Many polymers are provided as bags of small powder particles. Even though we know to "add the powder to the solvent", it is easy to get a few lumps which then take a long time to disappear. Given that you can't add some equivalent of sugar to keep the powder particles separate, what can you do? It was my colleague Dr YAMAMOTO Hiroshi who told me about a beautiful example of the principles behind this app.

Users of polyvinylidene fluoride, PVdF, often add it to a known not-so-good solvent (e.g. a ketone such as MEK) where it disperses nicely but hardly dissolves. Slowly adding a good solvent such as DMF (or some greener equivalent) leads to a nice solution. Adding PVdF directly to DMF gives an unstirrable mess. The not-so-good solvent acts like the sugar, keeping the particles apart, allowing the good solvent to dissolve the polymer nicely.

As Dr YAMAMOTO teaches on his university courses and his Pirika website, choosing the right pair of solvents can best be done using Hansen Solubility Parameters where you can even combine two not-so-good solvents to create an excellent one. Go to the Solvent Blends app and selected PVdF as the polymer then MEK and DMF as the solvents. Although 100% DMF is much better (smaller HSP Distance) than MEK, a 20:80 MEK:DMF blend is even better! With some exploration you can find some greener combinations that will achieve the same thing.

Commenting on a beta version of the app, Dr Hansen mentioned a similar example.Often nitrocellulose powders were first dispersed in a hydrocarbon poor solvent then the good solvent was added.