utils.py

Go to the documentation of this file.

"""Utility functions for optimization layers.
 
Contains parameter extraction and other helper utilities.
"""
 
from __future__ import annotations
 
from typing import Dict, Any
import numpy as np
 
from engine.pipeline.config_schemas import PintleEngineConfig
 
# Impinging injector bounds (Layer-1 + feasibility scripts): scale with chamber bore.
DEFAULT_IMPINGING_WALL_THICKNESS_M = 0.0254
IMPINGING_JET_PITCH_ESTIMATE_M = 0.004  # heuristic min center-to-center spacing for n_elements ceiling
IMPINGING_N_ELEMENTS_ABSOLUTE_CAP = 200
 
 
def total_wall_thickness_m(config: Any) -> float:
    """Total chamber-wall thickness (both sides) subtracted from the max OD to get
    the gas-side inner diameter: ``2 x (metal case + ablative liner)``.
 
    Derived from its physical parts instead of stored as a separate lump field:
      * metal — ``design_requirements.metal_wall_thickness_per_side_m`` (geometry
        envelope for the structural case; default 0.25 in/side), and
      * liner — ``ablative_cooling.initial_thickness`` when ablative cooling is
        enabled (the same field Layer 3 sizes, so the wall tracks the sized liner
        on reruns automatically — no write-back step to lose the metal term).
 
    The graphite insert is a THROAT insert (axial), not part of the chamber-barrel
    radial stack, so it does not contribute. Film/regen cooling contribute no liner
    thickness here (channel geometry is not modeled as barrel thickness).
 
    Falls back to the legacy 1-inch total (``DEFAULT_IMPINGING_WALL_THICKNESS_M``)
    only when the config lacks the fields (mocks / legacy config objects).
    """
    dr = getattr(config, "design_requirements", None)
    metal = getattr(dr, "metal_wall_thickness_per_side_m", None) if dr is not None else None
    try:
        metal = float(metal)
    except (TypeError, ValueError):
        return DEFAULT_IMPINGING_WALL_THICKNESS_M
    if not (np.isfinite(metal) and metal > 0.0):
        return DEFAULT_IMPINGING_WALL_THICKNESS_M
    liner = 0.0
    ab = getattr(config, "ablative_cooling", None)
    if ab is not None and bool(getattr(ab, "enabled", False)):
        try:
            t = float(getattr(ab, "initial_thickness", 0.0))
        except (TypeError, ValueError):
            t = 0.0
        if np.isfinite(t) and t > 0.0:
            liner = t
    return 2.0 * (metal + liner)
 
 
