martin/RollCalcPython
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
RollCalcPython/docs/STDDEV_RANGES_DOCS.md
T

8.9 KiB
Raw Permalink Blame History

RollCalc V14 - Quality of Life Update: Standard Deviation Ranges

🎯 Feature Overview

Add ±2σ (95% confidence intervals) for Roll Diameter and Roll Weight based on actual production data variance.

Implementation:

  • Direct Calculation Tab: Show MIN/NOM/MAX values
  • Forklift Checker: Use worst-case (maximum) weight
  • Load Optimizer: Use nominal values (no change)

📊 Where Data Comes From

Each product in article-data.json has:

{
  "nr": "180005",
  "thickness": 6.227909,
  "thickness_stddev": 0.379181,        // ← NEW: Use this
  "area_weight": 3899.020066,
  "area_weight_stddev": 133.240428,    // ← NEW: Use this
  ...
}

Interpretation:

  • thickness ± 2×stddev = 95% of rolls will be within this range
  • Same for area_weight

🧮 Formulas

Roll Diameter with ±2σ

t_min = thickness - 2×thickness_stddev  (thinnest product)
t_max = thickness + 2×thickness_stddev  (thickest product)

D_min = √(d² + 4×L×t_min / π)           (largest diameter)
D_nom = √(d² + 4×L×t_nom / π)           (nominal)
D_max = √(d² + 4×L×t_max / π)           (smallest diameter)

Note: Thinner product → Larger roll (counterintuitive but correct!)

Weight with ±2σ

aw_min = area_weight - 2×area_weight_stddev
aw_nom = area_weight
aw_max = area_weight + 2×area_weight_stddev

Weight_min = aw_min × Length × Width / 1000
Weight_nom = aw_nom × Length × Width / 1000
Weight_max = aw_max × Length × Width / 1000

🎨 UI Display

Direct Calculation Result

Before:

Roll Diameter (D)
460.5 mm

After:

Roll Diameter (D)
460.5 mm

Range (±2σ): 450.2 – 470.8 mm

Forklift Checker

Before:

Roll weight: 975 kg
Status: OK

After:

Roll weight: 975 kg (nom) / 1030 kg (worst-case)
Status: OK
[Uses 1030 kg for checking]

Load Optimizer

No change - continues to use nominal values.

🛠️ Implementation Steps

Step 1: Include New JavaScript Files

Add to roll_calculator.html in <head>:

<script src="/static/rollcalc_improvements.js"></script>
<script src="/static/rollcalc-stddev-ranges.js"></script>
<script src="/static/rollcalc-stddev-integration.js"></script>

Step 2: Store StdDev During Article Selection

In rollcalc_improvements.js, update article selection handler:

if (match) {
  // ... existing code ...
  
  // NEW: Store stddev values for later use
  document.getElementById('d-th').dataset.stddev = match.thickness_stddev || 0;
  document.getElementById('d-aw').dataset.stddev = match.area_weight_stddev || 0;
  
  console.log('[StdDev] Stored:', {
    thickness_stddev: match.thickness_stddev,
    area_weight_stddev: match.area_weight_stddev
  });
}

Step 3: Update Direct Calc Button Handler

Replace the diameter calculation in d-calc click handler:

if (mode === 'diameter') {
  const result = window.StdDevIntegration.calculateDiameterWithStddev(
    d_mm, t_mm, null, L_m, tol
  );
  if (!result) return;
  
  const diameterRanges = result.diameterRanges;
  const calculatedLength = result.calculatedLength;
  
  // Calculate weight with ranges
  const weightRanges = window.StdDevIntegration.calcWeightWithStddev(calculatedLength);
  
  // Forklift check with worst-case
  window.StdDevIntegration.evaluateForkliftWithWorstCase(d_mm, category);
}

Step 4: Update Weight Display

function calcWeight(length) {
  // Use new function that returns ranges
  return window.StdDevIntegration.calcWeightWithStddev(length);
}

📝 Example Output

User Input:

  • Article: 180005 (Bfix NSP 4000)
  • Length: 50 m
  • Core: 150 mm

Article Data:

{
  "thickness": 6.227909 mm,
  "thickness_stddev": 0.379181 mm,
  "area_weight": 3899.020066 g/m²,
  "area_weight_stddev": 133.240428 g/m²
}

Calculation (±2σ):

t_min = 6.228 - 2×0.379 = 5.470 mm
t_nom = 6.228 mm
t_max = 6.228 + 2×0.379 = 6.986 mm

D_min (largest) = √(150² + 4×50000×5.470/π) = 491.2 mm
D_nom = √(150² + 4×50000×6.228/π) = 502.8 mm
D_max (smallest) = √(150² + 4×50000×6.986/π) = 514.4 mm

aw_min = 3899.02 - 2×133.24 = 3632.54 g/m²
aw_nom = 3899.02 g/m²
aw_max = 3899.02 + 2×133.24 = 4165.50 g/m²

