Technical budgets¶

The resource budgets of the Apollo 11 mission system, in the order they drive each other: the Δv each maneuver needs, the propellant that Δv takes by the rocket equation, the mass of the vehicles that carry it, then power and reliability. The model's analyses and their status close the page. Cost is a programmatic resource, not a technical one: it has its own page, Cost.

Every value is labelled by where it comes from:

model value: stated in the model (an attribute's value);
model computes: the evaluator runs the model's own expressions, calculations and analyses;
page computes: a calculation this page adds, from the model's inputs and in the evaluator, where the model has no analysis for it (the propellant budget, the dry-mass rollup);
corrected estimate: where one of the model's analyses cannot produce a result, the page says exactly why and runs the model's own calculation with the defect worked around.

Where the values come from is stated in the repository's README (section 5, Assumptions and Estimates), not in the model: masses, thrust, specific impulse and durations are sourced from NASA documentation, while power, failure rates and costs are postulated by the model's authors to exercise the analyses, so those budgets illustrate the method rather than history.

18.4 km/s

Δv the mission requires (model computes)

4.8%

lowest propellant margin: S-IVB third stage (page computes)

2,870 t

gross mass at launch (stated: 2,970 t)

1.16

liftoff thrust-to-weight

+800 W

power margin, summed over assemblies (postulated)

0.99878

CSM + LM reliability, corrected (postulated)

10 of 26

model analysis results the model can compute

One value per quantity

Every mass, thrust and power is a single number: the model has no current best estimate (CBE) and maximum growth allowance (MGA) pair and no bounds such as the minimum propellant a mission needs or the capacity of its tanks.

Δv budget¶

Product Δv requirement by maneuver
The velocity change each major maneuver of the mission needs, as Apollo11MissionDeltaVBudgetAnalysis states or computes it (model value or model computes), and which hardware performs it.
Use it to start the budget from its driver: every propellant and mass figure below follows from these Δv.

Maneuver	Performed by	Model feature	Δv [m/s]	Source	Value in the model
Ascent to Earth orbit	S-IC + S-II (+ S-IVB first burn)	dv_required_leo	9,400	model value	9400 ['m⋅s⁻¹']
Trans-lunar injection	S-IVB	dv_required_tli	3,135	model computes: calculateTliDeltaV	calculateTliDeltaV(3.986E14 ['m³⋅s⁻²'], 6563 ['km'], 384400 ['km'])
Lunar orbit insertion	Service module	dv_required_loi	883	model computes: calculateLoiDeltaV	calculateLoiDeltaV(1000 ['m⋅s⁻¹'], 4.9E12 ['m³⋅s⁻²'], 1839 ['km'])
Powered descent and landing	LM descent stage	dv_required_landing	2,100	model value	2100 ['m⋅s⁻¹']
Lunar ascent	LM ascent stage	dv_required_ascent	1,870	model value	1870 ['m⋅s⁻¹']
Trans-Earth injection	Service module	dv_required_tei	1,000	model value	1000 ['m⋅s⁻¹']

The mission needs 18.4 km/s in all, 51% of it to reach Earth orbit. 2 of the 6 values are derived in the model (trans-lunar injection by calculateTliDeltaV, lunar orbit insertion by calculateLoiDeltaV); the others (ascent to Earth orbit, powered descent and landing, lunar ascent, trans-Earth injection) are stated. The analysis's 6 required-Δv features include none for midcourse corrections, attitude control (RCS) or reserves, so the budget below has no line for them.

Product Stage performance
Thrust and specific impulse of each propulsive stage, and the masses each one starts and ends its burn with, all evaluated from the model.
Use it to compare stages and check the inputs of the Δv budget.

Stage	Design	Engines	Thrust, vacuum [kN]	Isp [s]	m0 [kg]	mf [kg]
S-IC first stage	S-IC	5 × F-1	38,850	304	2,865,370	788,370
S-II second stage	S-II	5 × J-2	5,165	421	651,370	208,370
S-IVB third stage	S-IVB	1 × J-2	1,033	421	168,380	58,880
Service module	ApolloServiceModule	integral	91	314	24,600	6,160
LM descent stage	LunarModuleDescentStage	integral	45	305	10,350	2,100
LM ascent stage	LunarModuleAscentStage	integral	16	311	4,590	2,220

At liftoff the 5 F-1 engines give 33850 kN at sea level for a vehicle weight of 29125750 N: a thrust-to-weight ratio of 1.16 (sum(launchVehicle.stage1.engines.thrustSeaLevel) / (launchVehicle.launchMass * 9.80665 [m/s²])). Launch stages carry the payload stack the model's Δv analysis assigns them; spacecraft stages are counted with their own masses only, as the model's calculateSpacecraftBurnDeltaV does.

Product Δv budget
For each mission maneuver, the margin the model's Apollo11MissionDeltaVBudgetAnalysis computes, then a corrected estimate: the model's own calculateDeltaV, called with all four of its inputs.
Use it to see which maneuvers have margin, and what the model's own analysis needs fixing to say so itself.

What the model's Δv analysis computes
Stage	Model Δv capability	Why it cannot be computed
S-IC first stage	—	dv_stage1 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
S-II second stage	—	dv_stage2 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
S-IVB third stage	—	lm is the unit [lm], which has no feature totalMass (needed by dv_stage3_tli)
Service module	—	mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_csm)
LM descent stage	—	mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_lm_descent)
LM ascent stage	—	mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_lm_ascent)