def extract_all_parameters(config: PintleEngineConfig) -> Dict[str, Any]:
    """Extract all optimized parameters from config."""
    params = {}
    injector_type = getattr(getattr(config, "injector", None), "type", None)
    if injector_type is not None:
        params["injector_type"] = injector_type
    
    # Injector parameters
    if hasattr(config, 'injector') and config.injector.type == "pintle":
        geometry = config.injector.geometry
        if hasattr(geometry, 'fuel'):
            params["d_pintle_tip"] = geometry.fuel.d_pintle_tip
            params["h_gap"] = geometry.fuel.h_gap
            if hasattr(geometry.fuel, 'd_reservoir_inner'):
                params["d_reservoir_inner"] = geometry.fuel.d_reservoir_inner
        if hasattr(geometry, 'lox'):
            params["n_orifices"] = geometry.lox.n_orifices
            params["d_orifice"] = geometry.lox.d_orifice
            params["theta_orifice"] = geometry.lox.theta_orifice
    elif hasattr(config, 'injector') and config.injector.type == "impinging":
        g = config.injector.geometry
        nd = int(min(int(g.oxidizer.n_elements), int(g.fuel.n_elements)))
        params["n_doublets"] = nd
        # Canonical frontend keys for impinging geometry
        params["n_elements_O"] = int(g.oxidizer.n_elements)
        params["d_jet_O"] = g.oxidizer.d_jet
        params["imp_angle_O"] = g.oxidizer.impingement_angle
        params["spacing_O"] = g.oxidizer.spacing
        params["n_elements_F"] = int(g.fuel.n_elements)
        params["d_jet_F"] = g.fuel.d_jet
        params["imp_angle_F"] = g.fuel.impingement_angle
        params["spacing_F"] = g.fuel.spacing
        # Axial standoff from the injector face to where each doublet's jets collide.
        # Purely geometric (spacings + angles), but it is the number that says whether the
        # collision is far enough off the plate not to erode it, so it belongs in the
        # reported geometry rather than only in the spray diagnostics.
        from engine.core.injectors.impinging import impingement_standoff_m
        params["L_imp"] = impingement_standoff_m(
            nd, g.oxidizer.spacing, g.fuel.spacing,
            g.oxidizer.impingement_angle, g.fuel.impingement_angle,
        )
        # Pitch-circle diameters: the circles the jet CENTRES lie on. ``spacing`` is the arc
        # between adjacent holes on one ring, which reads as a tiny number and is routinely
        # mistaken for the ring size -- report both so there is nothing to misread.
        import math as _math
        params["D_pitch_O"] = nd * g.oxidizer.spacing / _math.pi
        params["D_pitch_F"] = nd * g.fuel.spacing / _math.pi
        params["ring_radial_offset"] = 0.5 * abs(params["D_pitch_O"] - params["D_pitch_F"])
        # Included angle between the two jet centrelines (what a drawing dimensions).
        params["included_angle_deg"] = float(g.oxidizer.impingement_angle) + float(g.fuel.impingement_angle)
        params["jet_angle_asymmetry_deg"] = abs(
            float(g.fuel.impingement_angle) - float(g.oxidizer.impingement_angle))
        # Backward-compatible aliases used by older views/scripts.
        params["d_jet_oxidizer"] = g.oxidizer.d_jet
        params["impingement_angle_oxidizer"] = g.oxidizer.impingement_angle
        params["spacing_oxidizer"] = g.oxidizer.spacing
        params["d_jet_fuel"] = g.fuel.d_jet
        params["impingement_angle_fuel"] = g.fuel.impingement_angle
        params["spacing_fuel"] = g.fuel.spacing
    
    # Chamber parameters
    from engine.pipeline.config_schemas import ensure_chamber_geometry
    cg = ensure_chamber_geometry(config)
    params["A_throat"] = cg.A_throat
    params["Lstar"] = cg.Lstar
    params["chamber_volume"] = cg.volume
    params["chamber_length"] = cg.length
    params["chamber_diameter"] = cg.chamber_diameter
    
    # Nozzle parameters
    params["A_exit"] = cg.A_exit
    params["expansion_ratio"] = cg.expansion_ratio
    
    # Ablative liner parameters
    if hasattr(config, 'ablative_cooling') and config.ablative_cooling and config.ablative_cooling.enabled:
        params["ablative_thickness"] = config.ablative_cooling.initial_thickness
        params["ablative_enabled"] = True
    else:
        params["ablative_thickness"] = 0.0
        params["ablative_enabled"] = False
    
    # Graphite insert parameters
    if hasattr(config, 'graphite_insert') and config.graphite_insert and config.graphite_insert.enabled:
        params["graphite_thickness"] = config.graphite_insert.initial_thickness
        params["graphite_enabled"] = True
    else:
        params["graphite_thickness"] = 0.0
        params["graphite_enabled"] = False
    
    return params
 
 
def impinging_chamber_inner_diameter_for_bounds(
    config: PintleEngineConfig,
    *,
    max_chamber_outer_diameter_m: float,
    wall_thickness_m: float = DEFAULT_IMPINGING_WALL_THICKNESS_M,
) -> float:
    """Bore used for impinging packing / n_elements limits.
 
    Prefer ``chamber_geometry.chamber_diameter``; else frozen outer diameter minus wall;
    else legacy heuristic ``0.5 * max_od - wall`` (underestimates full-OD designs).
    """
    cg = getattr(config, "chamber_geometry", None)
    if cg is not None:
        d = getattr(cg, "chamber_diameter", None)
        if d is not None and float(d) > 0.0:
            return float(d)
    dr = getattr(config, "design_requirements", None)
    if dr is not None:
        fp = getattr(dr, "frozen_parameters", None)
        if fp is not None:
            domm = getattr(fp, "D_chamber_outer_mm", None)
            if domm is not None and float(domm) > 0.0:
                return float(domm) * 1e-3 - wall_thickness_m
    min_outer = float(max_chamber_outer_diameter_m) * 0.5
    return float(max(min_outer - wall_thickness_m, 0.02))
 
 
def impinging_n_elements_hi_int(
    chamber_inner_diameter_m: float,
    *,
    pitch_est_m: float = IMPINGING_JET_PITCH_ESTIMATE_M,
    absolute_cap: int = IMPINGING_N_ELEMENTS_ABSOLUTE_CAP,
) -> int:
    """Upper integer count ~ circumference / pitch, capped for optimizer stability."""
    if chamber_inner_diameter_m <= 0.0:
        return 12
    n_circ = int(np.pi * chamber_inner_diameter_m / max(pitch_est_m, 1e-9))
    return int(max(12, min(absolute_cap, n_circ)))
 
 
def impinging_d_jet_upper_bound_m(chamber_inner_diameter_m: float) -> float:
    """Allow larger jets on larger bores; keep 4 mm floor for small chambers."""
    d = float(chamber_inner_diameter_m)
    return float(min(0.008, max(0.004, 0.038 * d)))
 
 
def impinging_spacing_upper_bound_m(chamber_inner_diameter_m: float) -> float:
    """Wider spacing cap for large injector faces (packing uses π D²/4)."""
    d = float(chamber_inner_diameter_m)
    return float(min(0.14, max(0.06, 0.42 * d)))