Roller Bending Calculator

Quick Start

This calculates the bend of a roller from its own weight, the load from the web and from any nip loads. You have freedom to place the webs and nip rolls at arbitrary angles so can explore a wide range of options.

Credits

This is taken from the old AbbottApps which are based on inputs from web-handling experts Dr David Roisum, Dr Dilwyn Jones and Tim Walker.

Roller Bending Calculator

Web Load Kg
Web θ1 °
Web θ2 °
Roller OD mm
Face mm
Nip Load kg
Nip θ °
Inset mm
Roller ID mm
Brg-Brg mm
Delta μm
D/F Class
Angle °
React. kg
Wt kg
Crit. RPM
Crit. MPM
MI kg.m
Steel
Aluminium
C-Low
C-Med
C-High
Dead Shaft
Live Shaft 
//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 = {
        WL:sliders.SlideWL.value,
        W1:sliders.SlideWeb1.value*Math.PI/180, //deg to rad
        W2:sliders.SlideWeb2.value*Math.PI/180, //deg to rad
        NL:sliders.SlideNL.value,
        NA:sliders.SlideNA.value*Math.PI/180, //deg to rad
        OD: sliders.SlideOD.value /1e3, //mm to m
        ID: sliders.SlideID.value /1e3, //mm to m
        Face: sliders.SlideFace.value /1e3, //mm to m
        Inset: sliders.SlideInset.value /1e3, //mm to m
        BB: sliders.SlideBB.value /1e3, //mm to m
        Steel: document.getElementById('Steel').checked,
        Aluminium: document.getElementById('Aluminium').checked,
        LowC: document.getElementById('LowC').checked,
        MedC: document.getElementById('MedC').checked,
        HighC: document.getElementById('HighC').checked,
        Dead: document.getElementById('Dead').checked,
        Live: document.getElementById('Live').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('Delta').value = result.Delta;
    document.getElementById('DF').value = result.Rel;
    document.getElementById('Angle').value = result.Theta;
    document.getElementById('Reaction').value = result.Mag;
    document.getElementById('Weight').value = result.Weight;
    document.getElementById('RPM').value = result.CV;
    document.getElementById('MPM').value = result.V;
    document.getElementById('MI').value = result.MI;

    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({ WL, W1, W2, OD, Face,NL,NA,Inset,ID,BB,Steel, Aluminium, LowC, MedC, HighC, Dead, Live}) {
    const L1=WL*9.807
    const L2=NL*9.807
    let AW1=W1
    let AW2=W2
    const A1=0.5*(AW1+AW2)-Math.PI/2
    if (AW1>AW2) A1-=Math.PI
    let A2=NA+Math.PI/2
    let IS=Inset
    ID=Math.min(ID,OD-0.001) //Don't allow ID>=OD!
    const Width=Face
    const WidthPlus=Math.max(Width,BB) //Don't allow to go below Width
    IS=Math.min(IS,Width/2*0.22) //You start getting end lift beyond 22% of the half width
    let Density=7860,E=2E11
    if (Aluminium) {Density=2710; E=6.9E10}
    if (LowC) {Density=1630; E=1.0E11}
    if (MedC) {Density=1630; E=1.65E11}
    if (HighC) {Density=1630; E=2.70E11}
    const rho=Density
    Density*=9.807 //N/m3
    const s=Density*Math.PI/4*(OD*OD-ID*ID)
    const Weight=s*Width/9.807 //Needed to correct the N change to density!
    let corr=Math.sin((AW1-AW2)/2)
    if (corr<0) corr=Math.sin(Math.PI+(AW1-AW2)/2)
    const Web=2*L1*corr/Width
    const Nip=L2/Width
    const x=Web*Math.cos(A1)+Nip*Math.cos(A2)
    const y=Web*Math.sin(A1)+Nip*Math.sin(A2)+s
    const w=Math.sqrt(x*x+y*y)
    let theta=Math.atan2(y,x)*180/Math.PI+90
    if (x==0) theta=0
    const I=Math.PI/64*(OD*OD*OD*OD-ID*ID*ID*ID)
    const MI=Width*rho*Math.PI/32*(OD*OD*OD*OD-ID*ID*ID*ID) //For Roisum
    let Delta=5*w*Math.pow(Width,4)/(384*E*I)
    if (IS>0.1)
    {
        //Swap to Tim Walker's nomenclature as originator of this calculation
        const WW=w, AA=IS, G5=Width-2*AA,G6=AA,EE=E,II=I 
     Delta=-WW/384*G5*G5*(24*G6*G6-5*G5*G5)/EE/II
    }
    if (Live) {Delta=(12*WidthPlus-7*Width)*w*Math.pow(Width,3)/(384*E*I)}
    
    const DWv=Delta/Width*1e6
    const DW=DWv.toFixed(0)
    let DWs="X"
    if (DWv<600) DWs="D"
    if (DWv<300) DWs="C"
    if (DWv<150) DWs="B"
    if (DWv<80) DWs="A"
    
//Now the Wt and Crit stuff
const CV=94.25*Math.sqrt(E*I/(Weight*Width*Width*Width))
const V=CV*Math.PI*OD

//Now the graphics

const theCanvas =document.getElementById('canvas');
ctx = theCanvas.getContext("2d");
const xc=theCanvas.width/2
const yc=theCanvas.height/2
const Radius=50
ctx.clearRect(0,0,theCanvas.width,theCanvas.width)
ctx.beginPath();
ctx.fillStyle="green"
ctx.arc(xc, yc, Radius, 0, 2 * Math.PI);
ctx.fill();
if (L2>0.01)
{
A2+=Math.PI
ctx.beginPath();
ctx.fillStyle="magenta"
const NLR=Math.pow(NL/5000,0.25)
ctx.arc(yc+(1+NLR)*Radius*Math.cos(A2), yc+(1+NLR)*Radius*Math.sin(A2), Radius*NLR, 0, 2 * Math.PI);
ctx.fill();

}
DrawArrow(xc,yc,180,Radius,'black',false,ctx)
if (L1>0){
AW1-=Math.PI
AW2-=Math.PI
var Lxc=Radius*Math.sin(AW1)
var Lyc=Radius*Math.cos(AW1)
DrawArrow(xc-Lxc,yc+Lyc,AW1*180/Math.PI-90,Radius,'blue',false,ctx)
var Lxc=Radius*Math.sin(AW2)
var Lyc=Radius*Math.cos(AW2)
DrawArrow(xc-Lxc,yc+Lyc,AW2*180/Math.PI+90,Radius,'blue',false,ctx)
}
DrawArrow(xc,yc,theta,Radius,'red',false,ctx)
    
        
    //Now we return everything - text boxes, plot and the name of the canvas, which is 'canvas' for a single plot
    return {
        Delta:(Delta*1e6).toPrecision(3),
        Rel:(DW+ " " + DWs),
        Theta:theta.toFixed(0),
        MI:MI.toPrecision(3),
        Mag:(w*Width/9.806/2).toFixed(1),
        CV:CV.toFixed(0),
        V:V.toFixed(0),
        Weight:Weight.toFixed(1),

    };
}

