Bearing Life Calculator: ISO 281 in PySide6

Bearing life calculation is the procedure that converts the relation between load, speed and load rating into operating hours through the ISO 281 basic rating life $L_{10}$. On lightly loaded R2R guide rolls, the upper limit of bearing size is set not by life but by the minimum-load condition. This article builds a PySide6 calculator that checks both conditions on one screen.

R2R guide-roll load path — web-tension resultant, roll weight, end bearings — Guide-roll load path concept. The web-tension resultant and the roll weight combine and split between the two end bearings.

1. Problem Definition — Life Is Ample, Yet the Review Is Not Finished

R2R roll bearings carry the web-tension resultant and the roll weight. Guide rolls are lightly loaded, so the calculated life comes out in tens of millions of hours. Design reviews often stop there.

The SKF catalogue, however, states as a general rule that a minimum load of 0.01C must be imposed on ball bearings and 0.02C on roller bearings. Under very light loads, failure mechanisms other than fatigue, such as skidding and smearing of raceways or cage damage, often prevail. The life equation alone does not show this condition. Which condition must be checked first on a lightly loaded roll, and does a larger bearing make it safer?

2. Kinematic Analysis — How the Tension Resultant Reaches the Bearings

When the web wraps the roll by angle $\theta$, the vector sum of entry and exit tension acts on the roll.

$$F_r=2T\sin\frac{\theta}{2}$$

Here $F_r$ is the tension resultant (N), $T$ the web tension (N) and $\theta$ the wrap angle (°). With roll weight $W$ (N) at angle $\gamma$ to the resultant, the total load combines by the law of cosines.

$$F_t=\sqrt{F_r^{2}+W^{2}+2F_rW\cos\gamma}$$

Assuming the two end bearings share the load equally, the radial load per bearing is $F_t/2$. Without axial load, the equivalent load $P$ is taken equal to the radial load (pure radial load assumption).

$$L_{10}=\left(\frac{C}{P}\right)^{p},\qquad L_{10h}=\frac{10^{6}}{60n}L_{10}$$

$C$ is the basic dynamic load rating (kN), $P$ the equivalent dynamic load (kN), $p$ the life exponent (ball 3, roller 10/3), $n$ the speed (rpm), $L_{10}$ the life in 10⁶ revolutions and $L_{10h}$ the life in hours (h).

$$s_0=\frac{C_0}{P_0}$$

$C_0$ is the basic static load rating (kN) and $P_0$ the equivalent static load (kN). Reference values are summarised below.

Item	Value	Source
Life exponent $p$	Ball 3, roller 10/3	SKF catalogue (per ISO 281)
Required life — machines for continuous 24-hour use	40,000–50,000 h	SKF catalogue Table 1
Required life — machines for 8 hours a day, fully utilised (incl. printing equipment, conveyor belts)	20,000–30,000 h	SKF catalogue Table 1
Recommended $s_0$ — ball, continuous motion, high load certainty	Permanent deformation accepted 0.5 / some 1 / not accepted 2	SKF catalogue Table 7
Recommended $s_0$ — ball, low load certainty (peak loading)	≥1.5 / ≥1.5 / ≥2	SKF catalogue Table 7
Minimum load	Ball 0.01C, roller 0.02C	SKF catalogue
SKF 6210 (deep groove ball)	50×90×20 mm, C 37.1 kN, C₀ 23.2 kN	SKF product data
SKF 22220 E (spherical roller)	100×180×46 mm, C 433 kN, C₀ 490 kN	SKF product data

R2R equipment does not appear in the SKF required-life table. Assuming electrode lines run continuously 24 hours a day, the 40,000–50,000 h row is applied and its upper value of 50,000 h is used as the required life (assumption).

3. Calculation/Formula Verification — SKF 6210 Guide-Roll Example

All example conditions are assumed values and must be re-confirmed by site measurement: web tension 300 N, wrap angle 180°, roll weight 200 N, resultant and weight in the same direction ($\gamma$=0°, worst case), line speed 60 m/min, roll diameter 100 mm.

$$F_r=2\times 300\times\sin 90^{\circ}=600\ \mathrm{N},\qquad F_t=600+200=800\ \mathrm{N},\qquad P=400\ \mathrm{N}$$

$$n=\frac{v}{\pi D}=\frac{60}{\pi\times 0.100}=191\ \mathrm{rpm}$$