Corrected estimate: the model's calculateDeltaV with g₀ passed
Stage	Corrected call (evaluated in Apollo11MissionSystem)	Corrected Δv
S-IC first stage	calculateDeltaV(launchVehicle.stage1.engines#(1).specificImpulseVacuum, 9.80665 [m/s²], launchVehicle.stage1.mass + payload, launchVehicle.stage1.dryMass + payload)	3847.22 m/s
S-II second stage	calculateDeltaV(launchVehicle.stage2.engines#(1).specificImpulseVacuum, 9.80665 [m/s²], launchVehicle.stage2.mass + payload, launchVehicle.stage2.dryMass + payload)	4705.62 m/s
S-IVB third stage	calculateDeltaV(launchVehicle.stage3.engines#(1).specificImpulseVacuum, 9.80665 [m/s²], launchVehicle.stage3.mass + payload, launchVehicle.stage3.dryMass + payload)	4338.01 m/s
Service module	calculateDeltaV(spacecraft.commandServiceModule.serviceModule.specificImpulse, 9.80665 [m/s²], spacecraft.commandServiceModule.serviceModule.dryMass + spacecraft.commandServiceModule.serviceModule.propellantMass, spacecraft.commandServiceModule.serviceModule.dryMass)	4263.8 m/s
LM descent stage	calculateDeltaV(spacecraft.lunarModule.lunarModuleDescentStage.specificImpulse, 9.80665 [m/s²], spacecraft.lunarModule.lunarModuleDescentStage.dryMass + spacecraft.lunarModule.lunarModuleDescentStage.propellantMass, spacecraft.lunarModule.lunarModuleDescentStage.dryMass)	4770.84 m/s
LM ascent stage	calculateDeltaV(spacecraft.lunarModule.lunarModuleAscentStage.specificImpulse, 9.80665 [m/s²], spacecraft.lunarModule.lunarModuleAscentStage.dryMass + spacecraft.lunarModule.lunarModuleAscentStage.propellantMass, spacecraft.lunarModule.lunarModuleAscentStage.dryMass)	2215.34 m/s

Where payload is the stack the model's analysis puts on each launch stage, with each assembly's gross mass (mass, or dryMass for the instrument unit) and the lunar module's two stages where the model writes lm:

S-IC first stage: stage2.mass + stage3.mass + instrumentUnit.dryMass + spacecraftLMAdapter.mass + serviceModule.mass + commandModule.mass + lunarModuleAscentStage.mass + lunarModuleDescentStage.mass
S-II second stage: stage3.mass + instrumentUnit.dryMass + spacecraftLMAdapter.mass + serviceModule.mass + commandModule.mass + lunarModuleAscentStage.mass + lunarModuleDescentStage.mass
S-IVB third stage: serviceModule.mass + commandModule.mass + lunarModuleAscentStage.mass + lunarModuleDescentStage.mass

Model margin versus corrected estimate (capability − dv_required_…, evaluated)
Maneuver	Provided by	Model margin	Required [m/s]	Corrected capability [m/s]	Corrected margin [m/s]
Ascent to Earth orbit	S-IC + S-II	— (ascentMargin needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit))	9,400	8,553	-847
Trans-lunar injection	S-IVB	— (lm is the unit [lm], which has no feature totalMass (needed by tliMargin))	3,135	4,338	+1,203
Lunar orbit insertion + trans-Earth injection	Service module	— (mf has no value (in calculateDeltaV: no argument for mf) (needed by loiMargin))	1,883	4,264	+2,380
Powered descent and landing	LM descent stage	— (mf has no value (in calculateDeltaV: no argument for mf) (needed by landingMargin))	2,100	4,771	+2,671
Lunar ascent	LM ascent stage	— (mf has no value (in calculateDeltaV: no argument for mf) (needed by ascentMargin_lunar))	1,870	2,215	+345

Required Δv comes from the model. Trans-lunar injection (3,135 m/s) is computed by calculateTliDeltaV, lunar orbit insertion (883 m/s) is computed by calculateLoiDeltaV; the others are stated values.
None of the model's stage capabilities compute, for the evaluator's reasons: S-IC first stage: dv_stage1 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit); S-II second stage: dv_stage2 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit); S-IVB third stage: lm is the unit [lm], which has no feature totalMass (needed by dv_stage3_tli); Service module: mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_csm); LM descent stage: mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_lm_descent); LM ascent stage: mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_lm_ascent). The corrected calls pass g₀ = 9.80665 m/s², use the instrument unit's dryMass, and put the lunar module where lm stands ([lm] → lunar module).
The ascent margin is negative (-847 m/s) even corrected, because the budget credits the S-IVB only with trans-lunar injection, while its first burn completed orbit insertion. The S-IVB's surplus (+1,203 m/s) covers it: +356 m/s for the launch vehicle as a whole.
The spacecraft margins are all positive (+345 to +2,671 m/s) with each stage credited with its own masses only; in flight the service module braked the docked CSM and LM, and the descent stage carried the ascent stage down. The propellant budget charges each stage with the stack it pushed.

