bluemira.fuel_cycle.lifecycle

Fusion power reactor lifecycle object.

Classes

LifeCycle

A life cycle object for a fusion reactor.

Module Contents

class bluemira.fuel_cycle.lifecycle.LifeCycle(config: LifeCycleParams | dict[str, float], learning_strategy: bluemira.fuel_cycle.timeline_tools.LearningStrategy, availability_strategy: bluemira.fuel_cycle.timeline_tools.OperationalAvailabilityStrategy, inputs: dict, rng_seed: int | numpy.random.SeedSequence = RNGSeeds.timeline_outages.value, *, _rng: numpy.random.BitGenerator | None = None)

A life cycle object for a fusion reactor.

Parameters:

config (LifeCycleParams | dict[str, float]) – Parameters for the reactor life cycle. See LifeCycleParams for parameters details. Set to an empty dict to use default values.
learning_strategy (bluemira.fuel_cycle.timeline_tools.LearningStrategy) – A concrete instance of a LearningStrategy for distributing the total operational availability over different operational phases.
availability_strategy (bluemira.fuel_cycle.timeline_tools.OperationalAvailabilityStrategy) – Concrete instance of an OperationalAvailabilityStrategy implementing a strategy to generate distributions of unplanned outages.
inputs (dict) – Currently unused.
rng_seed (int | numpy.random.SeedSequence) – Random number generator seed for operational outages
_rng (numpy.random.BitGenerator | None)

learning_strategy

availability_strategy

inputs

rng

total_planned_maintenance = None

total_ramptime = None

t_unplanned_m = None

t_on_total = None

t_interdown = None

cs_down = None

unplanned = None

min_downtime = None

T = None

a_ops = None

phase_names = None

phase_durations = None

n_blk_replace = None

n_div_replace = None

fpy = None

tf_lifeend = None

vv_lifeend = None

A_global = None

n_cycles = None

maintenance_l

maintenance_s

t_rampup

t_rampdown

t_flattop

t_min_down

life_neutronics(): Calculate the lifetime of various components based on their damage limits and fluences.

set_availabilities(load_factor: float)

Sets availability and distributes it between the two phases of planned operation. The planned maintenance windows are subtracted from the availability which needs to be achieved during the phase of operation. The target overall plant lifetime availability as specified in input parameter A remains the same.

Notes

\(A_{overall}=\dfrac{t_{on}}{t_{on}+t_{off}}\) \(A_{operations}=\dfrac{t_{on}}{t_{on}+t_{ramp}+t_{CS_{recharge}}+t_{m_{unplanned}}}\)

Parameters:: load_factor (float)

calc_n_pulses(phases: list[list[float]])

Calculate the number of pulses per phase.

Parameters:: phases (list[list[float]])

get_op_phases() → list[float]

Returns:: The operational phases for the LifeCycle.
Return type:: list[float]

make_timeline() → bluemira.fuel_cycle.timeline.Timeline

Returns:: The timeline instance
Return type:: bluemira.fuel_cycle.timeline.Timeline

sanity(): Perform a sanity check. Will raise warnings if the LifeCycle generates results that violate the tolerances.

summary(): Plot the load factor breakdown and learning curve

plot_life(): Plot the different maintenance events in the Lifecycle, and the slope of each operational phase

plot_load_factor(typ: str = 'pie', ax: matplotlib.pyplot.Axes | None = None)

Plots a pie or bar chart of the breakdown of the reactor lifetime

Parameters:

typ (str) – Whether to plot a pie or bar chart [‘pie’, ‘bar’]
ax (matplotlib.pyplot.Axes | None)

write(filename: str, **kwargs)

Save a Timeline to a JSON file.

Returns:: The json output
Parameters:: filename (str)

static read(filename: str)

Load a Timeline from a JSON file.

Returns:: The json loaded timeline
Parameters:: filename (str)