Title: {Space Elevators on Minor Planets}
Class: {blog}
Date: {Mon Aug 24 11:15:45 EDT 2020}
Content-Type: {html}
Format: {clay}
date: {Mon Aug 24 11:15:45 EDT 2020}
owner: 619eb03b-0f7d-490f-a2ac-9eb72e4c789d
uuid: 53d39806-e8c8-4ab8-a55d-d9e319e52711
--- BEGIN CONTENT ---
set pi [expr {4*atan(1.0)}]

#
# round number to significant digits
# according to
# http://perfdynamics.blogspot.de/2010/04/significant-figures-in-r-and-rounding.html
# round number num to n significant digits
# works only in the range of double
# it is published under the same licence as Tcl
# (c) J. Heidemeier 2014
#
proc signif {num n {decimalPoint .}} {
# arguments:
# num: number to be rounded (integer, real or exponential format)
# n: number of significant digits (positive integer)
# decimalPoint: decimal separator character for the output (default .)
#
# reasonable figure for significant digits ?
    if {!([string is integer $n] && $n > 0)} \
        {error  "number of significant digits $n is not a positive integer"}
#
# ensure that num is numeric
# and split into sign, integer, decimal and exponent part
#
if {[regexp {^([+,-]?)([0-9]+)(\.?[0-9]*)?([eE][+-]?[0-9]+)?$} $num -> s i d e]} {
# i must contain alt least one digit
if {![string length i]} "error wrong format $num, no digit in Integerpart "
#
# type of number
#
    set typ ""
    if {[string length $e]} {set typ e}
    if {[string length $d]} {
        if {$typ ne {e}} {set typ d}
    } else {
        if {$typ ne {e}} {
                set typ i
#
#
#
        } else {
# reformat iexx to i.0exx bringen
            set d {.0}
       }
    }
# remove leading 0, if digits 1-9 in i-part
# or collapse several 0 to 0
#
    if {[string length $i] > 1} {
        regexp  {^(0*)([1-9][0-9]*)$} $i -> NULL DIG
        if {[string length $DIG]} {
            set i $DIG
        } else {
            set i 0 ;# collapse to one 0
        }
    }
#
# build teststring for rounding process
#
set tstring $i

set decpos [expr {[string length $i] -1}]
# skip decimalpoint and append decimalpart
if {[string length $d]} {
       append tstring [string range $d 1 end]
}
# enough digits for the rounding process
    set ndigs [string length $tstring]
    if {$ndigs < $n} {error "more significant digits $n requested than available $ndigs"}

# x is the last significant digit
# y and z are the following 2 digits, if y or z are blank
# zeros are appended
    set x [string index $tstring $n-1]
        if  {$ndigs == $n} {
            set y 0
        } else {
        set y [string index $tstring $n]
    }
    if {$ndigs > $n} {
        set z [string index $tstring $n+1]
    } else {
        set z 0
    }
# the actual test; pad0 pads zeros for the integerpart
    if {$y < 5} {
        set rstring "[string range $tstring 0 $n-1][pad0 $decpos $n]"
    } elseif {$y > 5} {
         incr x
            set rstring "[string range $tstring 0 $n-2]$x[pad0 $decpos $n]"
    } else {
# y == 5; test for parity jitter
        if {$z >= 1} {
                set rstring "[string range $tstring 0 $n-1][pad0 $decpos $n]"
        } else {
            if {[isOdd $x]} {
                incr x
            }
                set rstring "[string range $tstring 0 $n-2]$x[pad0 $i $n $decpos]"
        }
    }
} else {
 error "number to round \"$num\" is not numeric"
}
# reformatting the output
    switch -exact -- $typ {
        i {set result "$s$rstring"}
        d {
            set decfrac [string range $rstring $decpos+1 end]
            if {![string length $decfrac]} {
                set result "$s$rstring"
            } else {
                set result "$s[string range $rstring 0 $decpos]$decimalPoint$decfrac"
            }
        }
        e {
            set result "$s[string range $rstring 0 $decpos]$decimalPoint[string range $rstring $decpos+1 end]$e"
        }
    }
return  $result
}
#
# pad integer part with 0 if necessary
# arguments
# decpos:  index of the last digit before the decimal point
# n:  number of significant digits
#
proc pad0 {decpos n} {

    set v {}
    incr decpos
    set x [expr {$decpos - $n}]

    if {$x} {
        set v [string repeat 0 $x]
    }
    return $v
 }