The load per bearing is 400 N. On this roll the tension resultant is three times the roll weight.

$$L_{10h}=\frac{10^{6}}{60\times 191}\left(\frac{37.1}{0.400}\right)^{3}=6.96\times 10^{7}\ \mathrm{h}$$

$$SF_{1}=\frac{L_{10h}}{L_{req}}=\frac{6.96\times 10^{7}}{50000}=1392,\qquad SF_{2}=s_0=\frac{23.2}{0.400}=58$$

$SF_{1}$ is the fatigue-life margin and $SF_{2}$ the static safety factor. Both far exceed the recommended values. Fatigue and static strength do not govern this roll.

Next, the lower-bound condition.

$$P_{min}=0.01C=0.01\times 37.1=0.371\ \mathrm{kN},\qquad \frac{P}{P_{min}}=\frac{0.400}{0.371}=1.08$$

At normal tension the minimum load is exceeded by 8%. When tension drops to 150 N, as in threading or standby, the bearing load falls to 250 N and the ratio to 0.67. Low-tension operation falls outside the minimum-load condition.

A larger bearing makes it worse. With the spherical roller bearing SKF 22220 E, the minimum load becomes $0.02\times 433=8.66$ kN. The normal-tension bearing load of 0.400 kN is only 4.6% of that. The larger the guide-roll bearing, the better the life calculation looks and the further the minimum-load condition moves away.

4. Practical Application (Shop-notes) — PySide6 Calculator

The code below computes the tension resultant, ISO 281 life, static safety factor and minimum-load ratio on one screen. It passed offscreen execution and hand-calculation comparison tests with Python 3.11 and PySide6 6.11. Installation steps:

☐ Install Python 3.11 or later (select the option to add Python to PATH)
☐ Create a virtual environment in the work folder: python -m venv venv
☐ Activate it — Windows venv\Scripts\activate, macOS source venv/bin/activate
☐ Run pip install PySide6
☐ Save the code below as bearing_calc.py and run python bearing_calc.py

# bearing_calc.py — R2R guide-roll bearing life calculator (ISO 281 basic rating life)
# Tested with Python 3.11, PySide6 6.11 / run: python bearing_calc.py
import math
import sys

from PySide6.QtWidgets import (QApplication, QComboBox, QDoubleSpinBox,
                               QFormLayout, QLabel, QPushButton, QWidget)


def roll_load(T, theta_deg, W, gamma_deg):
    """Combine web-tension resultant and roll weight into the radial load per bearing [N]."""
    # Tension resultant: Fr = 2·T·sin(θ/2)  (θ = wrap angle)
    Fr = 2.0 * T * math.sin(math.radians(theta_deg) / 2.0)
    # Add roll weight (law of cosines): Ft = √(Fr² + W² + 2·Fr·W·cosγ)
    Ft = math.sqrt(Fr**2 + W**2 + 2.0 * Fr * W * math.cos(math.radians(gamma_deg)))
    # Assume the two end bearings share the load equally
    return Fr, Ft, Ft / 2.0


def bearing_check(kind, C_kN, C0_kN, P_N, n_rpm, L_req_h):
    """Compute ISO 281 life, static safety factor and minimum-load ratio."""
    P = P_N / 1000.0                         # N → kN (same unit as C)
    p = 3.0 if kind == "ball" else 10.0 / 3.0  # Life exponent: ball 3, roller 10/3
    L10 = (C_kN / P) ** p                    # Basic rating life [10^6 rev]
    L10h = 1e6 / (60.0 * n_rpm) * L10        # Converted to hours [h]
    SF1 = L10h / L_req_h                     # SF1: fatigue-life margin
    s0 = C0_kN / P                           # SF2: static safety factor s0 = C0/P0 (assume P0 = Fr)
    k_min = 0.01 if kind == "ball" else 0.02   # Minimum-load factor (SKF general rule)
    P_min = k_min * C_kN
    return {"L10h": L10h, "SF1": SF1, "s0": s0,
            "P_min_kN": P_min, "min_ratio": P / P_min}