The Saturn V upper stages separating from the spent S-IC first stage during the Apollo 11 launch — Apollo 11 staging, 16 July 1969: the S-II and S-IVB stages and the spacecraft pull away from the spent S-IC first stage, about 38 miles up, photographed from a US Air Force EC-135N tracking aircraft. Each stage dropped is mass the stages above no longer accelerate, which is why the Δv budget is worked stage by stage. NASA, public domain.

Propellant budget¶

Product Propellant budget
For each stage that burns for the spacecraft's trajectory, the least propellant its required Δv takes by the rocket equation, m₀·(1 − e^(−Δv/(Isp·g₀))), against the propellant loaded (page computes, in the evaluator, from the model's Isp, masses and required Δv).
Use it to see how much of each stage's propellant the mission needs and how much is margin.

Stage	Burns	Stack	Required Δv [m/s]	Start mass [kg]	Minimum [kg] (page computes)	Loaded [kg] (model value)	Margin [kg]	Margin
S-IVB third stage	orbit insertion (what the S-IC and S-II leave of the ascent) + trans-lunar injection	the Δv budget's stack (S-IVB, CSM, LM)	3,982	168,380	104,202	109,500	+5,298	+4.8%
Service module	lunar orbit insertion (CSM + LM), then trans-Earth injection (CSM)	CSM + LM, then CSM	1,883	45,380	16,620	18,440	+1,820	+9.9%
LM descent stage	powered descent and landing	descent + ascent stages	2,100	14,940	7,537	8,250	+713	+8.6%
LM ascent stage	lunar ascent to orbit	ascent stage	1,870	4,590	2,104	2,370	+266	+11.2%

