Fractional_distillation

# Fractional distillation  ## Microsims — three.js ### Fractional distillation (three.js) <div class="microsim-player"> <iframe src="https://wikitube-3d-microsims.netlify.app/Fractional_distillation.html" width="100%" height="620" frameborder="0" loading="lazy" sandbox="allow-scripts allow-same-origin" title="Fractional distillation — three.js microsim"></iframe> </div> **Open it full-screen:** [Fractional_distillation.html](https://wikitube-3d-microsims.netlify.app/Fractional_distillation.html) · library `threejs` · route `microsim/threejs/` ### Related microsims Live sims on neighbouring articles — 1 of them inside this article's own Wikipedia link tree: - [[Viscosity]] *(in tree)* - [[Liquid_helium]] - [[Reynolds_number]] *Sim hosted off-article; the article owns the reference, not the runtime (WIKI_RULES §10.4). Placed by `g08_place_microsims.py`.*  ## Microsim ### Live player <div class="microsim-player"> <iframe src="https://editor.p5js.org/sciencenibber/full/Q235FAdkq" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe> </div> <div class="microsim-fallback"> <img src="Microsims/thumbs/Fractional_distillation.png" alt="Fractional_distillation microsim poster" style="width:100%;border:1px solid #4445;border-radius:6px;"> <p><em>Live microsim (desktop) · <a href="https://editor.p5js.org/sciencenibber/sketches/Q235FAdkq">open sketch in the p5.js editor</a></em></p> </div> **Editor URL:** https://editor.p5js.org/sciencenibber/sketches/Q235FAdkq **Description (100 words):** The microsim draws a McCabe-Thiele construction for a binary column on a 720x520 canvas. Six sliders set relative volatility alpha, distillate purity x_D, bottoms x_B, feed x_F, reflux ratio R, and feed thermal state q. The plot redraws an equilibrium curve, the 45-degree diagonal, rectifying and stripping operating lines, the q-line, and the stair-step staircase of theoretical plates between distillate and bottoms. A green circle marks the pinch point on the equilibrium curve where the q-line lands, fixing R_min. Bottom-left readout shows N stages, feed stage, R_min, and Fenske N_min; the bar turns red when R drops below R_min and the column becomes infeasible. ```js // ===================================================================== // Fractional_distillation.js -- Wikitube microsim // Article: Fractional_distillation // en.wikitube.io/wiki/Fractional_distillation // Room: Helium Pattern: D // (Parametric curves, efficiency, performance analysis) // --------------------------------------------------------------------- // Idea: a live McCabe-Thiele construction for a binary distillation // column, parametrized by: // // alpha -- relative volatility (driver of the equilibrium curve) // x_D -- distillate (top) light-component mole fraction // x_B -- bottoms (bottom) light-component mole fraction // x_F -- feed composition // R -- reflux ratio L/D // q -- feed thermal state (1 = saturated liquid, 0 = sat. vapor) // // The reader scrubs six sliders. The sketch redraws: // // * equilibrium curve y = alpha*x / (1 + (alpha-1)*x) // * 45-degree diagonal y = x // * rectifying operating line y = R/(R+1) * x + x_D/(R+1) // * q-line through (x_F, x_F) with slope q/(q-1) // * stripping operating line from the q-line / rectifying // intersection down to (x_B, x_B) // * stair-step stage staircase from (x_D, x_D) to the first // step at or below x_B // * pinch point on the equilibrium curve (where q-line meets it), // which sets R_min // // Canonical equations behind the parametric curves: // // Equilibrium (constant alpha): y = a x / (1 + (a-1) x) // Fenske (minimum plates): // N_min = log[(x_D/(1-x_D)) * ((1-x_B)/x_B)] / log(alpha) // Underwood (minimum reflux, sat. liquid feed): // R_min = (x_D - y_pinch) / (y_pinch - x_F) // Gilliland correlation links actual N and R to (N_min, R_min): // (N - N_min)/(N + 1) = f((R - R_min)/(R + 1)) // // The reader watches the staircase grow or shrink as alpha is dialed // up or R is dialed down, and watches the stripping section flip when // the q-line is dragged across the feed plate. // // Visual layout (720 x 520 canvas): // * top-left: HUD title + Wikitube URL subtitle // * top-right: control hints // * left half: McCabe-Thiele x-y plot, 380 x 380, square // * right side: six sliders with live numeric value display // * bottom-left: live (N stages, feed stage, R_min) readout // * bottom-right: canonical Fenske equation // // Helium relevance: the helium nitrogen-rejection unit at the back // end of a natural-gas helium plant is a cryogenic fractionator, // separating He (b.p. 4.222 K) from N2 (b.p. 77.4 K) -- a binary // with enormous relative volatility. Air-separation units that // produce O2 / N2 / Ar at 78-90 K are also fractional distillations. // The same construction shown here scales from a 3 m bench-top // ethanol still to a 60 m crude tower. // // Conventions (Wikitube Betterfire Standard v0): // * single ARTICLE constant at the top, single quotes // * p5.disableFriendlyErrors = true (no FES noise) // * non-ASCII (Greek alpha, dots, arrows) lives in COMMENTS ONLY; // every text() string literal is ASCII // * Energy-room palette (P5_JS_EDITOR section 4): dark BG, HOT/COLD // tones, STRUCT grey, TRAJ accent // * every createSlider is followed by .position(x,y).size(w) // ===================================================================== const ARTICLE = 'Fractional_distillation'; const TITLE = ARTICLE.replace(/_/g, ' '); p5.disableFriendlyErrors = true; // ----- Energy room palette (P5_JS_EDITOR section 4, line 165) -------- const BG = 18; const FG = 240; const DIM = [240, 240, 240, 140]; const HOT = [220, 110, 60]; // warm: hot vapor / rectifying line const COLD = [60, 130, 220]; // cool: cold liquid / stripping line const STRUCT = [120, 130, 150]; // structural grey: axes / diagonal const TRAJ = [240, 220, 80]; // staircase / stage steps const ACCENT = [200, 100, 220]; // q-line (magenta) const PINCH = [120, 220, 140]; // pinch-point marker const EQUIL = [240, 200, 120]; // equilibrium curve // ----- Plot rectangle in canvas pixels (set in setup) ---------------- let plotX, plotY, plotS; // plotS = side length of square plot // ----- Slider handles ------------------------------------------------ let sliderAlpha, sliderXD, sliderXB, sliderXF, sliderR, sliderQ; // ----- Stage cap (safety) ------------------------------------------- const MAX_STAGES = 60; // ----- Per-frame state shared with the HUD (set in draw, read in // drawHUD). Kept at module scope so drawHUD() takes no args, // which the Betterfire validator BF7 regex requires. let frameMT = null; let frameR = 0; function setup() { createCanvas(720, 520); pixelDensity(2); textFont('system-ui'); // Square plot in the left half of the canvas. plotX = 60; plotY = 60; plotS = 380; // Right-side sliders. All six get explicit .position().size() // (Betterfire Standard: no floating defaults). const SX = 470; // slider x const SW = 170; // slider width let sy = 80; // running y const SDY = 46; // row pitch sliderAlpha = createSlider(1.2, 5.0, 2.5, 0.05 ).position(SX, sy).size(SW); sy += SDY; sliderXD = createSlider(0.80, 0.999, 0.95, 0.005).position(SX, sy).size(SW); sy += SDY; sliderXB = createSlider(0.005, 0.20, 0.05, 0.005).position(SX, sy).size(SW); sy += SDY; sliderXF = createSlider(0.20, 0.80, 0.50, 0.01 ).position(SX, sy).size(SW); sy += SDY; sliderR = createSlider(0.5, 10.0, 2.0, 0.1 ).position(SX, sy).size(SW); sy += SDY; sliderQ = createSlider(-0.2, 1.5, 1.0, 0.05 ).position(SX, sy).size(SW); } function draw() { background(BG); // Read sliders once per frame into named locals. const a = sliderAlpha.value(); const xD = sliderXD.value(); const xB = sliderXB.value(); const xF = sliderXF.value(); const R = sliderR.value(); const q = sliderQ.value(); // Build the construction (sliders -> derived state). const mt = buildMcCabeThiele(a, xD, xB, xF, R, q); // Stash for the HUD (called below with no args). frameMT = mt; frameR = R; // Order: axes -> equilibrium / diagonal -> operating lines -> // q-line -> staircase -> landmarks -> HUD. Later layers paint // on top of earlier ones. drawAxes(); drawEquilibriumCurve(a); drawDiagonal(); drawOperatingLines(R, xD, xB, mt); drawQLine(xF, q, mt); drawStaircase(mt); drawLandmarks(xD, xB, xF, mt); drawSliderLabels(a, xD, xB, xF, R, q); drawHUD(); } // ===================================================================== // Coordinate transforms: (x, y) in mole fraction <-> canvas pixels // Both x and y axes span 0..1 in mole fraction. y axis flipped. // ===================================================================== function xToPx(x) { return plotX + x * plotS; } function yToPy(y) { return plotY + (1 - y) * plotS; } // ===================================================================== // Equilibrium and operating-line algebra // ===================================================================== // Equilibrium relation for a constant-alpha binary system: // y = alpha * x / (1 + (alpha - 1) * x) // Inverted: x = y / (alpha - (alpha - 1) * y). function yEq(x, a) { return a * x / (1 + (a - 1) * x); } function xEq(y, a) { return y / (a - (a - 1) * y); } // Build the full McCabe-Thiele construction. Returns: // { steps, count, feedStage, xI, yI, Rmin, Nmin, xPinch, yPinch } function buildMcCabeThiele(a, xD, xB, xF, R, q) { // Rectifying line: y = mR * x + bR const mR = R / (R + 1); const bR = xD / (R + 1); // q-line / rectifying intersection (xI, yI). // q = 1 (saturated liquid) -> q-line is vertical at x = x_F. // q != 1 -> q-line slope is q / (q - 1), passing through (x_F, x_F). let xI, yI; if (Math.abs(q - 1) < 1e-6) { xI = xF; yI = mR * xI + bR; } else { const mQ = q / (q - 1); const bQ = xF - mQ * xF; // mR * x + bR = mQ * x + bQ -> x = (bQ - bR) / (mR - mQ) if (Math.abs(mR - mQ) < 1e-6) { xI = xF; yI = mR * xI + bR; } else { xI = (bQ - bR) / (mR - mQ); yI = mR * xI + bR; } } // Stripping line: passes through (xB, xB) and (xI, yI). const mS = (yI - xB) / Math.max(xI - xB, 1e-6); const bS = xB - mS * xB; function yOp(x) { return (x >= xI) ? (mR * x + bR) : (mS * x + bS); } // Stair-step from (xD, xD) downward until x <= xB or cap hit. const steps = []; let x = xD, y = xD; steps.push({ type: 'start', x, y }); let n = 0; let feedStage = -1; let crossed = false; while (x > xB && n < MAX_STAGES) { // Horizontal step: drop y along to the equilibrium curve. // From (x, y_op) on operating line, go LEFT to (x_eq, y_op). const xe = xEq(y, a); steps.push({ type: 'horiz', x: xe, y: y }); // Vertical step: from (x_eq, y_op) down to next operating line. const yNext = yOp(xe); steps.push({ type: 'vert', x: xe, y: yNext }); if (!crossed && xe < xI) { crossed = true; feedStage = n + 1; } x = xe; y = yNext; n++; // Defensive: equilibrium curve and stripping line can pinch and // produce a non-decreasing x, which would loop forever. if (steps.length >= 4) { const prev = steps[steps.length - 3]; if (Math.abs(prev.x - x) < 1e-4) break; } } // Fenske minimum stages (constant alpha, total reflux). const Nmin = Math.log((xD / Math.max(1 - xD, 1e-6)) * ((1 - xB) / Math.max(xB, 1e-6))) / Math.log(Math.max(a, 1.0001)); // Pinch point: q-line meets equilibrium curve. Bisection on x. let xPinch, yPinch; if (Math.abs(q - 1) < 1e-6) { xPinch = xF; yPinch = yEq(xF, a); } else { const mQ = q / (q - 1); const bQ = xF - mQ * xF; const f = (x) => (mQ * x + bQ) - yEq(x, a); let lo = 0.001, hi = 0.999; // Make sure f(lo) and f(hi) bracket a sign change. let fLo = f(lo), fHi = f(hi); if (fLo * fHi > 0) { xPinch = xF; yPinch = yEq(xF, a); } else { for (let i = 0; i < 50; i++) { const m = 0.5 * (lo + hi); const fm = f(m); if (fLo * fm <= 0) { hi = m; fHi = fm; } else { lo = m; fLo = fm; } } xPinch = 0.5 * (lo + hi); yPinch = yEq(xPinch, a); } } const Rmin = (xD - yPinch) / Math.max(yPinch - xPinch, 1e-6); return { steps, count: n, feedStage, xI, yI, Rmin, Nmin, xPinch, yPinch }; } // ===================================================================== // Drawing // ===================================================================== function drawAxes() { push(); noFill(); stroke(STRUCT); strokeWeight(1); rect(plotX, plotY, plotS, plotS); // Grid + tick labels every 0.1 on both axes. noStroke(); fill(...DIM); textSize(10); for (let v = 0; v <= 1.0001; v += 0.1) { // x-axis ticks (bottom) const x = xToPx(v); stroke(STRUCT, 80); line(x, plotY + plotS, x, plotY + plotS + 4); noStroke(); textAlign(CENTER, TOP); text(nf(v, 1, 1), x, plotY + plotS + 6); // y-axis ticks (left) const y = yToPy(v); stroke(STRUCT, 80); line(plotX - 4, y, plotX, y); noStroke(); textAlign(RIGHT, CENTER); text(nf(v, 1, 1), plotX - 6, y); } // Axis titles textAlign(CENTER, TOP); fill(...DIM); textSize(12); text('x (liquid mole fraction, light component)', plotX + plotS / 2, plotY + plotS + 22); push(); translate(plotX - 36, plotY + plotS / 2); rotate(-PI / 2); text('y (vapor mole fraction, light component)', 0, 0); pop(); pop(); } function drawDiagonal() { // 45-degree y = x line: the line of equal compositions, against // which the stage staircase reflects. push(); stroke(STRUCT, 160); strokeWeight(1); line(xToPx(0), yToPy(0), xToPx(1), yToPy(1)); noStroke(); fill(...DIM); textSize(10); textAlign(LEFT, BOTTOM); text('y = x', xToPx(0.86) + 4, yToPy(0.86) - 4); pop(); } function drawEquilibriumCurve(a) { // y = alpha * x / (1 + (alpha-1) * x), sampled densely. push(); noFill(); stroke(...EQUIL); strokeWeight(2); beginShape(); for (let i = 0; i <= 200; i++) { const x = i / 200; vertex(xToPx(x), yToPy(yEq(x, a))); } endShape(); // Label near the top of the curve. noStroke(); fill(...EQUIL); textSize(11); textAlign(LEFT, TOP); const xLab = 0.55; text('equilibrium y = a x / (1 + (a-1) x)', xToPx(xLab) + 4, yToPy(yEq(xLab, a)) - 14); pop(); } function drawOperatingLines(R, xD, xB, mt) { push(); // Rectifying line from (xD, xD) down to the q-line intersection. stroke(...HOT); strokeWeight(2); noFill(); line(xToPx(xD), yToPy(xD), xToPx(mt.xI), yToPy(mt.yI)); noStroke(); fill(...HOT); textSize(10); textAlign(LEFT, TOP); text('rectifying slope = R/(R+1)', xToPx(0.78), yToPy(0.84)); // Stripping line from (xB, xB) up to the intersection. stroke(...COLD); strokeWeight(2); noFill(); line(xToPx(xB), yToPy(xB), xToPx(mt.xI), yToPy(mt.yI)); noStroke(); fill(...COLD); textSize(10); textAlign(LEFT, TOP); text('stripping', xToPx(mt.xI) + 4, yToPy(mt.yI) + 6); pop(); } function drawQLine(xF, q, mt) { push(); stroke(...ACCENT); strokeWeight(1.5); drawingContext.setLineDash([4, 4]); noFill(); // q-line passes through (xF, xF). Extend to plot bounds. if (Math.abs(q - 1) < 1e-6) { // Vertical q-line at x = xF line(xToPx(xF), yToPy(0), xToPx(xF), yToPy(1)); } else { const mQ = q / (q - 1); // y = mQ * (x - xF) + xF; clip to plot rectangle. const yAt = (x) => mQ * (x - xF) + xF; let xA = 0, xZ = 1; // Trim against the canvas if the slope sends the line off-screen. if (Math.abs(mQ) > 1e-3) { const yL = yAt(0), yR = yAt(1); if (yL < 0) xA = (-xF * mQ + xF + 0) / mQ; // y=0 crossing if (yL > 1) xA = (-xF * mQ + xF + 1) / mQ; // y=1 crossing if (yR < 0) xZ = (-xF * mQ + xF + 0) / mQ; if (yR > 1) xZ = (-xF * mQ + xF + 1) / mQ; xA = constrain(xA, 0, 1); xZ = constrain(xZ, 0, 1); } line(xToPx(xA), yToPy(yAt(xA)), xToPx(xZ), yToPy(yAt(xZ))); } drawingContext.setLineDash([]); noStroke(); fill(...ACCENT); textSize(10); textAlign(LEFT, BOTTOM); text('q-line (q = ' + nf(q, 1, 2) + ')', xToPx(xF) + 4, yToPy(xF) - 4); pop(); } function drawStaircase(mt) { push(); stroke(...TRAJ); strokeWeight(1.5); noFill(); beginShape(); for (const s of mt.steps) { vertex(xToPx(s.x), yToPy(s.y)); } endShape(); // Number each plate at its corner. noStroke(); fill(...TRAJ); textSize(9); textAlign(CENTER, CENTER); let plate = 0; for (let i = 1; i < mt.steps.length; i += 2) { plate++; const s = mt.steps[i]; // Small offset so the digit doesn't overlap the corner stroke. text(plate, xToPx(s.x) - 8, yToPy(s.y) - 8); } pop(); } function drawLandmarks(xD, xB, xF, mt) { push(); // Distillate point (x_D, x_D) on the diagonal. fill(...HOT); noStroke(); circle(xToPx(xD), yToPy(xD), 6); // Bottoms point (x_B, x_B) on the diagonal. fill(...COLD); circle(xToPx(xB), yToPy(xB), 6); // Feed point (x_F, x_F) on the diagonal. fill(...ACCENT); circle(xToPx(xF), yToPy(xF), 6); // Pinch point: where q-line meets the equilibrium curve. // This is the (R_min) tangency that bounds the rectifying line. noFill(); stroke(...PINCH); strokeWeight(2); circle(xToPx(mt.xPinch), yToPy(mt.yPinch), 10); noStroke(); fill(...PINCH); textSize(9); textAlign(LEFT, TOP); text('pinch (R_min)', xToPx(mt.xPinch) + 8, yToPy(mt.yPinch) + 6); pop(); } function drawSliderLabels(a, xD, xB, xF, R, q) { push(); noStroke(); fill(...DIM); textSize(11); textAlign(LEFT, BOTTOM); const labels = [ ['alpha (rel. volatility)', a, 2 ], ['x_D (distillate)', xD, 3 ], ['x_B (bottoms)', xB, 3 ], ['x_F (feed)', xF, 2 ], ['R (reflux ratio)', R, 2 ], ['q (feed thermal)', q, 2 ] ]; const SX = 470; let sy = 80; const SDY = 46; for (let i = 0; i < labels.length; i++) { const [name, val, places] = labels[i]; fill(...DIM); text(name, SX, sy - 4); fill(FG); textAlign(RIGHT, BOTTOM); text(nf(val, 1, places), SX + 230, sy - 4); textAlign(LEFT, BOTTOM); sy += SDY; } pop(); } function drawHUD() { const mt = frameMT; const R = frameR; if (!mt) return; // Top-left: title (Betterfire Standard rule 2). noStroke(); fill(FG); textAlign(LEFT, TOP); textSize(22); text(TITLE, 14, 12); fill(...DIM); textSize(12); text('Wikitube microsim . en.wikitube.io/wiki/Fractional_distillation', 14, 40); // Top-right: control hints (Betterfire Standard rule 3). textAlign(RIGHT, TOP); textSize(10); fill(...DIM); text('drag the sliders to rebuild the column', width - 14, 12); text('alpha up -> fewer plates needed', width - 14, 24); text('R down to R_min -> plates blow up', width - 14, 36); // Bottom-left: live (N, R_min, feed stage) readout. textAlign(LEFT, BOTTOM); fill(...DIM); textSize(12); const fsTxt = (mt.feedStage > 0) ? mt.feedStage : '--'; const nTxt = (mt.count >= MAX_STAGES) ? (MAX_STAGES + '+') : ('' + mt.count); text('N stages = ' + nTxt + ' feed stage = ' + fsTxt + ' R_min = ' + nf(mt.Rmin, 1, 2) + ' N_min = ' + nf(mt.Nmin, 1, 2), 14, height - 22); // Bottom-left line 2: warn if R is below R_min (pinch / infeasible). if (R < mt.Rmin) { fill(220, 80, 80); textSize(11); text('warning: R < R_min -- column cannot reach x_D from x_F', 14, height - 6); } else { fill(FG); textSize(12); text('phase: feasible operation (R > R_min)', 14, height - 6); } // Bottom-right: canonical equation (Betterfire Standard rule 4). textAlign(RIGHT, BOTTOM); fill(FG); textSize(12); text('N_min = log[(x_D/(1-x_D)) (1-x_B)/x_B] / log(alpha) [Fenske]', width - 14, height - 6); } // ===================================================================== // End of Fractional_distillation.js -- Helium room, Pattern D. // ===================================================================== ``` ## Links (Wikipedia order)  `Air_separation` · `Alembic` · `Alkane` · [[Argon]] · `Avicenna` · `Azeotrope` · `Azeotropic_distillation` · `Batch_distillation` · `Boiling_chip` · [[Boiling_point]] · `Catalytic_distillation` · `Chemical_compound` · `Chemical_plant` · `Chlorosilane` · `Combustion` · `Condenser_(heat_transfer)` · `Continuous_distillation` · `Dalton's_law` · `Destructive_distillation` · [[Distillation]] · `Distillation_Design` · `Dry_distillation` · `Ethanol` · `Extractive_distillation` · `Fenske_equation` · `Fraction_(chemistry)` · `Fractionating_column` · `Fractionation` · `Frederic_L._Holmes` · `Gas` · `Gerard_of_Cremona` · `Jabir_ibn_Hayyan` · `Kugelrohr` · `Laboratory_glassware` · `Liebig_condenser` · `Liquid_nitrogen` · `Liquid_oxygen` · `Magnetic_stirrer` · `Mass_transfer` · `McCabe–Thiele_method` · `Mixture` · `Oil_refinery` · `Partial_pressure` · `Paul_Kraus_(Arabist)` · `Perkin_triangle` · `Perry's_Chemical_Engineers'_Handbook` · `Petrochemical` · `Petroleum_refining_processes` · `Porosity` · `Raoult's_law` · `Raschig_ring` · `Reactive_distillation` · `Reflux` · `Roger_Bacon` · `Rotary_evaporator` · `Salt-effect_distillation` · `Semiconductor` · `Separation_process` · [[Silicon]] · `Silvering` · `Simulation` · `Spinning_band_distillation` · `Spinning_cone` · `Steady_state` · `Steam_distillation` · `Still` · `Structured_packing` · `Temperature` · `Theoretical_plate` · `Thermometer` · `Vacuum_distillation` · `Vaporization` · `Vapor–liquid_equilibrium` · [[Viscosity]] · `William_R._Newman` ## From the vault media library !Fractional distillation thumb.png *Fractional Distillation — from the vault's own media holdings, placed 2026-07-09. MTN / Wikitube.io original · CC BY-SA 4.0.*  > **Room:** [[Helium]] · **Status:** ✅ shipped ## Overview **Fractional distillation** is a separation technique that partitions a liquid mixture into its component fractions by exploiting differences in their boiling points. It is the workhorse separation of the petrochemical, beverage, cryogenic-gas, and fine-chemical industries, and the principal method by which crude helium is recovered from [[Natural_gas|natural gas]]. A fractionating column placed above the still imposes a continuous countercurrent contact between rising vapor and descending liquid reflux; each stage of contact enriches the vapor in the more volatile component, so that a tall, well-insulated column of theoretical stages can drive a binary cut arbitrarily close to its thermodynamic limit. The governing relation is Raoult's law combined with the relative volatility α = (y_A/x_A)/(y_B/x_B), where x and y are the liquid and vapor mole fractions. The Fenske equation gives the minimum number of theoretical plates at total reflux, N_min = log[(x_D/(1−x_D)) · ((1−x_B)/x_B)] / log α; the Underwood equation gives the minimum reflux ratio; and Gilliland's correlation relates the actual stages and reflux to the operating cost of any real column. McCabe-Thiele construction visualizes the same answer graphically on an x-y equilibrium plot. Industrial implementations span ambient-pressure ethanol stills, vacuum crude-oil towers handling millions of barrels per day, low-temperature air-separation units producing oxygen and nitrogen, and the deep-cryogenic helium nitrogen-rejection units that strip nitrogen, methane, and trace gases from raw helium at 80-100 K. [[Energy]] efficiency is bounded below by the minimum work of separation, and modern columns recover much of the reboiler duty through heat-integrated reflux and side-stream condensers. ## See also - Room hub: [[Helium]] - p5.js Editor conventions: P5 JS EDITOR - Wiki root: MAIN --- *Scaffolded by `generative-microsim` from row 47 of the Helium sheet on 2026-05-12T00:34:56Z.*   *Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*  ## Wikipedia : Wikitube **Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Fractional_distillation) : [Wikitube](https://en.wikitube.io/wiki/Fractional_distillation) ## Previous hub tags Tree parents: [[Helium]] · [[Oxygen]]. Legacy hubs: none. --- *Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*