class Calc(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("R2R Roll Bearing Life (ISO 281)")
        form = QFormLayout(self)
        self.kind = QComboBox()
        self.kind.addItems(["ball", "roller"])
        form.addRow("Bearing type", self.kind)
        # (label, default, min, max) — defaults = article example (SKF 6210, assumed conditions)
        spec = [("C [kN]", 37.1, 0.01, 5000), ("C0 [kN]", 23.2, 0.01, 5000),
                ("Tension T [N]", 300, 0, 1e5), ("Wrap angle θ [deg]", 180, 0, 360),
                ("Roll weight W [N]", 200, 0, 1e5), ("Angle γ [deg]", 0, 0, 180),
                ("Speed n [rpm]", 191, 0.01, 1e5), ("Required life [h]", 50000, 1, 1e7),
                ("Required s0", 1.5, 0.01, 100)]
        self.box = {}
        for label, val, vmin, vmax in spec:
            sb = QDoubleSpinBox()
            sb.setDecimals(2)
            sb.setRange(vmin, vmax)
            sb.setValue(val)
            form.addRow(label, sb)
            self.box[label] = sb
        btn = QPushButton("Calculate")
        btn.clicked.connect(self.run)
        form.addRow(btn)
        self.out = QLabel()
        self.out.setStyleSheet("font-family: monospace;")
        form.addRow(self.out)
        self.run()

    def v(self, key):
        return self.box[key].value()

    def run(self):
        Fr, Ft, P_N = roll_load(self.v("Tension T [N]"), self.v("Wrap angle θ [deg]"),
                                self.v("Roll weight W [N]"), self.v("Angle γ [deg]"))
        if P_N <= 0:  # Skip: the life equation diverges at zero load
            self.out.setText("P = 0 N: check tension and roll weight inputs.")
            return
        r = bearing_check(self.kind.currentText(), self.v("C [kN]"),
                          self.v("C0 [kN]"), P_N, self.v("Speed n [rpm]"),
                          self.v("Required life [h]"))
        ok = (r["SF1"] >= 1.0 and r["s0"] >= self.v("Required s0")
              and r["min_ratio"] >= 1.0)
        self.out.setText(
            f"Fr = {Fr:,.1f} N / Ft = {Ft:,.1f} N / P = {P_N:,.1f} N\n"
            f"L10h = {r['L10h']:,.0f} h / SF1 = {r['SF1']:,.1f}\n"
            f"s0 = {r['s0']:,.1f} / min load {r['P_min_kN']:.3f} kN "
            f"(ratio {r['min_ratio']:.2f})\nResult: {'OK' if ok else 'REVIEW'}")


if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = Calc()
    w.show()
    sys.exit(app.exec())

Alternative mechanism — spherical roller bearing (22220 E class): being self-aligning, it accommodates shaft inclination. Reason not adopted: its large rating makes the minimum load 0.02C (8.66 kN) about 22 times the guide-roll load (0.400 kN).
Input data: update C and C₀ in the calculator with the maker’s latest data. The SKF catalogue itself points to skf.com for the latest product data.
Low-tension modes: always enter the lowest tension of threading and standby modes and check the minimum-load ratio. If the ratio is below 1, review bearing size and load conditions.
Machinability: finish the bearing seats of the guide-roll shaft by grinding and specify the maker’s recommended fit tolerances on the drawing.

5. Design Checklist

Does the tension-resultant calculation include both maximum and minimum tension (including threading and standby)?
Is the angle γ between resultant and weight confirmed from the actual roll layout?
Are SF1 (life margin) and SF2 (static safety factor) compared with the maker’s recommendations?
Is the minimum-load ratio 1 or higher at the lowest tension?
Are C and C₀ updated with the maker’s latest data?

Items Requiring Confirmation

Required life for R2R equipment: not in the SKF table, so the continuous 24-hour row is applied (assumption).
Tension, weight, speed and roll diameter in the example: all assumed values.
Pure radial load: axial load is ignored by assumption. With axial load, apply the maker’s equivalent-load equation.
Minimum load 0.01C and 0.02C: SKF’s general rule. Re-check the precise requirement with the equations in the catalogue product sections.
ISO 281:2007 revision: the ISO web page states that this edition was confirmed in 2021 and is expected to be replaced by ISO/DIS 281. Re-check the scope of the life equation when the new edition is published.

One-line summary: On lightly loaded R2R guide rolls, the upper limit of bearing size is set not by the L10h life but by the 0.01C minimum load.

Sources: SKF, Rolling bearings PUB BU/P1 17000/1 EN (2018) · SKF 6210 product data · SKF 22220 E product data · ISO 281:2007 · ISO 76:2006 · BLH Nobel, Web Tension Design · Machine Design, Controlling web tension with load cells (2007-10-01)