The launch vehicle. This page takes the S-IC and S-II to burn to depletion: together they give 8,553 m/s of the 9,400 m/s ascent (corrected estimate). The model states one ascent requirement (dv_required_leo) for both, so they have no margin of their own. The S-IVB's first burn makes up the rest of the ascent (847 m/s) before trans-lunar injection (3,135 m/s): 3,982 m/s in all, which leaves 5,298 kg (4.8%) of its propellant unused. Its stack is the one the model's Δv analysis gives it (serviceModule, commandModule, lunarModuleAscentStage, lunarModuleDescentStage); adding the instrument unit and the adapter, which it also carried, the minimum grows to 106,548 kg and the margin shrinks to 2,952 kg (2.7%).
The spacecraft. Each stage is charged with the stack it pushed in flight (the Stack column), not with its own masses only as the model's calculateSpacecraftBurnDeltaV does: the service module first brakes the docked CSM and LM into lunar orbit, then the CSM alone, lighter by the propellant already burned, onto the trans-Earth trajectory. Counting own masses only, as the Δv budget does, the minimum would be 11,255 kg for the service module, 5,221 kg for the LM descent stage, and the margins correspondingly larger.

What the propellant budget cannot show

One nominal value per stage. The model states one propellantMass per stage: no minimum the mission needs, no tank capacity, and so no design margin between them. The minimum above is this page's calculation, not the model's.
No reserves. The model's Δv analysis has no requirement for midcourse corrections, attitude control or dispersions, so the minimum is a floor; a reserve requirement would consume part of each margin.
No consumable masses. No hardware in the model carries a mass of fuel-cell reactants (the LOX and LH₂ that made the CSM's power and water), breathing oxygen or water, so their share of the payload in the rocket equation, and their own margins, cannot be shown. Oxygen and water appear only as requirement thresholds and recorded levels (actualOxygenPressureMax, actualOxygenPressureMin, actualWaterProvidedPerCrewPerDay, maxOxygenPressureReqd, minOxygenPressureReqd, minWaterRequiredPerCrewPerDay, oxygenLevel, oxygenRemaining).

Mass budget¶

Product Dry mass rollup
The dry mass of each assembly, without the propellant it carries, from the model's dryMass (or mass where an assembly has no propellant): model value, summed by vehicle (page computes).
Use it to see where the hardware mass is, apart from what the mission burns.

Vehicle	Assembly	Design	Dry [kg]	From
Saturn V (SA-506)	stage1	S-IC	137,000	dryMass
Saturn V (SA-506)	stage2	S-II	36,200	dryMass
Saturn V (SA-506)	stage3	S-IVB	13,500	dryMass
Saturn V (SA-506)	instrumentUnit	SaturnVInstrumentUnit	1,950	dryMass
Saturn V (SA-506)	subtotal		188,650	page computes
Apollo spacecraft	serviceModule	ApolloServiceModule	6,160	dryMass
Apollo spacecraft	commandModule	ApolloCommandModule	5,840	mass (no propellant modeled)
Apollo spacecraft	launchEscapeSystem	ApolloLaunchEscapeSystem	4,170	mass (no propellant modeled)
Apollo spacecraft	lunarModuleAscentStage	LunarModuleAscentStage	2,220	dryMass
Apollo spacecraft	lunarModuleDescentStage	LunarModuleDescentStage	2,100	dryMass
Apollo spacecraft	spacecraftLMAdapter	ApolloSpacecraftLMAdapter	1,840	mass (no propellant modeled)
Apollo spacecraft	subtotal		22,330	page computes
Launch stack	total		210,980	page computes

The launch stack's hardware weighs 210,980 kg, 7.4% of its gross mass at liftoff. commandModule, launchEscapeSystem, spacecraftLMAdapter have a mass but no propellantMass in the model, so their mass counts as dry; any propellant they carried is either inside that figure or not modeled.

No growth allowance

The model gives every mass as a single value. A design-phase mass budget carries two per item: the current best estimate (CBE) and the maximum growth allowance (MGA, the CBE grown by a factor set by the design's maturity), and rolls up the MGA values so the vehicle is not sized short. Without them the rollups here cannot be padded for growth; for an as-flown model, the values stand for measured masses (MGA = CBE).

Product Gross mass at liftoff
The gross mass of the launch stack at liftoff by assembly: dry mass plus the nominal propellant loaded, as the model computes each assembly's mass (model computes; for the stages, mass = dryMass + propellantMass), against the stated launch mass (model value).
Use it to check that the vehicle closes on its stated launch mass and see where the mass is.

Vehicle	Assembly	Design	Model mass [kg]	Dry [kg]	Propellant, nominal loaded [kg]	Gross [kg]	Gross from	Why not
Saturn V (SA-506)	stage1	S-IC	2,214,000	137,000	2,077,000	2,214,000	mass
Saturn V (SA-506)	stage2	S-II	479,200	36,200	443,000	479,200	mass
Saturn V (SA-506)	stage3	S-IVB	123,000	13,500	109,500	123,000	mass
Saturn V (SA-506)	instrumentUnit	SaturnVInstrumentUnit		1,950	0	1,950	dryMass (no mass)	instrumentUnit.mass has no value
Apollo spacecraft	serviceModule	ApolloServiceModule	24,600	6,160	18,440	24,600	mass
Apollo spacecraft	lunarModuleDescentStage	LunarModuleDescentStage	10,350	2,100	8,250	10,350	mass
Apollo spacecraft	commandModule	ApolloCommandModule	5,840	5,840	0	5,840	mass
Apollo spacecraft	lunarModuleAscentStage	LunarModuleAscentStage	4,590	2,220	2,370	4,590	mass
Apollo spacecraft	launchEscapeSystem	ApolloLaunchEscapeSystem	4,170	4,170	0	4,170	mass
Apollo spacecraft	spacecraftLMAdapter	ApolloSpacecraftLMAdapter	1,840	1,840	0	1,840	mass

Model: the assemblies' mass values add up to 2,867,590 kg; instrumentUnit has no mass, only a dryMass of 1,950 kg.
Corrected estimate: counting that dryMass instead (the Gross from column) gives 2,869,540 kg, 100,460 kg (3.4%) less than the Saturn V's stated launchMass of 2,970,000 kg. No element of the model has a mass for the interstages, propellant residuals or ullage propellant, which would likely account for the difference.
Propellant is 93% of the stack.

Power budget¶

Product Electrical power budget
Power generated and consumed: what the model's Apollo11MissionSystemPowerAnalysis computes, then the model's own roll-ups and margin calculation applied to the concrete vehicles (postulated values).
Use it to check that each assembly can supply its own loads.

What the model's power analysis computes

totalPowerGenerated = 0 W, totalPowerLoad = 0 W, powerMargin = 0 W: its subject apollo11MissionSystem is typed by the generic System, which has no parts, so rollupPowerGeneration finds nothing to sum.
Its assertion powerMargin > 0[W] is therefore violated: powerMargin > 0[W] with powerMargin = 0 W.

Assembly	Generated [W]	Load [W]	Margin [W]
Command and service module	3,000	2,500	+500
Lunar module	3,000	2,200	+800
Launch escape system	0	50	-50
Saturn V instrument unit	0	450	-450
Mission system (corrected estimate)	6,000	5,200	+800

Corrected estimate: the model's own roll-ups, applied to the concrete vehicles instead of the abstract subject, and its own margin calculation:

calculatePowerMargin(rollupPowerGeneration(spacecraft) + rollupPowerGeneration(launchVehicle), rollupPowerConsumption(spacecraft) + rollupPowerConsumption(launchVehicle)) = 800 W (6000 W generated for 5200 W of load). Command and service module and Lunar module generate power; the launch escape system and the Saturn V instrument unit only consume. Each assembly's margin above is calculatePowerMargin(powerGenerated, powerLoad) (0 W generated where an assembly has none).

What a mission power budget would need

One steady value per assembly. The model gives power only as part attributes (powerGenerated, powerLoad), none on a phase or an operation, so power cannot be budgeted by mission phase or activity (an engine burn, the lunar stay, re-entry on batteries).
No peak power versus mission energy. The peak demand sizes the power system; the total energy over the mission is the driver here, because the CSM's fuel cells made it by consuming reactants. The model has no peak, energy or reactant attribute.
No link to the propellant budget. No hardware carries a reactant mass, so the energy budget cannot feed the payload term of the rocket equation in the propellant budget above.

Reliability budget¶

Product Reliability budget
The probability that each spacecraft module survives its exposure time: what the model's Apollo11LifecycleReliabilityAnalysis computes, then its own formula with e in place of eulerNumber (postulated failure rates).
Use it to see which module drives mission risk.

Module	Model result	λ	Exposure	Corrected formula	Corrected R
Command module	— (cmReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value)	1.5e-6 1/h	195.3 h	exp(-(commandModule.failureRate * plannedDuration))	0.999707
Service module	— (smReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value)	2e-6 1/h	195.3 h	exp(-(serviceModule.failureRate * plannedDuration))	0.999609
Lunar module (descent + ascent stages)	— (lmReliability needs lm.failureRate, which has no value (none in LM-5))	5.5e-6 1/h	97.65 h	exp(-((lunarModuleDescentStage.failureRate + lunarModuleAscentStage.failureRate) * plannedDuration / 2))	0.999463

Model: none of the 3 results computes: command module: cmReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value; service module: smReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value; lunar module (descent + ascent stages): lmReliability needs lm.failureRate, which has no value (none in LM-5). ISQCharacteristicNumbers::eulerNumber is the fluid-dynamics Euler number; the constant e was meant.
Corrected estimate: the same formula with exp, and the LM's two stage rates combined, evaluated in series (the product of the three) gives R = 0.998780 over the planned 195.3 h (the lunar module over half of it): about one failure in 820 missions from these modules alone.

Analysis status¶

Product Analysis status
Every result of the model's own analyses (AnalysisPackage) as the model computes it, and every asserted constraint with its verdict. Where a result cannot be computed, the reason names the defect.
Use it to see at a glance which analyses the model can execute today and what blocks the others.

Analysis	Result feature	Result	Why it cannot be computed
Apollo11LifecycleReliabilityAnalysis	cmReliability		cmReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value
Apollo11LifecycleReliabilityAnalysis	smReliability		smReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value
Apollo11LifecycleReliabilityAnalysis	lmReliability		lmReliability needs lm.failureRate, which has no value (none in LM-5)
Apollo11MissionCostAnalysis	totalMissionCost	11000000000 $
Apollo11MissionDeltaVBudgetAnalysis	dv_stage1		dv_stage1 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
Apollo11MissionDeltaVBudgetAnalysis	dv_stage2		dv_stage2 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
Apollo11MissionDeltaVBudgetAnalysis	dv_stage3_tli		lm is the unit [lm], which has no feature totalMass (needed by dv_stage3_tli)
Apollo11MissionDeltaVBudgetAnalysis	dv_csm		mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_csm)
Apollo11MissionDeltaVBudgetAnalysis	dv_lm_descent		mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_lm_descent)
Apollo11MissionDeltaVBudgetAnalysis	dv_lm_ascent		mf has no value (in calculateDeltaV: no argument for mf) (needed by dv_lm_ascent)
Apollo11MissionDeltaVBudgetAnalysis	dv_required_tli	3135.16 m/s
Apollo11MissionDeltaVBudgetAnalysis	dv_required_loi	883.42 m/s
Apollo11MissionDeltaVBudgetAnalysis	dv_required_leo	9400 m/s
Apollo11MissionDeltaVBudgetAnalysis	dv_required_landing	2100 m/s
Apollo11MissionDeltaVBudgetAnalysis	dv_required_ascent	1870 m/s
Apollo11MissionDeltaVBudgetAnalysis	dv_required_tei	1000 m/s
Apollo11MissionDeltaVBudgetAnalysis	ascentCapability		ascentCapability needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
Apollo11MissionDeltaVBudgetAnalysis	ascentMargin		ascentMargin needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
Apollo11MissionDeltaVBudgetAnalysis	tliMargin		lm is the unit [lm], which has no feature totalMass (needed by tliMargin)
Apollo11MissionDeltaVBudgetAnalysis	loiMargin		mf has no value (in calculateDeltaV: no argument for mf) (needed by loiMargin)
Apollo11MissionDeltaVBudgetAnalysis	landingMargin		mf has no value (in calculateDeltaV: no argument for mf) (needed by landingMargin)
Apollo11MissionDeltaVBudgetAnalysis	ascentMargin_lunar		mf has no value (in calculateDeltaV: no argument for mf) (needed by ascentMargin_lunar)
Apollo11MissionSuccessAnalysis	overallMissionSuccess		overallMissionSuccess needs apollo11Mission.crewReturnedSafely, which has no value (none in Apollo11MissionIndividual)
Apollo11MissionSystemPowerAnalysis	totalPowerGenerated	0 W
Apollo11MissionSystemPowerAnalysis	totalPowerLoad	0 W
Apollo11MissionSystemPowerAnalysis	powerMargin	0 W