Weight_min = 3632.54 × 50 × 5.0 / 1000 = 908.1 kg
Weight_nom = 3899.02 × 50 × 5.0 / 1000 = 974.8 kg
Weight_max = 4165.50 × 50 × 5.0 / 1000 = 1041.4 kg

Result Display:

Roll Diameter (D)
502.8 mm

Range (±2σ): 491.2 – 514.4 mm

---

Roll Weight
974.8 kg (nom)

Range (±2σ): 908.1 – 1041.4 kg

[Forklift Checker uses: 1041.4 kg worst-case]

🧪 Testing Checklist

Test Case 1: Direct Calc with StdDev

  • Select article with stddev data
  • Verify ranges display in result
  • Check formula is correct (min < nom < max for weight)
  • Check diameter order is correct (thinner product → larger roll)

Test Case 2: Article with Zero StdDev

  • Select article with stddev = 0
  • Ranges should show: nom = min = max
  • System should handle gracefully

Test Case 3: Forklift Checker Uses Worst-Case

  • Calculate weight with ranges
  • Check forklift checker uses weight_max
  • Try to trigger warning with worst-case

Test Case 4: Load Optimizer Gets Nominal

  • Complete calculation with ranges
  • Open Load Optimizer
  • Verify it uses nominal weight (not max)

Test Case 5: Backward Compatibility

  • Article data without stddev fields should work
  • Default stddev to 0 if missing
  • Display should adjust gracefully

💻 Code Files

Two new JavaScript modules are provided:

rollcalc-stddev-ranges.js

Core calculation functions:

  • calculateDiameterRanges() - Calculate D_min/nom/max
  • calculateWeightRanges() - Calculate Weight_min/nom/max
  • displayDiameterResult() - Format and display results
  • displayWeightRanges() - Store weight ranges in data attributes
  • evaluateForkliftWithStddev() - Forklift check with worst-case

Export: window.StdDevCalculator

rollcalc-stddev-integration.js

Integration functions:

  • calculateDiameterWithStddev() - Wrapper for direct calc
  • calcWeightWithStddev() - Weight calculation with ranges
  • evaluateForkliftWithWorstCase() - Forklift evaluation

Export: window.StdDevIntegration

🔄 Data Flow

Article Selected
    ↓
Store thickness_stddev & area_weight_stddev in data attributes
    ↓
User clicks "Calculate"
    ↓
calculateDiameterWithStddev()
├─ Read stddev from data attribute
├─ Calculate D_min, D_nom, D_max
└─ Display results with ranges
    ↓
calcWeightWithStddev()
├─ Read stddev from data attribute
├─ Calculate Weight_min, nom, max
└─ Store in data attributes (weight_min, weight_max)
    ↓
Parallel paths:
├─ Forklift Checker → Use weight_max (worst-case)
└─ Load Optimizer → Use weight_nom (nominal)

🎯 Confidence Level (±2σ)

95% Confidence Interval:

  • 95% of all manufactured rolls will fall within MIN/MAX range
  • 5% of rolls may exceed these bounds (acceptable for manufacturing)

Why ±2σ and not ±1σ?

  • ±1σ = 68% confidence (too narrow, misses real variation)
  • ±2σ = 95% confidence (practical for manufacturing planning)
  • ±3σ = 99.7% confidence (too conservative, unrealistic)

🚨 Edge Cases Handled

Case Behavior
No stddev data Default to 0, show nom only
Negative stddev Clamp to 0
stddev > nominal Allow, shows full realistic range
Article without match No ranges calculated
Missing d-aw field Weight ranges skipped

📈 Performance Impact

New calculations per click:

  • 2 square roots (for D_min/max): ~1ms
  • 2 multiplications (for weight ranges): ~0.1ms
  • Total per calculation: ~1.1ms (negligible)

Memory footprint:

  • 6 new data attributes per article field: ~100 bytes
  • JavaScript module size: ~8 KB

✅ Backward Compatibility

✅ 100% Backward Compatible

  • Existing articles without stddev fields work fine
  • StdDev defaults to 0 if missing
  • Old calculations still work
  • No breaking changes to API or data format

📞 Questions?

What if an article has no stddev data? → System defaults stddev to 0, displays nominal value only

Can I disable stddev ranges? → Set stddev to 0 in article-data.json

Does this affect offline mode? → No, all calculations happen client-side

Can I export the ranges? → Add export button to include nom/min/max in output

🎉 Summary

This QoL update adds production variance visibility to the calculator:

✅ Users see realistic MIN/MAX expectations
✅ Forklift checker uses worst-case for safety
✅ Load Optimizer keeps using nominal values
✅ All based on actual production data
✅ Zero performance impact
✅ 100% backward compatible

Result: Better planning, fewer surprises! 🚀

Version: 14.1 (Quality of Life Update)
Date: 2026-07-01
Status: Ready for Implementation

Reference in New Issue View Git Blame Copy Permalink