// 

function DrawArrow(xc, yc, theta, l, col, inverted, ctx) {
    const sign=inverted?1:-1
    theta*=Math.PI/180
    theta+=sign*Math.PI/2
    // Compute end of shaft
    const  headLength = l * 0.2, headAngle = Math.PI / 8
    const x2 = xc + l * Math.cos(theta);
    const y2 = yc + l * Math.sin(theta);
  
    ctx.save();                             // Preserve current context state
    ctx.strokeStyle = col;
    ctx.fillStyle   = col;
    ctx.lineWidth   = 2; 
  
    // Draw shaft
    ctx.beginPath();
    ctx.moveTo(xc, yc);
    ctx.lineTo(x2, y2);
    ctx.stroke();
  
    // Draw arrowhead as a filled triangular wedge
    ctx.beginPath();
    // Compute the two wing points of the arrowhead
    const angle1 = theta + Math.PI - headAngle;
    const angle2 = theta + Math.PI + headAngle;
    const x3 = x2 + headLength * Math.cos(angle1);
    const y3 = y2 + headLength * Math.sin(angle1);
    const x4 = x2 + headLength * Math.cos(angle2);
    const y4 = y2 + headLength * Math.sin(angle2);
  
    ctx.moveTo(x2, y2);
    ctx.lineTo(x3, y3);
    ctx.lineTo(x4, y4);
    ctx.closePath();
    ctx.fill();
  
    ctx.restore();                          // Restore context to pre‑draw state
  }

What does this app do?

To find out how much a roller will bend under any combination of its own weight, the tension of the web and the force from a nip roller. The web and nip can act at arbitrary angles. All aspects of roller design are covered in The Web Handling Handbook by Roisum, Walker and Jones in Chapter 3, which includes an explanation of bending deflection and its effects.

Bending equation

Under a load, L, a roller of width W, modulus E and "area moment of inertia" I will bend by `Delta=(5LW^4)/(384EI)`