proc isOdd {int} {
    if {[string is integer $int]} {
        return [expr {$int%2}]
    } else {
        error "no integer $int"
    }
}






para {I was working on if it would be better to build surface settlements on the likes
of [link https://en.wikipedia.org/wiki/16_Psyche {Psyche}] and [link https://en.wikipedia.org/wiki/Ceres_(dwarf_planet) {Ceres}]
or keep habitats in orbit around the planets. Planetary settlements are nice and stable,
but hard to move if you need to get them out of the way of a meteorite strike or enemy
attack. Also: when you deplete the resources of a minor planet, a settlement on the surface
has to be broken down and launched off the surface. Or abandoned in place.}

para {There is a LOT of math here, and if someone wants to check my work [link /[my request get PREFIX_URI]/source.txt {all of the calculations are in the markup for this page}]}

para {On the other hand, orbital settlements are a giant pain in the ass to move material
around to. Yes, most asteroids have tiny escape velocities. However this means that a misplaced
bit of thrust can lob that precious ore (or pod full of school kids) out into deep space if
the trajectory is just a little bit off.}

para {And in crunching the numbers I discovered some interesting quirks in the rotational properties of the two worlds.}

para {Normally, as objects drop in mass, they spin slower. Earth, as we all know, makes a
rotation 360 turn in 23 hours and 56 minutes. A day on Jupiter, which has 320 times Earth's mass,
is 9.95 hours long. On Mercury, which has 5% of the mass of Earth, a day lasts 1407 hours.}

para {Psyche and Ceres have quite a bit of spin to them, given their tiny size.
Psyche rotates every 4.2 hours. Ceres rotates every 9 hours. That the high spin and
the low mass meant gave [link https://en.wikipedia.org/wiki/Geostationary_orbit {synchronous equatorial orbit}]
on both worlds some interesting properties.}

para {Synchronous equatorial orbit you may know better as Geostationary Orbit. Essentially,
the satellite always sits over the same part of the planet below. And someone on the planet
below can always look up and see that satellite in the same chunk of sky. They are great
for weather satellites and communication satellites. I was also thinking they would be a
great target to aim a mass driver at.}

para {Geosynchronous orbit on Earth happens at a distance of 35,786 km (22,236 miles)
above the Earth's equator. A satellite orbing at that distance goes around in 23 hours
and 56 minutes. The same speed as the Earth below. A lower orbit makes more passes in a
unit time. A higher orbit makes fewer in a unit time. The [link https://en.wikipedia.org/wiki/Orbit_of_the_Moon {Moon orbits}]
at mean distance of 385,000 km (239,000 mi). It takes a whole month to go around.
The [link https://en.wikipedia.org/wiki/International_Space_Station {Internation Space Station}]
orbits at a mean distance of 400 kilometres (250 mi). It goes around the world every 93 minutes
(about 15.5 orbits per day).}

my tag img src /[my request get PREFIX_URI]/earth_geostationary.svg width 500

para {You can compute the radius with this handy equation:}

my tag img src /[my request get PREFIX_URI]/equation_02.svg

para {μ is the [link {https://en.wikipedia.org/wiki/Geocentric_gravitational_constant} {geocentric gravitational constant}] of the planetoid.}
para {T is the period (in seconds) of the planet's rotation.}
para {r ends up being the orbital distance, in meters}

my tag h3 {Space Elevators}

para {In between looking at [link https://en.wikipedia.org/wiki/Mass_driver {Mass Drivers}]
I review the math on [link https://en.wikipedia.org/wiki/Space_elevator {Space Elevators}].}

para {What makes a space elevator work is an interesting quirk of physics that occurs at
higher orbits. The centripital force of the orbit
starts to exceed the weight of the object due to gravitation. Imagine that our space
station on the cable is acting like a bucket of water on a string:}

my tag img width 500 src /[my request get PREFIX_URI]/centripital-force.jpg

my tag img  src /[my request get PREFIX_URI]/centrifugal-force.gif

para {Because these tiny worlds spin as fast as they do, we get that effect at a much shorter
distance than, say, the Earth or the Moon. Into the realm where we can implement a plausible
[link https://en.wikipedia.org/wiki/Space_elevator {Space Elevator}]. And using steel cable,
not some exotic nanomaterial.}

para {We can put all of the chips on the table to solve for at what radius a weight on the
end of the cable ceases to put any weight on the cable:}

my tag img src /[my request get PREFIX_URI]/equation_03.svg

para {When we solve for when g = 0, and replace a few terms (MG=μ , ω can be converted orbital speed and period (T)) we get:}

my tag img src /[my request get PREFIX_URI]/equation_02.svg

para {That's our equation for geostationary orbit. A space station orbiting 16 Psyche
just needs to be attached by a cable that is longer than 97.8 km, and have a mass greater
than the cable itself to hold the cable in perfect tension.}

para {For a thought experiment, lets make the cable 100km long and the station equal to the mass of
the cable itself. There is more than enough nickel/iron in near pure form to fashion
them both right from the surface of the planetoid. Let's assume we boost our station (and rolled up cable)
to 100km above the planet's surface.}

para {Orbital speed is defined by the equation:}

my tag img src /[my request get PREFIX_URI]/equation_04.svg

para {The a is the semi-major axis. As our orbit will be, or all intents and purposes
circular, this is the same as our radius.}

para {Now, how thick of a cable are we going to need? Well we kind of have to know how much
weight it's going to have to hold. But we actually make giant cables that hold massive
weights, and we have been since the 19th century. For suspension bridges.}

para {For our opening bid, lets just hang a cable that is equivilent to one of the main
cables on
the [link {https://www.goldengate.org/bridge/history-research/statistics-data/design-construction-stats/} {Golden Gate Bridge}].
It will hang from a satellite in orbit, straight down to the surface of the planet.
For the moment we will ignore the fact the length of the cable in orbit is weighs less than an
equivilent length on the planet's surface.}

set cable_area [signif [expr {(.92*0.5)**2*$pi}] 4]
set cable_mass_unit [signif [expr {22220000.0/2332.0/2.0/$cable_area}] 6]

para {After crunching some numbers both cables on the Golden Gate (and their trappings) have
a mass of 22,220,000 kg, and are 2332 meters long. We also know that are .92m in diameter,
giving us a cross sectional area of $cable_area m<sup><span style="font-weight: normal">2</span></sup>. This gives is a density of $cable_mass_unit
kg/m<sup><span style="font-weight: normal">3</span></sup>. To check our work,
[link https://amesweb.info/Materials/Density_of_Steel.aspx {the density of solid steel is between}]:  7750-8670
kg/m<sup><span style="font-weight: normal">3</span></sup>. Wire rope is not solid steel, and
the gaps between the wires and galvanic coatings make the cable less dense.}


set G 6.674e-11
set t3 [expr {1.0/3.0}]
set pi [expr {4*atan(1.0)}]
set empire 331122430
set bodies {}
dict set bodies {16 Psyche} {
  mass            {2.41e19 kg}
  planet_radius   {112500 meters}
  rotation_period {4.195948 hours}
}
dict set bodies {1 Ceres} {
  μ               6.26325e10
  mass            {9.3835e20 kg}
  planet_radius   {470000 meters}
  rotation_period {9.074170 hours}
}
dict set bodies {Luna} {
  μ               4.90486959e12
  mass            {9.3835e20 kg}
  planet_radius   {470000 meters}
  rotation_period {9.074170 hours}
}
dict set bodies {Earth} {
  μ     3.9860044188e14
  mass  {5.97237e24 kg}
  planet_radius   {6378100 meters}
  rotation_period {23.93447232 hours}
}
set tab [my tag table border 1]

set row [$tab row]
$row column Body
$row column {geostationary radius<br>(planet center)}
$row column {geostationary radius<br>(planet surface)}
$row column {geostationary speed<br>(meters/second)}
$row column {Cable mass<br>(Kg)}
$row column {Cable mass<br>(Empire State Buildings)}

dict for {body info} $bodies {
  set row [$tab row]
  $row column $body
  set mass [lindex [dict get $info mass] 0]
  if {[dict exists $info μ]} {
    set const [lindex [dict get $info μ] 0]
  } else {
    set const [expr {$mass*$G}]
    dict set bodies $body μ $const
  }
  set T [expr {[lindex [dict get $info rotation_period] 0]*3600.0}]
  set R [lindex [dict get $info planet_radius] 0]
  set radius3 [expr {($const*$T**2)/(4.0*$pi**2)}]
  set radius [expr {pow($radius3,$t3)}]
  set length [expr {$radius-$R}]
  set speed  [expr {sqrt($const/$radius)}]
  set cable_mass [expr {$length*$cable_mass_unit}]
  $row column [signif $radius 6]
  $row column [signif $length 6]
  $row column [signif $speed 6]
  $row column [format %e [signif $cable_mass 6]]
  $row column [signif [expr {$cable_mass/$empire}] 6]
}

para {Even for the shortest cable on Psyche, we are talking about a lot of mass of cable.
And for my purposes I like to have something to compare it too. So, I chose the mass of
[link https://en.wikipedia.org/wiki/Empire_State_Building {Empire State Building}] (331,122,430 kg).}

para {Ok, so far we have established that for the Asteroid 16 Psyche, we need to lob the
mass of 2.1 Empire state buildings worth of cable into an 87.5 m/s orbit.
For Earth we would need 368x as much material,
boosted to a much faster speed. That is what makes a space elevator for Earth utterly
impractical. But for Psyche... it won't be cheap, but we may well be in the realm of what
technology could pull off. In fact, this cable weighs less than some of the planetary
settlements I have envisioned, and a lot less than some of the spacecraft.}

set modulus [expr {200*1e9}]



set length 100000
set info [dict get $bodies {16 Psyche}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit*$cable_area + $length*$cable_mass_unit*$cable_area}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Length: [signif $length 6] m"
$UL item "Speed: [signif $speed 6] m/s"
$UL item "Total Mass: [format %e [signif $mass 6]] kg ( [signif [expr $mass/$empire] 3] Empire State Buildings)"
$UL item "Orbital Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2"
set IL [$UL tag UL]
$IL item "([signif [expr {$energy/4184000000.0}] 6] Tons of TNT)"
$IL item "([signif [expr {$energy/(33375000.0*168.0)}] 5] Saturn V First stages)"
$UL item "Load: [format %e [signif $load 4]] N"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"
$UL item "Stretch: [signif [expr {$load*$length/($cable_area*$modulus)}] 4] meters"

para {Ok... so, still a bit of an engineering challenge. The Stretch factor tells you how
much the cable is going to elongate under the load of the counterweight. Stress is how much
load is on a unit section cable. Repeating the process for Ceres, but with a 730km cable:}

set length 730000
set info [dict get $bodies {1 Ceres}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit*$cable_area + $length*$cable_mass_unit*$cable_area}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Length: [signif $length 6] m"
$UL item "Speed: [signif $speed 6] m/s"
$UL item "Total Mass: [format %e [signif $mass 6]] kg ( [signif [expr $mass/$empire] 3] Empire State Buildings)"
$UL item "Orbital Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2"
set IL [$UL tag UL]
$IL item "([signif [expr {$energy/4184000000.0}] 6] Tons of TNT)"
$IL item "([signif [expr {$energy/(33375000.0*168.0)}] 5] Saturn V First stages)"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"
$UL item "Stretch: [signif [expr {$load*$length/($cable_area*$modulus)}] 4] meters"

para {And for completeness, let's try the Moon with a 4630km cable:}

set length 4630000
set info [dict get $bodies {Luna}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit*$cable_area + $length*$cable_mass_unit*$cable_area}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Length: [signif $length 6] m"
$UL item "Speed: [signif $speed 6] m/s"
$UL item "Total Mass: [format %e [signif $mass 6]] kg ( [signif [expr $mass/$empire] 3] Empire State Buildings)"
$UL item "Orbital Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2"
set IL [$UL tag UL]
$IL item "([signif [expr {$energy/4184000000.0}] 6] Tons of TNT)"
$IL item "([signif [expr {$energy/(33375000.0*168.0)}] 5] Saturn V First stages)"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"
$UL item "Stretch: [signif [expr {$load*$length/($cable_area*$modulus)}] 4] meters"

para {And finally... Earth. With a 35786km long cable...}

set length 35786000
set info [dict get $bodies {Earth}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit*$cable_area + $length*$cable_mass_unit*$cable_area}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Length: [signif $length 6] m"
$UL item "Speed: [signif $speed 6] m/s"
$UL item "Total Mass: [format %e [signif $mass 6]] kg ( [signif [expr $mass/$empire] 3] Empire State Buildings)"
$UL item "Orbital Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2"
set IL [$UL tag UL]
$IL item "([signif [expr {$energy/4184000000.0}] 6] Tons of TNT)"
$IL item "([signif [expr {$energy/(33375000.0*168.0)}] 5] Saturn V First stages)"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"
$UL item "Stretch: [signif [expr {$load*$length/($cable_area*$modulus)}] 4] meters"

para {Assuming this is science fiction and we have
[link https://en.wikipedia.org/wiki/Fusion_rocket {fusion powered rocket engines}],
and [link https://en.wikipedia.org/wiki/Mass_driver {Mass Drivers}] at our disposal, the
energy requirements to get the material in orbit are not all that crazy.}

para {But we have more to wrestle with than energy to orbit. Note that stress column.
I picked the cable on the Golden Gate Bridge because we know
[link https://www.goldengate.org/bridge/history-research/statistics-data/design-construction-stats/ {roughly how much weight it can hold}].
The strength of wire rope is a [link {https://www.nap.edu/read/23338/chapter/8#151} {very well understood}]
problem in Engineering. The bridge is still standing after nearly a century, so they must have
gotten the answer right. Long story short, the strength of a cable increases with the cross sectional area. And you
can build up immense cross sectional areas by adding together smaller wires.}

my tag img src /[my request get PREFIX_URI]/susp1.gif

my tag img width 400 src /[my request get PREFIX_URI]/golden-gate-bridge-cable-cross-section.jpg

set load [expr {(21772000*0.5)*9.8}]

para {Two cables on the Golden Gate Bridge hold up about 21,772,000 kg of structure.
So we can say that each cable is holding up half.
But we are concerned with WEIGHT so, we have to remember to multiply mass by
Gravity (9.8 m/s^2) to get Newtons: [format %e [signif $load 5]] N.
The stress on those cables is the load / area. Thus we can guestimate a safe stress to be
[set GGB_strain [format %e [signif [expr {$load/$cable_area}] 5]]] [link https://en.wikipedia.org/wiki/Pascal_(unit) Pascals].}

para {However raw strength isn't the complete answer. Steel rope (and indeed virtually every
structural material) [link {https://www.assemblyspecialty.com/guide-to-wire-rope/technical-information/physical-properties-of-wire-rope/} {stretches under load}].
Below the yield strength, steel stretches by a relationship between stress and strain
known as the [link https://www.engineeringtoolbox.com/young-modulus-d_417.html {Young's Modulus}].
Stretch the material to [link {https://www.engineeringtoolbox.com/young-modulus-d_417.html#yield_strength} {the yield strength}].
and you will permanently deform the material. The material will continue stretching until
the [link https://www.engineeringtoolbox.com/young-modulus-d_417.html#ultimate_tensile_strength {ultimate tensile strength}],
at which point it will break.
For generic structural steel, the Young's Modulus is 2.00e11, the Yield Strength is 2.5e8 Pa,
and the Ultimate Tensile Strength is 4.0e+08 Pa.}

para {Our calculation for cable strain on the Golden Gate Bridge ($GGB_strain Pa) is only a fraction of
the yield strength of steel (2.5e8 Pa). This is by design.
A bridge needs to handle a lot of strain in addition to its own weight. In fact the operators
of the Golden Gate bridge never allow the strain to exceed 40% of the Tensile strength on the cables.}

para {For our Psyche cable we have a stress of 1.152000e+08 Pa. An accountant might
say we have [signif [expr {(1.0-1.152000e+08/1.604200e+08)*100}] 3]% more rope
than would be strictly called for if this cable were on a bridge. What happens if we make the cable 28% smaller?}


set length 100000
set scale [expr {1.152000e+08/1.604200e+08}]
set cable_area [signif [expr {(.92*0.5)**2*$pi*$scale}] 4]
set info [dict get $bodies {16 Psyche}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit*$cable_area + $length*$cable_mass_unit*$cable_area}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Speed: [signif $speed 6] m/s"
$UL item "Cable Area: [signif $cable_area 4] m^2"
$UL item  "Total Mass: [format %e [signif $mass 6]] kg ([signif [expr {$mass/$empire}] 3] empire state buildings)"
$UL item "Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2 ([signif [expr {$energy/4184000000.0}] 6] Tons of TNT) ([signif [expr {$energy/(33375000.0*168.0)}] 5] Saturn V First stages)"
$UL item "Load: [format %e [signif $load 4]] N"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"
$UL item "Stretch: [signif [expr {$load*$length/($cable_area*$modulus)}] 4] meters"

para {As the size of the cable goes down, so does its mass, and so too does the load needed
to keep that mass aloft. The strain remains constant.}

para {If a 28% reduction has such a profound change, what about 98%?}
set cable_area [signif [expr {(.92*0.5)**2*$pi*0.02}] 4]
set length 100000
set scale [expr {.02}]
set info [dict get $bodies {16 Psyche}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit*$cable_area + $length*$cable_mass_unit*$cable_area}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Speed: [signif $speed 6] m/s $scale"
$UL item "Cable Area: [signif $cable_area 4] m^2"
$UL item  "Total Mass: [format %e [signif $mass 6]] kg ([signif [expr {$mass/$empire}] 3] empire state buildings)"
$UL item "Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2 ([signif [expr {$energy/4184000000.0}] 6] Tons of TNT) ([signif [expr {$energy/(33375000.0*168.0)}] 5] Saturn V First stages)"
$UL item "Load: [format %e [signif $load 4]] N"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"
$UL item "Stretch: [signif [expr {$load*$length/($cable_area*$modulus)}] 4] meters"

para {Our case for space elevator on Psyche is more or less made. Decide on the mass of
your orbiting station, and pretty much size your cable accordingly. The smaller the station,
the less cable you need. The less cable you need... the less cable you need. Most of the
load is dealing with the weight of the cable.}

set cable_area [signif [expr {(0.05*0.5)**2*$pi}] 4]

para {You will note that for our larger bodies, though, the stress on the rope exceeds not
just the Yield strength, but the ultimate tensile strength of Steel. But what if we learned
from our little experiment using something with a higher tensile strength? I've picked out a cable that can be
purchased, today, [link http://www.hampidjan.com.au/dynice-warp-winch-ropes.html {from a catalogue}].
It's 50mm in diameter. It has a breaking strength of [format %e [expr {169*1000*9.8/$cable_area}]] Pa. And a mass of 1.3 kg/m.
Let's try that out on Ceres, the Moon, and Earth.}

my tag img  width 500 src /[my request get PREFIX_URI]/dynice-warp-winch-diagram.jpg

set cable_mass_unit 1.3

para "Ceres:"

set length 730000
set scale [expr {6.147000e+08/5.667900e+09}]
set info [dict get $bodies {1 Ceres}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit + $length*$cable_mass_unit}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Speed: [signif $speed 6] m/s"
$UL item  "Total Mass: [format %e [signif $mass 6]] kg ([signif [expr {$mass/$empire}] 3] empire state buildings)"
$UL item "Kinetic Energy: [format %e [signif $energy 3]] kg⋅m⋅s−2"
$UL item "Load: [format %e [signif $load 4]] N"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"

para "Luna:"

set length 4630000
set info [dict get $bodies {Luna}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit + $length*$cable_mass_unit}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Speed: [signif $speed 6] m/s"
$UL item  "Total Mass: [format %e [signif $mass 6]] kg ([signif [expr {$mass/$empire}] 3] empire state buildings)"
$UL item  "Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"

para {Earth:}

set length 35786000
set scale 0.0203
set info [dict get $bodies {Earth}]
set const [dict get $info μ]
set speed [expr {sqrt($const/$length)}]
set mass [expr {$length*$cable_mass_unit + $length*$cable_mass_unit}]
set energy [expr {$speed**2*$mass}]
set load [expr {$mass*0.5*$speed**2/$length}]
set UL [my tag UL]
$UL item "Speed: [signif $speed 6] m/s"
$UL item  "Total Mass: [format %e [signif $mass 6]] kg ([signif [expr {$mass/$empire}] 3] empire state buildings)"
$UL item  "Kinetic Energy: [format %e [signif $energy 6]] kg⋅m⋅s−2"
$UL item "Stress: [format %e [signif [expr {$load/$cable_area}] 4]] Pa"

para {Earth... we just can't seem to make it work for Earth. Luna is inside the breaking
strength of the cable, but not within any kind of comfortable safety margin. For Ceres,
the 50mm cable is well inside the breaking strength.}

para {So in the end, how practical would a space elevator be?}

my tag h3 {Psyche}

para {The stress and strain needed for a cable would permit massive loads to be moved into
orbit using conventional steel. That cable system could scale to practically any size
station in orbit.}

my tag h3 {Ceres}

para {A practical cargo/passenger system could be devised using advanced composite cables.
But you aren't moving the likes of ships into orbit with it.}

my tag h3 {Luna}

para {A cable is possible as a tourist attraction or for moving high-value/low volume
cargo. But it's not something that would be cost effective to operate, as the cable will
likely fatigue quickly under normal working loads barring it being made of an exotic material.}

my tag h3 {Earth}

para {Not happening. End of statement.}

para {Images credits:}
set ul [my tag ul]
foreach url {
https://wikimedia.org/api/rest_v1/media/math/render/svg/1385eed5863f0e40f86905c95cd3d4af7788ce9e
https://wikimedia.org/api/rest_v1/media/math/render/svg/07005f1d6ce59ad5df80225ee26642603650be0e
https://wikimedia.org/api/rest_v1/media/math/render/svg/c597ae5584d3dd6749cf0c49908afa9df45e9c5a
https://www.scienceabc.com/wp-content/uploads/2018/08/centripital-force.jpg
https://www.engineersedge.com/physics/centrifugal-force.gif
https://wikimedia.org/api/rest_v1/media/math/render/svg/c86493d99fd1b940ca6e1ed1fdc0157c86580263
https://technologystudent.com/images6/susp1.gif
https://c8.alamy.com/comp/F7278F/multi-colored-strands-of-a-bridge-suspension-cable-from-the-new-span-F7278F.jpg
https://www.inside-guide-to-san-francisco-tourism.com/images/golden-gate-bridge-cable-cross-section.jpg
http://www.hampidjan.com.au/images/dynice-warp-winch-diagram.jpg
} {
  $ul item $url
}