 Model of the Hindenburg airship. The reflective coating is to avoid heating up of the internal gasses.

# Calculating Lifting Capacity of Airships

How big does an airship need to be to lift a particular weight or alternatively how much can an airship of a particular size lift?

Further I would like to explore how usage of different materials for the envelope affects how much can be lifted as well as how different gasses inside the envelope and outside affecting the lifting power.

To make sure these calculations are done correctly I will be comparing with the LZ 129 Hindenburg Zeppelin statistics:

• Length: 243 m
• Diameter: 41.2
• Volume 200 000 m³ gas capacity
• Empty weight: 130,000 kg
• Useful lift: 232 000 kg typical gross lift

I am going to show you code written in the Julia programming language for doing these calculation. However you can probably follow along without knowing any Julia, because it is mainly math equations and will look quite similar in almost any language.

# Zeppelin Volume Calculations

A zeppelin is shaped roughly as an ellipsoid.

We can express a function to calculate the volume as:

`ellipsoid_volume(a, b, c) =  (4/3)*π*a*b*c`

If we use this function in a Julia REPL environment, we get the following result:

`julia> ellipsoid_volume(245.0/2, 41.2/2, 41.2/2)217750.48888463626`

We divide all the numbers on 2, since the formula expects radii and not diameter and length.

Thus we get roughly 218 000 m³ in volume. That seems pretty close. Not everything inside the Zeppelin can be use for filling up gas so that this is about 8% higher doesn’t look strange.

# Zeppelin Lift Calculations

A fluid will lift a mass corresponding to the mass of the displaced fluid. So to see how much a Zeppelin can lift we need to look at the mass of the air that it displaces.

We can use the ideal gas law to figure that out.

If you look at this equation we can gleam several relationships. If pressure increases then volume must be reduce if all other things stay equal. Increased temperature means increased volume. That is why e.g. hot air takes more space than cold and we can utilize this to create hot air balloons.

We can then define the ideal gas law in code. You can find all the code on my github.

`gas_volume(n, T::Kelvin, P) = n*R*T/P`

I don’t want to always write temperatures in Kelvin however so I made a utility function:

`gas_volume(n, T::Temperature, P) = gas_volume(n, convert(Kelvin, T), P)`

However we don’t really want volume. We want weight of this volume of air. To get that we need to rearrange the equation to find the number of molecules in the gas. The number of molecules are given in the unit mole. I won’t go into detail why we use this seemingly odd unit. It is very practical to use however when dealing with atomic masses, as in chemistry.

`gas_moles(P, V, T::Kelvin) = (P*V)/(R*T)`

This give us the number, but we want to go further and find the mass of this gas, so we multiple with the molecular mass.

`gas_mass(P, V, T::Kelvin, molecular_mass) = gas_moles(P, V, T) * molecular_mass`

The equation requires the SI unit pascal for pressure but I usually read pressures given in bars, so lets provide some conversion functions:

`pascal(bar) = bar*1e5bar(pascal) = pascal/1e5julia> gas_mass(pascal(1), 200_000, Celsius(5), AirMass)250792.70022997505`

Roughly 251 000 kg, but lets subtract the weight of the hydrogen in the ballonets inside the envelope:

`julia> gas_mass(pascal(1), 200_000, Celsius(5), HydrogenMass)17296.048291722418julia> 250792 - ans233495.95170827757`

So we are left with 233 500 kg of calculated lifting capacity for Hindenburg. That is very close officially given 232 000 kg.

To figure out how much the Zeppelin envelope weighs we have to find out the area of it. There is no general method to do that. Instead we need to pick an equation depending on whether the ellipsoid can be characterized as either:

1. oblate spheroid, or disc shaped. This is what we get when we rotate an ellipse around its minor axis.
2. prolate spheroid, or cigar shaped. When we rotate around its major axis.

Since we are dealing with a cigar shaped Zeppelin we’ll implement the prolate spheroid equation in Julia:

`function prolate_spheroid_area(a::Number, c::Number)    @assert c > a "c is the semi-major axis and must largest"    α = acos(a/c)    2π*(a^2 + a*c*α/sin(α))end`

Using this in the Julia REPL we get that the Hindenburg must have had an enveloper covering around 25 000 m². However I’ve been unable to confirm this online.

`julia> prolate_spheroid_area(41.2/2, 245.0/2)25214.31956115058`

