engine.layerx.diag.thrustshape Namespace Reference

Functions
Callable[[float, float], Optional[Dict[str, float]]]	_sampler (Any config, float ambient_pa)
Tuple[Optional[Dict[str, float]], int, float]	feed_solve (Callable[[float, float], Optional[Dict[str, float]]] sampler, float p_out_O, float p_out_F, float K_O, float K_F, Tuple[float, float] m0)
Tuple[Optional[float], str]	_target (Any config, Optional[float] target_N)
Dict[str, Any]	shape_stats (np.ndarray t, np.ndarray F, float mean, float settle_t, Optional[float] target)
Dict[str, Any]	build_thrust_shape (Mapping[str, Any] result, Any prep=None, Any config=None, *, Optional[Callable[[float, float], Optional[Dict[str, float]]]] sampler=None, Optional[float] target_N=None, float settle_s=SETTLE_S, Optional[float] ambient_pa=None)

Variables
float	G0 = 9.80665
float	SETTLE_S = 0.2
int	FEED_TOL = 1e-9
int	FEED_ITERS = 60

Detailed Description

How flat the delivered thrust is, and where its change over the burn comes from.

``build_thrust_shape(result, prep=None, config, *, sampler=None, target_N=None)`` ->
``diagnostics.thrust_shape`` (DATA-CONTRACT 3).

**Shape.** Over the delivered thrust (``delivered.thrust_N``, the replay's eroded engine at the
twin's line-exit pressures) from the first settled step (``settle_s`` after Fire, 0.2 s: the same
window ``replay.delivered`` takes its minimum over): the mean (``delivered.summary.mean_thrust_N``,
the headline), the largest and the RMS deviation from it in percent, the spread, and against a
target when there is one (the config's ``design_requirements.target_thrust``, or ``target_N``).

**Breakdown**, on the replay's own points (the delivered thrust is interpolated between them),
of the change from the first settled point k0, ``dF(t) = F_del(t) - F_del(k0)``:

* ``erosion_N`` = ``[F_del - F_ab](t) - [F_del - F_ab](k0)``, where ``F_ab`` is the **as-built**
  engine (EngineDesign at the line exit, ``engine.layerx.card.EngineSampler``: the replay's model
  with no recession) at the same line-exit pressures. Geometry is the only difference between
  the two, so this is exact.
* ``tank_pressure_N`` = ``F_T(p_pad(t)) - F_T(p_pad(k0))``: the as-built engine fed through the
  drawn lines **held at k0** -- each side's line loss as ``K mdot^2`` with ``K`` the twin's own
  ``(outlet - inlet) / mdot^2`` at k0 -- from the tank outlet pressure on a one-g basis,
  ``p_pad = p_ullage + head g0 / a``. The feed loop ``inlet = p_out - K mdot(inlet)^2`` is solved
  (fixed point; its slope is the line drop over the orifice drop, ~0.1-0.2 here, and the solve
  reports its own convergence).
* ``accel_head_N`` (flown runs) = ``[F_T(p_out) - F_T(p_pad)](t) - [same](k0)``: the liquid
  column's head at the flight's specific force ``a(t)`` (``flight.schedule.accel_m_s2``) against
  the same column at one g. Zero on the pad.
* ``residual_N`` = ``dF - (tank + erosion + accel)`` = ``[F_ab(t) - F_ab(k0)] - [F_T(p_out(t)) -
  F_T(p_out(k0))]``: what the twin's feed did beyond a fixed-K line -- the line's K drifting with
  Reynolds number, the network's coupling -- plus the fixed-point tolerance.

The components are differences of one model, so they add exactly to ``dF`` by construction; the
residual is the measure of how much the fixed-K feed explains.

Function Documentation

_sampler()

Callable[[float, float], Optional[Dict[str, float]]] engine.layerx.diag.thrustshape._sampler ( Any config, float ambient_pa )

protected

Definition at line 54 of file thrustshape.py.

Referenced by build_thrust_shape().

_target()

Tuple[Optional[float], str] engine.layerx.diag.thrustshape._target ( Any config, Optional[float] target_N )

protected

Definition at line 80 of file thrustshape.py.

Referenced by build_thrust_shape().

build_thrust_shape()

Dict[str, Any] engine.layerx.diag.thrustshape.build_thrust_shape	(	Mapping[str, Any]	result,
		Any	prep = None,
		Any	config = None,
		*	,
		Optional[Callable[[float, float], Optional[Dict[str, float]]]]	sampler = None,
		Optional[float]	target_N = None,
		float	settle_s = SETTLE_S,
		Optional[float]	ambient_pa = None )

``diagnostics.thrust_shape``. Never raises. ``sampler`` ((p_line_O, p_line_F) [Pa] ->
{F, mdot_O, mdot_F, ...}) defaults to EngineDesign at the line exit on ``config``.

Definition at line 124 of file thrustshape.py.

References _sampler(), _target(), feed_solve(), max, and shape_stats().

feed_solve()

Tuple[Optional[Dict[str, float]], int, float] engine.layerx.diag.thrustshape.feed_solve	(	Callable[[float, float], Optional[Dict[str, float]]]	sampler,
		float	p_out_O,
		float	p_out_F,
		float	K_O,
		float	K_F,
		Tuple[float, float]	m0 )

The as-built engine fed through fixed-K lines from tank-outlet pressures [Pa]:
``inlet = p_out - K mdot^2`` (K in Pa/(kg/s)^2), solved by fixed point on the two flows.
Returns (engine point, iterations, last relative change).

Definition at line 60 of file thrustshape.py.

References max.

Referenced by build_thrust_shape().

shape_stats()

Dict[str, Any] engine.layerx.diag.thrustshape.shape_stats	(	np.ndarray	t,
		np.ndarray	F,
		float	mean,
		float	settle_t,
		Optional[float]	target )

Deviation statistics of ``F`` about ``mean`` over ``t >= settle_t`` (trapezoid weights).

Definition at line 90 of file thrustshape.py.

Referenced by build_thrust_shape().

Variable Documentation

FEED_ITERS

int engine.layerx.diag.thrustshape.FEED_ITERS = 60

Definition at line 51 of file thrustshape.py.

FEED_TOL

int engine.layerx.diag.thrustshape.FEED_TOL = 1e-9

Definition at line 50 of file thrustshape.py.

G0

float engine.layerx.diag.thrustshape.G0 = 9.80665

Definition at line 45 of file thrustshape.py.

SETTLE_S

float engine.layerx.diag.thrustshape.SETTLE_S = 0.2

Definition at line 46 of file thrustshape.py.