10 of 26 analysis results compute. The blocked ones trace to a few defects: mf has no value (6×); cmReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value (1×); smReliability needs ISQCharacteristicNumbers::eulerNumber, which has no value (1×); lmReliability needs lm.failureRate, which has no value (none in LM-5) (1×); dv_stage1 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit) (1×); dv_stage2 needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit) (1×); lm is the unit [lm], which has no feature totalMass (needed by dv_stage3_tli) (1×); ascentCapability needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit) (1×); ascentMargin needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit) (1×); lm is the unit [lm], which has no feature totalMass (needed by tliMargin) (1×); overallMissionSuccess needs apollo11Mission.crewReturnedSafely, which has no value (none in Apollo11MissionIndividual) (1×).

Asserted constraints
Assertion	Verdict	Why
SystemPowerAnalysis	violated	powerMargin > 0[W] with powerMargin = 0 W
Apollo11MissionDeltaVBudgetAnalysis	undetermined	ascentMargin needs instrumentUnit.mass, which has no value (none in SaturnVInstrumentUnit)
Apollo11MissionSuccessAnalysis	undetermined	its body has no result expression, so it constrains nothing (a body of declarations only)

Analysis definitions¶

Product Analysis register
The calculations defined in the model that the budgets above run, with their formula and where they are used.
Use it to see what the model executes, and reuse the definitions for other missions.