I could not find data on how thick the Hindenburg envelope was, but the recently built Goodyear Zeppelin has 1.5 mm thick polyester envelope. Polyester (mylar) has a density of 1390 kg/m³. Total mass should thus be:

`mass = volume * density     = area * thickness * density    = 25214 * 0.0015 * 1390    ≈ 52 571.2`

So if we subtract this from the lift capacity after subtracting the hydrogen mass we get:

`233 500 kg - 52 571 kg = 180 929 kg`

From this we got to subtract a whole bunch of other things to see how much payload the airship can take.

Within deadweight I assume that that includes the aluminum air frame, weight of hydrogen and weight of envelope. Lets do the calculation in tons:

`deadweight - hydrogen - envelope = frame118  - 17 - 52 = 49`

Is that plausible? We could test it roughly. The frame is made up of something like 15 sections (judging by eye measure) made up for 3 smaller sections. So we got 45 aluminum sections, each with roughly a circumference given by `πd`. We can then calculate an estimate for weight per meter of these aluminum frames.

`total_frame_weight/number_of_sections = weight_of_section49/45 = 1.08 tons = 1080 kgweight_of_section / circumference_of_section1080 / 41.2π  = 1080 / 129.4 ≈ 8.4 kg`

So 8.4 kg for 1 meter of aluminum. Doesn’t sound totally unreasonable. Lets check if further. We’ll

`volume * density = weightthickness*lenght*width * density = weightweight/(thickness*length*density) = width8.4/(0.03*1*2700) ≈ 0.1 m`

I assume the thickness of the aluminum was 3 cm. That is just taken out of thin air. Anyway what we end up with are 10 cm wide aluminum frame. So that Hindenburg was made up of rings of aluminum 3 cm thick and 10 cm wide seems like a fairly reasonable assumption.

# Goodyear Wingfoot One

Lets look at another Zeppelin to check our calculations. Unlike earlier Goodyear blimps this is actually a Zeppelin with aluminum and carbon Fiber Trusses internally. I looked up the specs of it and converted to metric:

• Length: 75.1m
• Width: 14.16 m
• Height: 17.55 m. I don’t think this is the height of the envelope but might include the rudder. So for calculation of volume it is not accurate.
• Volume: 8425.02 m3
• Max weight without Helium: 8972.0571 kg
• Static lift: 1333.562 kg. The is lift create by buoyancy.
• Max Dynamic lift: 499.85879 kg. Lift caused by movement. Just like how a airplane generates lift by aerodynamics.
• Total Usable lift: 1833.42036 kg

Lets use our volume calculation to check if we get the specified volume. since we don’t know the heigh, we use a range instead as input.

`julia> ellipsoid_volume.(14.16/2, [14.16/2, 17.55/2], 75.1/2)2-element Array{Float64,1}: 7884.33 9771.9`

This looks okay since `7884.33 < 8425.02 < 9771.9 `. With some experimentation I find that using 14.6 as semi-minor axis gives a volume closest to what is specified. I'll make these helper functions to calculate the aerostatic lift (buoyancy).

Gives lift for a given volume, given we use gas with mass `lift_gas_mass` per mole, inside the balloon. The gas in the atmosphere outside, that gets displaced, has mass `displaced_gas_mas` per mole.

`function lift(V, lift_gas_mass, displaced_gas_mas)    T = Celsius(20)    P = pascal(1)    gas_mass(P, V, T, displaced_gas_mas) - gas_mass(P, V, T, lift_gas_mass)end`

Now we can define a function for calculating the lift on earth of a cigar shaped Zeppelin as:

`function prolate_spheroid_lift_earth(a, c, thickness, density, liftgas = HydrogenMass)    V = Volume.ellipsoid_volume(a, a, c)    A = Volume.prolate_spheroid_area(a, c)    l = lift(V, liftgas, AirMass)    l -  A*thickness*densityend`

`thickness` is the thickness of the material used as envelope. `density` is the density of this material.

`julia> prolate_spheroid_lift_earth(14.6/2, 75.1/2, 0.0015, MylarDensity, HeliumMass)2858.0403494657667`

So we calculate lift of 2.8 tons, but specs give static lift of 1.3 tons. We don’t know the weight of the carbon fibre composite frame inside or the gondola and engines. It does not seem unreasonable that they would weigh 1.5 tons at least.

# Disc Shaped Skylifter

