rizer.boulder_plugin.pulsed_plasma#

Boulder GUI kind for the adaptive PulsedPlasmaReactor.

Like nrp (PlasmaReactor2T), the node is wired as a circuit — Generator --CoaxialCable--> PulsedPlasmaReactor — so the GUI shows the electrical topology, not a single opaque block. The difference is what the node is: a composite reactor that marches its own isochoric-deposition -> isentropic-expansion -> isobaric-cooling ladder with automatic, physics-derived model switching, driven by its own solve() rather than by a cantera.ReactorNet.

Because the circuit is supplied by the post-build wiring hook (after the builder runs), the composite is built lazily at solve time. The pieces:

PulsedReactorNode – a minimal zero-RHS cantera.ExtensibleReactor shell. It must be a real Cantera reactor so Boulder’s non-reservoir stage list picks it up and the post-solve visualization ct.ReactorNet can hold it (a plain object raises TypeError there; a ct.Reservoir is filtered out of the stage network entirely). It carries the plasma params + the accuracy knobs, and receives the circuit params from the wiring hook.
RizerPulsedNetwork – a CustomStageNetwork (plain object, not a ReactorNet) whose advance builds the composite from the wired circuit, runs its ladder once, and records the AdaptiveResult as states + scalars.
build_pulsed_reactor() / wire_pulsed_circuit() / fix_pulsed_reactor_meta() – the Boulder builder and post-build hooks (topology wiring + metadata), mirroring nrp.py / circuit.py.

Attributes#

PULSED_KIND

Classes#

`PulsedReactorNode`	Shell around a `PulsedPlasmaReactor`.
`RizerPulsedNetwork`	`CustomStageNetwork` for `PulsedReactorNode`.

Functions#

`translate_pulsed_node`(→ tuple[Dict[str, Any], ...)	Translate STONE `PulsedPlasmaReactor` props to (params, knobs).
`build_pulsed_reactor`(→ PulsedReactorNode)	Boulder reactor builder for the `PulsedPlasmaReactor` kind.
`wire_pulsed_circuit`(→ None)	Post-build hook: attach the `Generator --CoaxialCable--> node` circuit.
`fix_pulsed_reactor_meta`(→ None)	Point Boulder's reactor metadata at the composite's plasma phase.

Module Contents#

rizer.boulder_plugin.pulsed_plasma.PULSED_KIND = 'PulsedPlasmaReactor'#

rizer.boulder_plugin.pulsed_plasma.translate_pulsed_node(props: Dict[str, Any]) → tuple[Dict[str, Any], Dict[str, Any]]#

Translate STONE PulsedPlasmaReactor props to (params, knobs).

params is the nrp_driver-layout plasma + simulation blocks (the circuit is wired separately, from the Generator node and Cable edge); knobs carries the composite’s accuracy/fidelity settings (tol, first_stage, lte_ionization_fraction, t_end). ambient_temperature and wall_temperature (null for an adiabatic isobaric stage) are required node properties, passed on params["plasma"].

class rizer.boulder_plugin.pulsed_plasma.PulsedReactorNode(contents, *, name: str = PULSED_KIND, **kwargs)#

Bases: rizer.boulder_plugin.shell.PlasmaShellNode

Shell around a PulsedPlasmaReactor.

The composite does all the real integration (via RizerPulsedNetwork); this shell exists only so the object is a genuine ct.ReactorBase — required both to survive Boulder’s non-reservoir stage-network list and to be held by the post-solve visualization ct.ReactorNet. Its RHS is identically zero, and its state mirrors the plasma Solution so a viz advance(0.0) is a no-op that preserves the final composite state.

plasma_params: Dict[str, Any]#

knobs: Dict[str, Any]#

electric_circuit_params: Dict[str, Any] | None = None#

pulsed: Any = None#

configure(plasma_params: Dict[str, Any], knobs: Dict[str, Any], mass: float, volume: float) → None#: Store the plasma params + knobs (composite built at solve time).

set_circuit(generator_props, cable, include_reflections: bool)#: Receive the circuit from the wiring hook (Generator + Cable).

property t_end: float#

class rizer.boulder_plugin.pulsed_plasma.RizerPulsedNetwork(reactors: Sequence[Any], meta: Any = None, **kwargs: Any)#

CustomStageNetwork for PulsedReactorNode.

Not a cantera.ReactorNet: advance builds the composite from the wired circuit, runs its adaptive ladder once (to the node’s t_end) and exposes the trajectory through the states / scalars protocol Boulder reads after each stage.

reactors#

meta = None#

time = 0.0#

rtol = 1e-06#

atol = 1e-08#

max_time_step = 0.0#

max_steps = 0#

property initial_time: float#

advance(t: float, *args: Any, **kwargs: Any)#: Build + run the composite ladder (once) to its t_end.

advance_to_steady_state(*args: Any, **kwargs: Any)#

step(*args: Any, **kwargs: Any) → float#

property states: cantera.SolutionArray | None#: Full adaptive trajectory as a SolutionArray (None before solve).

property cable_delay_s: float#: One-way cable propagation delay L/c [s] (lab-frame Scope shift).

property scalars: Dict[str, Any]#: KPIs + model-switch provenance (JSON-serialisable).

rizer.boulder_plugin.pulsed_plasma.build_pulsed_reactor(converter: Any, node: Dict[str, Any]) → PulsedReactorNode#

Boulder reactor builder for the PulsedPlasmaReactor kind.

Builds the plasma Solution (circuit deferred to wire_pulsed_circuit(), the composite itself to solve time — the circuit is not known until the Generator/CoaxialCable wiring is in place).

rizer.boulder_plugin.pulsed_plasma.wire_pulsed_circuit(converter: Any, config: Dict[str, Any]) → None#

Post-build hook: attach the Generator --CoaxialCable--> node circuit.

Mirrors the PlasmaReactor2T branch of rizer.boulder_plugin.circuit.wire_electrical_circuit(), but hands the composite the circuit parameters (it rebuilds the circuit itself at solve time).

rizer.boulder_plugin.pulsed_plasma.fix_pulsed_reactor_meta(converter: Any, config: Dict[str, Any]) → None#

Point Boulder’s reactor metadata at the composite’s plasma phase.

Mirrors rizer.boulder_plugin.nrp.fix_plasma_reactor_meta: series recording runs on the two-temperature plasma phase (more species than the node-mechanism default), so the metadata must reference it.