Calculation	Result	Purpose	Used by
calculateDeltaV(isp, g0, m0, mf)	isp * g0 * ln(m0 / mf)	Calculates the maximum change in velocity a stage can provide using the Tsiolkovsky Rocket Equation.	calculateLaunchStageDeltaV, calculateSpacecraftBurnDeltaV
calculateLaunchStageDeltaV(stage, payloadStack)	calculateDeltaV(isp, initialMass, finalMass)	Calculates the delta-v provided by a launch stage (like S-IC or S-II) carrying an upper stack.	Apollo11MissionDeltaVBudgetAnalysis
calculateLoiDeltaV(v_inf, mu_Moon, r_periapsis)	(v_inf^2 + 2*mu_Moon/r_periapsis)^(1/2) - (mu_Moon/r_periapsis)^(1/2)	Calculates the required braking Delta-V for Lunar Orbit Insertion from a hyperbolic approach.	Apollo11MissionDeltaVBudgetAnalysis
calculateMassBudgetStep(initialMass, propellantUsed, jettisonedMass)	initialMass - propellantUsed - jettisonedMass	Calculates the remaining mass of a vehicle after a mission event.	SystemMassAnalysis
calculatePowerMargin(sourcePower, totalLoadPower)	sourcePower - totalLoadPower	Calculates the difference between available power and the sum of all electrical loads.	SystemPowerAnalysis
calculateReliability(failureRate, missionTime)	eulerNumber^(-(failureRate * missionTime))	Calculates the reliability of a component over time using the exponential failure distribution.	Apollo11LifecycleReliabilityAnalysis
calculateSpacecraftBurnDeltaV(spacecraft)	calculateDeltaV(isp, initialMass, finalMass)	Calculates the delta-v provided by a self-propelled spacecraft (CSM or LM stages).	Apollo11MissionDeltaVBudgetAnalysis
calculateTliDeltaV(mu_Earth, r_leo, r_apoapsis)	(mu_Earth * (2/r_leo - 2/(r_leo + r_apoapsis)))^(1/2) - (mu_Earth / r_leo)^(1/2)	Calculates the required Delta-V for a Hohmann-like Translunar Injection.	Apollo11MissionDeltaVBudgetAnalysis
evaluateMissionSuccess(crewSafe, landed, samplesReturned, instrumentsDeployed)	crewSafe and landed and samplesReturned and instrumentsDeployed	Evaluates the overall mission success based on the achievement of primary objectives.	Apollo11MissionSuccessAnalysis
rollupPowerConsumption(system)	system.subparts->select { in sys : Part; sys istype PowerConsumer } ->collect { in sys : PowerConsumer; sys.powerLoad } ->sum()		SystemPowerAnalysis
rollupPowerGeneration(system)	system.subparts->select { in sys : Part; sys istype PowerProvider } ->collect { in sys : PowerProvider; sys.powerGenerated } ->sum()		SystemPowerAnalysis
sumCosts(r_d, mfg, ops, personnel)	r_d + mfg + ops + personnel	Sums the major cost categories to find the total program cost.	MissionCostAnalysis
sumDryMass(components)	sum(components.dryMass)	A utility to sum the dry mass of a set of components.
sumGrossMass(components)	sum(components.totalMass)	A utility to sum the gross (fully fueled) mass of a set of components.	calculateLaunchStageDeltaV