The cargo carrying airship Skylifter doesn’t have cigar shape but is shaped like a disc, it is oblate in other words. The specs say that it has a 150 m in diameter and can lift 150 tons.

We need to implement an oblate function to calculate this.

`function oblate_spheroid_lift_earth(a, c, thickness, density, liftgas = HeliumMass)    V = Volume.ellipsoid_volume(a, a, c)    A = Volume.oblate_spheroid_area(a, c)    l = lift(V, liftgas, AirMass)    l -  A*thickness*densityend`

I assume it is filled with Helium and will just assume its envelope is similar to the Goodyear one using some kind of polyester film. We’ll assume the same thickness. I don’t know the height, but if I experiment I can find static lift of 150 tons roughly with a heigh of 57m.

`julia> oblate_spheroid_lift_earth(57/2, 150/2, 0.0015, MylarDensity)152591.01523577614`

That doesn’t seem too far fetched.

Lets look at how the lift capacity would develop for such an airship as we increase its size and use different materials for envelope. SkyLifter Ltd itself has posted their own graph for how payload increased with diameter.

I’ll simplify a bit here and assume the disc shaped airship has a height 1/3 of its length. So our example would be 150 m long and 50 m tall.

First lets make an array of all the densities of materials we want to use for envelope.

`const materials = [MylarDensity, CarbonfibreCompositeDensity, AluminiumDensity, SteelDensity]`

This is a bit silly since I am using aluminum and steel, which are way to heavy to consider for this. But I wanted to check this for fun and completeness.

`len = linspace(100, 400, 10) # Lengths of airshipheight = len/3               # with heights are 1/3envelope_thickness = 0.0015  # in metersM = copy(len)                # column of lengthsfor (i, m) in enumerate(materials)   lifts = oblate_spheroid_lift.(height/2, len/2, 0.0015, m)   M = hcat(M, lifts/1000)    # adds lift column in tonsend`

You can put this table `M` in a CSV files and load it into some kind of plotting tool or use e.g. Gadfly to plot it directly. I had so much problems with Gadfly when I wrote this that opted to use Omni GraphSketcher and Apple Numbers instead. To facilitate this and not have to store to file which I then have to open again, I made this little utility function:

`function export_table(M)    io = IOBuffer()    writecsv(io, M)    s = String(take!(io))    clipboard(s)end`

It puts the table `M` in CSV format on the clipboard. Then I can just paste it into Omni GraphSketcher or Numbers and it will properly get into multiple columns.

You can see that whether we use polyester or carbon fibre composite, doesn’t make a huge difference in terms of weight. Which is not strange since they got mass densities of 1390 and 1600 kg/m³ respectively. Aluminum and steel is in another ballpark with 2700 and 7800 kg/m³.

As you can see, even if we go beyond Hindenburg size we can’t get a steel airship to float. But around 300 m long and 100 m tall, we see it flatten out and start going upwards. So making is sufficiently large and even steel would work given that it could handle the stress at those size of course.

Worth nothing is how rapidly the lift capacity grows with size. That is because volume grows much faster than dimensions of airship.

Of course one problem with the examples I’ve used thus far is that we assume we can use the same thickness for our airship envelope as it grows in size. That might not be realistic. I am not an engineer, so I don’t know how the thickness requirements for ships, submarines, airships, airplanes or whatever grows with volume.

However it ought to be safe to assume that we can grow the thickness proportional. By that I mean that if I double the dimensions of the airship, then I also double the thickness of the envelope. So an airship 30 m long, 10 m tall, should have an envelope with twice the thickness of an airship 15 m long, 5 m tall.

In the code example we don’t really deal with any kind of realistic volumes or thicknesses. That is because we aren’t really interested in specific volumes or surface areas but rather how the volume of the airship and the envelope grows with growth in the thickness of the envelope.

`thickness = 1:12len = thickness*15height = thickness*5c = len/2a = height/2V  = ellipsoid_volume.(a, a, c)A  = oblate_spheroid_area.(a, c)Ve = A .* thicknessM = hcat(thickness, V, Ve)export_table(M)`

Plotting these gives us the graph. If we scale up the airship with the thickness of the envelope, we see that the volume of the airship (blue) grows faster than volume of envelope (black).

What we see from this graph is that the envelope volume (black) grows more slowly than the airship volume (blue).

# Conclusion

There are significant benefits to going large when building airships. The ability to lift cargo will increase rapidly as you increase the dimensions of the airship.

Written by