Electric_power_transmission

# Electric power transmission ## Microsim <iframe src="https://editor.p5js.org/sciencenibber/full/xsQloH63c" width="100%" height="620" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe> <img src="../SPINTRONICS Images/Electric_power_transmission.png" alt="Electric_power_transmission microsim"> *Live sketch: [open in the p5.js editor](https://editor.p5js.org/sciencenibber/sketches/xsQloH63c). The poster image above is a placeholder pending an attended or server-side canvas capture.* ### p5.js source ```js // Electric_power_transmission.js -- Wikitube MicroSim // Hub: SPINTRONICS · Branch: P - Power transmission // Pattern: chart-frame + schematic glyphs (a quantitative law shown as a // one-line diagram whose conductor heats with loss, plus a // loss-fraction vs voltage curve). INPUT-DRIVEN: noLoop()+redraw(). // // CONCEPT // To feed real power P into a line at voltage V, the current is I = P/V, so // the resistive line loss is P_loss = I^2 R = (P/V)^2 R = P^2 R / V^2. // For fixed P and R the loss scales as 1/V^2 -- doubling the voltage quarters // the loss. That is the whole reason the grid transmits at high voltage. The // loss fraction is P_loss/P = P*R/V^2 and efficiency is eff = 1 - P*R/V^2. // Line resistance is R = r0*L (r0 = resistance per km, L = length). // (Single-phase, unity power factor, lumped R, reactance ignored. Three-phase // adds a sqrt(3)/factor-of-3 bookkeeping but the same 1/V^2 law.) // // GOLDEN RULES honoured: 720x520 + pixelDensity(2); layout derived from // width/height (no magic coords in draw); ASCII-only strings (Unicode only in // comments); SI units internally, convert at the input; default noLoop() + // redraw() on slider input (nothing animates -> editor-clean, no per-frame // inner loops); static scenery baked once into an offscreen buffer; HUD // watermark drawn last; one concept per control; reset restores ALL state; // p5.disableFriendlyErrors = true. const ARTICLE = "Electric_power_transmission"; // single source of truth (HUD + save + URL) // ---- physical constant ---- const R0_OHM_PER_KM = 0.07; // r0: typical overhead ACSR conductor resistance per km // ---- control ranges (real symbols, meaningful ranges) ---- const V_MIN = 10, V_MAX = 765, V_DEF = 230; // V, kV (10 kV .. 765 kV line) const P_MIN = 10, P_MAX = 1000, P_DEF = 300; // P, MW (power fed into the line) const L_MIN = 50, L_MAX = 1000, L_DEF = 300; // L, km (R = r0 * L) // ---- controls ---- let vSlider, pSlider, lSlider, resetButton; // ---- layout (all derived; bake-once friendly) ---- let schCY; // schematic conductor y let srcX0, srcX1, ldX0, ldX1; // source / load box x-edges let lineX0, lineX1; // conductor x-span let chartX0, chartX1, chartTop, chartBot; // chart frame // ---- baked static scenery ---- let scenery; // ---- palette (ASCII identifiers only; none collide with p5 globals) ---- let BG, INK, MUTE, FRAME, WIRE, COOL, HOT, ACCENT, GOOD, BAD; function setup() { createCanvas(720, 520); pixelDensity(2); p5.disableFriendlyErrors = true; // clean + cheap; no FES overhead textFont("monospace"); BG = color(14, 18, 32); INK = color(232, 238, 248); MUTE = color(120, 134, 158); FRAME = color(60, 72, 96); WIRE = color(150, 165, 190); COOL = color(90, 200, 255); // low-loss conductor (cool) HOT = color(255, 80, 70); // high-loss conductor (hot) ACCENT = color(255, 196, 90); // operating-point marker GOOD = color(120, 230, 150); BAD = color(255, 110, 120); // --- derive geometry from width/height --- schCY = 104; // conductor height in the schematic band srcX0 = 24; srcX1 = 104; // source box ldX0 = 612; ldX1 = 696; // load box lineX0 = 168; lineX1 = 548; // high-voltage conductor span (between transformers) chartX0 = 70; chartX1 = 662; // loss-curve frame chartTop = 206; chartBot = 336; // y: top = 100% loss, bottom = 0% loss buildControls(); buildScenery(); // bake once -> draw() only paints dynamic layer noLoop(); // INPUT-DRIVEN: redraw only when a slider moves } function buildControls() { // one slider per concept, carrying the field's real symbol + a meaningful range vSlider = createSlider(V_MIN, V_MAX, V_DEF, 5); // V, kV pSlider = createSlider(P_MIN, P_MAX, P_DEF, 10); // P, MW lSlider = createSlider(L_MIN, L_MAX, L_DEF, 10); // L, km vSlider.position(24, 392); vSlider.style("width", "180px"); pSlider.position(24, 430); pSlider.style("width", "180px"); lSlider.position(24, 468); lSlider.style("width", "180px"); resetButton = createButton("reset"); resetButton.position(24, 362); resetButton.mousePressed(resetAll); // INPUT-DRIVEN refresh: any slider change repaints the single static frame vSlider.input(redraw); pSlider.input(redraw); lSlider.input(redraw); } function resetAll() { // reset restores ALL state, not just some vSlider.value(V_DEF); pSlider.value(P_DEF); lSlider.value(L_DEF); redraw(); } // Pure model: SI in, named results out. Keeps draw() readable and unit-clean. function computeModel(Vkv, Pmw, Lkm) { const Vsi = Vkv * 1e3; // volts const Psi = Pmw * 1e6; // watts (power fed into the line) const R = R0_OHM_PER_KM * Lkm; // ohms (R = r0 * L) const I = Psi / Vsi; // amps (I = P / V) const loss = I * I * R; // watts (P_loss = I^2 R) const frac = loss / Psi; // == P*R/V^2 (loss fraction, can exceed 1) const eff = Math.max(0, 1 - frac); // fraction of input power delivered const dV = I * R; // volts (resistive drop along the line) const dVfrac = dV / Vsi; // per-unit voltage drop return { Vsi, Psi, R, I, loss, frac, eff, dV, dVfrac }; } // loss fraction as a function of voltage at the CURRENT P and L (for the curve) function fracAtVoltage(Vkv, Psi, R) { const Vsi = Vkv * 1e3; return (Psi * R) / (Vsi * Vsi); // P*R/V^2 } function draw() { background(BG); image(scenery, 0, 0); // blit baked static scenery // read every control ONCE into named locals const Vkv = vSlider.value(); // kV const Pmw = pSlider.value(); // MW const Lkm = lSlider.value(); // km const m = computeModel(Vkv, Pmw, Lkm); // heat: perceptual map of loss fraction -> conductor color (sqrt spreads the // realistic few-percent range); clamps to fully HOT once loss >= input. const heat = constrain(Math.sqrt(m.frac), 0, 1); drawConductor(heat, m); // dynamic: hot/cool line + glow + flow arrows drawSchematicReadouts(Vkv, Pmw, Lkm, m); drawChartCurve(Vkv, m); // dynamic: 1/V^2 curve + operating point drawReadouts(Vkv, Pmw, Lkm, m); // control-region numeric block drawHUD(Vkv, Pmw, Lkm, m); // HUD watermark, drawn LAST } // ---- dynamic conductor (color encodes I^2 R loss) ---- function drawConductor(heat, m) { const col = lerpColor(COOL, HOT, heat); // soft glow grows with heat (a few bounded translucent passes -> cheap) const glow = 4 + heat * 16; noFill(); stroke(red(col), green(col), blue(col), 60); strokeWeight(glow); line(lineX0, schCY, lineX1, schCY); // the conductor itself stroke(col); strokeWeight(4); line(lineX0, schCY, lineX1, schCY); // bright core stroke(255, 255, 255, 140); strokeWeight(1.2); line(lineX0, schCY, lineX1, schCY); // three power-flow arrows L -> R, tinted by heat (static positions) fill(col); noStroke(); for (let k = 0; k < 3; k++) { const ax = lerp(lineX0 + 40, lineX1 - 40, k / 2); triangle(ax, schCY - 5, ax, schCY + 5, ax + 9, schCY); } } // ---- in-context labels on the schematic ---- function drawSchematicReadouts(Vkv, Pmw, Lkm, m) { const midX = (lineX0 + lineX1) / 2; // current above the line, loss below it noStroke(); textAlign(CENTER, BOTTOM); textSize(12); fill(INK); text("I = P/V = " + fmtAmp(m.I), midX, schCY - 16); textAlign(CENTER, TOP); fill(MUTE); text("P_loss = I^2 R = " + fmtWatt(m.loss), midX, schCY + 14); // efficiency / infeasible badge near the load textAlign(CENTER, CENTER); textSize(13); if (m.frac >= 1) { fill(BAD); text("INFEASIBLE", (ldX0 + ldX1) / 2, schCY - 30); textSize(10); text("I^2R > P_in", (ldX0 + ldX1) / 2, schCY - 16); } else { fill(m.eff > 0.9 ? GOOD : ACCENT); text("eff " + (m.eff * 100).toFixed(1) + "%", (ldX0 + ldX1) / 2, schCY - 22); } } // ---- dynamic loss-fraction vs voltage curve ---- function drawChartCurve(Vkv, m) { // curve: frac(V) = P*R/V^2 across the full voltage range, clipped to [0,1] stroke(COOL); strokeWeight(2); noFill(); beginShape(); for (let px = chartX0; px <= chartX1; px += 2) { // bounded, cheap const V = map(px, chartX0, chartX1, V_MIN, V_MAX); const f = constrain(fracAtVoltage(V, m.Psi, m.R), 0, 1); vertex(px, map(f, 0, 1, chartBot, chartTop)); } endShape(); // operating point: vertical marker at the current V + a dot on the curve const xCur = map(Vkv, V_MIN, V_MAX, chartX0, chartX1); const fCur = constrain(m.frac, 0, 1); const yCur = map(fCur, 0, 1, chartBot, chartTop); stroke(ACCENT, 150); strokeWeight(1); drawingContext.setLineDash([4, 4]); line(xCur, chartTop, xCur, chartBot); drawingContext.setLineDash([]); noStroke(); fill(ACCENT); circle(xCur, yCur, 9); // label the operating point with its loss fraction textAlign(LEFT, BOTTOM); textSize(11); fill(ACCENT); const lab = (m.frac * 100).toFixed(m.frac < 0.1 ? 2 : 1) + "% loss"; const lx = xCur < chartX1 - 90 ? xCur + 8 : xCur - 8; textAlign(xCur < chartX1 - 90 ? LEFT : RIGHT, BOTTOM); text(lab, lx, Math.max(yCur - 6, chartTop + 12)); } // ---- control-region numeric readout block ---- function drawReadouts(Vkv, Pmw, Lkm, m) { // slider value labels (control hints), middle column fill(INK); textSize(12); textAlign(LEFT, CENTER); noStroke(); text("V = " + Vkv.toFixed(0) + " kV", 214, 401); text("P = " + Pmw.toFixed(0) + " MW", 214, 439); text("L = " + Lkm.toFixed(0) + " km (R = " + m.R.toFixed(1) + " ohm)", 214, 477); // numeric results, right column const bx = 452, by = 392; textAlign(LEFT, TOP); textSize(12); fill(INK); text("I = " + fmtAmp(m.I), bx, by); text("P_loss = " + fmtWatt(m.loss), bx, by + 18); text("dV = IR = " + fmtVolt(m.dV) + " (" + (m.dVfrac * 100).toFixed(1) + "%)", bx, by + 36); if (m.frac >= 1) { fill(BAD); text("eff = -- (infeasible)", bx, by + 54); } else { fill(m.eff > 0.9 ? GOOD : ACCENT); text("eff = " + (m.eff * 100).toFixed(2) + " %", bx, by + 54); } } // ---- HUD watermark: title, URL, control hints, live equation footer ---- function drawHUD(Vkv, Pmw, Lkm, m) { noStroke(); textAlign(LEFT, TOP); fill(INK); textSize(15); text("Electric Power Transmission -- why the grid runs at high voltage", 16, 12); fill(MUTE); textSize(11); text("en.wikitube.io/wiki/Electric_power_transmission", 16, 33); text("raise V -> loss falls as 1/V^2 | drag V, P, L | reset", 92, 368); // live equation footer (drawn last, bottom) fill(MUTE); textSize(12); textAlign(LEFT, BOTTOM); text("P_loss = P^2 R / V^2 eff = 1 - P*R/V^2 R = r0*L, r0 = 0.07 ohm/km", 16, height - 10); } // ---- baked static scenery (never changes -> offscreen buffer) ---- function buildScenery() { scenery = createGraphics(720, 520); const g = scenery; g.pixelDensity(2); g.background(BG); g.textFont("monospace"); // --- schematic: source -> step-up -> line(pylons) -> step-down -> load --- drawBox(g, srcX0, schCY - 26, srcX1 - srcX0, 52, "SOURCE", "generator"); drawBox(g, ldX0, schCY - 26, ldX1 - ldX0, 52, "LOAD", "city"); // transformer glyphs (two coils) just inside each end of the HV line drawTransformer(g, 122, schCY, "step up"); drawTransformer(g, 578, schCY, "step down"); // short leads from boxes to the transformers (low-voltage stubs) g.stroke(WIRE); g.strokeWeight(2); g.line(srcX1, schCY, 110, schCY); g.line(594, schCY, ldX0, schCY); // pylons under the HV line (lattice-tower glyphs); conductor drawn dynamically for (let k = 0; k < 3; k++) { const px = lerp(lineX0 + 30, lineX1 - 30, k / 2); drawPylon(g, px, schCY); } g.noStroke(); g.fill(MUTE); g.textSize(10); g.textAlign(CENTER, TOP); g.text("high-voltage transmission line", (lineX0 + lineX1) / 2, schCY + 44); // --- chart frame: loss fraction (y) vs voltage (x) --- g.noStroke(); g.fill(INK); g.textSize(12); g.textAlign(LEFT, BOTTOM); g.text("loss fraction P*R/V^2 vs line voltage V", chartX0, chartTop - 8); g.stroke(FRAME); g.strokeWeight(1.5); g.line(chartX0, chartTop, chartX0, chartBot); // y axis g.line(chartX0, chartBot, chartX1, chartBot); // x axis // y ticks: 0,25,50,75,100 percent loss g.textSize(10); g.textAlign(RIGHT, CENTER); for (let pct = 0; pct <= 100; pct += 25) { const y = map(pct, 0, 100, chartBot, chartTop); g.stroke(34, 44, 62); g.line(chartX0, y, chartX1, y); g.noStroke(); g.fill(MUTE); g.text(pct + "%", chartX0 - 6, y); g.stroke(FRAME); } // x ticks: voltage gridlines g.textAlign(CENTER, TOP); const vticks = [10, 150, 300, 450, 600, 765]; for (let i = 0; i < vticks.length; i++) { const x = map(vticks[i], V_MIN, V_MAX, chartX0, chartX1); g.stroke(34, 44, 62); g.line(x, chartTop, x, chartBot); g.noStroke(); g.fill(MUTE); g.text(vticks[i], x, chartBot + 5); g.stroke(FRAME); } g.noStroke(); g.fill(MUTE); g.textAlign(RIGHT, TOP); g.text("V (kV)", chartX1, chartBot + 18); // --- divider between drawing region and control region --- g.stroke(FRAME); g.strokeWeight(1); g.line(16, 352, 704, 352); } // rounded labelled component box (used for source + load) function drawBox(g, x, y, w, h, title, sub) { g.noStroke(); g.fill(26, 32, 50); g.rect(x, y, w, h, 6); g.stroke(FRAME); g.strokeWeight(1.5); g.noFill(); g.rect(x, y, w, h, 6); g.noStroke(); g.fill(INK); g.textSize(12); g.textAlign(CENTER, CENTER); g.text(title, x + w / 2, y + h / 2 - 7); g.fill(MUTE); g.textSize(9); g.text(sub, x + w / 2, y + h / 2 + 9); } // two-coil transformer glyph centred at (cx, cy) function drawTransformer(g, cx, cy, label) { g.noFill(); g.stroke(WIRE); g.strokeWeight(1.5); g.circle(cx - 6, cy, 18); g.circle(cx + 6, cy, 18); g.stroke(FRAME); g.strokeWeight(1); g.line(cx, cy - 12, cx, cy + 12); // core line between windings g.noStroke(); g.fill(MUTE); g.textSize(9); g.textAlign(CENTER, TOP); g.text(label, cx, cy + 14); } // simple lattice transmission tower under the line at (cx, cy) function drawPylon(g, cx, cy) { const baseY = cy + 40, topW = 9, baseW = 22; g.stroke(70, 84, 110); g.strokeWeight(1.5); g.line(cx - topW, cy, cx - baseW, baseY); // left leg g.line(cx + topW, cy, cx + baseW, baseY); // right leg g.line(cx - 15, cy + 20, cx + 15, cy + 20);// cross brace g.line(cx - topW, cy, cx + topW, cy); // cross arm carrying the conductor // X bracing g.stroke(50, 62, 84); g.line(cx - topW, cy, cx + baseW, baseY); g.line(cx + topW, cy, cx - baseW, baseY); } // ---- compact engineering-unit formatters (ASCII units) ---- function fmtAmp(a) { if (a >= 1000) return (a / 1000).toFixed(2) + " kA"; return a.toFixed(0) + " A"; } function fmtVolt(v) { if (v >= 1000) return (v / 1000).toFixed(1) + " kV"; return v.toFixed(0) + " V"; } function fmtWatt(w) { if (w >= 1e9) return (w / 1e9).toFixed(2) + " GW"; if (w >= 1e6) return (w / 1e6).toFixed(2) + " MW"; if (w >= 1e3) return (w / 1e3).toFixed(1) + " kW"; return w.toFixed(0) + " W"; } ``` ## MicroSim A one-line diagram runs left to right: source -> step-up transformer -> high-voltage line (slung between pylons) -> step-down transformer -> load. As the three sliders change, the conductor heats from cool blue to hot red in proportion to its `I^2R` loss, and a live readout reports `I`, `P_loss`, efficiency, and voltage drop. Below the diagram a **loss-fraction vs voltage** curve plots `P*R/V^2` across the whole voltage range with a dot at the current `V`, making the `1/V^2` collapse visible: raise `V` and watch the operating point slide down the steep part of the curve. At very low `V` the model flags the infeasible regime where loss would exceed the input. The sketch is input-driven (`noLoop()` + `redraw()` on slider input) — nothing animates, so it stays editor-clean. **Possible extensions (publish/refine):** add a three-phase toggle (the `sqrt(3)` factor and `3 I^2 R`); add a power-factor `cos(phi)` slider; overlay an HVDC comparison line; show conductor catenary sag competing with thermal expansion as current rises. ## Links (Wikipedia order)  `1996_Western_North_America_blackouts` · `2011_Southwest_blackout` · `ACCC_conductor` · `AC_motor` · `AC_power` · `AEG_(German_company)` · `Acute_toxicity` · [[Alternating_current]] · [[Aluminium]] · `Aluminium-conductor_steel-reinforced_cable` · `Ameralik_Span` · `American_Superconductor` · `American_wire_gauge` · `Ancillary_services` · `Arc-fault_circuit_interrupter` · `Arnold_Heertje` · `Automatic_generation_control` · `Availability_factor` · `Backfeeding` · `Balancing_authority` · `Baltic_Cable` · `Baltic_Sea` · `Base_load` · `Bass_Strait` · `Basslink` · `Battery_energy_storage_system` · `Biofuel` · `Biogas` · `Biomass` · [[Black_box]] · `Black_start` · `Boston` · `Brownout_(electricity)` · `Capacitance` · `Capacity_factor` · `Carbon_offsets_and_credits` · `Carcinogen` · `Cascading_failure` · `Charles_Eugene_Lancelot_Brown` · `Circuit_breaker` · `Circular_mil` · `Coal` · `Cogeneration` · `Columbia_River` · `Common_carrier` · `Compressed-air_energy_storage` · `Compressed_carbon_dioxide_energy_storage` · `Conductor_gallop` · `Consolidated_Edison` · `Continental_Europe` · `Contingency_(electrical_grid)` · `Cooling_tower` · `Corona_discharge` · `Cost_of_electricity_by_source` · `Critical_infrastructure` · `Cross_Sound_Cable` · `Demand_factor` · `Demand_response` · `Direct_current` · `Dispatchable_generation` · `Distributed_generation` · `Distributed_temperature_sensing` · `Droop_speed_control` · `Dynamic_demand_(electric_power)` · `Earth-leakage_circuit_breaker` · `Easement` · `Eastern_Interconnection` · [[Electric_current]] · `Electric_energy_consumption` · `Electric_locomotive` · `Electric_multiple_unit` · `Electric_power` · `Electric_power_distribution` · `Electric_power_quality` · `Electric_power_system` · `Electrical_busbar_system` · `Electrical_energy` · `Electrical_fault` · [[Electrical_grid]] · `Electrical_impedance` · `Electrical_resistance_and_conductance` · `Electricity_delivery` · `Electricity_market` · `Electricity_retailing` · `Electricity_sector_in_Russia` · `Electromagnetic_radiation_and_health` · `Energy_demand_management` · `Energy_return_on_investment` · `Energy_subsidy` · `Environmental_tax` · `Federal_Energy_Management_Program` · `Federal_Energy_Regulatory_Commission` · `Federal_government_of_the_United_States` · `Feed-in_tariff` · `Ferranti_effect` · `Flexible_AC_transmission_system` · `Flywheel_energy_storage` · `Fossil_fuel_phase-out` · `Fossil_fuel_power_station` · `Frankfurt` · `Galileo_Ferraris` · `Ganz_Works` · `Gauss_(unit)` · `General_Electric` · `Generator_interlock_kit` · `Geomagnetically_induced_current` · `George_Westinghouse` · `Geothermal_power` · `Grand_Coulee_Dam` · `Great_Barrington,_Massachusetts` · `Great_Britain` · `Greenland` · `Grid-tied_electrical_system` · `Grid_balancing` · `Grid_code` · `Grid_energy_storage` · `Grosvenor_Gallery` · `Herbicide` · `Hidetsugu_Yagi` · `High-voltage_cable` · `High-voltage_direct_current` · `High-voltage_shore_connection` · `High_voltage` · `History_of_electric_power_transmission` · `Holbrook_Superconductor_Project` · `Home_energy_storage` · `Hoover_Dam` · `Hydroelectricity` · `Inductance` · `Induction_generator` · `Induction_motor` · `Inertial_response` · `Inflation_Reduction_Act` · `Interconnector` · `Inverter-based_resource` · `Islanding` · `John_Dixon_Gibbs` · `Joule_heating` · `Kazakhstan` · `Lake_Erie_Connector` · `Liquid_nitrogen` · `List_of_electricity_sectors` · `List_of_energy_storage_power_plants` · `List_of_high-voltage_underground_and_submarine_cables` · `List_of_major_power_outages` · `Load-following_power_plant` · `Load_factor_(electrical)` · `Load_management` · `Load_profile` · `Load_serving_entity` · `Long_Island` · `Los_Angeles` · `Lucien_Gaulard` · `Magnetic_field` · `Mains_electricity_by_country` · `Marine_current_power` · `Marine_energy` · `Merit_order` · `Micro_combined_heat_and_power` · `Microgeneration_(energy)` · `Microwave` · `Mikhail_Dolivo-Dobrovolsky` · `Minnesota` · `Murraylink` · `Nameplate_capacity` · `National_Institute_of_Environmental_Health_Sciences` · [[Natural_gas]] · `Natural_monopoly` · `Net_metering` · `New_Haven,_Connecticut` · `New_Jersey` · `New_York_City` · `New_York_City_blackout_of_1977` · `Nikola_Tesla` · `Non-renewable_resource` · `NorNed` · `North_Sea` · `North_Sea_Link` · `Northeast_blackout_of_2003` · `Nuclear_power` · `Numerical_relay` · `Ocean_thermal_energy_conversion` · `Oil_shale` · `Optical_fiber` · `Optical_ground_wire` · `Orem,_Utah` · `Osmotic_power` · `Overhead_power_line` · `PacifiCorp` · `Pacific_DC_Intertie` · `Path_15` · `Peak_demand` · `Peaking_power_plant` · `Performance_and_modelling_of_AC_transmission` · `Petroleum` · `Philippines` · `Pi_(letter)` · `Pigouvian_tax` · `Polyphase_system` · `Portland,_Oregon` · `Power-flow_study` · `Power-line_communication` · `Power-to-gas` · `Power_factor` · `Power_outage` · `Power_station` · `Power_system_protection` · `Power_system_reliability` · `Power_system_simulation` · `Propagation_constant` · `Protective_relay` · `Public_utilities_commission` · `Pumped-storage_hydroelectricity` · `Radio_frequency_power_transmission` · `Rankine_cycle` · `Rectenna` · `Red_Eléctrica_de_España` · [[Redundancy_(engineering)]] · `Renewable_Energy_Certificate_(United_States)` · `Renewable_energy` · `Renewable_energy_commercialization` · `Repowering` · `Residual-current_device` · `Riverland` · `Rolling_blackout` · `Rotary_converter` · `Rural_electrification` · `Sayreville,_New_Jersey` · `Seasonal_thermal_energy_storage` · `Seattle` · `Shoreham,_New_York` · `Short_circuit` · `Siemens_&_Halske` · `Single-phase_electric_power` · `Single-wire_earth_return` · `Skin_effect` · `Smart_grid` · `Solar_power` · `Southern_California` · `Spark_spread` · `Stanford_University` · `Static_VAR_compensator` · `Street_light` · `Submarine_power_cable` · `Substation` · `Sulfur_hexafluoride_circuit_breaker` · `Sunraysia` · `Super_grid` · `Superconducting_magnetic_energy_storage` · `Sustainable_biofuel` · `Tasmania` · `Telegrapher's_equations` · `Tesla_(unit)` · `Texas_Interconnection` · `The_New_York_Times` · `Thermal_energy_storage` · `Thomas_P._Hughes_(historian)` · `Three-phase_electric_power` · `Tidal_power` · `Traction_power_network` · `Transformer` · `Transmission_system_operator` · `Transmission_tower` · `Transposition_tower` · `Tres_Amigas_SuperStation` · `Ultra-high-voltage_electricity_transmission_in_China` · `Underground_power_line` · `United_States` · `United_States_Cyber_Command` · `United_States_Department_of_Energy` · `United_States_Department_of_Homeland_Security` · `Utility_frequency` · `Utility_pole` · `Variable_renewable_energy` · `Vehicle-to-grid` · `Viking_Link` · `Virtual_power_plant` · [[Voltage]] · `Voltage_control_and_reactive_power_management` · `Voltage_divider` · `Voltage_drop` · `Wave_power` · [[Wayback_Machine]] · `Western_Interconnection` · `Wheeling_(electric_power_transmission)` · `White_House` · `Wide_area_synchronous_grid` · `Willamette_Falls` · `Wind_power` · `Wind_turbine` · `Wired_(magazine)` · `Wireless_power_transfer` · `World's_Columbian_Exposition` · `World_Health_Organization` · `World_War_I` *SPINTRONICS · branch **P — Power transmission** · MicroSim pattern **chart-frame + schematic glyphs** — a quantitative law (`P_loss = P^2 R / V^2`) shown as a one-line diagram whose conductor heats with loss, plus a loss-vs-[[Voltage|voltage]] curve. Draft staged by the headless draft queue; the publish stage adds frontmatter, the live editor iframe, and routes this into the Power-transmission branch folder.* ## Overview **Electric power transmission** is the bulk movement of electrical [[Energy|energy]] from generating stations to substations over the high-voltage lines of the grid, the stage between generation and local distribution. The defining [[Engineering|engineering]] choice is the **transmission voltage**. Carrying a given amount of power at a higher voltage needs proportionally less current, and because resistive heating in the wires grows with the *square* of the current, raising the voltage collapses the losses. That is why the grid steps voltage **up** to tens or hundreds of kilovolts for the long-distance line and back **down** near the load — and why long-distance transmission uses AC, which transformers step easily, or high-voltage DC (HVDC). ## The physics / derivation **Current for a given power.** To feed real power `P` into a line held at voltage `V` (single-phase, unity power factor), the line current is ``` I = P / V ``` **Resistive loss.** The conductor has resistance `R`, so it dissipates ``` P_loss = I^2 * R = (P/V)^2 * R = P^2 * R / V^2 ``` For fixed `P` and `R` the loss scales as **1/V^2** — double the voltage and the loss drops to a quarter. That single fact is the entire reason for high-voltage transmission. **Loss fraction and efficiency.** Dividing the loss by the input power gives a clean closed form, ``` P_loss / P = P * R / V^2 eff = 1 - P_loss / P = 1 - P * R / V^2 ``` **Line resistance.** `R = r0 * L` — the resistance per unit length `r0` (set by conductor material and cross-section) times the line length `L`. A typical overhead aluminium-conductor [[Steel|steel]]-reinforced (ACSR) cable has `r0 ~ 0.05-0.1 ohm/km`; the sim uses `r0 = 0.07 ohm/km`. **Voltage drop.** The resistive drop along the line is `dV = I * R`, so the receiving end sits at about `V - I*R`; the per-unit drop `I*R / V` is the line's voltage regulation. **Three-phase note.** Real grids are three-phase: `P = sqrt(3) * V_LL * I * cos(phi)` with total loss `3 * I^2 * R`. The `1/V^2` scaling of loss with voltage is identical, so the single-phase picture here captures the essential law. The sim ignores line reactance and treats `R` as a lumped series resistance. **Why a regime can be "infeasible."** If `V` is low enough that `P*R / V^2 >= 1`, the line would dissipate more than the power fed into it — the current and `I^2R` heating run away (the conductor melts) and no usable power reaches the load. The sim flags this regime instead of printing a negative efficiency. ## Parameter table (controls -> real symbols) | Control | Symbol | Meaning | Range (sim) | |---------|:------:|---------|-------------| | transmission voltage | `V` | sending-end line voltage; `I = P/V` | 10 – 765 kV | | transmitted power | `P` | real power fed into the line | 10 – 1000 MW | | line length | `L` | sets `R = r0 * L`, with `r0 = 0.07 ohm/km` | 50 – 1000 km | *Derived and displayed:* line current `I = P/V`, resistance `R = r0*L`, loss `P_loss = I^2 R`, loss fraction `P*R/V^2`, efficiency `eff = 1 - P*R/V^2`, and voltage drop `dV = I*R`. ## Learning objective Understand that for a fixed transmitted power, **transmission loss falls as the square of the line voltage** (`P_loss = P^2 R / V^2`), so stepping the voltage up is what makes long-distance electric power transmission efficient — and watch the loss curve collapse as you raise `V`.  *Built to the [[WT!P5_js_Microsim_Master_Class|p5.js Master Class]].*   *Connected to the Apex Spine:* Electric power transmission → [[Hydroelectricity|Hydroelectricity]] — [[WT!Thury_Hydrodynamics_Compendium|Compendium]] section 16, *Hydroelectricity*.   **Microsim — three.js (Wikitube framework):** *Electric power transmission* <div class="wt-sim" data-src="https://wikitube-3d-microsims.netlify.app/matter/Electric_power_transmission.html" data-title="Electric power transmission"></div> *Built from `MICROSIM_GUIDE/specs/sims/Electric_power_transmission.json`; part of the [[PORTAL_Matter|Matter portal]] spine (section sims and See-also variants).*  ## Wikipedia : Wikitube **Strict pair:** [Wikipedia](https://en.wikipedia.org/wiki/Electric_power_transmission) : [Wikitube](https://en.wikitube.io/wiki/Electric_power_transmission) ## Previous hub tags Tree parent: [[System_dynamics]]. Legacy hubs: none. --- *Sources: 1 legacy note. Minted wave 1, 2026-07-30 (v1.6 order).*