diff --git a/process/data_structure/power_variables.py b/process/data_structure/power_variables.py index bb292545e2..464b992213 100644 --- a/process/data_structure/power_variables.py +++ b/process/data_structure/power_variables.py @@ -32,6 +32,12 @@ p_plant_core_systems_elec_mw: float = None +e_plant_net_electric_pulse_mj: float = None +"""Net electric energy output per pulse (MJ)""" + +e_plant_net_electric_pulse_kwh: float = None +"""Net electric energy output per pulse (kWh)""" + f_p_div_primary_heat: float = None delta_eta: float = None @@ -40,6 +46,39 @@ p_turbine_loss_mw: float = None +p_hcd_electric_total_profile_mw: list[float] = None +"""Profile of total HCD electric power (MW) over pulse""" + +p_tf_electric_supplies_profile_mw: list[float] = None +"""Profile of total TF coil electric power (MW) over pulse""" + +p_pf_electric_supplies_profile_mw: list[float] = None +"""Profile of total PF coil electric power (MW) over pulse""" + +p_coolant_pump_elec_total_profile_mw: list[float] = None +"""Profile of total coolant pump electric power (MW) over pulse""" + +vachtmw_profile_mw: list[float] = None +"""Profile of total active vacuum pump power (MW) over pulse""" + +p_tritium_plant_electric_profile_mw: list[float] = None +"""Profile of total tritium plant electric power (MW) over pulse""" + +p_cryo_plant_electric_profile_mw: list[float] = None +"""Profile of total cryo plant electric power (MW) over pulse""" + +p_plant_electric_base_total__profile_mw: list[float] = None +"""Profile of total plant electric base power (MW) over pulse""" + +p_plant_electric_gross_profile_mw: list[float] = None +"""Profile of total plant electric gross power (MW) over pulse""" + +p_plant_electric_net_profile_mw: list[float] = None +"""Profile of total plant electric net power (MW) over pulse""" + +p_fusion_total_profile_mw: list[float] = None +"""Profile of total fusion power (MW) over pulse""" + def init_power_variables(): global qmisc @@ -93,6 +132,12 @@ def init_power_variables(): global p_plant_core_systems_elec_mw p_plant_core_systems_elec_mw = 0.0 + global e_plant_net_electric_pulse_mj + e_plant_net_electric_pulse_mj = 0.0 + + global e_plant_net_electric_pulse_kwh + e_plant_net_electric_pulse_kwh = 0.0 + global f_p_div_primary_heat f_p_div_primary_heat = 0.0 @@ -104,3 +149,6 @@ def init_power_variables(): global p_turbine_loss_mw p_turbine_loss_mw = 0.0 + + global p_hcd_electric_total_profile_mw + p_hcd_electric_total_profile_mw = [] diff --git a/process/io/plot_proc.py b/process/io/plot_proc.py index 286d096c11..440ca3a699 100644 --- a/process/io/plot_proc.py +++ b/process/io/plot_proc.py @@ -3242,6 +3242,187 @@ def plot_current_profiles_over_time( axis.grid(True, linestyle="--", alpha=0.6) +def plot_system_power_profiles_over_time( + axis: plt.Axes, + mfile_data: mf.MFile, + scan: int, + fig, +) -> None: + """ + Plots the power profiles over time for various systems. + + Arguments: + axis (plt.Axes): Axis object to plot to. + mfile_data (mf.MFile): MFILE data object. + scan (int): Scan number to use. + """ + + t_precharge = mfile_data.data["t_plant_pulse_coil_precharge"].get_scan(scan) + t_current_ramp_up = mfile_data.data[ + "t_plant_pulse_plasma_current_ramp_up" + ].get_scan(scan) + t_fusion_ramp = mfile_data.data["t_plant_pulse_fusion_ramp"].get_scan(scan) + t_burn = mfile_data.data["t_plant_pulse_burn"].get_scan(scan) + t_ramp_down = mfile_data.data["t_plant_pulse_plasma_current_ramp_down"].get_scan( + scan + ) + t_between_pulse = mfile_data.data["t_plant_pulse_dwell"].get_scan(scan) + + # Define a cumulative sum list for each point in the pulse + t_steps = np.cumsum([ + 0, + t_precharge, + t_current_ramp_up, + t_fusion_ramp, + t_burn, + t_ramp_down, + t_between_pulse, + ]) + + # Create empty arrays for the power at each time step for each system + power_profiles = { + "Fusion Power": np.zeros(len(t_steps)), + "Plant Base Load": np.zeros(len(t_steps)), + "Cryo Plant": np.zeros(len(t_steps)), + "Tritium Plant": np.zeros(len(t_steps)), + "Vacuum Pumps": np.zeros(len(t_steps)), + "TF Coil Supplies": np.zeros(len(t_steps)), + "PF Coil Supplies": np.zeros(len(t_steps)), + "Coolant Pump Elec Total": np.zeros(len(t_steps)), + "HCD Electric Total": np.zeros(len(t_steps)), + "Gross Electric Power": np.zeros(len(t_steps)), + "Net Electric Power": np.zeros(len(t_steps)), + } + + # Fill power_profiles arrays using vectorized assignment + for label, key in [ + ("Fusion Power", "p_fusion_total_profile_mw"), + ("Gross Electric Power", "p_plant_electric_gross_profile_mw"), + ("Net Electric Power", "p_plant_electric_net_profile_mw"), + ("Plant Base Load", "p_plant_electric_base_total_profile_mw"), + ("Cryo Plant", "p_cryo_plant_electric_profile_mw"), + ("Tritium Plant", "p_tritium_plant_electric_profile_mw"), + ("Vacuum Pumps", "vachtmw_profile_mw"), + ("TF Coil Supplies", "p_tf_electric_supplies_profile_mw"), + ("PF Coil Supplies", "p_pf_electric_supplies_profile_mw"), + ("Coolant Pump Elec Total", "p_coolant_pump_elec_total_profile_mw"), + ("HCD Electric Total", "p_hcd_electric_total_profile_mw"), + ]: + for time in range(len(t_steps)): + power_profiles[label][time] = mfile_data.data[f"{key}{time}"].get_scan(scan) + + # Define line styles for each system + # All net drains (negative power flows) use the same line style: dashed + line_styles = { + "Fusion Power": ":", + "Plant Base Load": "--", + "Cryo Plant": "--", + "Tritium Plant": "--", + "Vacuum Pumps": "--", + "TF Coil Supplies": "--", + "PF Coil Supplies": "--", + "Coolant Pump Elec Total": "--", + "HCD Electric Total": "--", + "Gross Electric Power": "-", + "Net Electric Power": "-", + } + + # Plot each system's power profile over time with different line styles + for label, powers in power_profiles.items(): + style = line_styles.get(label, "-") + axis.plot(t_steps, powers, label=label, linestyle=style) + + # Move the x-axis to 0 on the y-axis + axis.spines["bottom"].set_position("zero") + + # Annotate key points + # Create a secondary x-axis for annotations + secax = axis.secondary_xaxis("bottom") + secax.set_xticks(t_steps) + secax.set_xticklabels( + [ + "Precharge", + r"$I_{\text{P}}$ Ramp-Up", + "Fusion Ramp", + "Burn", + "Ramp Down", + "Between Pulse", + "Restart Pulse", + ], + rotation=60, + ) + secax.tick_params(axis="x", which="major") + + # Add axis labels + axis.set_xlabel("Time [s]", fontsize=12) + axis.xaxis.set_label_coords(1.05, 0.5) + axis.set_ylabel("Power [MW]", fontsize=12) + + # Add a title + axis.set_title("System Power Over Time", fontsize=14) + + # Add a legend + axis.legend() + + axis.set_yscale("symlog") + # axis.set_xscale() + axis.minorticks_on() + axis.grid(True, which="both", linestyle="--", linewidth=0.5, alpha=0.2) + + # Add a grid for better readability + axis.grid(True, linestyle="--", alpha=0.6) + + # Add energy produced info + textstr_energy = ( + f"$\\mathbf{{Energy \\ Production:}}$\n\n" + f"Energy produced over whole pulse: {mfile_data.data['e_plant_net_electric_pulse_mj'].get_scan(scan):,.4f} MJ \n" + f"Energy produced over whole pulse: {mfile_data.data['e_plant_net_electric_pulse_kwh'].get_scan(scan):,.4f} kWh \n" + ) + + axis.text( + 0.075, + 0.2, + textstr_energy, + fontsize=9, + verticalalignment="top", + transform=fig.transFigure, + bbox={ + "boxstyle": "round", + "facecolor": "grey", + "alpha": 1.0, + "linewidth": 2, + }, + ) + + # Add energy produced info + + textstr_times = ( + f"$\\mathbf{{Pulse \\ Timings:}}$\n\n" + f"Coil precharge, $t_{{\\text{{precharge}}}}$: {mfile_data.data['t_plant_pulse_coil_precharge'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_coil_precharge'].get_scan(scan))})\n" + f"Current ramp up, $t_{{\\text{{current ramp}}}}$: {mfile_data.data['t_plant_pulse_plasma_current_ramp_up'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_plasma_current_ramp_up'].get_scan(scan))})\n" + f"Fusion ramp, $t_{{\\text{{fusion ramp}}}}$: {mfile_data.data['t_plant_pulse_fusion_ramp'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_fusion_ramp'].get_scan(scan))})\n" + f"Burn, $t_{{\\text{{burn}}}}$: {mfile_data.data['t_plant_pulse_burn'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_burn'].get_scan(scan))})\n" + f"Ramp down, $t_{{\\text{{ramp down}}}}$: {mfile_data.data['t_plant_pulse_plasma_current_ramp_down'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_plasma_current_ramp_down'].get_scan(scan))})\n" + f"Between pulse, $t_{{\\text{{between pulse}}}}$: {mfile_data.data['t_plant_pulse_dwell'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_dwell'].get_scan(scan))})\n\n" + f"Total pulse length, $t_{{\\text{{cycle}}}}$: {mfile_data.data['t_plant_pulse_total'].get_scan(scan):,.1f} s ({secs_to_hms(mfile_data.data['t_plant_pulse_total'].get_scan(scan))})\n" + ) + + axis.text( + 0.6, + 0.225, + textstr_times, + fontsize=9, + verticalalignment="top", + transform=fig.transFigure, + bbox={ + "boxstyle": "round", + "facecolor": "grey", + "alpha": 1.0, + "linewidth": 2, + }, + ) + + def plot_cryostat(axis, _mfile_data, _scan, colour_scheme): """Function to plot cryostat in poloidal cross-section""" @@ -3315,6 +3496,13 @@ def color_key(axis, mfile_data, scan, colour_scheme): ) +# helper to convert seconds to "Hh Mm Ss" +def secs_to_hms(s): + """Convert seconds to 'Hh Mm Ss' string.""" + s = float(s) + return f"{int(s // 3600)}h {int((s % 3600) // 60)}m {int(s % 60)}s" + + def toroidal_cross_section(axis, mfile_data, scan, demo_ranges, colour_scheme): """Function to plot toroidal cross-section Arguments: @@ -12092,6 +12280,7 @@ def main_plot( fig22, fig23, fig24, + fig25, m_file_data, scan, imp="../data/lz_non_corona_14_elements/", @@ -12366,6 +12555,11 @@ def main_plot( fig24.add_subplot(111, aspect="equal"), m_file_data, scan, fig24 ) + ax24 = fig25.add_subplot(111) + # set_position([left, bottom, width, height]) -> height ~ 0.66 => ~2/3 of page height + ax24.set_position([0.08, 0.35, 0.84, 0.57]) + plot_system_power_profiles_over_time(ax24, m_file_data, scan, fig25) + def main(args=None): # TODO The use of globals here isn't ideal, but is required to get main() @@ -12682,6 +12876,7 @@ def main(args=None): page22 = plt.figure(figsize=(12, 9), dpi=80) page23 = plt.figure(figsize=(12, 9), dpi=80) page24 = plt.figure(figsize=(12, 9), dpi=80) + page25 = plt.figure(figsize=(12, 9), dpi=80) # run main_plot main_plot( @@ -12710,6 +12905,7 @@ def main(args=None): page22, page23, page24, + page25, m_file, scan=scan, demo_ranges=demo_ranges, @@ -12743,6 +12939,7 @@ def main(args=None): pdf.savefig(page22) pdf.savefig(page23) pdf.savefig(page24) + pdf.savefig(page25) # show fig if option used if args.show: @@ -12773,6 +12970,7 @@ def main(args=None): plt.close(page22) plt.close(page23) plt.close(page24) + plt.close(page25) if __name__ == "__main__": diff --git a/process/output.py b/process/output.py index b6ebd9ac17..527fc678dc 100644 --- a/process/output.py +++ b/process/output.py @@ -140,6 +140,7 @@ def write(models, _outfile): models.power.output_cryogenics() models.power.output_plant_thermal_powers() models.power.output_plant_electric_powers() + models.power.output_power_profiles_over_time() # Water usage in secondary cooling system models.water_use.run(output=True) diff --git a/process/power.py b/process/power.py index 7e08e455b2..936d1de535 100644 --- a/process/power.py +++ b/process/power.py @@ -2,6 +2,7 @@ import math import numpy as np +import scipy as sp from process import constants from process import process_output as po @@ -30,6 +31,7 @@ class Power: def __init__(self): self.outfile = constants.NOUT + self.mfile = constants.MFILE def pfpwr(self, output: bool): """ @@ -1303,6 +1305,21 @@ def output_plant_electric_powers(self): heat_transport_variables.p_plant_electric_net_mw, ) + po.oblnkl(self.outfile) + + po.ovarre( + self.outfile, + "Total electric energy output per pulse (MJ)", + "(e_plant_net_electric_pulse_mj)", + power_variables.e_plant_net_electric_pulse_mj, + ) + po.ovarre( + self.outfile, + "Total electric energy output per pulse (kWh)", + "(e_plant_net_electric_pulse_kwh)", + power_variables.e_plant_net_electric_pulse_kwh, + ) + def plant_electric_production(self) -> None: """ This method completes the calculation of the plant's electrical and thermal power flows, @@ -1408,6 +1425,40 @@ def plant_electric_production(self) -> None: - heat_transport_variables.p_plant_electric_net_mw ) / heat_transport_variables.p_plant_electric_gross_mw + ( + power_variables.e_plant_net_electric_pulse_kwh, + power_variables.e_plant_net_electric_pulse_mj, + power_variables.p_plant_electric_base_total_profile_mw, + power_variables.p_plant_electric_gross_profile_mw, + power_variables.p_plant_electric_net_profile_mw, + power_variables.p_hcd_electric_total_profile_mw, + power_variables.p_coolant_pump_elec_total_profile_mw, + power_variables.p_tf_electric_supplies_profile_mw, + power_variables.p_pf_electric_supplies_profile_mw, + power_variables.vachtmw_profile_mw, + power_variables.p_tritium_plant_electric_profile_mw, + power_variables.p_cryo_plant_electric_profile_mw, + power_variables.p_fusion_total_profile_mw, + ) = self.power_profiles_over_time( + t_precharge=times_variables.t_plant_pulse_coil_precharge, + t_current_ramp_up=times_variables.t_plant_pulse_plasma_current_ramp_up, + t_fusion_ramp=times_variables.t_plant_pulse_fusion_ramp, + t_burn=times_variables.t_plant_pulse_burn, + t_ramp_down=times_variables.t_plant_pulse_plasma_current_ramp_down, + t_between_pulse=times_variables.t_plant_pulse_dwell, + p_plant_electric_base_total_mw=heat_transport_variables.p_plant_electric_base_total_mw, + p_cryo_plant_electric_mw=heat_transport_variables.p_cryo_plant_electric_mw, + p_tritium_plant_electric_mw=heat_transport_variables.p_tritium_plant_electric_mw, + vachtmw=heat_transport_variables.vachtmw, + p_tf_electric_supplies_mw=heat_transport_variables.p_tf_electric_supplies_mw, + p_pf_electric_supplies_mw=pfcoil_variables.p_pf_electric_supplies_mw, + p_coolant_pump_elec_total_mw=heat_transport_variables.p_coolant_pump_elec_total_mw, + p_hcd_electric_total_mw=heat_transport_variables.p_hcd_electric_total_mw, + p_fusion_total_mw=physics_variables.p_fusion_total_mw, + p_plant_electric_gross_mw=heat_transport_variables.p_plant_electric_gross_mw, + p_plant_electric_net_mw=heat_transport_variables.p_plant_electric_net_mw, + ) + def cryo( self, i_tf_sup, @@ -2197,3 +2248,258 @@ def tfcpwr( ) return (tfckw, len_tf_bus, drarea, tfcbv, p_tf_electric_supplies_mw) + + def power_profiles_over_time( + self, + t_precharge: float, + t_current_ramp_up: float, + t_fusion_ramp: float, + t_burn: float, + t_ramp_down: float, + t_between_pulse: float, + p_plant_electric_base_total_mw: float, + p_cryo_plant_electric_mw: float, + p_tritium_plant_electric_mw: float, + vachtmw: float, + p_tf_electric_supplies_mw: float, + p_pf_electric_supplies_mw: float, + p_coolant_pump_elec_total_mw: float, + p_hcd_electric_total_mw: float, + p_fusion_total_mw: float, + p_plant_electric_gross_mw: float, + p_plant_electric_net_mw: float, + ) -> float: + """ + Calculate time-dependent power profiles for different electric systems + + :param t_precharge: Precharge time (s). + :type t_precharge: float + :param t_current_ramp_up: Current ramp-up time (s). + :type t_current_ramp_up: float + :param t_fusion_ramp: Fusion ramp time (s). + :type t_fusion_ramp: float + :param t_burn: Burn time (s). + :type t_burn: float + :param t_ramp_down: Ramp-down time (s). + :type t_ramp_down: float + :param t_between_pulse: Time between pulses (s). + :type t_between_pulse: float + :param p_plant_electric_base_total_mw: Plant base electric load (MW). + :type p_plant_electric_base_total_mw: float + :param p_cryo_plant_electric_mw: Cryogenic plant electric load (MW). + :type p_cryo_plant_electric_mw: float + :param p_tritium_plant_electric_mw: Tritium plant electric load (MW). + :type p_tritium_plant_electric_mw: float + :param vachtmw: Vacuum pumps electric load (MW). + :type vachtmw: float + :param p_tf_electric_supplies_mw: TF coil electric supplies (MW). + :type p_tf_electric_supplies_mw: float + :param p_pf_electric_supplies_mw: PF coil electric supplies (MW). + :type p_pf_electric_supplies_mw: float + :param p_coolant_pump_elec_total_mw: Total coolant pump electric load (MW). + :type p_coolant_pump_elec_total_mw: float + :param p_hcd_electric_total_mw: HCD electric total (MW). + :type p_hcd_electric_total_mw: float + :param p_fusion_total_mw: Fusion power (MW). + :type p_fusion_total_mw: float + :param p_plant_electric_gross_mw: Gross electric power produced (MW). + :type p_plant_electric_gross_mw: float + :param p_plant_electric_net_mw: Net electric power produced (MW). + :type p_plant_electric_net_mw: float + + :notes: + - Assumes step-function changes in power at each phase transition. + - Negative values indicate power consumption (loads). + + :returns: Total net electric energy produced over the pulse (MJ). + :rtype: float + """ + + t_steps = np.cumsum([ + 0, + t_precharge, + t_current_ramp_up, + t_fusion_ramp, + t_burn, + t_ramp_down, + t_between_pulse, + ]) + + # Number of time steps + n_steps = len(t_steps) + + # Initialize arrays for each power profile + p_fusion_total_profile_mw = np.zeros(n_steps) + p_plant_electric_base_total_profile_mw = np.zeros(n_steps) + p_cryo_plant_electric_profile_mw = np.zeros(n_steps) + p_tritium_plant_electric_profile_mw = np.zeros(n_steps) + vachtmw_profile_mw = np.zeros(n_steps) + p_tf_electric_supplies_profile_mw = np.zeros(n_steps) + p_pf_electric_supplies_profile_mw = np.zeros(n_steps) + p_coolant_pump_elec_total_profile_mw = np.zeros(n_steps) + p_hcd_electric_total_profile_mw = np.zeros(n_steps) + p_plant_electric_gross_profile_mw = np.zeros(n_steps) + p_plant_electric_net_profile_mw = np.zeros(n_steps) + + # Fusion power: zero until ramp-up, then during burn + p_fusion_total_profile_mw[:2] = 0 + p_fusion_total_profile_mw[2:5] = p_fusion_total_mw + p_fusion_total_profile_mw[5:] = 0 + + # Plant base load: constant negative load throughout + p_plant_electric_base_total_profile_mw[:] = -p_plant_electric_base_total_mw + + # Cryo plant: constant negative load throughout + p_cryo_plant_electric_profile_mw[:] = -p_cryo_plant_electric_mw + + # Tritium plant: constant negative load throughout + p_tritium_plant_electric_profile_mw[:] = -p_tritium_plant_electric_mw + + # Vacuum pumps: constant negative load throughout + vachtmw_profile_mw[:] = -vachtmw + + # TF coil supplies: assume coil is always charged, so constant negative load + p_tf_electric_supplies_profile_mw[:] = -p_tf_electric_supplies_mw + + # PF coil supplies: zero for first step, then negative during ramp-up and burn, then zero + p_pf_electric_supplies_profile_mw[0] = 0 + p_pf_electric_supplies_profile_mw[1:5] = -p_pf_electric_supplies_mw + p_pf_electric_supplies_profile_mw[5:] = 0 + + # Coolant pump elec total: zero for first two steps, then negative during ramp-up and burn, then zero + p_coolant_pump_elec_total_profile_mw[:2] = 0 + p_coolant_pump_elec_total_profile_mw[2:5] = -p_coolant_pump_elec_total_mw + p_coolant_pump_elec_total_profile_mw[5:] = 0 + + # HCD electric total: zero for first two steps, then negative during ramp-up and burn, then zero + p_hcd_electric_total_profile_mw[:2] = 0 + p_hcd_electric_total_profile_mw[2:5] = -p_hcd_electric_total_mw + p_hcd_electric_total_profile_mw[5:] = 0 + + # Gross electric power: zero for first two steps, then positive during burn, then zero + p_plant_electric_gross_profile_mw[:2] = 0 + p_plant_electric_gross_profile_mw[2:5] = p_plant_electric_gross_mw + p_plant_electric_gross_profile_mw[5:] = 0 + + # Net electric power: calculated by subtracting all loads from gross electric power + p_plant_electric_net_profile_mw = ( + p_plant_electric_gross_profile_mw + + p_plant_electric_base_total_profile_mw + + p_cryo_plant_electric_profile_mw + + p_tritium_plant_electric_profile_mw + + vachtmw_profile_mw + + p_tf_electric_supplies_profile_mw + + p_pf_electric_supplies_profile_mw + + p_coolant_pump_elec_total_profile_mw + + p_hcd_electric_total_profile_mw + ) + + if p_plant_electric_net_profile_mw[3] != p_plant_electric_net_mw: + logger.error( + "Calculated net electric power during burn does not match input value." + f"Calculated: {p_plant_electric_net_profile_mw[3]}, Input: {p_plant_electric_net_mw}" + ) + + # Integrate net electric power over the pulse to get total energy produced (MJ) + # Assume t_steps in seconds, power in MW, so energy in MJ + energy_made_mj = sp.integrate.trapezoid( + p_plant_electric_net_profile_mw, t_steps + ) + energy_made_kwh = energy_made_mj / 3.6 + + return ( + energy_made_kwh, + energy_made_mj, + p_plant_electric_base_total_profile_mw, + p_plant_electric_gross_profile_mw, + p_plant_electric_net_profile_mw, + p_hcd_electric_total_profile_mw, + p_coolant_pump_elec_total_profile_mw, + p_tf_electric_supplies_profile_mw, + p_pf_electric_supplies_profile_mw, + vachtmw_profile_mw, + p_tritium_plant_electric_profile_mw, + p_cryo_plant_electric_profile_mw, + p_fusion_total_profile_mw, + ) + + def output_power_profiles_over_time( + self, + ): + for i, val in enumerate(power_variables.p_plant_electric_base_total_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric base load at time point {i}", + f"(p_plant_electric_base_total_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_plant_electric_gross_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric gross at time point {i}", + f"(p_plant_electric_gross_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_plant_electric_net_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric net at time point {i}", + f"(p_plant_electric_net_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_hcd_electric_total_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric HCD at time point {i}", + f"(p_hcd_electric_total_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_coolant_pump_elec_total_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric coolant pump at time point {i}", + f"(p_coolant_pump_elec_total_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_tf_electric_supplies_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric TF supplies at time point {i}", + f"(p_tf_electric_supplies_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_pf_electric_supplies_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric PF supplies at time point {i}", + f"(p_pf_electric_supplies_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.vachtmw_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric vacuum pump power at time point {i}", + f"(vachtmw_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_tritium_plant_electric_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric tritium plant power at time point {i}", + f"(p_tritium_plant_electric_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_cryo_plant_electric_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric cryo plant power at time point {i}", + f"(p_cryo_plant_electric_profile_mw{i})", + val, + ) + for i, val in enumerate(power_variables.p_fusion_total_profile_mw): + po.ovarre( + self.mfile, + f"Plant total electric fusion plant power at time point {i}", + f"(p_fusion_total_profile_mw{i})", + val, + )