Defects that stop the model's own analyses

eulerNumber is not e. calculateReliability uses eulerNumber, which resolves to ISQCharacteristicNumbers::eulerNumber (a quantity with no value), so no reliability computes.
lm is the lumen. The Δv stacks list lm, which the analysis never defines; through import SI::* it resolves to the SI unit lm. The lunar module (lmds, lmas) was meant.
g0 is never passed. calculateDeltaV(isp, initialMass, finalMass) binds 3 of its 4 inputs (isp, g0, m0, mf): by position initialMass goes to g0 and mf stays unbound.
The instrument unit declares its own dryMass instead of redefining mass, so totalMass and the Δv stacks have no mass for it.
The power analysis's subject is a plain System, so the roll-up has no parts to sum and the margin is 0; its subject should be the mission system.
LM-5 has no failure rate; only its two stages do.
The Apollo11MissionSuccessAnalysis assertion is vacuous. Its body only declares a feature (because of a trailing semicolon), so it constrains nothing.
ln is declared with 2 inputs (x, y) and no body; it is evaluated as the natural logarithm of its first argument.
The gravitational parameter is typed ISQ::force (mu_Earth, mu_Moon), although its unit (m³⋅s⁻²) is that of a gravitational parameter; the evaluator still computes the TLI and LOI requirements (3,135 and 883 m/s).