Air Lubrication Calculator

//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 = {
        Tin:sliders.SlideTin.value,
        mps: sliders.Slidempm.value /60, //min to s
        Radius: sliders.SlideD.value /2000, //D to R and mm to m
        Wrap: sliders.SlideWrap.value*Math.PI/180, //Deg to rad
        Thick: sliders.Slideh.value/1e6, //μm to m
        Roughness: sliders.SlideRoughness.value, //keep in μm
        Coeff: sliders.SlideCoeff.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('AirGap').value = result.AirGap;
    document.getElementById('FricCalc').value = result.FricCalc;
    document.getElementById('TFrac').value = result.TFrac;
    document.getElementById('GPitch').value = result.GPitch;
    document.getElementById('GWidth').value = result.GWidth;
    document.getElementById('GDepth').value = result.GDepth;
    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({ Tin, mps, Radius, Wrap, Thick, Roughness, Coeff}) {
    const AirViscosity  = 0.00001793
    //In the AbbottApps version this was 6 * mps but it should be 12 for two rollers moving
    const AirGap=1000000.0 * 0.643 * Radius *Math.pow (12 * mps * AirViscosity / Tin, 0.666)
    let ui= Coeff
    if (AirGap >= 3 * Roughness) ui = 0
    if (AirGap > Roughness && AirGap < 3 * Roughness)  ui = Coeff * (1.5 - AirGap / (2 * Roughness))
    const TMax  = Tin * Math.exp(ui * Wrap)
    const TDelta  = TMax - Tin
    const TFrac=TDelta/Tin

    //Everything in mm
    const GWidth=10*Thick*1000
    const GPitch=2*GWidth
    const EGT=4*AirGap/1000
    const GDepth=EGT*GPitch/GWidth
    
    //Now we return everything - text boxes, plot and the name of the canvas, which is 'canvas' for a single plot
    return {
        AirGap:AirGap.toFixed(1),
        FricCalc:ui.toFixed(2),
        TFrac:TFrac.toFixed(2),
        GPitch:GPitch.toFixed(2),
        GWidth:GWidth.toFixed(2),
        GDepth:GDepth.toFixed(3),
    };
}

                        

Application

To see the effective of speed, diameter and tension on the air lubrication flying height of a web over a roller. Then to look at the effective friction coefficient which depends on roller roughness and to see the maximum fraction of the tension that can be maintained without slipping. And to create good estimates for roller grooving for when the flying height is too large to control via roughness or tension. To understand more about the science and application, consult The Web Handling Handbook by Roisum, Walker and Jones, especially Chapter 4.

Air lubrication

The faster the roller turns the more air gets trapped under the web. The flying height (air gap) is given by: `Gap="Constant"."Radius" (("Speed". "AirViscosity") / "Tension")^0.666`

Effective coefficient of friction

If the flying height is less than the effective roughness (in this modeller only one roughness is used, in reality it is the combined roughness of the roller (RR) and the web (RW) given by `"Roughness"=sqrt("RR"^2+"RW"^2))` then the coefficient of friction is that given by the input. If the flying height is >3* the roughness then the coefficient of friction=0. In the intermediate zone there is a linear ramp. So there is some forgiveness as the flying height starts to exceed the roughness - but if you are in this zone then small changes to the system can suddenly cause slippage to appear.

Will it slip?

TFrac is the fraction of the tension value that the wrap and the (effective) coefficient of friction can support before the web will slip over the roller.

What about grooved rollers?

If you are in or close to the danger zone, i.e. if the roughness is not great enough given the speed and tension then the only way to be secure from slipping is to put grooves into the roller so that air can escape through the grooves. The problem facing the user under such circumstances is not so much "Should I get some grooved rollers?" (to which the answer is "Yes") but "How do I choose from the myriad of designs out there?" As a user you have a choice - go with gut feel, magic or with science. This Calculator suggests some science for you.

One scientifically excellent way to help air to escape is via microgrooving where there are many tiny grooves. Unfortunately these can be difficult and/or expensive to make and the microgrooves can easily become clogged with debris which reduces their effectiveness. Scientifically (again!) a few deep grooves will have the capacity to remove the excess air - but it might take too long for the air to move sideways into those grooves. Scientifically (yet again!) a few narrow peaks (and therefore broad, flat grooves) will do an excellent job in removing the air, but the web will tend to wrinkle around those peaks.

As none of those three approaches seems sensible, a wise balance becomes appropriate. One approach is recommended by David Roisum (whose assistance in the implementation in ALC is gratefully acknowledged) in The Mechanics of Rollers (a more complex approach is discussed below). Here are the steps:

1. Don't risk either fouling (grooves too narrow) or wrinkling (grooves too wide). Therefore the width of the grooves must be no greater than 10x the thickness of the web - hence the web thickness is an input to the calculator.
2. Don't involve too much machining work, nor allow the width along the top of the grooves to be too large. In short, choose a total spacing (Pitch) = 2x width - in other words the lands and the grooves are the same dimension.
3. Make the grooves deep enough to be sure to let the air escape - without too much machining. The Effective Groove Thickness is Width*Depth/Pitch. Make this 4x the flying height to allow a reasonable margin of error. Given that we know Width (= 10x web thickness) and Pitch (=2xWidth) and we know the flying height from the speed/tension calculations, we have everything we need to calculate a recommended Depth.
4. Don't go in for visual magic. A roller looks much more impressive if it has, say, cross-spiral grooves. But any irregularity in the pattern means that some portions are super-optimal and some are sub-optimal. Given that you've just calculated an optimum why not stick with it? So a simple spiral, easy to machine, is all it needs?
5. Remember that grooves do NOT have any effect on spreading. So the fact that your grooves spiral in one direction has NO impact on the web handling. The optical illusion of spiralled grooves has fooled countless converters. Just be proud that you are not one to be fooled by a mere illusion.

Following those principles will get you to a few very simple designs that will work very well over a good range of products. Although the Calculator doesn't allow you to input alternative values for Width, Pitch or Depth, if you think that Width = 10xThickness is too restrictive, feel free to enter a dummy thickness (it has no other effect on the calculation) that forces the Width to a different value. The Pitch and Depth will automatically follow.