We all know that wider rollers bend more, but just a 10% increase in width gives a 50% increase in deflection, so the width effects are strong.

The "area moment of inertia" depends on the dimensions of the roller. Rollers are shells with an ID and OD. The moment of inertia depends on OD4-ID4 so a slightly thinner shell (smaller OD or larger ID) gives more deflection - a 15% decrease in OD doubles the deflection.

There is a choice of three materials, each with its representative Density and Modulus. The "Composite" has been split into three types, Low, Med and High based on expert input on the Density and Modulus values for these materials. There is a significant cost factor across this range as the high modulus version uses super-expensive carbon fibres.

A Dead Shaft roller uses the equation as shown. a Live Shaft roller uses a slightly more complex equation with a Width+ term which includes the bearings. For those who care just about deflection relative to the web, simply used the Dead Shaft calculation. If inputs to the calculation aren't realistic (e.g. ID>OD) the calculation provides some safe value - it's up to you to spot the fact that there is something wrong with the input.

Inset

A rather more complex roller design allows the shell to be coupled to the support shaft at a distance ("inset") from the end of the roller. As the inset moves closer to the center the deflection at the center decreases. As you move Inset away from the default ("normal") setting of 0 you will find that the central deflection decreases but after a certain point it makes no further difference. This is because beyond 22% of the distance from the edge to the center, although bending in the centre is reduced, bending at the end increases. As this app is only concerned with central bending it would be deceptive to allow calculations beyond 22%

Note that the calculation does not work for Live rollers, where the Inset value will be ignored.

The formula for the Inset option was kindly provided by Timothy Walker, one of the gurus behind these web handling apps.

Load

The Load comes from 3 effects.

  1. The weight of the roller itself based on its calculated volume and the Density of the material. Because the volume of material depends on OD²-ID², even though a thicker shell gives a bigger load, the deflection is always less because OD4 is bigger than OD².
  2. The tension from the web - this is twice the input value because the roller is being pulled by the incoming and outgoing web.
  3. The load from a nip roller.

Loads are given in kg and then converted to load/width for the calculation. The web and nip are assumed to act over the full width of the roller. Provided they are not too much narrower than the roller, errors from this approximation are very small.

Direction

Gravity always acts downwards (defined as 180°). The web and the nip can act in any direction. For example, a nip at the bottom of the roller (angle=180°) acts as a force upwards and in principle can stop the bending of the roller or, under extreme load, bend the roller upwards. The RBC calculates not only the overall bending but also its direction. The definitions of angles can be confusing, but the visual feedback should make it clear.

Results

The Deflection of the roller is calculated along with its Angle plus the Resultant of the combination of loads. Note that the Reaction shown is the Resultant divided by 2 - i.e. the load on each bearing. The ratio of Deflection/Face (multiplied by 1E6) gives an idea of how serious the deflection might be. The result is compared to a quality Class where A is the best and D is the worst. It is for you to judge if you have over- or under-engineered the roller. In Slider mode, playing with OD and ID whilst looking at the Class is a good way to see how much you can downsize the roller without sacrificing performance.

Roller Weight

Although the basic roller weight is calculated for you, you can calculate the weight of the whole roller (and get the full deflection) via the following steps which were suggested by an RBC user. Although a more sophisticated app could do this automatically, it was decided to keep things simple, hence this slightly inconvenient work-around.

  • Set up your roller ID, OD and material Set Nip and Web loads to zero
  • The "React." output, i.e. the force on each end, is half the weight of the roller - so just multiply by 2
  • If you want the weight of the journal, enter the total length of the journal, set Roller ID to 0 and Roller OD to the journal diameter. Multiply React. by 2
  • If you want the bending from the whole weight, go back to your roller then add the journal weight as a nip load at 0°

Mass Moment of Inertia

This is `(πρL)/32(OD^4-ID^4)` and is included for those who are interested in the value. The calculations are based on shell only: the head, journals and other elements are considered negligible as is almost always the case. Be careful of units.

Critical speed

It is often said that you can calculate a Critical Speed at which the roller will spontaneously start to vibrate. It is also often said that this calculation isn't worthwhile. You can choose to use the output or not. There are two formulae commonly used, the one used here is the Dunkerley method. Where E is the modulus, I is the second moment of area, m is the mass and L is the roll length: `Nc=94.25√((EI)/(mL^3))`.

The value is calculated both in RPM and in the peripheral velocity of the roller.

Acknowledgement

The sage advice of Dr David Roisum in developing and debugging this app is very much appreciated. The formulae and Deflection Classes are taken from his Mechanics of Rollers (Tappi Press, 1996) pp 30-33.