520 lines
17 KiB
JavaScript
520 lines
17 KiB
JavaScript
import { machFromAreaRatio, areaRatioFromMach } from './numerics.js'
|
||
|
||
// Each equation:
|
||
// id – unique key
|
||
// name – display name
|
||
// formula – formula string shown to user
|
||
// variables – all variable ids involved
|
||
// solvers – map of { variableId: fn(knownValues) => number }
|
||
// A solver may return NaN/Infinity to signal infeasibility.
|
||
|
||
export const EQUATIONS = [
|
||
|
||
// ── Thrust ─────────────────────────────────────────────────────────────
|
||
{
|
||
id: 'fundamental_thrust',
|
||
name: 'Fundamental Thrust Equation',
|
||
formula: 'F = ṁ·Vₑ + (pₑ − pₐ)·Aₑ',
|
||
category: 'Thrust',
|
||
variables: ['F', 'mdot', 'Ve', 'pe', 'pa', 'Ae'],
|
||
solvers: {
|
||
F: v => v.mdot * v.Ve + (v.pe - v.pa) * v.Ae,
|
||
mdot: Object.assign(
|
||
v => (v.F - ('Ae' in v ? (v.pe - v.pa) * v.Ae : 0)) / v.Ve,
|
||
{
|
||
requires: known => {
|
||
const adapted = 'pe' in known && 'pa' in known && known.pe === known.pa
|
||
return adapted ? ['F', 'Ve', 'pe', 'pa'] : ['F', 'Ve', 'pe', 'pa', 'Ae']
|
||
},
|
||
},
|
||
),
|
||
Ve: v => (v.F - (v.pe - v.pa) * v.Ae) / v.mdot,
|
||
pe: v => (v.F - v.mdot * v.Ve) / v.Ae + v.pa,
|
||
pa: v => v.pe - (v.F - v.mdot * v.Ve) / v.Ae,
|
||
Ae: v => (v.F - v.mdot * v.Ve) / (v.pe - v.pa),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'thrust_from_isp',
|
||
name: 'Thrust from Isp',
|
||
formula: 'F = ṁ·Isp·g₀',
|
||
category: 'Thrust',
|
||
variables: ['F', 'mdot', 'Isp', 'g0'],
|
||
solvers: {
|
||
F: v => v.mdot * v.Isp * v.g0,
|
||
mdot: v => v.F / (v.Isp * v.g0),
|
||
Isp: v => v.F / (v.mdot * v.g0),
|
||
g0: v => v.F / (v.mdot * v.Isp),
|
||
},
|
||
},
|
||
|
||
// ── Effective Exhaust Velocity ─────────────────────────────────────────
|
||
{
|
||
id: 'ceff_def',
|
||
name: 'Effective Exhaust Velocity',
|
||
formula: 'cₑ = F / ṁ',
|
||
category: 'Thrust',
|
||
variables: ['ceff', 'F', 'mdot'],
|
||
solvers: {
|
||
ceff: v => v.F / v.mdot,
|
||
F: v => v.ceff * v.mdot,
|
||
mdot: v => v.F / v.ceff,
|
||
},
|
||
},
|
||
|
||
// ── Specific Impulse ───────────────────────────────────────────────────
|
||
{
|
||
id: 'isp_from_ve',
|
||
name: 'Isp from Effective Exhaust Velocity',
|
||
formula: 'Isp = cₑ / g₀',
|
||
category: 'Specific Impulse',
|
||
variables: ['Isp', 'ceff', 'g0'],
|
||
solvers: {
|
||
Isp: v => v.ceff / v.g0,
|
||
ceff: v => v.Isp * v.g0,
|
||
g0: v => v.ceff / v.Isp,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'isp_from_thrust',
|
||
name: 'Isp from Thrust & Mass Flow',
|
||
formula: 'Isp = F / (ṁ·g₀)',
|
||
category: 'Specific Impulse',
|
||
variables: ['Isp', 'F', 'mdot', 'g0'],
|
||
solvers: {
|
||
Isp: v => v.F / (v.mdot * v.g0),
|
||
F: v => v.Isp * v.mdot * v.g0,
|
||
mdot: v => v.F / (v.Isp * v.g0),
|
||
g0: v => v.F / (v.Isp * v.mdot),
|
||
},
|
||
},
|
||
|
||
// ── Characteristic Velocity ────────────────────────────────────────────
|
||
{
|
||
id: 'cstar_def',
|
||
name: 'Characteristic Velocity',
|
||
formula: 'c* = p₀·Aₜ / ṁ',
|
||
category: 'Nozzle Performance',
|
||
variables: ['cstar', 'p0', 'At', 'mdot'],
|
||
solvers: {
|
||
cstar: v => (v.p0 * v.At) / v.mdot,
|
||
p0: v => (v.cstar * v.mdot) / v.At,
|
||
At: v => (v.cstar * v.mdot) / v.p0,
|
||
mdot: v => (v.p0 * v.At) / v.cstar,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'cstar_from_cf_isp',
|
||
name: 'c* from Thrust Coefficient & Isp',
|
||
formula: 'c* = Isp·g₀ / Cꜰ',
|
||
category: 'Nozzle Performance',
|
||
variables: ['cstar', 'Isp', 'g0', 'CF'],
|
||
solvers: {
|
||
cstar: v => (v.Isp * v.g0) / v.CF,
|
||
Isp: v => (v.cstar * v.CF) / v.g0,
|
||
g0: v => (v.cstar * v.CF) / v.Isp,
|
||
CF: v => (v.Isp * v.g0) / v.cstar,
|
||
},
|
||
},
|
||
|
||
// ── Thrust Coefficient ─────────────────────────────────────────────────
|
||
{
|
||
id: 'thrust_coefficient',
|
||
name: 'Thrust Coefficient',
|
||
formula: 'Cꜰ = F / (p₀·Aₜ)',
|
||
category: 'Nozzle Performance',
|
||
variables: ['CF', 'F', 'p0', 'At'],
|
||
solvers: {
|
||
CF: v => v.F / (v.p0 * v.At),
|
||
F: v => v.CF * v.p0 * v.At,
|
||
p0: v => v.F / (v.CF * v.At),
|
||
At: v => v.F / (v.CF * v.p0),
|
||
},
|
||
},
|
||
|
||
// ── Tsiolkovsky Rocket Equation ────────────────────────────────────────
|
||
{
|
||
id: 'tsiolkovsky_ve',
|
||
name: 'Tsiolkovsky Rocket Equation (cₑ)',
|
||
formula: 'Δv = cₑ·ln(m₀/mf)',
|
||
category: 'Rocket Equation',
|
||
variables: ['dv', 'ceff', 'm0', 'mf'],
|
||
solvers: {
|
||
dv: v => v.ceff * Math.log(v.m0 / v.mf),
|
||
ceff: v => v.dv / Math.log(v.m0 / v.mf),
|
||
m0: v => v.mf * Math.exp(v.dv / v.ceff),
|
||
mf: v => v.m0 / Math.exp(v.dv / v.ceff),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'tsiolkovsky_isp',
|
||
name: 'Tsiolkovsky Rocket Equation (Isp)',
|
||
formula: 'Δv = Isp·g₀·ln(m₀/mf)',
|
||
category: 'Rocket Equation',
|
||
variables: ['dv', 'Isp', 'g0', 'm0', 'mf'],
|
||
solvers: {
|
||
dv: v => v.Isp * v.g0 * Math.log(v.m0 / v.mf),
|
||
Isp: v => v.dv / (v.g0 * Math.log(v.m0 / v.mf)),
|
||
g0: v => v.dv / (v.Isp * Math.log(v.m0 / v.mf)),
|
||
m0: v => v.mf * Math.exp(v.dv / (v.Isp * v.g0)),
|
||
mf: v => v.m0 / Math.exp(v.dv / (v.Isp * v.g0)),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'mass_ratio',
|
||
name: 'Mass Ratio',
|
||
formula: 'MR = m₀ / mf',
|
||
category: 'Rocket Equation',
|
||
variables: ['MR', 'm0', 'mf'],
|
||
solvers: {
|
||
MR: v => v.m0 / v.mf,
|
||
m0: v => v.MR * v.mf,
|
||
mf: v => v.m0 / v.MR,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'propellant_mass',
|
||
name: 'Propellant Mass',
|
||
formula: 'mₚ = m₀ − mf',
|
||
category: 'Rocket Equation',
|
||
variables: ['mp', 'm0', 'mf'],
|
||
solvers: {
|
||
mp: v => v.m0 - v.mf,
|
||
m0: v => v.mp + v.mf,
|
||
mf: v => v.m0 - v.mp,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'mass_fraction',
|
||
name: 'Propellant Mass Fraction',
|
||
formula: 'ζ = mₚ / m₀',
|
||
category: 'Rocket Equation',
|
||
variables: ['zeta', 'mp', 'm0'],
|
||
solvers: {
|
||
zeta: v => v.mp / v.m0,
|
||
mp: v => v.zeta * v.m0,
|
||
m0: v => v.mp / v.zeta,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'burn_time',
|
||
name: 'Burn Time',
|
||
formula: 'tᵦ = mₚ / ṁ',
|
||
category: 'Rocket Equation',
|
||
variables: ['tb', 'mp', 'mdot'],
|
||
solvers: {
|
||
tb: v => v.mp / v.mdot,
|
||
mp: v => v.tb * v.mdot,
|
||
mdot: v => v.mp / v.tb,
|
||
},
|
||
},
|
||
|
||
// ── Isentropic Flow Relations ──────────────────────────────────────────
|
||
{
|
||
id: 'isentropic_temp',
|
||
name: 'Isentropic Temperature Ratio',
|
||
formula: 'T/T₀ = (1 + (γ−1)/2·M²)⁻¹',
|
||
category: 'Isentropic Flow',
|
||
variables: ['T', 'T0', 'M', 'gamma'],
|
||
solvers: {
|
||
T: v => v.T0 / (1 + (v.gamma - 1) / 2 * v.M * v.M),
|
||
T0: v => v.T * (1 + (v.gamma - 1) / 2 * v.M * v.M),
|
||
M: v => Math.sqrt((v.T0 / v.T - 1) * 2 / (v.gamma - 1)),
|
||
gamma: v => {
|
||
// T/T0 = 1/(1 + (γ-1)/2·M²) → T0/T - 1 = (γ-1)/2·M²
|
||
// γ = 1 + 2(T0/T - 1)/M²
|
||
return 1 + 2 * (v.T0 / v.T - 1) / (v.M * v.M)
|
||
},
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'isentropic_pressure',
|
||
name: 'Isentropic Pressure Ratio',
|
||
formula: 'p/p₀ = (1 + (γ−1)/2·M²)^(−γ/(γ−1))',
|
||
category: 'Isentropic Flow',
|
||
variables: ['p_static', 'p0', 'M', 'gamma'],
|
||
solvers: {
|
||
p_static: v => {
|
||
const exp = v.gamma / (v.gamma - 1)
|
||
return v.p0 / Math.pow(1 + (v.gamma - 1) / 2 * v.M * v.M, exp)
|
||
},
|
||
p0: v => {
|
||
const exp = v.gamma / (v.gamma - 1)
|
||
return v.p_static * Math.pow(1 + (v.gamma - 1) / 2 * v.M * v.M, exp)
|
||
},
|
||
M: v => {
|
||
// p0/p = (1 + (γ-1)/2·M²)^(γ/(γ-1))
|
||
// (p0/p)^((γ-1)/γ) = 1 + (γ-1)/2·M²
|
||
const ratio = Math.pow(v.p0 / v.p_static, (v.gamma - 1) / v.gamma)
|
||
return Math.sqrt((ratio - 1) * 2 / (v.gamma - 1))
|
||
},
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'isentropic_density',
|
||
name: 'Isentropic Density Ratio',
|
||
formula: 'ρ/ρ₀ = (1 + (γ−1)/2·M²)^(−1/(γ−1))',
|
||
category: 'Isentropic Flow',
|
||
variables: ['rho', 'rho0', 'M', 'gamma'],
|
||
solvers: {
|
||
rho: v => {
|
||
const exp = 1 / (v.gamma - 1)
|
||
return v.rho0 / Math.pow(1 + (v.gamma - 1) / 2 * v.M * v.M, exp)
|
||
},
|
||
rho0: v => {
|
||
const exp = 1 / (v.gamma - 1)
|
||
return v.rho * Math.pow(1 + (v.gamma - 1) / 2 * v.M * v.M, exp)
|
||
},
|
||
M: v => {
|
||
const ratio = Math.pow(v.rho0 / v.rho, v.gamma - 1)
|
||
return Math.sqrt((ratio - 1) * 2 / (v.gamma - 1))
|
||
},
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'speed_of_sound',
|
||
name: 'Speed of Sound',
|
||
formula: 'a = √(γ·R·T)',
|
||
category: 'Isentropic Flow',
|
||
variables: ['a_sound', 'gamma', 'R', 'T'],
|
||
solvers: {
|
||
a_sound: v => Math.sqrt(v.gamma * v.R * v.T),
|
||
T: v => (v.a_sound * v.a_sound) / (v.gamma * v.R),
|
||
R: v => (v.a_sound * v.a_sound) / (v.gamma * v.T),
|
||
gamma: v => (v.a_sound * v.a_sound) / (v.R * v.T),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'flow_velocity',
|
||
name: 'Flow Velocity',
|
||
formula: 'v = M·a',
|
||
category: 'Isentropic Flow',
|
||
variables: ['v_flow', 'M', 'a_sound'],
|
||
solvers: {
|
||
v_flow: v => v.M * v.a_sound,
|
||
M: v => v.v_flow / v.a_sound,
|
||
a_sound: v => v.v_flow / v.M,
|
||
},
|
||
},
|
||
|
||
// ── Nozzle Geometry ────────────────────────────────────────────────────
|
||
{
|
||
id: 'expansion_ratio',
|
||
name: 'Nozzle Expansion Ratio',
|
||
formula: 'ε = Aₑ / Aₜ',
|
||
category: 'Nozzle Geometry',
|
||
variables: ['eps', 'Ae', 'At'],
|
||
solvers: {
|
||
eps: v => v.Ae / v.At,
|
||
Ae: v => v.eps * v.At,
|
||
At: v => v.Ae / v.eps,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'area_ratio_mach',
|
||
name: 'Isentropic Area Ratio (supersonic)',
|
||
formula: 'ε = (1/Mₑ)·[(2/(γ+1))·(1+(γ−1)/2·Mₑ²)]^((γ+1)/(2(γ−1)))',
|
||
category: 'Nozzle Geometry',
|
||
variables: ['eps', 'Me', 'gamma'],
|
||
solvers: {
|
||
eps: v => areaRatioFromMach(v.Me, v.gamma),
|
||
Me: v => machFromAreaRatio(v.eps, v.gamma, true),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'choked_mass_flow',
|
||
name: 'Choked Throat Mass Flow',
|
||
formula: 'ṁ = Aₜ·p₀·√(γ/(R·T₀))·(2/(γ+1))^((γ+1)/(2(γ−1)))',
|
||
category: 'Nozzle Geometry',
|
||
variables: ['mdot', 'At', 'p0', 'gamma', 'R', 'T0'],
|
||
solvers: {
|
||
mdot: v => {
|
||
const exp = (v.gamma + 1) / (2 * (v.gamma - 1))
|
||
return v.At * v.p0 * Math.sqrt(v.gamma / (v.R * v.T0)) * Math.pow(2 / (v.gamma + 1), exp)
|
||
},
|
||
At: v => {
|
||
const exp = (v.gamma + 1) / (2 * (v.gamma - 1))
|
||
const coeff = v.p0 * Math.sqrt(v.gamma / (v.R * v.T0)) * Math.pow(2 / (v.gamma + 1), exp)
|
||
return v.mdot / coeff
|
||
},
|
||
p0: v => {
|
||
const exp = (v.gamma + 1) / (2 * (v.gamma - 1))
|
||
const coeff = v.At * Math.sqrt(v.gamma / (v.R * v.T0)) * Math.pow(2 / (v.gamma + 1), exp)
|
||
return v.mdot / coeff
|
||
},
|
||
T0: v => {
|
||
const exp = (v.gamma + 1) / (2 * (v.gamma - 1))
|
||
const coeff = v.At * v.p0 * Math.pow(2 / (v.gamma + 1), exp)
|
||
// mdot = coeff * sqrt(gamma/(R*T0))
|
||
// mdot/coeff = sqrt(gamma/(R*T0))
|
||
// (mdot/coeff)^2 = gamma/(R*T0)
|
||
// T0 = gamma/(R * (mdot/coeff)^2)
|
||
const ratio = v.mdot / coeff
|
||
return v.gamma / (v.R * ratio * ratio)
|
||
},
|
||
},
|
||
},
|
||
|
||
// ── Exit Conditions ────────────────────────────────────────────────────
|
||
// Order matters for the greedy solver: exit_pressure must come before
|
||
// exit_temperature so that Mₑ is in `known` when exit_temperature runs.
|
||
// If exit_pressure appeared after exit_temperature, the solver would
|
||
// reach exit_velocity first (with Mₑ freshly set) and use Vₑ = Isp·g₀
|
||
// to back-calculate an unphysical Tₑ > T₀.
|
||
{
|
||
id: 'exit_pressure',
|
||
name: 'Nozzle Exit Pressure',
|
||
formula: 'pₑ = p₀·(1 + (γ−1)/2·Mₑ²)^(−γ/(γ−1))',
|
||
category: 'Nozzle Geometry',
|
||
variables: ['pe', 'p0', 'Me', 'gamma'],
|
||
solvers: {
|
||
pe: v => {
|
||
const exp = v.gamma / (v.gamma - 1)
|
||
return v.p0 / Math.pow(1 + (v.gamma - 1) / 2 * v.Me * v.Me, exp)
|
||
},
|
||
p0: v => {
|
||
const exp = v.gamma / (v.gamma - 1)
|
||
return v.pe * Math.pow(1 + (v.gamma - 1) / 2 * v.Me * v.Me, exp)
|
||
},
|
||
Me: v => {
|
||
const ratio = Math.pow(v.p0 / v.pe, (v.gamma - 1) / v.gamma)
|
||
return Math.sqrt((ratio - 1) * 2 / (v.gamma - 1))
|
||
},
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'exit_temperature',
|
||
name: 'Nozzle Exit Temperature',
|
||
formula: 'Tₑ = T₀ / (1 + (γ−1)/2·Mₑ²)',
|
||
category: 'Nozzle Geometry',
|
||
variables: ['Te', 'T0', 'Me', 'gamma'],
|
||
solvers: {
|
||
Te: v => v.T0 / (1 + (v.gamma - 1) / 2 * v.Me * v.Me),
|
||
T0: v => v.Te * (1 + (v.gamma - 1) / 2 * v.Me * v.Me),
|
||
Me: v => Math.sqrt((v.T0 / v.Te - 1) * 2 / (v.gamma - 1)),
|
||
gamma: v => 1 + 2 * (v.T0 / v.Te - 1) / (v.Me * v.Me),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'exit_velocity',
|
||
name: 'Nozzle Exit Velocity',
|
||
formula: 'Vₑ = Mₑ·√(γ·R·Tₑ)',
|
||
category: 'Nozzle Geometry',
|
||
variables: ['Ve', 'Me', 'gamma', 'R', 'Te'],
|
||
solvers: {
|
||
Ve: v => v.Me * Math.sqrt(v.gamma * v.R * v.Te),
|
||
Me: v => v.Ve / Math.sqrt(v.gamma * v.R * v.Te),
|
||
Te: v => (v.Ve / v.Me) ** 2 / (v.gamma * v.R),
|
||
R: v => (v.Ve / v.Me) ** 2 / (v.gamma * v.Te),
|
||
gamma: v => (v.Ve / v.Me) ** 2 / (v.R * v.Te),
|
||
},
|
||
},
|
||
|
||
// ── Performance ────────────────────────────────────────────────────────
|
||
{
|
||
id: 'twr',
|
||
name: 'Thrust-to-Weight Ratio',
|
||
formula: 'TWR = F / (mᵥ·g₀)',
|
||
category: 'Performance',
|
||
variables: ['TWR', 'F', 'm_vehicle', 'g0'],
|
||
solvers: {
|
||
TWR: v => v.F / (v.m_vehicle * v.g0),
|
||
F: v => v.TWR * v.m_vehicle * v.g0,
|
||
m_vehicle: v => v.F / (v.TWR * v.g0),
|
||
g0: v => v.F / (v.TWR * v.m_vehicle),
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'total_impulse',
|
||
name: 'Total Impulse',
|
||
formula: 'J = F·tᵦ',
|
||
category: 'Performance',
|
||
variables: ['J', 'F', 'tb'],
|
||
solvers: {
|
||
J: v => v.F * v.tb,
|
||
F: v => v.J / v.tb,
|
||
tb: v => v.J / v.F,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'isp_from_impulse',
|
||
name: 'Isp from Total Impulse',
|
||
formula: 'Isp = J / (mₚ·g₀)',
|
||
category: 'Performance',
|
||
variables: ['Isp', 'J', 'mp', 'g0'],
|
||
solvers: {
|
||
Isp: v => v.J / (v.mp * v.g0),
|
||
J: v => v.Isp * v.mp * v.g0,
|
||
mp: v => v.J / (v.Isp * v.g0),
|
||
g0: v => v.J / (v.Isp * v.mp),
|
||
},
|
||
},
|
||
|
||
// ── Propellant ─────────────────────────────────────────────────────────
|
||
{
|
||
id: 'of_ratio',
|
||
name: 'Oxidiser/Fuel Ratio',
|
||
formula: 'O/F = ṁₒₓ / ṁf',
|
||
category: 'Propellant',
|
||
variables: ['OF', 'mdot_ox', 'mdot_f'],
|
||
solvers: {
|
||
OF: v => v.mdot_ox / v.mdot_f,
|
||
mdot_ox: v => v.OF * v.mdot_f,
|
||
mdot_f: v => v.mdot_ox / v.OF,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'total_mass_flow',
|
||
name: 'Total Mass Flow',
|
||
formula: 'ṁ = ṁₒₓ + ṁf',
|
||
category: 'Propellant',
|
||
variables: ['mdot', 'mdot_ox', 'mdot_f'],
|
||
solvers: {
|
||
mdot: v => v.mdot_ox + v.mdot_f,
|
||
mdot_ox: v => v.mdot - v.mdot_f,
|
||
mdot_f: v => v.mdot - v.mdot_ox,
|
||
},
|
||
},
|
||
|
||
{
|
||
id: 'of_mass_split',
|
||
name: 'Mass Flow Split from O/F',
|
||
formula: 'ṁ_f = ṁ/(1+OF), ṁ_ox = ṁ·OF/(1+OF)',
|
||
category: 'Propellant',
|
||
variables: ['mdot', 'OF', 'mdot_f', 'mdot_ox'],
|
||
solvers: {
|
||
mdot_f: Object.assign(v => v.mdot / (1 + v.OF), { requires: () => ['mdot', 'OF'] }),
|
||
mdot_ox: Object.assign(v => v.mdot * v.OF / (1 + v.OF), { requires: () => ['mdot', 'OF'] }),
|
||
},
|
||
},
|
||
]
|
||
|
||
// Equation presets: named groups that seed the workspace with a useful set of variables
|
||
export const EQUATION_PRESETS = [
|
||
{ id: 'fundamental_thrust', label: 'Fundamental Thrust', equationIds: ['fundamental_thrust'] },
|
||
{ id: 'rocket_equation', label: 'Rocket Equation', equationIds: ['tsiolkovsky_isp', 'mass_ratio', 'propellant_mass', 'burn_time'] },
|
||
{ id: 'nozzle_full', label: 'Full Nozzle', equationIds: ['exit_pressure', 'exit_temperature', 'exit_velocity', 'area_ratio_mach', 'choked_mass_flow', 'thrust_coefficient', 'cstar_def'] },
|
||
{ id: 'isentropic', label: 'Isentropic Flow', equationIds: ['isentropic_temp', 'isentropic_pressure', 'speed_of_sound', 'flow_velocity'] },
|
||
{ id: 'performance', label: 'Performance', equationIds: ['twr', 'total_impulse', 'isp_from_impulse', 'isp_from_thrust'] },
|
||
{ id: 'propellant', label: 'Propellant Mix', equationIds: ['of_ratio', 'total_mass_flow', 'burn_time'] },
|
||
]
|