diff --git a/.gitignore b/.gitignore index 8d93c64..4d2c09b 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,28 @@ single_point.png dist/ build/ *.egg-info/ +uv.lock +.ipynb_checkpoints/POPCON-checkpoint.png +.ipynb_checkpoints/single_point-checkpoint.png +my_scans/MANTA/gMANTA +my_scans/MANTA/manta_ex.ipynb +my_scans/MANTA/plotsettings.yml +my_scans/MANTA/POPCON_input_example.yaml +my_scans/MANTA/profsMANTA.csv +my_scans/NSF/gNSF +my_scans/NSF/makeNSFprofiles.py +my_scans/NSF/NSF_POPCON.yaml +my_scans/NSF/NSF_run.ipynb +my_scans/NSF/plotsettings.yml +my_scans/NSF/pNSF.csv +my_scans/NSF_NT_CMOD/plotsettings.yml +my_scans/NSF_NT_CMOD/POPCON_input_example.yaml +my_scans/radiative_ARC/ARC_EX copy.ipynb +my_scans/radiative_ARC/plotsettings.yml +my_scans/radiative_ARC/POPCON_input_example.yaml +my_scans/SPARC/plotsettings.yml +my_scans/SPARC/POPCON_input_example.yaml +my_scans/SPARC/SPARC_EX.ipynb +betan.md +NEW_SESSION_PROMPT.md +SESSION_RECAP.md diff --git a/README.MD b/README.MD index e866afd..e760a04 100644 --- a/README.MD +++ b/README.MD @@ -1,4 +1,4 @@ -# OpenPOPCON v2.1.0 +# OpenPOPCON v2.2.0 # =================================== OpenPOPCON is a tool for scoping Tokamak design and operation with 0-D fitted scaling laws. This version has been refactored from the original developed for MIT 22.63, with major contributions from Sam Frank, Richard Nies, Tal Rubin, Oak Nelson, Matthew Pharr, Leonardo Corsaro, and many minor contributions from others. This code is intended for use in Columbia's Fusion Reactor Design course. @@ -39,6 +39,18 @@ cd my_scans/MANTA Each example directory has its own settings file, a notebook, and where applicable a gEQDSK and a profiles file. +| Example | Machine | Notes | +| --- | --- | --- | +| `MANTA` | 4.55 m, 11 T, 10 MA, negative triangularity | gEQDSK + profiles file | +| `SPARC` | 1.85 m, 12.2 T, 8.7 MA | parabolic profiles | +| `ITER` | 6.2 m, 5.3 T, 15 MA | 500 MW at Q = 10, parabolic profiles | +| `CENTAUR` | 2.0 m, 10.9 T, 9.6 MA, negative triangularity | 40 MW breakeven, `H_NT23` scaling | +| `radiative_ARC` | 4.2 m, 11.5 T, 14 MA | radiative L-mode, `H89` | +| `NSF` | 0.8 m, 3 T, 1 MA, negative triangularity | gEQDSK + profiles file | +| `NSF_NT_CMOD` | 0.8 m, 3 T, 1 MA | parabolic profiles | + +`ITER` and `CENTAUR` deliberately use parabolic profiles rather than a gEQDSK, which keeps their geometry free for `POPCON_scan` to vary. Each of the two carries a note at the bottom of its settings file on how closely the 0-D result tracks the published design point, and where it does not. + ```python # 1. Import the POPCON class import openpopcon as op @@ -73,6 +85,50 @@ ValueError: Found 2 problem(s) in .../POPCON_input_example.yaml: Grid points where power balance has no physical solution are reported in aggregate after a run and masked out of the plot. +### Plot axes + +Either plot axis takes any of seven labels, listed in `openpopcon.PLOT_AXES` and documented in the plotsettings files. They are not split into an x set and a y set: the only rule is that one has to be a density and the other a temperature, since those are the two grid dimensions. + +```yaml +yax: "nG" # nG, n20_av, n20_ax +xax: "T_i_av" # T_i_av, T_i_ax, T_e_av, T_e_ax +``` + +Putting `nG` on `xax` and `T_i_av` on `yax` draws the same POPCON with the axes swapped. + +### Scanning machine parameters + +`POPCON_scan` runs a full POPCON at every combination of two machine parameters and tiles them into one figure, for scoping a design space rather than a single machine. + +```python +sc = op.POPCON_scan( + settingsfile=settingsfile, + plotsettingsfile=plotsettingsfile, + scan={"rows": ("I_P", {"min": 7.0, "max": 12.0, "N": 3}), + "cols": ("B_0", [9.0, 10.5, 12.0])}, +) +sc.run_scan() +sc.plot() # the N x M grid of POPCONs +sc.plot_metric("Q", "max") # one number per cell, as a heatmap +sc.output # every cell in one xarray Dataset +``` + +The same scan can live in the settings file instead, which is what the `ITER` and `CENTAUR` examples do: + +```yaml +scan: + rows: {parameter: I_P, min: 7.0, max: 12.0, N: 3} + cols: {parameter: B_0, values: [9.0, 10.5, 12.0]} +``` + +Each axis takes either an explicit list of `values` or a `min`/`max`/`N` range, and a `scan=` argument overrides the settings file. Parameters are named as they appear in the settings file, and the whole settings derivation is re-run for each cell rather than a solved field being patched, so scanning `R` on a file that specifies `qstar` correctly re-derives `Ip`. `openpopcon.SCANNABLE_SETTINGS_KEYS` lists what can be varied. + +Every panel is drawn on the same contour levels so the cells can be compared directly, and the y axis is shared only when it is the Greenwald fraction, since an absolute density axis moves with `n_G = I_p / (pi a^2)`. + +Scanning `R`, `a`, `kappa`, `delta` or `I_P` on an example that supplies a gEQDSK is refused rather than silently ignored: `__get_geometry` takes those from the equilibrium, and always takes the ohmic current from it, so some cells would come out identical and others not. Scan `B_0` or `H_fac` on those examples, or clear `gfilename` to use parabolic profiles. + +`sc.write_output()` saves the base settings, the scan specification, the combined arrays and the grid plot; `op.POPCON_scan.read_output(name)` reads it back. + The trapped particle fraction that the neoclassical resistivity needs is taken from the gEQDSK when one is supplied. Without a gEQDSK it falls back to `f_t = sqrt(2*rho*a/R)`, which stays below 1 for the aspect ratios these examples use but would not for a spherical tokamak. ## Development @@ -83,7 +139,7 @@ Run the tests with: uv run --extra test pytest ``` -The suite (in `tests/`) solves the MANTA example on a small grid and checks the results against a frozen golden file (`tests/data/golden_manta.json`), verifies physics/consistency invariants, and checks that settings validation accepts every shipped example while rejecting bad inputs. GitHub Actions runs it on every commit to an open pull request. If a change intentionally alters the computed results, regenerate the golden file and commit it alongside the change: +The suite (in `tests/`) solves the MANTA example on a small grid and checks the results against a frozen golden file (`tests/data/golden_manta.json`), verifies physics/consistency invariants, checks that settings validation accepts every shipped example while rejecting bad inputs, covers every plot axis pairing including the swapped ones, and runs a small `POPCON_scan` end to end. GitHub Actions runs it on every commit to an open pull request. If a change intentionally alters the computed results, regenerate the golden file and commit it alongside the change: ```bash uv run python tests/generate_golden.py @@ -109,6 +165,8 @@ uv run python tests/generate_golden.py [9] Y. R. Lin-Liu and R. L. Miller, Upper and lower bounds of the effective trapped particle fraction in general tokamak equilibria, Physics of Plasmas 2, 1666 (1995). +[10] *Compact Experimental Negative TriAngUlarity Reactor (CENTAUR): A design study for a compact, affordable breakeven tokamak,* arXiv:2605.27549. Source of the `CENTAUR` example's machine parameters. + @@ -155,4 +213,22 @@ class POPCON: "Reads in a previous solution" def write_output(self): "Writes the current solution to a folder or zip archive" + +class POPCON_scan: + """Scoping two machine parameters at once. Holds one POPCON per cell, + each with its own settings, geometry and output, rather than mutating + one; POPCON_settings.with_overrides re-runs the whole derivation chain + for each, so nothing derived is left stale.""" + self.cells: list[list[POPCON]] # [row][col] + self.row, self.col: ScanAxis # parameter name and its values + self.output: xarray.Dataset # every cell, scan dims first + + def run_scan(self): + "Solves every cell, one at a time" + def plot(self): + "Tiles the cells into one figure on shared contour levels" + def plot_metric(self, name, reduce): + "One number per cell, as a heatmap" + def metric(self, name, reduce): + "The same numbers, reduced over the valid points only" ``` diff --git a/openpopcon/__init__.py b/openpopcon/__init__.py index 56ff8dc..2882230 100644 --- a/openpopcon/__init__.py +++ b/openpopcon/__init__.py @@ -21,12 +21,14 @@ POPCON_plotsettings, POPCON_algorithms, POPCON_data_spec, + ScanAxis, build_dataset, + PLOT_AXES, + SCANNABLE_SETTINGS_KEYS, + __version__, ) from .lib.openpopcon_util import example_dir, list_examples -__version__ = "2.0.0" - __all__ = [ "POPCON", "POPCON_scan", @@ -34,7 +36,10 @@ "POPCON_plotsettings", "POPCON_algorithms", "POPCON_data_spec", + "ScanAxis", "build_dataset", + "PLOT_AXES", + "SCANNABLE_SETTINGS_KEYS", "example_dir", "list_examples", "__version__", diff --git a/openpopcon/core.py b/openpopcon/core.py index a9658cf..0d6852a 100644 --- a/openpopcon/core.py +++ b/openpopcon/core.py @@ -30,15 +30,25 @@ from .lib import phys_lib as phys import shutil import datetime +import io +import contextlib +from importlib.metadata import version as _pkg_version, PackageNotFoundError # resistivity_model in the settings file -> resistivity_alg on the State RESISTIVITY_MODELS = {"jardin": 0, "paz-soldan": 1, "maximum": 2, "max": 2} -__version__ = "2.0.0" +try: + __version__ = _pkg_version("openpopcon") +except PackageNotFoundError: # running from a source tree that is not installed + __version__ = "unknown" # P_aux at a grid point with no physical solution. Plotting masks on this. UNPHYSICAL = 99999.0 +# plotting masks at slightly less than UNPHYSICAL, so that a point that solved +# to a legitimately enormous P_aux is still distinguishable from a failure +UNPHYSICAL_PLOT_CUTOFF = 99998.0 + # why a grid point has no physical solution. P_aux is set to UNPHYSICAL for all # of these; the flag survives so the reason can be reported INVALID_OK = 0 @@ -99,6 +109,7 @@ "resistivity_model", "verbosity", "parallel", + "scan", } # keys that used to do something. They are still accepted so that older @@ -110,6 +121,197 @@ "err": "the solver is closed-form and has no convergence tolerance", } +# settings-file keys a scan may vary. These are the YAML-facing names, not the +# attribute names, because a scan re-derives the whole settings object from the +# raw file contents rather than patching derived fields +SCANNABLE_SETTINGS_KEYS = { + "R", + "a", + "kappa", + "delta", + "B_0", + "B_coil", + "wall_thickness", + "I_P", + "qstar", + "H_fac", + "scalinglaw", + "tipeak_over_tepeak", + "Zeff_target", + "fuel", + "j_alpha1", + "j_alpha2", + "j_offset", + "ne_alpha1", + "ne_alpha2", + "ne_offset", + "ni_alpha1", + "ni_alpha2", + "ni_offset", + "Ti_alpha1", + "Ti_alpha2", + "Ti_offset", + "Te_alpha1", + "Te_alpha2", + "Te_offset", + "nmin_frac", + "nmax_frac", + "Tmin_keV", + "Tmax_keV", + "resistivity_model", +} + +# scanning these would change array shapes between cells, or means nothing +UNSCANNABLE_REASONS = { + "Nn": "the density grid must be the same size in every cell", + "NTi": "the temperature grid must be the same size in every cell", + "nr": "the radial grid must be the same size in every cell", + "name": "it only labels the run", + "gfilename": "the geometry file is what a scan holds fixed", + "profsfilename": "the profiles file is what a scan holds fixed", + "verbosity": "it only controls printing", + "parallel": "it only controls how the solve is threaded", + "impurityfractions": "it is an array; scan Zeff_target instead", + "impurity": "it selects which species Zeff_target applies to", +} + +# read() prefers the first key of each pair, so overriding the second without +# removing the first would silently do nothing and produce identical cells +SCAN_SHADOWS = { + "qstar": ("I_P",), + "B_coil": ("B_0",), + "wall_thickness": ("B_0",), +} + +# geometry that __get_geometry takes from the gEQDSK when one is supplied, +# overriding whatever the settings file says +GEQDSK_OWNED_KEYS = {"R", "a", "kappa", "delta", "I_P", "qstar"} + + +# Everything __get_geometry takes from a gEQDSK depends only on the file and +# nr, but it costs contour tracing plus half a dozen spline fits, all in plain +# Python. A scan repeats it identically for every cell, so it is cached. +_GEOMETRY_CACHE = {} + + +def _compute_gfile_geometry(gfilename: str, nr: int) -> dict: + gfile = read_eqdsk(gfilename) + psin, volgrid, agrid, fs = get_fluxvolumes(gfile, nr) + sqrtpsin = np.linspace(0.001, 0.98, nr) + volgrid = np.interp(sqrtpsin, np.sqrt(psin), volgrid) + _, jrms, jtoravg, cross_sec_areas = get_current_density(gfile, nr) + qpsi = np.asarray(gfile["qpsi"]) + psiq = np.linspace(0, 1, qpsi.shape[0]) + qr = np.interp(sqrtpsin, np.sqrt(psiq), qpsi) + + Ipint = np.abs(np.trapezoid(y=jtoravg, x=cross_sec_areas)) / 1e6 + Jrmsint = np.abs(np.trapezoid(y=jrms, x=cross_sec_areas)) + Jrms_norm = jrms / Jrmsint + + lcfs = fs[-1] + geq_a = (np.max(lcfs[:, 0]) - np.min(lcfs[:, 0])) / 2 + geq_R = np.max(lcfs[:, 0]) - geq_a + geq_z0 = (np.max(lcfs[:, 1]) + np.min(lcfs[:, 1])) / 2 + geq_kappa = np.abs(np.max(lcfs[:, 1]) - np.min(lcfs[:, 1])) / (2 * geq_a) + geq_Rtop = lcfs[np.argmax(lcfs[:, 1]), 0] + geq_Rbot = lcfs[np.argmin(lcfs[:, 1]), 0] + geq_delta = ((geq_R - geq_Rtop) / geq_a + (geq_R - geq_Rbot) / geq_a) / 2 + + psin_ft, ftrapped_profile = get_trapped_particle_fraction(gfile) + ftrapped_profile = np.interp(sqrtpsin, np.sqrt(psin_ft), ftrapped_profile) + + return { + "sqrtpsin": sqrtpsin, + "volgrid": volgrid, + "agrid": agrid, + "qr": qr, + "Jrms_norm": Jrms_norm, + "ftrapped_profile": ftrapped_profile, + "Ipint": Ipint, + "geq_a": geq_a, + "geq_R": geq_R, + "geq_z0": geq_z0, + "geq_kappa": geq_kappa, + "geq_delta": geq_delta, + } + + +def _gfile_geometry(gfilename: str, nr: int) -> dict: + """ + Cached gEQDSK geometry, keyed on the file's identity and mtime so an + edited equilibrium is never served stale. + """ + key = (os.path.abspath(gfilename), os.stat(gfilename).st_mtime_ns, int(nr)) + if key not in _GEOMETRY_CACHE: + _GEOMETRY_CACHE[key] = _compute_gfile_geometry(gfilename, nr) + cached = _GEOMETRY_CACHE[key] + # copies, because _addextprof stores the array by reference and + # np.ascontiguousarray in build_state will not copy an already-contiguous + # float64 array. Without this, one run could mutate another's geometry + return { + k: (np.array(v, copy=True) if isinstance(v, np.ndarray) else v) + for k, v in cached.items() + } + + +def _prepare_output_dir(name, directory, overwrite, default_name): + """ + Works out where write_output should write, and makes an empty directory + there. Shared by POPCON and POPCON_scan. + """ + if name == "": + stamp = datetime.datetime.now().strftime(r"%Y-%m-%d_%H-%M-%S") + name = re.sub(r"[^A-Za-z0-9._-]+", "_", default_name) + "_" + stamp + + if directory is None: + outputsdir = pathlib.Path.cwd().joinpath("OpenPOPCON_outputs") + else: + outputsdir = pathlib.Path(directory) + + direxists = outputsdir.joinpath(name).exists() + zipexists = outputsdir.joinpath(name + ".zip").exists() + if not (direxists or zipexists): + outputsdir.joinpath(name).mkdir(parents=True) + elif overwrite: + if zipexists: + outputsdir.joinpath(name + ".zip").unlink() + if direxists: + shutil.rmtree(outputsdir.joinpath(name)) + outputsdir.joinpath(name).mkdir(parents=True) + else: + raise ValueError( + f"{'Archive' * zipexists}{' and ' * zipexists * direxists}{'Directory' * direxists} already exist{'s' * (not (direxists and zipexists))}. Set overwrite=True to overwrite." + ) + + return name, outputsdir, outputsdir.joinpath(name) + + +def _finalize_output(savedir, outputsdir, name, archive): + """ + Zips up a finished output directory if asked. Returns what was written. + """ + if archive: + written = outputsdir.joinpath(name + ".zip") + shutil.make_archive(str(outputsdir.joinpath(name)), "zip", savedir) + shutil.rmtree(savedir) + else: + written = savedir + return written + + +def _apply_overrides(data: dict, overrides: dict) -> dict: + """ + Replaces raw settings-file keys, dropping any key that would shadow one + being set. Without the drop, overriding qstar in a file that also gives + I_P would be ignored and every cell of a scan would come out identical. + """ + for key, value in overrides.items(): + for shadowed in SCAN_SHADOWS.get(key, ()): + data.pop(shadowed, None) + data[key] = value + return data + + DEFAULT_PLOTSETTINGS = package_resource("default_plotsettings.yml") DEFAULT_SCALINGLAWS = package_resource("scalinglaws.yml") @@ -1345,11 +1547,35 @@ class POPCON_settings: def __init__( self, - filename: str, + filename: str = "", + data: dict = None, + settingsfile: str = "", + overrides: dict = None, ) -> None: - self.read(filename) + """ + Normally reads a YAML file. A scan instead passes the raw contents of + one as `data` plus a dict of `overrides`, so that every derived + quantity is recomputed from scratch for each cell rather than patched + after the fact. + """ + if data is not None: + merged = _apply_overrides(dict(data), overrides or {}) + self._load(merged, settingsfile or "") + else: + self.read(filename) pass + def with_overrides(self, **overrides): + """ + A copy of these settings with some raw settings-file keys replaced. + The whole derivation chain is re-run, so overriding 'R' on a file that + specifies 'qstar' correctly re-derives Ip, and overriding 'Tmax_keV' + re-derives the impurity fraction from Zeff_target. + """ + return POPCON_settings( + data=self.rawdata, settingsfile=self.settingsfile, overrides=overrides + ) + def _resolve(self, path: str) -> str: """ Resolves a filename given in the settings file against the directory @@ -1371,9 +1597,21 @@ def read(self, filename: str) -> None: else: raise ValueError("Filename must end with .yaml or .yml") - self.settingsfile = os.path.abspath(filename) + self._load(data, os.path.abspath(filename)) + + def _load(self, data: dict, settingsfile: str) -> None: + """ + Sets the settings from an already-parsed settings file. Split out from + read so that a scan can re-derive a whole settings object from raw + contents it has modified, rather than mutating derived fields. + """ + self.settingsfile = settingsfile self.settingsdir = os.path.dirname(self.settingsfile) self.rawkeys = set(data.keys()) + # kept so that with_overrides can re-run the derivation chain below. + # a dict, so build_dataset's (int, float, str, bool, ndarray) filter + # leaves it out of the saved attributes + self.rawdata = dict(data) try: # ----------------------------------------------------------- @@ -1498,8 +1736,10 @@ def read(self, filename: str) -> None: ).lower() self.verbosity = int(data["verbosity"]) self.parallel = bool(data["parallel"]) + # left raw; POPCON_scan validates it. A plain POPCON ignores it + self.scan = safe_get(data, "scan", {}) except KeyError as e: - raise KeyError(f"Key {e} not found in {filename}") + raise KeyError(f"Key {e} not found in {self.settingsfile}") POPCON_data_spec = [ @@ -1577,6 +1817,23 @@ def read(self, filename: str) -> None: AXES_N = ("n_G_frac", "n_e_20_max", "n_e_20_avg") AXES_T = ("T_i_max", "T_i_avg", "T_e_max", "T_e_avg") +# Every axis a POPCON can be plotted against: the xax/yax value in a +# plotsettings file -> (output variable, which grid dimension it indexes, axis +# label). Adding an entry here is all it takes to add an axis. Either of xax +# and yax takes any entry, as long as the two index different dimensions, so +# a density-on-x plot is just a plotsettings change. Only the 1-D coordinates +# can appear: contours need a rectilinear grid, so a 2-D output like Q cannot +# be an axis. +PLOT_AXES = { + "T_i_av": ("T_i_avg", DIM_T, r"$\langle T_i\rangle$ (keV)"), + "T_i_ax": ("T_i_max", DIM_T, r"$T_i$ (keV, On-axis)"), + "T_e_av": ("T_e_avg", DIM_T, r"$\langle T_e\rangle$ (keV)"), + "T_e_ax": ("T_e_max", DIM_T, r"$T_e$ (keV, On-axis)"), + "n20_av": ("n_e_20_avg", DIM_N, r"$\langle n_{20}\rangle$ ($10^{20} m^{-3}$)"), + "n20_ax": ("n_e_20_max", DIM_N, r"$n_{20}(0)$"), + "nG": ("n_G_frac", DIM_N, r"$\langle n\rangle /n_G$"), +} + UNITS = { "n_G_frac": "", "n_e_20_max": "1e20 m^-3", @@ -1714,7 +1971,11 @@ class POPCON: """ def __init__( - self, settingsfile=None, plotsettingsfile=None, scalinglawfile=None + self, + settingsfile=None, + plotsettingsfile=None, + scalinglawfile=None, + settings=None, ) -> None: self.algorithms: POPCON_algorithms self.settings: POPCON_settings @@ -1723,7 +1984,11 @@ def __init__( # these are kept as absolute paths so that write_output can still copy # them if the working directory has changed since construction - if settingsfile is not None: + if settings is not None: + # a scan cell, built from raw settings contents it has modified + self.settings = settings + self.settingsfile = settings.settingsfile + elif settingsfile is not None: self.settings = POPCON_settings(settingsfile) self.settingsfile = os.path.abspath(settingsfile) else: @@ -2082,35 +2347,71 @@ def single_point( # Plotting # ------------------------------------------------------------------- - def plot(self, show: bool = True, savefig: str = "", names=None): + def _resolve_axes(self): + """ + Turns the xax/yax settings into the meshgrid to plot on, the axis + labels, and the dimension order that 2-D output arrays have to be + transposed into. That last part is what lets either axis be either + family: the arrays are stored (n_index, T_index), so putting a density + on x means every array has to come out transposed. + """ + + def look_up(key, which): + try: + return PLOT_AXES[key] + except KeyError: + raise ValueError( + f"Invalid {which}-axis '{key}'. Change {which}ax in " + f"plotsettings. Available: {', '.join(sorted(PLOT_AXES))}." + ) + + xvar, xdim, xlabel = look_up(self.plotsettings.xax, "x") + yvar, ydim, ylabel = look_up(self.plotsettings.yax, "y") + if xdim == ydim: + raise ValueError( + f"xax '{self.plotsettings.xax}' and yax '{self.plotsettings.yax}' " + f"are both labels for the {xdim} axis, so they cannot be the two " + f"axes of one plot. Pick one density and one temperature." + ) + xx, yy = np.meshgrid(self.output[xvar].values, self.output[yvar].values) + return xx, yy, xlabel, ylabel, (ydim, xdim) + + def _grid(self, name: str, dimorder) -> np.ndarray: + """ + A 2-D output array laid out to match the meshgrid from _resolve_axes. + """ + return self.output[name].transpose(*dimorder).values + + def plot( + self, + show: bool = True, + savefig: str = "", + names=None, + ax=None, + legend: bool = True, + infobox: bool = True, + title=None, + ): """ Plots the output data. If variable names is specified, only plots those variables. Otherwise, refers to the plotsettings file. + + Passing an existing ax draws into it instead of making a new figure, + which is how POPCON_scan tiles a grid of these. The legend and the + info box are drawn outside the axes, so they are worth turning off + when tiling. """ - figsize = self.plotsettings.figsize - fig, ax = plt.subplots(figsize=figsize) - if self.plotsettings.xax == "T_i_av": - xx = self.output.T_i_avg - elif self.plotsettings.xax == "T_i_ax": - xx = self.output.T_i_max - elif self.plotsettings.xax == "T_e_av": - xx = self.output.T_e_avg - elif self.plotsettings.xax == "T_e_ax": - xx = self.output.T_e_max - else: - raise ValueError("Invalid x-axis. Change xax in plotsettings.") - - if self.plotsettings.yax == "n20_av": - yy = self.output.n_e_20_avg - elif self.plotsettings.yax == "n20_ax": - yy = self.output.n_e_20_max - elif self.plotsettings.yax == "nG": - yy = self.output.n_G_frac + if ax is None: + fig, ax = plt.subplots(figsize=self.plotsettings.figsize) + owns_figure = True else: - raise ValueError("Invalid y-axis. Change yax in plotsettings.") - xx, yy = np.meshgrid(xx, yy) - mask = np.logical_or(np.isnan(self.output.Paux), self.output.Paux >= 99998.0) + fig = ax.get_figure() + owns_figure = False + + xx, yy, xlabel, ylabel, dimorder = self._resolve_axes() + Paux = self._grid("Paux", dimorder) + mask = np.logical_or(np.isnan(Paux), Paux >= UNPHYSICAL_PLOT_CUTOFF) if mask.all(): raise ValueError( "No point in this scan has a physical solution, so there is nothing " @@ -2132,10 +2433,9 @@ def plot(self, show: bool = True, savefig: str = "", names=None): (0, 0), 0, 0, fc="k", alpha=0.5, label="No physical solution" ) ) - if np.any(self.output.Q > 1e4): - maskburning = np.logical_not( - np.logical_or(np.isnan(self.output.Q), self.output.Q >= 1e4) - ) + Qgrid = self._grid("Q", dimorder) + if np.any(Qgrid > 1e4): + maskburning = np.logical_not(np.logical_or(np.isnan(Qgrid), Qgrid >= 1e4)) ax.contourf( xx, yy, @@ -2147,9 +2447,6 @@ def plot(self, show: bool = True, savefig: str = "", names=None): if names is None: names = self.plotsettings.plotoptions.keys() for name in names: - mask = np.logical_or( - np.isnan(self.output.Paux), self.output.Paux >= 99998.0 - ) opdict = self.plotsettings.plotoptions[name] if opdict["plot"] == False: continue @@ -2160,8 +2457,7 @@ def plot(self, show: bool = True, savefig: str = "", names=None): opdict["fontsize"], opdict["fmt"], ] - data = getattr(self.output, name) - data = np.ma.array(data, mask=mask) + data = np.ma.array(self._grid(name, dimorder), mask=mask) if opdict["spacing"] == "lin": if opdict["scale"] == "minmax": if self.settings.verbosity > 1: @@ -2207,42 +2503,36 @@ def plot(self, show: bool = True, savefig: str = "", names=None): print(f"Plotting {name} with levels {levels} and options {plotoptions}") self.plot_contours(opdict["plot"], ax, data, xx, yy, levels, *plotoptions) - if self.plotsettings.xax == "T_i_av": - ax.set_xlabel(r"$\langle T_i\rangle$ (keV)") - elif self.plotsettings.xax == "T_i_ax": - ax.set_xlabel(r"$T_i$ (keV, On-axis)") - elif self.plotsettings.xax == "T_e_av": - ax.set_xlabel(r"$\langle T_e\rangle$ (keV)") - elif self.plotsettings.xax == "T_e_ax": - ax.set_xlabel(r"$T_e$ (keV, On-axis)") - else: - pass + ax.set_xlabel(xlabel) + ax.set_ylabel(ylabel) + if title is not None: + ax.set_title(title) - if self.plotsettings.yax == "n20_av": - ax.set_ylabel(r"$\langle n_{20}\rangle$ ($10^{20} m^{-3}$)") - elif self.plotsettings.yax == "n20_ax": - ax.set_ylabel(r"$n_{20}(0)$") - elif self.plotsettings.yax == "nG": - ax.set_ylabel(r"$\langle n\rangle /n_G$") - else: - pass p = self.algorithms # 1 = D-D, 2 = D-T, 3 = D-He3 fueldict = {1: "D-D", 2: "D-T", 3: "D-He3"} - ax.legend(bbox_to_anchor=(1, 1), loc="upper left") - infoboxtext = f"$I_p$ = {p.Ip:.2f}\n$B_0$ = {p.B0:.2f}\nR = {p.R:.2f}\na = {p.a:.2f}\n$\\kappa$ = {p.kappa:.2f}\n$\\delta$ = {p.delta:.2f}\n$M_i$ = {p.M_i:.2f}\nti/te = {p.tipeak_over_tepeak:.2f}\nfuel = {fueldict[p.fuel]}\n={p.Zeff(np.average(xx)):.2f}" - ax.text( - x=np.max(xx) + (np.max(xx) - np.min(xx)) / 64, - y=np.min(yy), - s=infoboxtext, - bbox=dict(boxstyle="round", fc="w", ec="0.5", alpha=0.8), - ) - fig.tight_layout() + if legend: + ax.legend(bbox_to_anchor=(1, 1), loc="upper left") + if infobox: + # Zeff is a function of temperature, so it has to come off the + # temperature axis whichever of x and y that happens to be + Tav = np.average(self.output.T_i_avg.values) + infoboxtext = f"$I_p$ = {p.Ip:.2f}\n$B_0$ = {p.B0:.2f}\nR = {p.R:.2f}\na = {p.a:.2f}\n$\\kappa$ = {p.kappa:.2f}\n$\\delta$ = {p.delta:.2f}\n$M_i$ = {p.M_i:.2f}\nti/te = {p.tipeak_over_tepeak:.2f}\nfuel = {fueldict[p.fuel]}\n={p.Zeff(Tav):.2f}" + ax.text( + x=np.max(xx) + (np.max(xx) - np.min(xx)) / 64, + y=np.min(yy), + s=infoboxtext, + bbox=dict(boxstyle="round", fc="w", ec="0.5", alpha=0.8), + ) + if owns_figure: + fig.tight_layout() if savefig != "": - plt.savefig(savefig) - if show: + # not plt.savefig: with a caller-supplied ax, the current figure + # is not necessarily the one being drawn into + fig.savefig(savefig) + if show and owns_figure: plt.show() return fig, ax @@ -2282,27 +2572,9 @@ def custom_plot( fontsize: int = 11, fmt: str = "%1.2f", ): - if self.plotsettings.xax == "T_i_av": - xx = self.output.T_i_avg - elif self.plotsettings.xax == "T_i_ax": - xx = self.output.T_i_max - elif self.plotsettings.xax == "T_e_av": - xx = self.output.T_e_avg - elif self.plotsettings.xax == "T_e_ax": - xx = self.output.T_e_max - else: - raise ValueError("Invalid x-axis. Change xax in plotsettings.") - - if self.plotsettings.yax == "n20_av": - yy = self.output.n_e_20_avg - elif self.plotsettings.yax == "n20_ax": - yy = self.output.n_e_20_max - elif self.plotsettings.yax == "nG": - yy = self.output.n_G_frac - else: - raise ValueError("Invalid y-axis. Change yax in plotsettings.") - xx, yy = np.meshgrid(xx, yy) - mask = np.logical_or(np.isnan(self.output.Paux), self.output.Paux >= 99998.0) + xx, yy, xlabel, ylabel, dimorder = self._resolve_axes() + Paux = self._grid("Paux", dimorder) + mask = np.logical_or(np.isnan(Paux), Paux >= UNPHYSICAL_PLOT_CUTOFF) self.plot_contours( True, ax, @@ -2332,31 +2604,9 @@ def write_output( overwrites the directory/zip if it already exists. The directory parameter allows specifying the storage location. """ - if name == "": - stamp = datetime.datetime.now().strftime(r"%Y-%m-%d_%H-%M-%S") - name = re.sub(r"[^A-Za-z0-9._-]+", "_", self.settings.name) + "_" + stamp - - if directory is None: - outputsdir = pathlib.Path.cwd().joinpath("OpenPOPCON_outputs") - else: - outputsdir = pathlib.Path(directory) - - direxists = outputsdir.joinpath(name).exists() - zipexists = outputsdir.joinpath(name + ".zip").exists() - if not (direxists or zipexists): - outputsdir.joinpath(name).mkdir(parents=True) - elif overwrite: - if zipexists: - outputsdir.joinpath(name + ".zip").unlink() - if direxists: - shutil.rmtree(outputsdir.joinpath(name)) - outputsdir.joinpath(name).mkdir(parents=True) - else: - raise ValueError( - f"{'Archive' * zipexists}{' and ' * zipexists * direxists}{'Directory' * direxists} already exist{'s' * (not (direxists and zipexists))}. Set overwrite=True to overwrite." - ) - - savedir = outputsdir.joinpath(name) + name, outputsdir, savedir = _prepare_output_dir( + name, directory, overwrite, self.settings.name + ) shutil.copyfile(self.settingsfile, savedir.joinpath("settings.yaml")) shutil.copyfile(self.plotsettingsfile, savedir.joinpath("plotsettings.yaml")) @@ -2378,14 +2628,7 @@ def write_output( self.plot(show=False, savefig=str(savedir.joinpath("POPCON_plot.pdf"))) plt.close("all") - if archive: - written = outputsdir.joinpath(name + ".zip") - shutil.make_archive(str(outputsdir.joinpath(name)), "zip", savedir) - shutil.rmtree(savedir) - else: - written = savedir - - print(f"Wrote output to {written}") + print(f"Wrote output to {_finalize_output(savedir, outputsdir, name, archive)}") return def read_output(self, name: str, directory: str = None) -> None: @@ -2539,29 +2782,19 @@ def __get_geometry(self) -> None: self.algorithms.Itot = self.settings.Ip else: - gfile = read_eqdsk(self.settings.gfilename) - psin, volgrid, agrid, fs = get_fluxvolumes(gfile, self.settings.nr) - sqrtpsin = np.linspace(0.001, 0.98, self.settings.nr) - volgrid = np.interp(sqrtpsin, np.sqrt(psin), volgrid) - _, jrms, jtoravg, cross_sec_areas = get_current_density( - gfile, self.settings.nr - ) - qpsi = np.asarray(gfile["qpsi"]) - psiq = np.linspace(0, 1, qpsi.shape[0]) - qr = np.interp(sqrtpsin, np.sqrt(psiq), qpsi) - - Ipint = np.abs(np.trapezoid(y=jtoravg, x=cross_sec_areas)) / 1e6 - Jrmsint = np.abs(np.trapezoid(y=jrms, x=cross_sec_areas)) - Jrms_norm = jrms / Jrmsint - - lcfs = fs[-1] - geq_a = (np.max(lcfs[:, 0]) - np.min(lcfs[:, 0])) / 2 - geq_R = np.max(lcfs[:, 0]) - geq_a - geq_z0 = (np.max(lcfs[:, 1]) + np.min(lcfs[:, 1])) / 2 - geq_kappa = np.abs(np.max(lcfs[:, 1]) - np.min(lcfs[:, 1])) / (2 * geq_a) - geq_Rtop = lcfs[np.argmax(lcfs[:, 1]), 0] - geq_Rbot = lcfs[np.argmin(lcfs[:, 1]), 0] - geq_delta = ((geq_R - geq_Rtop) / geq_a + (geq_R - geq_Rbot) / geq_a) / 2 + geo = _gfile_geometry(self.settings.gfilename, self.settings.nr) + sqrtpsin = geo["sqrtpsin"] + volgrid = geo["volgrid"] + agrid = geo["agrid"] + qr = geo["qr"] + Ipint = geo["Ipint"] + Jrms_norm = geo["Jrms_norm"] + ftrapped_profile = geo["ftrapped_profile"] + geq_a = geo["geq_a"] + geq_R = geo["geq_R"] + geq_z0 = geo["geq_z0"] + geq_kappa = geo["geq_kappa"] + geq_delta = geo["geq_delta"] if self.settings.verbosity > 1: print("gEQDSK geometry:") @@ -2572,14 +2805,10 @@ def __get_geometry(self) -> None: print(f"z0: {geq_z0}") print("gEQDSK Ip:", Ipint) - psin, ftrapped_profile = get_trapped_particle_fraction(gfile) - ftrapped_profile = np.interp(sqrtpsin, np.sqrt(psin), ftrapped_profile) - if self.settings.verbosity > 1: - print("Len of psin:", len(psin)) print("Len of sqrtpsin:", len(sqrtpsin)) print("Len of volgrid:", len(volgrid)) - print("Len of jrms:", len(jrms)) + print("Len of Jrms_norm:", len(Jrms_norm)) print("Len of qr:", len(qr)) print("Len of agrid:", len(agrid)) print("Len of ftrapped_profile:", len(ftrapped_profile)) @@ -3030,18 +3259,703 @@ def populate_outputs(state, n_e_20_max, T_i_max, T_e_max, Paux, Nn, NTi): ) -class POPCON_scan(POPCON): +class ScanAxis: + """ + One scanned parameter and the values it takes. + """ + + def __init__(self, parameter: str, values) -> None: + self.parameter = str(parameter) + self.values = list(values) + # never a bare 'n' or 'T': Dataset.T is transpose + self.dim = "scan_" + re.sub(r"\W", "_", self.parameter) + + @property + def label(self) -> str: + return self.parameter + + def __len__(self) -> int: + return len(self.values) + + def __repr__(self) -> str: + return f"ScanAxis({self.parameter!r}, {self.values!r})" + + +def _parse_axis_spec(spec, which): + """ + Accepts the several ways a scan axis can be written and returns a + ScanAxis. Handles ('I_P', [...]), {'parameter':..., 'values': [...]} and + {'parameter':..., 'min':..., 'max':..., 'N':...}. + """ + if isinstance(spec, (tuple, list)) and len(spec) == 2: + parameter, rest = spec + if isinstance(rest, dict): + return _parse_axis_spec({"parameter": parameter, **rest}, which) + return ScanAxis(parameter, np.asarray(rest, dtype=float).tolist()) + + if not isinstance(spec, dict): + raise ValueError( + f"{which}: could not read the scan specification {spec!r}. Give " + f"either ('I_P', [6.0, 8.0, 10.0]) or " + f"{{'parameter': 'I_P', 'min': 6.0, 'max': 10.0, 'N': 3}}." + ) + + spec = dict(spec) + parameter = spec.pop("parameter", None) + if parameter is None: + raise ValueError(f"{which}: the scan specification needs a 'parameter'.") + + if "values" in spec: + return ScanAxis(parameter, list(spec["values"])) + + missing = [k for k in ("min", "max", "N") if k not in spec] + if missing: + raise ValueError( + f"{which}: scanning '{parameter}' needs either 'values', or all of " + f"'min', 'max' and 'N'. Missing: {', '.join(missing)}." + ) + # N is validated in _check_scan; guard only against linspace throwing here + N = int(spec["N"]) + if N < 1: + return ScanAxis(parameter, []) + return ScanAxis( + parameter, np.linspace(float(spec["min"]), float(spec["max"]), N).tolist() + ) + + +def _fmt_value(v): + return f"{v:g}" if isinstance(v, (int, float, np.floating)) else str(v) + + +class POPCON_scan: """ Class POPCON_scan - Placeholder class for running scans. Inherits from POPCON. + Runs a POPCON at every combination of two scanned machine parameters and + plots the results as a grid, so a design space can be looked at in one + figure. Holds one fully-formed POPCON per cell rather than subclassing + POPCON, because every cell has its own settings, geometry and output. + + sc = op.POPCON_scan(settingsfile='POPCON_input_example.yaml', + plotsettingsfile='plotsettings.yml', + scan={'rows': ('I_P', {'min': 7, 'max': 12, 'N': 3}), + 'cols': ('B_0', [9.0, 10.5, 12.0])}) + sc.run_scan() + sc.plot() + sc.plot_metric('Q') + + The scan can equally be written as a `scan:` block in the settings file. + Parameters are named as they appear in the settings file, and the whole + settings derivation is re-run for each cell, so scanning R on a file that + specifies qstar correctly re-derives Ip. """ - def __init__(self) -> None: - self.datas: list - self.algorithms_list: list[POPCON_algorithms] - self.settings: POPCON_settings - self.plotsettings: list[POPCON_plotsettings] - self.scalinglaws: dict - self.scanvariables: dict[str, np.ndarray] - pass + def __init__( + self, + settingsfile=None, + plotsettingsfile=None, + scalinglawfile=None, + scan=None, + ) -> None: + self.settingsfile = os.path.abspath(settingsfile) + self.plotsettingsfile = plotsettingsfile + self.scalinglawfile = scalinglawfile + self.base_settings = POPCON_settings(settingsfile) + + spec = scan if scan is not None else self.base_settings.scan + if not spec: + raise ValueError( + "No scan specified. Give scan={'rows': ..., 'cols': ...} or add " + "a 'scan:' block to the settings file." + ) + self.row, self.col = self._read_spec(spec) + self._check_scan() + + self.cells = [] + self.cell_overrides = [] + self._output = None + self._build_cells() + + # ------------------------------------------------------------------- + # Setup + # ------------------------------------------------------------------- + + def _read_spec(self, spec): + if not isinstance(spec, dict): + raise ValueError( + "The scan specification must be a mapping with 'rows' and " + f"'cols' keys, got {type(spec).__name__}." + ) + unknown = set(spec) - {"rows", "cols"} + if unknown: + raise ValueError( + f"Unknown key(s) in the scan specification: " + f"{', '.join(sorted(unknown))}. Expected 'rows' and 'cols'." + ) + row = _parse_axis_spec(spec["rows"], "rows") if "rows" in spec else None + col = _parse_axis_spec(spec["cols"], "cols") if "cols" in spec else None + return row, col + + def _check_scan(self) -> None: + """ + Reports everything wrong with the scan specification at once, in the + same style as POPCON.__check_settings. + """ + bad, warn = [], [] + s = self.base_settings + + if self.row is None or self.col is None: + bad.append( + "a scan needs two parameters, given as 'rows' and 'cols'. " + "To vary just one, give the other a single value." + ) + if self.row is not None and self.col is not None: + if self.row.parameter == self.col.parameter: + bad.append( + f"rows and cols both scan '{self.row.parameter}'; they must " + f"be different parameters." + ) + + for axis, which in ((self.row, "rows"), (self.col, "cols")): + if axis is None: + continue + p = axis.parameter + if p in UNSCANNABLE_REASONS: + bad.append( + f"{which}: '{p}' cannot be scanned, because {UNSCANNABLE_REASONS[p]}." + ) + elif p not in SCANNABLE_SETTINGS_KEYS: + bad.append( + f"{which}: '{p}' is not a scannable setting. Available: " + f"{', '.join(sorted(SCANNABLE_SETTINGS_KEYS))}." + ) + if len(axis.values) < 1: + bad.append(f"{which}: '{p}' has no values to scan.") + if len(set(map(repr, axis.values))) != len(axis.values): + warn.append( + f"{which}: '{p}' has repeated values, so some cells will be identical." + ) + # the gEQDSK trap: __get_geometry overrides these from the + # equilibrium, and always takes the ohmic current from it + if s.gfilename != "" and p in GEQDSK_OWNED_KEYS: + bad.append( + f"{which}: '{p}' cannot be scanned while gfilename is set " + f"({os.path.basename(s.gfilename)}). The geometry is read from " + f"the gEQDSK, which overrides R, a, kappa, delta and Ip whenever " + f"they differ from the settings by more than 10%, and always " + f"takes the ohmic current from the equilibrium. Some cells would " + f"silently be identical and others not. Scan B_0 or H_fac " + f"instead, or clear gfilename to use parabolic profiles." + ) + + for w in warn: + print(f"Warning: {w}") + if bad: + raise ValueError( + f"Found {len(bad)} problem(s) in the scan specification in " + f"{self.settingsfile}:\n - " + "\n - ".join(bad) + ) + + def _build_cells(self) -> None: + """ + Builds every cell's POPCON up front, so that a settings problem at one + corner of the scan is reported before anything is solved. + """ + problems = [] + self.cells = [[None] * len(self.col) for _ in range(len(self.row))] + self.cell_overrides = [[None] * len(self.col) for _ in range(len(self.row))] + + for i, vi in enumerate(self.row.values): + for j, vj in enumerate(self.col.values): + overrides = {self.row.parameter: vi, self.col.parameter: vj} + self.cell_overrides[i][j] = overrides + try: + with contextlib.redirect_stdout(io.StringIO()): + settings = self.base_settings.with_overrides(**overrides) + cell = POPCON( + plotsettingsfile=self.plotsettingsfile, + scalinglawfile=self.scalinglawfile, + settings=settings, + ) + self.cells[i][j] = cell + except (ValueError, KeyError) as e: + problems.append( + f"cell ({i}, {j}) with {self.row.parameter}=" + f"{_fmt_value(vi)}, {self.col.parameter}={_fmt_value(vj)}: {e}" + ) + + if problems: + raise ValueError( + f"{len(problems)} of {len(self.row) * len(self.col)} scan cells have " + f"invalid settings:\n - " + "\n - ".join(problems) + ) + + # ------------------------------------------------------------------- + # Solving + # ------------------------------------------------------------------- + + @property + def shape(self): + return (len(self.row), len(self.col)) + + def run_scan(self, progress: bool = True, quiet: bool = None) -> None: + """ + Solves every cell. Cells run one at a time: settings.parallel already + threads the solve across the whole n,T grid, so a second layer of + parallelism would only oversubscribe the cores. + """ + if quiet is None: + # a scan reports its own per-cell line, so the cells' own output is + # suppressed unless the settings file asks for real verbosity + quiet = self.base_settings.verbosity < 2 + + nrow, ncol = self.shape + total = nrow * ncol + gridpoints = total * self.base_settings.Nn * self.base_settings.NTi + if gridpoints > 5e5: + print( + f"Warning: this scan is {nrow}x{ncol} cells of " + f"{self.base_settings.Nn}x{self.base_settings.NTi} points " + f"({gridpoints:.0f} total). Consider smaller Nn/NTi." + ) + + for i in range(nrow): + for j in range(ncol): + cell = self.cells[i][j] + label = ( + f"{self.row.parameter}={_fmt_value(self.row.values[i])}, " + f"{self.col.parameter}={_fmt_value(self.col.values[j])}" + ) + start = datetime.datetime.now() + if quiet: + # read() and __report_invalid print unconditionally; across + # a whole scan that is a wall of text + with contextlib.redirect_stdout(io.StringIO()): + cell.run_POPCON() + else: + cell.run_POPCON() + elapsed = (datetime.datetime.now() - start).total_seconds() + if progress: + valid = int( + np.count_nonzero( + cell.output.Paux.values < UNPHYSICAL_PLOT_CUTOFF + ) + ) + npts = cell.output.Paux.size + print( + f" [{i * ncol + j + 1}/{total}] {label} " + f"{valid}/{npts} points solved ({elapsed:.1f} s)" + ) + + self._output = None + + # ------------------------------------------------------------------- + # Results + # ------------------------------------------------------------------- + + @property + def datas(self): + """Every cell's output Dataset, row-major.""" + return [c.output for row in self.cells for c in row if hasattr(c, "output")] + + @property + def algorithms_list(self): + return [ + c.algorithms for row in self.cells for c in row if hasattr(c, "algorithms") + ] + + @property + def scanvariables(self): + return { + self.row.parameter: np.asarray(self.row.values), + self.col.parameter: np.asarray(self.col.values), + } + + @property + def output(self): + """ + Every cell's results in one Dataset, with the two scan parameters as + extra dimensions. Built on first use. + """ + if self._output is None: + self._output = self._combine() + return self._output + + def _combine(self): + missing = [ + (i, j) + for i, row in enumerate(self.cells) + for j, c in enumerate(row) + if c is None or not hasattr(c, "output") + ] + if missing: + raise RuntimeError( + f"{len(missing)} cell(s) have no output: {missing}. Call run_scan() first." + ) + + grid = [[c.output for c in row] for row in self.cells] + # coords='all' is deliberate. n_e_20_max and friends genuinely differ + # between cells whenever I_P or a is scanned (n_G = Ip/(pi a^2)), and + # the default 'different' would make the result's shape depend on which + # parameter happened to be scanned. They are non-index coordinates, so + # concatenation is positional and nothing is silently dropped + ds = xr.combine_nested( + grid, + concat_dim=[self.row.dim, self.col.dim], + coords="all", + data_vars="all", + join="exact", + combine_attrs="drop_conflicts", + ) + ds = ds.assign_coords( + { + self.row.dim: np.asarray(self.row.values), + self.col.dim: np.asarray(self.col.values), + } + ) + # combine_nested leaves the two new dimensions in its own order, which + # is not the (rows, cols) the cells are indexed by. Pin it, so that + # positional use of the arrays lines up with cells[i][j] + ds = ds.transpose(self.row.dim, self.col.dim, DIM_N, DIM_T) + ds[self.row.dim].attrs["parameter"] = self.row.parameter + ds[self.col.dim].attrs["parameter"] = self.col.parameter + ds.attrs["scan_parameters"] = json.dumps( + [self.row.parameter, self.col.parameter] + ) + return ds + + def metric(self, name: str = "Q", reduce: str = "max"): + """ + One number per cell, reduced over the n,T grid with the unphysical + points left out. 'Q'/'max' answers "how far does this machine get". + """ + field = getattr(self.output, name) + valid = self.output.Paux < UNPHYSICAL_PLOT_CUTOFF + reduced = getattr(field.where(valid), reduce)(dim=[DIM_N, DIM_T]) + # (rows, cols), so that .values lines up with cells[i][j] and with + # the tick labels plot_metric puts on the axes + return reduced.transpose(self.row.dim, self.col.dim) + + # ------------------------------------------------------------------- + # Plotting + # ------------------------------------------------------------------- + + def _shared_axes(self): + """ + Whether the cells' axes actually mean the same thing. Sharing y is + only right for the Greenwald fraction: an absolute density axis moves + with n_G = Ip/(pi a^2) and would be misleading if shared. + """ + scanned = {self.row.parameter, self.col.parameter} + yax = self.cells[0][0].plotsettings.yax + sharey = yax == "nG" and not (scanned & {"nmin_frac", "nmax_frac"}) + sharex = not (scanned & {"Tmin_keV", "Tmax_keV", "tipeak_over_tepeak"}) + return sharex, sharey + + def _harmonize_levels(self, names=None) -> None: + """ + Puts every panel on the same contour levels. Without this, 'minmax' + scaling picks levels from each panel's own range and no two panels in + the figure are comparable. Each cell owns its plotsettings, so this + does not leak between them. + """ + cells = [c for row in self.cells for c in row if hasattr(c, "output")] + if not cells: + return + if names is None: + names = list(cells[0].plotsettings.plotoptions.keys()) + + for name in names: + opts = cells[0].plotsettings.plotoptions[name] + if not opts["plot"] or opts["spacing"] == "manual": + continue + lo, hi = np.inf, -np.inf + for c in cells: + if name not in c.output: + continue + valid = c.output.Paux < UNPHYSICAL_PLOT_CUTOFF + data = c.output[name].where(valid).values + if np.all(np.isnan(data)): + continue + lo = min(lo, float(np.nanmin(data))) + hi = max(hi, float(np.nanmax(data))) + if not np.isfinite(lo) or not np.isfinite(hi) or hi <= lo: + continue + if opts["spacing"] == "log" and lo <= 0: + lo = hi * 1e-4 + for c in cells: + o = c.plotsettings.plotoptions[name] + o["scale"] = "specified" + o["min"], o["max"] = lo, hi + + def plot( + self, + show: bool = True, + savefig: str = "", + names=None, + figsize=None, + panel_size=(3.4, 2.8), + sharex=None, + sharey=None, + harmonize_levels: bool = True, + infobox: bool = False, + ): + """ + The scan as a grid of POPCONs, one per cell. + """ + nrow, ncol = self.shape + auto_x, auto_y = self._shared_axes() + sharex = auto_x if sharex is None else sharex + sharey = auto_y if sharey is None else sharey + if figsize is None: + figsize = (panel_size[0] * ncol + 2.4, panel_size[1] * nrow + 1.0) + + if harmonize_levels: + self._harmonize_levels(names) + + fig, axs = plt.subplots( + nrow, ncol, figsize=figsize, squeeze=False, sharex=sharex, sharey=sharey + ) + + for i in range(nrow): + for j in range(ncol): + ax = axs[i][j] + cell = self.cells[i][j] + try: + # plot() narrates its contour levels at verbosity > 0, + # which across a whole grid is just noise + with contextlib.redirect_stdout(io.StringIO()): + cell.plot( + ax=ax, + show=False, + names=names, + legend=False, + infobox=infobox, + ) + except ValueError as e: + # one hopeless corner cell must not take the figure with it + ax.text( + 0.5, + 0.5, + "no physical\nsolution", + ha="center", + va="center", + color="0.4", + transform=ax.transAxes, + ) + if self.base_settings.verbosity > 0: + print(f" cell ({i}, {j}) not plotted: {e}") + if i == 0: + ax.set_title( + f"{self.col.label} = {_fmt_value(self.col.values[j])}", + fontsize=11, + ) + if j == ncol - 1: + twin = ax.twinx() + twin.set_yticks([]) + twin.set_ylabel( + f"{self.row.label} = {_fmt_value(self.row.values[i])}", + fontsize=11, + ) + if sharex and i < nrow - 1: + ax.set_xlabel("") + if sharey and j > 0: + ax.set_ylabel("") + + handles, labels = [], [] + for i in range(nrow): + for j in range(ncol): + h, lbl = axs[i][j].get_legend_handles_labels() + if len(h) > len(handles): + handles, labels = h, lbl + if handles: + fig.legend(handles, labels, loc="center left", bbox_to_anchor=(1.0, 0.5)) + + fig.suptitle( + f"{self.base_settings.name}: {self.row.parameter} vs {self.col.parameter}", + fontsize=13, + ) + fig.tight_layout() + if savefig != "": + fig.savefig(savefig, bbox_inches="tight") + if show: + plt.show() + return fig, axs + + def plot_metric( + self, + name: str = "Q", + reduce: str = "max", + show: bool = True, + savefig: str = "", + ax=None, + cmap: str = "viridis", + fmt: str = "{:.3g}", + ): + """ + One scalar per cell as a heatmap, so the trend across the scan reads + at a glance. + """ + z = self.metric(name, reduce).values + if ax is None: + fig, ax = plt.subplots( + figsize=(1.4 * self.shape[1] + 3, 1.1 * self.shape[0] + 2.5) + ) + owns_figure = True + else: + fig, owns_figure = ax.get_figure(), False + + im = ax.imshow(z, cmap=cmap, origin="lower", aspect="auto") + ax.set_xticks(range(self.shape[1])) + ax.set_xticklabels([_fmt_value(v) for v in self.col.values]) + ax.set_yticks(range(self.shape[0])) + ax.set_yticklabels([_fmt_value(v) for v in self.row.values]) + ax.set_xlabel(self.col.parameter) + ax.set_ylabel(self.row.parameter) + ax.set_title(f"{reduce} {name} over the n,T grid") + + finite = z[np.isfinite(z)] + mid = (finite.max() + finite.min()) / 2 if finite.size else 0.0 + for i in range(self.shape[0]): + for j in range(self.shape[1]): + if not np.isfinite(z[i, j]): + continue + ax.text( + j, + i, + fmt.format(z[i, j]), + ha="center", + va="center", + color="w" if z[i, j] < mid else "k", + fontsize=9, + ) + fig.colorbar(im, ax=ax, label=f"{reduce} {name}") + + if owns_figure: + fig.tight_layout() + if savefig != "": + fig.savefig(savefig, bbox_inches="tight") + if show and owns_figure: + plt.show() + return fig, ax + + # ------------------------------------------------------------------- + # File I/O + # ------------------------------------------------------------------- + + def write_output( + self, + name: str = "", + archive: bool = True, + overwrite: bool = False, + directory: str = None, + ) -> None: + """ + Saves the whole scan: the base settings, the scan specification, the + combined arrays and the grid plot. + """ + name, outputsdir, savedir = _prepare_output_dir( + name, directory, overwrite, self.base_settings.name + "_scan" + ) + + shutil.copyfile(self.settingsfile, savedir.joinpath("settings.yaml")) + cell0 = self.cells[0][0] + shutil.copyfile(cell0.plotsettingsfile, savedir.joinpath("plotsettings.yaml")) + shutil.copyfile(cell0.scalinglawfile, savedir.joinpath("scalinglaws.yaml")) + + # per-cell provenance goes here rather than into the netCDF attributes: + # combine_attrs='drop_conflicts' discards the differing settings JSON, + # and a few dozen KB of attributes would make ncdump unusable anyway + with open(savedir.joinpath("scan.json"), "w") as f: + json.dump( + { + "rows": { + "parameter": self.row.parameter, + "values": self.row.values, + }, + "cols": { + "parameter": self.col.parameter, + "values": self.col.values, + }, + "overrides": self.cell_overrides, + }, + f, + indent=1, + ) + + for axis in (self.row, self.col): + if not all(isinstance(v, (int, float, np.floating)) for v in axis.values): + raise ValueError( + f"Cannot write a scan over '{axis.parameter}' to netCDF: its " + f"values are not numeric, and the default netCDF backend " + f"cannot store string coordinates. Install " + f"openpopcon[netcdf4] or scan a numeric parameter." + ) + self.output.to_netcdf(savedir.joinpath("arrays.nc")) + + if self.base_settings.gfilename != "": + shutil.copyfile( + self.base_settings.gfilename, + savedir.joinpath(os.path.basename(self.base_settings.gfilename)), + ) + if self.base_settings.profsfilename != "": + shutil.copyfile( + self.base_settings.profsfilename, + savedir.joinpath(os.path.basename(self.base_settings.profsfilename)), + ) + + self.plot(show=False, savefig=str(savedir.joinpath("POPCON_scan_plot.pdf"))) + plt.close("all") + + print(f"Wrote output to {_finalize_output(savedir, outputsdir, name, archive)}") + + @classmethod + def read_output(cls, name: str, directory: str = None): + """ + Reads back a scan written by write_output. Returns a POPCON_scan whose + cells are set up but not re-solved; each cell's output is sliced out + of the saved arrays. + """ + if directory is None: + outputsdir = pathlib.Path.cwd().joinpath("OpenPOPCON_outputs") + else: + outputsdir = pathlib.Path(directory) + + if name.endswith(".zip"): + readdir = outputsdir.joinpath(name[:-4]) + shutil.unpack_archive(outputsdir.joinpath(name), readdir, "zip") + else: + readdir = outputsdir.joinpath(name) + + with open(readdir.joinpath("scan.json"), "r") as f: + spec = json.load(f) + + sc = cls( + settingsfile=str(readdir.joinpath("settings.yaml")), + plotsettingsfile=str(readdir.joinpath("plotsettings.yaml")), + scalinglawfile=str(readdir.joinpath("scalinglaws.yaml")), + scan={ + "rows": (spec["rows"]["parameter"], spec["rows"]["values"]), + "cols": (spec["cols"]["parameter"], spec["cols"]["values"]), + }, + ) + + ds = xr.load_dataset(readdir.joinpath("arrays.nc")) + sc._output = ds + for i in range(sc.shape[0]): + for j in range(sc.shape[1]): + cell = sc.cells[i][j] + if cell.settings.gfilename != "": + cell.settings.gfilename = str( + readdir.joinpath(os.path.basename(cell.settings.gfilename)) + ) + if cell.settings.profsfilename != "": + cell.settings.profsfilename = str( + readdir.joinpath(os.path.basename(cell.settings.profsfilename)) + ) + with contextlib.redirect_stdout(io.StringIO()): + cell.run_POPCON(setuponly=True) + cell.output = ds.isel({sc.row.dim: i, sc.col.dim: j}).drop_vars( + [sc.row.dim, sc.col.dim] + ) + return sc diff --git a/openpopcon/resources/default_plotsettings.yml b/openpopcon/resources/default_plotsettings.yml index e92242f..71b26b2 100644 --- a/openpopcon/resources/default_plotsettings.yml +++ b/openpopcon/resources/default_plotsettings.yml @@ -2,11 +2,20 @@ # OpenPOPCON Plotting Settings #----------------------------------------------------------------------- -yax: "nG" # y-axis variable; nG for greenwald fraction, n20 for density -xax: "T_i_av" # x-axis variable; T_i_av for average ion temperature, - # T_i_ax for maximum ion temperature, - # T_e_av for average electron temperature, - # T_e_ax for maximum electron temperature +# Either axis takes any of the seven names below. They are not split into +# an x set and a y set; the only rule is that one has to be a density and +# the other a temperature, since those are the two grid dimensions. So +# xax: "nG" with yax: "T_i_av" draws the same POPCON with the axes swapped. +# +# nG Greenwald fraction, /n_G +# n20_av volume-averaged electron density, 10^20 m^-3 +# n20_ax on-axis electron density, 10^20 m^-3 +# T_i_av volume-averaged ion temperature, keV +# T_i_ax on-axis ion temperature, keV +# T_e_av volume-averaged electron temperature, keV +# T_e_ax on-axis electron temperature, keV +yax: "nG" # y-axis variable +xax: "T_i_av" # x-axis variable figsize: [8, 6] # figure size in inches fill_invalid: True # shade points with no physical solution diff --git a/openpopcon/resources/examples/CENTAUR/CENTAUR_ex.ipynb b/openpopcon/resources/examples/CENTAUR/CENTAUR_ex.ipynb new file mode 100644 index 0000000..96920a0 --- /dev/null +++ b/openpopcon/resources/examples/CENTAUR/CENTAUR_ex.ipynb @@ -0,0 +1,338 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# OpenPOPCON CENTAUR example\n", + "\n", + "CENTAUR is a compact, high-field, **negative triangularity** breakeven\n", + "tokamak: 2.0 m major radius, 10.9 T, delta = -0.55, designed for 40 MW of\n", + "fusion power at Q = 1.3 in a 10 s pulse. Parameters are from Table 1 of\n", + "[arXiv:2605.27549](https://arxiv.org/abs/2605.27549).\n", + "\n", + "Because it is a negative triangularity device, this example uses the\n", + "`H_NT23` confinement scaling rather than `H98y2`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:56.539506Z", + "iopub.status.busy": "2026-08-04T20:20:56.539230Z", + "iopub.status.idle": "2026-08-04T20:20:57.363546Z", + "shell.execute_reply": "2026-08-04T20:20:57.362985Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import openpopcon as op" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and run" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:57.365337Z", + "iopub.status.busy": "2026-08-04T20:20:57.365148Z", + "iopub.status.idle": "2026-08-04T20:20:58.314844Z", + "shell.execute_reply": "2026-08-04T20:20:58.314110Z" + } + }, + "outputs": [], + "source": [ + "settingsfile = \"./POPCON_input_example.yaml\"\n", + "plotsettingsfile = \"./plotsettings.yml\"\n", + "\n", + "pc = op.POPCON(settingsfile=settingsfile, plotsettingsfile=plotsettingsfile)\n", + "pc.run_POPCON()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting\n", + "\n", + "The grey region is where the balance has no physical solution, here because\n", + "impurity radiation exceeds the confinement loss. CENTAUR is a marginal,\n", + "breakeven-class device, so that boundary sits close to the operating point\n", + "and a good part of the low-temperature grid is inaccessible." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:58.316837Z", + "iopub.status.busy": "2026-08-04T20:20:58.316720Z", + "iopub.status.idle": "2026-08-04T20:20:58.685420Z", + "shell.execute_reply": "2026-08-04T20:20:58.684726Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = pc.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Checking against the design point\n", + "\n", + "The published operating point is 0.55 of the Greenwald density at a\n", + "volume-averaged ion temperature of 5.15 keV. The profile shapes in the\n", + "settings file were chosen so the fusion power there matches the published\n", + "40 MW.\n", + "\n", + "Read the note at the bottom of `POPCON_input_example.yaml` before comparing\n", + "Q or tau_E with the paper: the published scalars are not mutually consistent\n", + "under a plain 0-D energy balance, and `H_NT23` has a power degradation\n", + "exponent of -0.89, which makes `P_heat = (W_tot/K)**9.09` and therefore very\n", + "stiff. This is a scoping model of the CENTAUR machine, not a reproduction of\n", + "the CENTAUR design point." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:58.687335Z", + "iopub.status.busy": "2026-08-04T20:20:58.687235Z", + "iopub.status.idle": "2026-08-04T20:20:58.691285Z", + "shell.execute_reply": "2026-08-04T20:20:58.690776Z" + } + }, + "outputs": [], + "source": [ + "i = int(np.abs(pc.output.n_G_frac.values - 0.55).argmin())\n", + "j = int(np.abs(pc.output.T_i_avg.values - 6.5).argmin())\n", + "point = pc.output.isel(n_index=i, T_index=j)\n", + "\n", + "print(f\"n/n_G = {float(point.n_G_frac):.2f}\")\n", + "print(f\" = {float(point.T_i_avg):.1f} keV\")\n", + "print(f\"P_fus = {float(point.Pfusion):.0f} MW\")\n", + "print(f\"P_aux = {float(point.Paux):.0f} MW\")\n", + "print(f\"Q = {float(point.Q):.2f}\")\n", + "print(f\"beta_N = {float(point.betaN):.2f} (Table 1 gives 1.5)\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scoping a single operating point\n", + "\n", + "`single_point` solves one density/temperature pair and shows the profiles\n", + "behind it, which is the quickest way to see why a point on the POPCON sits\n", + "where it does." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:58.692796Z", + "iopub.status.busy": "2026-08-04T20:20:58.692673Z", + "iopub.status.idle": "2026-08-04T20:20:58.985797Z", + "shell.execute_reply": "2026-08-04T20:20:58.985380Z" + } + }, + "outputs": [], + "source": [ + "pc.single_point(n_G_frac=0.55, Ti_av=6.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scanning the current against the field\n", + "\n", + "This is the main worked scan in the repository. `POPCON_scan` runs a full\n", + "POPCON at every combination of two machine parameters and tiles them. The\n", + "3 x 3 grid of `I_P` against `B_0` below comes from the `scan:` block in the\n", + "settings file.\n", + "\n", + "Only parameters that are re-derived on every run can be scanned; the list is\n", + "in `openpopcon.SCANNABLE_SETTINGS_KEYS`. Scanning geometry on an example that\n", + "supplies a gEQDSK is refused, because the equilibrium overrides it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:58.987433Z", + "iopub.status.busy": "2026-08-04T20:20:58.987326Z", + "iopub.status.idle": "2026-08-04T20:20:58.989693Z", + "shell.execute_reply": "2026-08-04T20:20:58.989090Z" + } + }, + "outputs": [], + "source": [ + "print(sorted(op.SCANNABLE_SETTINGS_KEYS))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:58.990956Z", + "iopub.status.busy": "2026-08-04T20:20:58.990855Z", + "iopub.status.idle": "2026-08-04T20:21:05.917702Z", + "shell.execute_reply": "2026-08-04T20:21:05.917222Z" + } + }, + "outputs": [], + "source": [ + "sc = op.POPCON_scan(settingsfile=settingsfile, plotsettingsfile=plotsettingsfile)\n", + "sc.run_scan()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Every panel is put on the same contour levels, so they can be compared\n", + "directly. The y axis is shared because it is the Greenwald fraction; had the\n", + "plotsettings asked for an absolute density it would not be, since\n", + "`n_G = I_p / (pi a^2)` moves with the scanned current." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:21:05.919234Z", + "iopub.status.busy": "2026-08-04T20:21:05.919133Z", + "iopub.status.idle": "2026-08-04T20:21:06.569188Z", + "shell.execute_reply": "2026-08-04T20:21:06.568611Z" + } + }, + "outputs": [], + "source": [ + "fig, axs = sc.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:21:06.573202Z", + "iopub.status.busy": "2026-08-04T20:21:06.573088Z", + "iopub.status.idle": "2026-08-04T20:21:06.662058Z", + "shell.execute_reply": "2026-08-04T20:21:06.661555Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = sc.plot_metric(\"Q\", reduce=\"max\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Scanning from Python instead of the settings file\n", + "\n", + "Passing `scan=` overrides the block in the settings file. Each axis takes\n", + "either an explicit list of values or a `min`/`max`/`N` range." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:21:06.663613Z", + "iopub.status.busy": "2026-08-04T20:21:06.663510Z", + "iopub.status.idle": "2026-08-04T20:21:14.549855Z", + "shell.execute_reply": "2026-08-04T20:21:14.548940Z" + } + }, + "outputs": [], + "source": [ + "sc2 = op.POPCON_scan(\n", + " settingsfile=settingsfile,\n", + " plotsettingsfile=plotsettingsfile,\n", + " scan={\n", + " \"rows\": (\"H_fac\", [0.7, 0.87, 1.0]),\n", + " \"cols\": (\"delta\", {\"min\": -0.55, \"max\": -0.25, \"N\": 3}),\n", + " },\n", + ")\n", + "sc2.run_scan()\n", + "fig, axs = sc2.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving and reloading a scan\n", + "\n", + "`write_output` saves the whole scan: the base settings, the scan\n", + "specification, the combined arrays and the grid plot." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:21:14.553242Z", + "iopub.status.busy": "2026-08-04T20:21:14.553103Z", + "iopub.status.idle": "2026-08-04T20:21:15.475595Z", + "shell.execute_reply": "2026-08-04T20:21:15.475045Z" + } + }, + "outputs": [], + "source": [ + "sc.write_output(name=\"centaur_scan\", archive=False, overwrite=True)\n", + "\n", + "back = op.POPCON_scan.read_output(\"centaur_scan\")\n", + "print(back.shape, back.row.parameter, back.col.parameter)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "openPOPCON", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/openpopcon/resources/examples/CENTAUR/POPCON_input_example.yaml b/openpopcon/resources/examples/CENTAUR/POPCON_input_example.yaml new file mode 100644 index 0000000..3ca7bcb --- /dev/null +++ b/openpopcon/resources/examples/CENTAUR/POPCON_input_example.yaml @@ -0,0 +1,167 @@ +#----------------------------------------------------------------------- +# OpenPOPCON input file: CENTAUR +# +# Compact Experimental Negative TriAngUlarity Reactor: a compact, high +# field, negative triangularity breakeven tokamak. Parameters from Table 1 +# of arXiv:2605.27549, "Compact Experimental Negative TriAngUlarity Reactor +# (CENTAUR): A design study for a compact, affordable breakeven tokamak". +# +# Design point: 40 MW fusion power, Q = 1.3, 10 s pulse. +# +# Parabolic profiles rather than a gEQDSK, deliberately: it keeps R, a, +# kappa, delta and I_P available to POPCON_scan, which the gEQDSK path +# overrides. +#----------------------------------------------------------------------- + +name: "CENTAUR" + +#---------------------- +# Machine parameters +#---------------------- + +R: 2.0 # major radius, m +a: 0.72 # minor radius, m (aspect ratio 2.78) +kappa: 1.65 # elongation +delta: -0.55 # triangularity -- negative, this is an NT device + +I_P: 9.6 # plasma current, MA (q95 = 2.58, q0 = 1.04) +B_0: 10.9 # on-axis toroidal field, T + +# Table 1 gives volume-averaged Ti = 5.15 keV and Te = 4.15 keV +tipeak_over_tepeak: 1.24 + +#---------------------- +# Plasma composition +#---------------------- + +fuel: 2 # 50/50 D-T + +# He, Ne, Ar, Kr, Xe, W +# 1% helium: the pulse is 10 s at Q = 1.3, so very little ash accumulates +impurityfractions: [0.01, 0., 0., 0., 0., 0.] + +# Table 1 gives Zeff = 1.43, with argon in the core and neon at the edge, +# and puts 13.5% of the radiated power between the separatrix and the +# plasma facing components. This model has a single impurity radiating +# uniformly from the core, so it cannot represent that split; neon is used +# as the Zeff carrier because taking the full Zeff as core argon +# substantially overstates core radiation for a device that radiates mostly +# in the divertor. +Zeff_target: 1.43 +impurity: 1 # 0 He, 1 Ne, 2 Ar, 3 Kr, 4 Xe, 5 W + +#---------------------- +# Confinement +#---------------------- + +# H_NT23 is the negative-triangularity scaling, which is the relevant one +# here. Table 1 quotes H_NT = 0.87 (and H98,y2 = 0.54) at the design point. +scalinglaw: "H_NT23" +H_fac: 0.87 + +nr: 100 # number of radial points + +#---------------------- +# Profiles +#---------------------- + +gfilename: "" +profsfilename: "" + +# f(rho) = (1 - offset) * (1 - rho^alpha1)^alpha2 + offset +# +# Broad, weakly peaked profiles. NT plasmas are ELM-free and have no +# pedestal, and these shapes are what reproduce the published 40 MW of +# fusion power at the Table 1 operating point: density peaking 1.23 and +# temperature peaking 1.24, i.e. Ti(0) = 6.4 keV at = 5.15 keV. +# Peaking matters more than anything else here, because the fusion power +# goes as the volume integral of n^2 (T). +j_alpha1: 2. +j_alpha2: 3. +j_offset: 0.01 + +ne_alpha1: 2. +ne_alpha2: 0.6 +ne_offset: 0.5 + +ni_alpha1: 2. +ni_alpha2: 0.6 +ni_offset: 0.5 + +Ti_alpha1: 2. +Ti_alpha2: 0.9 +Ti_offset: 0.6 + +Te_alpha1: 2. +Te_alpha2: 0.9 +Te_offset: 0.6 + +#---------------------- +# Algorithm settings +#---------------------- + +Nn: 50 # number of density points +NTi: 50 # number of temperature points + +# n_G = Ip / (pi a^2) = 5.90e20 m^-3; Table 1 gives a volume-averaged +# n_e of 3.21e20, i.e. a Greenwald fraction of roughly 0.55 +nmax_frac: 0.9 +nmin_frac: 0.2 + +# Table 1's operating point is = 5.15 keV. The window runs well past +# it because H_NT23 has Pheat_alpha = -0.89, so the closed-form balance +# solves P_heat = (W_tot/K)^9.09. That exponent makes P_heat extremely +# stiff, and the accessible region has a sharp lower edge in temperature +# where impurity radiation overtakes it. See the note at the end. +Tmax_keV: 14. +Tmin_keV: 4. + +resistivity_model: "Jardin" # Jardin, Paz-Soldan, or maximum + +verbosity: 1 +parallel: True + +#---------------------- +# Scan (used by POPCON_scan; ignored by a plain POPCON) +#---------------------- + +scan: + rows: + parameter: I_P + min: 7. + max: 12. + N: 3 + cols: + parameter: B_0 + min: 9. + max: 12. + N: 3 + +#----------------------------------------------------------------------- +# A note on agreement with the paper +# +# The machine here is Table 1 exactly: R, a, kappa, delta, I_P, B_0, fuel, +# Zeff, the NT confinement scaling and H_NT = 0.87. The profile shapes are +# chosen so that the fusion power at the published operating point comes +# out at the published 40 MW. +# +# The 0-D closed-form balance does not reproduce the paper's Q = 1.3 and +# tau_E = 0.41 s at the same time, and it is worth knowing why rather than +# being surprised by it: +# +# - The published scalars are not mutually consistent under a plain 0-D +# energy balance. The quoted n_e, T and plasma volume give a stored +# energy of about 25 MJ, which with tau_E = 0.41 s implies 60 MW of +# loss power, and with 40 MW of fusion power that is Q ~ 0.8, not 1.3. +# The paper's numbers come from an integrated model with a real +# transport solve, not from this kind of scoping balance. +# +# - H_NT23's power degradation exponent of -0.89 makes P_heat go as +# (W_tot/K)^9.09. A 10% change in stored energy moves the required +# heating power by more than a factor of two, so this machine has a +# narrow band between "impurity radiation exceeds the confinement +# loss" and "ignited, needs no auxiliary power at all". +# +# Treat this as a scoping model of the CENTAUR machine, not a reproduction +# of the CENTAUR design point. +#----------------------------------------------------------------------- diff --git a/openpopcon/resources/examples/CENTAUR/plotsettings.yml b/openpopcon/resources/examples/CENTAUR/plotsettings.yml new file mode 100644 index 0000000..67f25b6 --- /dev/null +++ b/openpopcon/resources/examples/CENTAUR/plotsettings.yml @@ -0,0 +1,83 @@ +#----------------------------------------------------------------------- +# OpenPOPCON Plotting Settings: CENTAUR +# +# Only the entries that differ from resources/default_plotsettings.yml are +# listed; anything left out falls back to the default. +# +# CENTAUR is a 40 MW, Q = 1.3 device, so the default power and Q contour +# levels (which are set for a ~500 MW reactor) are rescaled here. Without +# this, every default level falls off the plot. +#----------------------------------------------------------------------- + +yax: "nG" # nG, n20_av or n20_ax +xax: "T_i_av" # T_i_av, T_i_ax, T_e_av or T_e_ax; either axis takes either family +figsize: [8, 6] +fill_invalid: True + +plotoptions: + Paux: + plot: True + color: r + linewidth: 3 + label: $P_{aux}$ + fontsize: 12 + fmt: '%.2d' + spacing: manual + manuallevels: [1,5,10,20,30,50,80,120] # MW; CENTAUR is externally heated + scale: minmax + levels: 10 + Pfusion: + plot: True + color: k + linewidth: 2 + label: $P_{fus}$ + fontsize: 12 + fmt: '%.2d' + spacing: manual + manuallevels: [5,10,20,40,60,80,120] # MW; design point is 40 + scale: minmax + levels: 10 + Prad: + plot: True + color: purple + linewidth: 2 + label: $P_{rad}$ + fontsize: 12 + fmt: '%.2d' + spacing: manual + manuallevels: [2,5,10,20,40] + scale: minmax + levels: 3 + Q: + plot: True + color: orange + linewidth: 2 + label: $Q$ + fontsize: 12 + fmt: '%.2f' + spacing: manual + manuallevels: [0.2,0.5,1.0,1.3,2.0,5.0] # design point is Q = 1.3 + scale: minmax + levels: 6 + H98: + plot: False # H_NT23 is the relevant scaling here, not H98y2 + color: blue + linewidth: 2 + label: $H_{98y2}$ + fontsize: 12 + fmt: '%.1f' + spacing: lin + manuallevels: [] + scale: minmax + levels: 5 + betaN: + plot: True + color: forestgreen + linewidth: 2 + label: $\beta_N$ + fontsize: 12 + fmt: '%.2f' + spacing: manual + manuallevels: [1.0,1.5,2.0,2.5] # design point is 1.5 + scale: minmax + levels: 5 diff --git a/openpopcon/resources/examples/ITER/ITER_ex.ipynb b/openpopcon/resources/examples/ITER/ITER_ex.ipynb new file mode 100644 index 0000000..0c02985 --- /dev/null +++ b/openpopcon/resources/examples/ITER/ITER_ex.ipynb @@ -0,0 +1,471 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# OpenPOPCON ITER example\n", + "\n", + "The ITER baseline inductive scenario: 15 MA, 5.3 T, 500 MW of fusion power at\n", + "Q = 10. Machine parameters come from the ITER Physics Basis and Progress in\n", + "the ITER Physics Basis (references [7] in the repository README).\n", + "\n", + "This example uses parabolic profiles rather than a gEQDSK, which keeps `R`,\n", + "`a`, `kappa`, `delta` and `I_P` free for `POPCON_scan` to vary." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:35.659638Z", + "iopub.status.busy": "2026-08-04T20:20:35.659445Z", + "iopub.status.idle": "2026-08-04T20:20:36.489216Z", + "shell.execute_reply": "2026-08-04T20:20:36.488737Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import openpopcon as op" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and run\n", + "\n", + "`settingsfile` holds the machine and algorithm settings, `plotsettingsfile`\n", + "the contour levels and axes. Both are read from this directory.\n", + "\n", + "The numerics are compiled with numba the first time they run, so the first\n", + "solve in a fresh kernel takes a few seconds longer than the rest." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:36.491140Z", + "iopub.status.busy": "2026-08-04T20:20:36.490969Z", + "iopub.status.idle": "2026-08-04T20:20:37.607641Z", + "shell.execute_reply": "2026-08-04T20:20:37.607167Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Impurity fractions = [0.025 0.0079697 0. 0. 0. 0. ] calculated from Zeff_target.\n", + "Setting up algorithm object\n", + "Solving power balance equations\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power balance solutions found. Populating output arrays.\n", + "350 of 2500 grid points (14.0%) have no physical solution and are masked in the plot:\n", + " 350 impurity radiation exceeds the confinement loss\n", + "590 of 2500 grid points need no auxiliary heating (P_aux cannot be less than zero, setting P_aux = 0).\n" + ] + } + ], + "source": [ + "settingsfile = \"./POPCON_input_example.yaml\"\n", + "plotsettingsfile = \"./plotsettings.yml\"\n", + "\n", + "pc = op.POPCON(settingsfile=settingsfile, plotsettingsfile=plotsettingsfile)\n", + "pc.run_POPCON()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:37.609444Z", + "iopub.status.busy": "2026-08-04T20:20:37.609327Z", + "iopub.status.idle": "2026-08-04T20:20:37.996875Z", + "shell.execute_reply": "2026-08-04T20:20:37.996175Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plotting Paux with levels [ 10. 20. 50. 73. 100. 200. 500.] and options ['r', 3, '$P_{aux}$', 12, '%.2d']\n", + "Plotting Pfusion with levels [ 50. 100. 200. 500. 1000. 2000.] and options ['k', 2, '$P_{fus}$', 12, '%.2d']\n", + "Plotting Prad with levels [ 10. 50. 100. 200.] and options ['purple', 2, '$P_{rad}$', 12, '%.2d']\n", + "Plotting Q with levels [ 1. 2. 5. 10. 20. 50. 100.] and options ['orange', 2, '$Q$', 12, '%.f']\n", + "Plotting H98 with levels [0.99 0.995 1. 1.005 1.01 ] and options ['blue', 2, '$H_{98y2}$', 12, '%.1f']\n", + "Plotting betaN with levels [1. 1.8 2.5 3. ] and options ['forestgreen', 2, '$\\\\beta_N$', 12, '%.2f']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = pc.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Checking against the design point\n", + "\n", + "The baseline sits near 0.85 of the Greenwald density at a volume-averaged ion\n", + "temperature around 8.5 keV. The fusion power there should come out close to\n", + "the nominal 500 MW.\n", + "\n", + "Q comes out higher than the nominal 10. That is expected rather than wrong:\n", + "ITER's Q = 10 point carries 50 MW of external heating for burn control, not\n", + "because 50 MW is the minimum required, and a 0-D balance with parabolic\n", + "profiles finds the ignition boundary nearby. Read the Q contours as\n", + "optimistic." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:37.998449Z", + "iopub.status.busy": "2026-08-04T20:20:37.998367Z", + "iopub.status.idle": "2026-08-04T20:20:38.002165Z", + "shell.execute_reply": "2026-08-04T20:20:38.001774Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n/n_G = 0.85\n", + " = 8.6 keV\n", + "P_fus = 481 MW (nominal 500)\n", + "P_aux = 5 MW\n", + "Q = 20.4\n", + "beta_N = 2.62\n" + ] + } + ], + "source": [ + "valid = pc.output.Paux < 99998.0\n", + "i = int(np.abs(pc.output.n_G_frac.values - 0.85).argmin())\n", + "j = int(np.abs(pc.output.T_i_avg.values - 8.5).argmin())\n", + "point = pc.output.isel(n_index=i, T_index=j)\n", + "\n", + "print(f\"n/n_G = {float(point.n_G_frac):.2f}\")\n", + "print(f\" = {float(point.T_i_avg):.1f} keV\")\n", + "print(f\"P_fus = {float(point.Pfusion):.0f} MW (nominal 500)\")\n", + "print(f\"P_aux = {float(point.Paux):.0f} MW\")\n", + "print(f\"Q = {float(point.Q):.1f}\")\n", + "print(f\"beta_N = {float(point.betaN):.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scoping a single operating point\n", + "\n", + "`single_point` solves one density/temperature pair and shows the profiles\n", + "behind it, which is the quickest way to see why a point on the POPCON sits\n", + "where it does." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:38.003838Z", + "iopub.status.busy": "2026-08-04T20:20:38.003745Z", + "iopub.status.idle": "2026-08-04T20:20:38.300932Z", + "shell.execute_reply": "2026-08-04T20:20:38.300356Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Params:\n", + "n_i_average = 0.8981282498110913 x 10^20 m^-3\n", + "n_e_average = 1.015 x 10^20 m^-3\n", + "n_G = 1.194 x 10^20 m^-3\n", + "n_i_axis = 1.129 x 10^20 m^-3\n", + "n_e_axis = 1.276 x 10^20 m^-3\n", + "Ti_average = 8.5 keV\n", + "Ti_axis = 14.1 keV\n", + "Solution:\n", + "P_aux = 3.99 MW\n", + "P_fusion = 471.35 MW\n", + "P_SOL = 68.21 MW\n", + "P_load = 0.103 MW/m^2\n", + "P_ohmic = 18.977 MW\n", + "P_brems = 25.172 MW\n", + "P_synch = 3.703 MW\n", + "P_imprad = 20.503 MW\n", + "P_rad = 49.38 MW\n", + "P_heat = 88.72 MW\n", + "P_alpha = 94.27 MW\n", + "P_dd = 0.531 MW\n", + "P_dt = 470.82 MW\n", + "Wtot/TauE = 88.72 MW\n", + "f_rad = 0.420 \n", + "tauE = 3.754 s\n", + "Q = 20.526 \n", + "H89 = 2.22\n", + "H98 = 1.00\n", + "vloop = 1.2651 V\n", + "betaN = 2.600\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa8AAAEqCAYAAACiFt9qAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXAdJREFUeJztnQeUFOXShouccwYRJEfJQRGQoATFCAImFFDk1ysqigoK6FUxi1eQIEFRFBEkSU4qiBJFkCBJYJEcJcf+z9MfvTu77C6zsxN6Zuo5p8/uzM7M9qSurvreeiuNZVmWKIqiKEoYkTbUO6AoiqIoKUWDl6IoihJ2aPBSFEVRwg4NXoqiKErYocFLURRFCTs0eCmKoihhhwYvRVEUJezQ4KUoiqKEHRq8FEVRlLAjvbiAixcvyrRp02To0KGyceNGGTdunNSvXz/Z+xw7dkw+/vhjmT17tpw4cUIqV64sL7zwgtSoUcPr/3vhwgX5/fffpVChQpI2rcZxRVHCn0uXLsm+ffvsY2H69K44xAcEVzyzl156STZt2iTt27eXzp07y5kzZ656n6eeesoOWAMHDrTfIAJfw4YNZfXq1VKmTBmv/i+Bq27dun54BoqiKO5i2bJlUqdOHYlU0rjB25AMiAC0a9cuKV68uCxcuFBuvvnmq2Zr6dKli3c5c+bMMmzYMDsAesPOnTulRIkS9ptcpEiRVD8PRVGUULNnzx77pHzHjh1y7bXXSqTiiszLl9TWM3DBxIkT7dLf1cqNnjilQgLXNddck+J9UBRFcStpI3wpxBXBy1d++ukn6dSpk/z7779CAjl16lSpVKlSkrc/e/asvTkcP348SHuqKIqi+JOwDs2kxj/++KPMmTNH2rVrJ/fff78t+EiKAQMGSK5cuWK35AKdoiiK4l7COnhlyZJFSpYsKbVr15bhw4dL4cKFZdCgQUne/uWXX7ZVis62fv36oO6voiiK4h/CumyYkOzZs8upU6eS/HumTJnszYFyo6Io4SsJP3funEQbGTJkuGLNPxoJm+CFnB5pO31dBKh+/fpJr169pECBArbScOTIkbJ8+XJ59dVXQ72riqIEGILW33//bQewaCR37tx2pSlNmjQSrbgieE2YMEGef/55OwhBhw4dbNn7M888Y29w8OBB+eeff2LLhUjca9WqZfeE0aTM5a+++kpuv/32kD4XRVECC+Is5OBkH7TWRLqqLuFz5+R9//799uVobvFxRZ8XwYfglNjZBRscOnTIVgoWLVo03m24Plu2bHawSylOX1lMTIz3Uvnz5+XC0RNy9owlaTNnlDRZMkv6zOmFLD6KT4IUJWicP39etmzZYh8LEF5FI4cOHbIDWLly5a4oIab0uEZFa8iQITJ58mRp2rSp7XCUFDz2jTfeaC+5sA+hLF+md8taFVty5MuXL0XXB4zJkyX9fffFe+GI/pakkYuSRi5IBjlT8FrJXbe8SMGCsv9EFlk7e7fsy1Za9uapILsK15Gj11SRnLnTCt+7Fi1EbrzRPM7p0yLbtokUKCCSNy/9b8F9aooSDjgVmowZM0q0kjVr1thAnpoAglEDpg7dunWzs1kSieRedxTdBMz58+fbWWAo0cNjSrlw4YqrSLjSiCVpxZL0clYy798s8sNm+28FRaQZvxwTkd0iss4Eu7OSSQ5JPvl3aiORnreJVK0qf56oKHVvMl9Isrg8eUQKFxYpVMj87NhRpE0b8z9pV9uzR6RYMRZwU/kpUJQwJJrXe9L46bmToZF5AW1HyQWv1157zdYY3H333XbwCjUavFLKfffJhZa3y9nDJ8Q6c07k1Cm5ePRfsQ4dFuvAIbH27pPMBXOKfWJ04ICcWbFGrEW/SPoTRyXdudOS5hL5mUhmOSvFZLcUWz1O5CGTptdKm05OSwbZKcVllVVTZh5uJeMPt5P1681ZVu3acbuxdq0ItmWU+6mk4gJTsqTIddeZ7aabRMqX998HRVGU6A2CP/74o3z++ed2oJs5c6a4AQ1eKSVdOkmfJ4e9ecMVK3Gc2fz6q8jSpSKrVqHfF0GIsnatpD16VDLLRSknm+2tg3wrn8sjcj5LLjlQqLJcOP6YyKn7qBnIoUPmrmRgu3aZbcmSuH/z3ntxweuvv0R69xYpV06kQgWRihXNz5w5U/zsFUXxga1bt0qzZnYNJkmYivHkk0/67fU9fvx4vHaghK1C3oIe4aGHHpLRo0cHf5kmGTR4BRvW9m65xWyeUD9evRrppciiRSIbNrAqi6JGMp4+JsW2LxHpv0TkzcdFbrhBWtSsKaeH1ZD9ze+XHf+klx07RLZvF/n7b7NuVr16/Czt+++v3BXWcitXFunZ88rdURTFfxQrVszOXhyYoIFC+t133429jpKcP6mUwEGI9qL+/fun+HFYE7vvvvukefPm4iY0eLkF0ndmkXnOI2N9bdYske++E1m82KRZZGk//2xvJPyF0jwihcqUkbp33SXy3HNmcSwBBLKPPxbBOYuNuLh3b1zG9vjjcbfl3/XqZe5Ts6bZ2KUc3iWaiqIkAmpo3IAcGAGF+MHzOn+zfv16O2g6+JJ1AfZ7BF56aR2RCOTPn98Ohk47U7DR4OVmkBvSt+b0rpGdbd0qMneuyPvvmxSL6zZvNnVCNvo+7rxT5I03kGLad2O82dNPx3/oI0f4cIv8+Wec2hFWrjSZGtuXX8bFVUqQrLG99BJndEF7BRQlIkuIR48elZqcGQaQHDlySE4/rA0w2NJTWTh+/HhbncjzuJpKPJBo8AoniCJEIrbu3c362ZAhIl9/baIQmRoSxKFDRUaNMkEPieJtt9HZHe+hUDI2aGA2T7p2Fbn+elPBZEmOYBYTE5e1Pf983G2nTDFJIMGPx0kk6VOUwMOBNRlbuICCMiuFyj9EDwglqnvW9j38VynRpWQifKBJ2EvnyPS5PpSTmjV4hTOc9bzwgtmwyWG9DGNiFBp04LPQxYYkEbUG6f1jj5nLSYAsHzm+I8kHHmrFCrN5Zl089JgxIh9+aC6XLi3SsKHZmCWK6jGK1cxKsCBwhSoD4AQyW7YU3WXVqlX2tHcyo4Qw4qlUqVISTEqXLm03HOPcQYaFMQQZFQ3JbsYVDhuhwieHjXCAt3TNGpFvvjEZ2IEDcX+jsbNlSxEWilOppZ82TQTV7C+/mDKj5yeJoIUikgwPTp5M8XdcURIFSzh8Da+77jrjrMOHK4yCV8uWLe0AkZyTRYpfg1Qc11AkJvSIJDNMyr2ENa+TJ0/Guh+FCs28IhEiR7VqZmPtC7UG5UXWy3DhnjrVbKRGb76JmaRPKZJnhnbsmJHqI5SklMiarhO4oHVrozVB1YhoqWnT+H9XFJ+hjJVMc21AuVxCS2nZsCcS30SCCGtJ33DSGURypnBdDFf7UAcu0OAV6VCT5ovCRhkAxcWkSabUgq7+/vuN0IOSYvv2pnnMBzhJa9XKbOB5IodIkpIj/5L4yZIclct69Yw9Fktyng3YipIiOPEKk7SerAhPwsTEGkzFiGbLq5QSPXbMimns+uorU2b5/HOTmVFywB6mUyejTiQtIsKkEs9lNeIhOhLKjD16mCZpghu92rSdJGw9OX5c3ywlMnGsmBITZCxbtkzqcUaneIUGr2iFYIWkkGzsrbeMVJCghmcZakaUUEQXP0FlAvHjwIFGor9zp8hnn4m0bWs2B67HlBgzAqqdNF4rSqRw8803y44dOxJ1qli6dKnUrVs3JPsVjmjwinb4Er38ssm2/u//4iT1f/xhNPCoFOkr8zPFixtZPv3XjzwSdz3rZSj+FywwlUyW5Yijr71mNCjRKy9SIgEUhtdiRJoIa9askWpUQxSv0OClxC08Dx5sFr4HDIhTU9AAfeutppFr06aAv1oPPiiyZYuR3zdubMqPxFFKi3yvWa5TlEgD0ffUqVNtMYTiHRq8lASfiLRG1HH4sKnrFWSoixgpIYtVlBuJLgGEfrFnn8XJ2vSYjR5tVI2IQjzt1Vi269NHMzIl/EGaXqVKlVDvRlihwUtJGup6+/YZw0OiByoLupIpJVatatbMglDVpKyIsp9d8VT1fvKJWa4jI+N7j+ofxyxFUSKftG5T4tC4h5TUGw4fPixz586VhQsXyhHM+pTAgJ6d6LF8uVkHY+EJOyoUU9hpBKkT31PFzy5gLIIfMdcjAnnlFZO1sYv0ZiuKErm4InjNmzdP6tevb48J6Nixo+2GfLX6cPfu3aVq1ary3nvvyauvvmqPFxilR6zAQjMWdhoffRTnaIDbPQvQNDqfOSPBbO3hX7IGRkZGaZEGaKqeiCRJFq8yAFtRlDDGFcGL0dMfffSRLEBi5gUEL1Q52KNg17948WJ555137O70nWitlcCCDBBLDWansMBMGvTtt2ZR6vLYhGDCv6W0OGeOSQI/+EDEc6YfVo9MhsBUeN26oO+eoiiRGrzuuusuueGGG7y+fdq0aeWJJ56I141+7733yoULF+RPyllK4CHFeecdkaNHRdq1M6kQ1lOsk2GZgUoxBDARhrFmKBUdiKtUoglqrI3Vr29ibKgchRRFiZDg5a/SI4qdhNNDPTl79qztH+ZsjMlW/CCxHz/eWE2hcycTmzHD2M/TaczUyxDTu7dZsmN9DLespUtNjC1aVOSJJxhzHuo9VBQlKoPX9u3b7WmerIMlN5l0wIABtlOysyUX6JQUUqKEmV5J5ovBodNpjCUV5cUErtXBhICFWJL1McqKJIyYiHDuQlbmaYunTdCKEh64aiSKY+WPehAbFW/YvXu3NG7cWCpUqCDff/99sk1+ZF5sDv/8848dwCJuJEqo4SOFJQbadUcpUaCAmTfWqJG4ZRfpI2PQ5sMPx11HuZGyImYjAZzQrqSC5MaBuBXmZfWhKTEZbrvtNmnjOUgvSCNRwpWwzrwIXE2aNJFy5crJhAkTrtqdnilTJtv+39kSGwan+AHWv7DEQAaIlB6YKUZkYD3s9GlX7GKTJnGBy7GmYqQLJvtI7ikzkjy65/ROCVeYgcXkZGf76aef7NYgz+sYUKmkAMtFxMTEcJiwFi5ceMXfli1bZs2cOTP28u7du61y5cpZrVu3ts6cOZOq/8dPJYDMmGFZuXMTA8yWJ49lrVjhupf8wgXLmjLFsm65JW5X2a6/3rJGjbKs06dDvYcKnD592lq/fr39M1y55pprrNdffz0gr0FMlBzXXJF5kf7SnIy3FyCZ57KncnDYsGHyPFrny+W/Zs2aydGjR+W+++6TSZMm2bdn26YWC+6DNTDGKnfpYlIeGsoZ/YANlQuyMId06UTuuMNI7mk17N7d6FEwBO7c2ZQZFSW1HDx40C7tJTbTSwmzYZT0Zk2ePNn+nUblTZs22Vv69Olj/b4YFZDnslnsuXPn5Prrr7d/n8kceg8KFSokpUqVCvpzULyQ1o8YIfLqqyZoMQId5QTdxa+/LtKtm6teQmwcP/3ULNux25QPMRpxmD5dpEIFU15UXAIjfZI7M/FcG0rutnxWnekKyd3WxwGYq1atsn9q8EolVhQTLem1K6E+lz9/XG2uTh3LOnLECgdOnLCsvHktK21ay2rXzpUV0IgmyZKZZ6034da6dfzbZs2a9G0bN45/W8/PqefmIwMGDLAKFSpkpYbTWjZ0R9lQiUKozy1bJuJkyfgmFipkJj27HCqgVD1R/zOPDNcssjLKiiruULzJvDTrSj0avJTQwaRJhmDSRUypBoeOhx4yzc1B9ElMKVg50ofNnDH6sqlIsU6GevGmmzCYDvUeRilYpiS1TZwY/7ZYriR12wRLEfY478RuF4DgxTr+iBEjbLu7v/A1U5JEg5cSelhYQiGBASGwwEQWFiKLKW9h2ZW+bHYTcQfu9pgCey6XKEGENaiktoT9YMndNuEbmNTtfABnH0RliQWvjRs32tcjoacHtWXLlnKAFhMlUTR4Ke6gfHmUO8avCf79lxVtkS++cH0tjgQScQcOWewuQg6HN94QmTLF9U9BCRIEJlbnEgtezz77rJQtW9YWptGHmjdvXvmD9F5JFA1einugdDhkiFkLo/5GaQa7eBqbw2BaAKbAVD0dyMj69TPNznXqmFKjBrHopnDhwnbbT2I2dgS2hg0b2o4ZbHfffbdURPaqJIoGL8V9cKRH/UA5kYDGGgSa9BCMW0ntFGhsHakwrVxpYjCDMr2c/KNEIOXLl5fHH3880b/RDvTbb7/JqVOnbPsn2oGKOaV05Qo0eCnuBBUEQo6xY42zLh6JzriVMJksmTcvZtCmnEh/PUspv/1m9CjNm4toP73iyfjx4+WBBx6wbevIvDAPV1zepKwoScK4ZGa9UUbEEp7aG2ejTHAuWzYsXjg8ifFLZM7YW2/hFmMyscs994piQ8BikrziHZp5KeExbmXHDpH774+TObMWMHy4hBOsiX3yicimTSahdIIX62Dvvy+yZ0+o91BRwgcNXkp4wNoXR3xspZgecPGiUSb+739hp4Jgrb5167jLP/wg8sILZsYYAg+d8KwoV0eDlxJetG9vFosQcBC0evQQodQSxkf8woXNDLFTp4zNI9VQ/BSJz4qiJI4GLyX8YMAeOvSBA42Yg3HIBLNZsyRcxZVLlphZnTyNvXtFHntMpEYNkfnzQ7137sVFc3SDjhXFz91Bg5cSnjBahazrp59Ecuc262CMXkGhGKZP5957jdHIRx+Zp7R2rciTT4aNuDJopEOJenm6RLRyijRd5KoDeCMZVRumkLlzRV5+2RxsWIbhJyf/fJ/4yWcpY0az4UjjbMyFYqPnJ3t28zNnzriNg5Wz8TiKl9A4RQBjYjOuHGjTf/nFpCxh+ELyuXnmGdPs/NprJh47T+P8eWbZmc9PNMOopKxZs9rWSRy80/JFjKKMi8C1f/9+yZ07d2wgj0bC79sdYg4fNjLnQEIwo0eIDZm1sxUsaCz/WCNBucZPro/iz2+cySBSPQIZdjo//yxSvLhxqqfEGIbQ4IwWxROUih98YGT3LPNx4hSNpEmTRooUKWIPsd2BCjUKyZ07t+3W4c+guGHDBsmSJYtch99ZIhA08VwsXry4LesPNWmYDSNRCtNMeSNiYmLkGi8PchwjcQ3nVWMkBj9ZWKe0w8bZMdUMzpCdjQyfgcHMtON3tAXHj5ufJAvHjuEm7ZvmgLNyPsO0PnG8xvGcn6jLUbXxE0l21BzoWCxC7eCkMUj5brlFwh0+a4xecRzrGzcWGTxYpHJliVouXboUlaVDss10yZyxpuS4xus3ePBg27KK2zdp0kR+4DvjwZo1a6RPnz7y008/2cN+efwuXbrIwIED7Sw4VGjmlULIeNgCAcGPIEZ2x3bwoJkdhbE0Szps+/aZBX2CKJe5D727bEuXJp3JMTaLEyrk2KjZ+FmunEjRohEW2D77zDQ0d+liziLuvluEKd1YWoQxVMYQdXz4oTH7pVJarZpZ9uvfXyRHDok6KBe6IQMIZw4dOmRnr0yy79+/v5xI5Ax65cqV8sQTT8iUKVPs13z9+vW2ByOZ3yuvvCKhQjOvFGZeboLARSDbvTsugMXEGA9bqimMISLYJQdrbwQzen5xQ+cnZ/MENxKXsGXNGpF77jHzwjhLRQXx1FMREal5b599VmTSJHOZrJsZnjffHOo9U8K1ogQdOnSwg1fCzCsxHnzwQdmzZ4/MD6Ec1jWZ148//ihDhw61Z9owjK02NZIA3CeSIGPns8lWt27it6FMSRDDX4/jOBsq8y1bTLsUpczVq82W8LGZUlKlikjVqmZZiTN9SpJhcfxnh//8U6RbN5ExY0Seflpk9GhjK4VyJoyhFPz998avmHjMyUr+/KHeKyVasCxL/vzzz5BPg3ZF8HrppZfk119/tUcAfPvtt4mmrv64TzTCcbpSJbMlhPU5Ahh2RRs3imzYYKTabKzJrVtnNtqoHFg/q17d9CDx2a1Vy5QfXSn4oqT0+efmyb/0klkwIvquWmUiQJiDEpH4jD6FkwwHLqNdCUOxpeJHjh8/bg+/dMiUKZO9pZZ3333XThi+ZBJrKLFcwIkTJ+yfMTExiEeshQsXBuQ+CXHuy08ljkuXLGvHDsuaPt2y3nnHsh54wLKqVrWs9OmRp1y5Zc9uWY0bW9bzz1vW+PGWtX27eQxX0bt33A5nzGhZPnxewoHff7esdOksq2ZN87sSfcRcPq4l3Pr165fs/dq3b2/ddtttyd7miy++sDJkyGCNGzfOCjWuODfL5sNIbV/uo3gHZUFUi2yeHnwoJ8nKSGBIXtgoN5L0IiBgS2h5hCE8WQAZWsLp6kGF2WCUEh94wAg5mjYVGTpUJInZSuEKa56IN3hvqKLjmYhfouoaoo/169fHmweW2qxr7Nix0rVrVxk9erS0x6YtxLgieAWLs2fP2ptnWq14D599yoVsnTvHiUYoOa5YYQYgs9FqhZAEkR8b0LzNwRQhIP3E/Az6SBC+cKhT+Of0LrAeRq0UMUeE0KaNeUos8X33ncjbbxthx6hR5iRCiR5y5MghOZEa+4FvvvlGOnfuLKNGjbJnjrkBN65UBIwBAwbYA96crVJiC0FKimBdhfWWRx4R+fRTE8Qos6OLoJkWwR+N1ayv/fqrue6OO0wTLmtnSL0JcEeOBOmFZ6EOBYvT4Ik/4jvvhJ0zfXLw1MaPN0GLto6//jLxOkyds5QA8+eff8rq1avl6NGj9hoZv6/Fm+wykyZNkoceekiefvppqVKliv13Nta9QomrpPKOxHPhwoVys5e635TcJ2HmRbc4ASxcpfLhAp8whCEENDYEBYhEEpYqCWa0YzFpmOwsoKJASof8E1JFwETw448jzq6Ek4KePY3QkqdHRqZENimVytOYfCTB2SP2W0toLBSRvn37ytSpU6+4H04cBLZQEVXBK6n7avAKPjRZL1pEu4PIwoWm9OgJPWZkC7feKtKihZHpB0SiT+bFiGO+BvXqiUyfbtLCCAO7R9YfHVUoJw8IL0O6DqkEhF1RclwLm7Lh66+/Lm3btg31bih+gnLWffeZUiNrNDRaM2vy0UfNQZXEaMECo3BnjQ0nEEqTlMNwIfEbuOCyOET9E4sSPLVohIswGjSIC1z09iGzR0QTaJ9ORYno4EVKWr16dWnBKbaIrWjhMg3IDjt37oxXY/XmPkp4BbP77zfCAhwkeKsxor39duMCggDkiy+M5oKG3EaN6DcxgS/VtQNmkZCBkdohnWQRj/pmhEKDOs3rvHYoQhmAqWNXlHDDFWXDw4cP28EpIXhnOc7JpMC4GpfH9sHL+1yNaEmvwx2WKSl74SgxY4aR63uClRUikDvvNBmGz8tW1PVRmOC0TJpCd3aEZvt4ZnbvbpJOIIhhMcUwTCW82RUlxzVXBK9QES1vcqSB1RVLU1iwsV7maSxOVkYQIwYh/EhxawtySRbbHGEP6R8eTBEI3/yvvxb5v/8zClHmhDGGhfJsWFiAKVF9XHNF2VBRUgLu+MSTWbOM8/6ECWZ4I31jXB45UuS228z8swcfNFJ82rq8gmY06mlOf8x//iMybFhEvkEEKFp28DCmDEvF1MnEFMXtaOYVBWco0QK9ZCgYMa1FwYsIxIGsgowMkQjLpFfNyJhJg70+i23UIZkRRkoSoVApRUpPMKMvz8nMNAMLP3Zp5qUo4QUuHrg+DRpkbJJoU0EFj3qRrAI1IwGMJdGuXUWY5sBBO1EYY019koDFjZBBYlcRoRCfea2cwAUYkDA7LMnXSFFCiGZemnlFPEwhRgWPzJ7NMyND5dixo8k4kORfkWmQfvTqJfL+++YyHkukd6600fcfCGRY+oMmTYyYg3YFxf3s0sxLUSID4gwNulgYkpHRGE1WQXJFszTTiel5Ym4Z8vt//vG4M9EMTyvHz410jo7pCNeWo9qkNYE2BUQxuJ/MmxfqvVKUOCL79FFREglkjRsbQ3kC15QpIu3amTUwZpe9+KJx06eJlyztzJnLdyT16NDB/M4QLYaYxf4xMnn4YdPEjBn/gQPG7QSHei0jKm5Ag5cStWBBRX8YQQpdxvDhJuOgzIiSkYZoSmX4AaLIk2++iZPNsx5WqpTRmEcwtFX+9puZHEMFlYZmmskVJdRo8FIUEcmdW+Sxx4yxBu5QffqIIEDFr5RWLyqFdeuKjKj2iZx9/rI9O6kbAQx9fgSD/yHdAiSfzAqLYNGlEkZo8FIUudKxA5Udk1Nw9cBkAyXj8uUmwOUf+qZMrPeOPZ7WtqqgxhgFs+FY9iPh5Ok6YOUVvTYHSijR4KUoycjHW7Y0jbuIONBtMMsS2X3bpb2ku3wqp9Jms105Lt1yq58dg92Jp+E+Y25QaLI2hleiogQTDV6K4gUFCog8/7wZ7IjbPSKPkem7S6NLP8phySNpl/4m+8vUlz0//hU1ryfDRVnyo5yImpOsTFGChQYvRUkBKOfpe0Lkgez+rv/WlvYFCWC5peChvyR3k+rybIt19tpZpJfTKCMin8eGC0ELzlo0fitKMNDgpSg+glPHK6+IzPznelnfe6xclLSSRc7I23NqypMNV0udOiYr8TQOjjSY/4qcnsCFoxZyevrpIj1wK6FHg5eipBLmWN70ZmtJN2eWWGnTSSY5J8ulrlgrV9iGwRgJ4yyVYNJ6xIAq8+efzdoXbQbYTI0eHeq9UiIdDV6K4i9uuUXSzJ9nKz0yynlZlvZGaZlvuW1H9fLLxmORwc0o9CJRTv/55ybroldOe8GUQKPBS1H8XUf76Sc7HUt36bzMOHajTO273LaeOnnSOLcz8JGMbO3ayFsPJDjz9DNnNteRiW3dGuo9UyIRDV6K4m9IPaijpU8vaS5ckDZftJM/pu2U2bPNgEzslVgLw3apTRuj2oskPCdZsyaILyKDQxUlYoPXtm3bZNasWXKYlV8v2bBhg/z444+yb9++gO6boqQItOOY+LLgtWOHpGnaRG6tGGOr8xjWjNSeTIWDOkb1KBhR6kWS0IH5asuWmb44bLhUyKFEXPBasmSJtGzZUho2bCitWrWSNbaRXPKcPHlSWrRoITfeeKO88MILUrJkSXk7guctKWEIckNqaFhI0dFLCrJ0qe1gj9R+40aRLl2MewdO982bm0CGq0ckBDGeF8/F8UVEyMFg6gg35FeiKXjt2LFDevToIb+moH7St29f2bRpk2zevFmWL18ukydPlpdfflkW02CjKG4BlQaRifkrVBQYkoXPlBhjegY0sybEQZ11IkxwW7cWqVdPZPr08A9iBDAc/BmHRqY5eLDIXXeZbExRQhq8Nm0y8344wfS1w75jx452xpU2BQP+xowZI126dJH8+fPbl8nCatSoIV8whEhR3BbAqA+iqSftYE1s1ap4f/7f/8z3p2dPo9wjvt1+uwliONyHcxAjaPG8sNkiQBOU6QdDzKEoQQ1eBCzOFBkZzsgERq8jsqI6wiwkZMG4DwRyUujBgwftYOUJl//4448k73f27Fn5999/Y7fjUWCmqrhoDeyyiMNeDKpfX2T16iuanslQMAR+4QWRrFlNEMMIl4SNk8Rw5t57zXPAkYPjR4QPo1YCTIo+PqikmG1Us6YI+oh33jFz+fbvN/OQ+C6++qqRAFeqJNK/f2B2+uhlA9S8lGI8yJcvnxxJphN0wIABkitXrtitEjupKMEMYBy9keMRwEir+AIlgIM7E53JxFgnIltB+8FJIutiS5eG71tGzGbkTMeOcdfpGliEs2GDyMCBZvHzvvtEunc3M3ZS2fCYouCFzQ3fO75ULDgz16dyZWNaShbGzCNGRlAhYX8DZbKdkSmCInL69Ol41586dSr2b4nBmtixY8dit/Xr1wdmBxUlKUihkBzyReILhaiDuWCJQBD74AOj9WAGJutHKBIJAHffLRKuH9+cOeN+p4GbloFp00K5R0pA4MPasKHJZBiKR0mBDIizF6aaUqqjNu5RQg9Y8KIWj9yVYOWNZQzBNhAUL15c0qVLJzEJapOUE1EdJkWmTJkkZ86csVsOJuspSrChxo4Mj7rZmTNGoZFMe0iRIua7z3f+0UfN3SZPFrvxmcuBLNEHGsbMcKJLMFZLqQjigw9EunY1PRK7dhlV0pw5IhMnmpM3Zgwht0V6e9ttZkE0haSq6hzMReR169bJL7/8Yv+eJUsWadSoka0wdCCTmjdvni25VxTXc8stZkGL9Ip6e4sWfIiTvUuJEiKjRplK4z33GMEDlkyoFl96KTzHiVEe7dTJnJB37mwuKxFAixZmfhCLt8WKJX4bhuO99po5K6Nsl1IsL9m927Juv92yGjSwrJUrzc8cOSxr4EAr1ezatcuaOXOm9eWXXxIOrXfeece+vHnz5tjbdOnSxapcuXLs5V9//dXKlCmT9dRTT1ljx461brrpJqtChQrWyZMnvf6/MTEx9v/jp6KEhLVrLStfPs4DLatgQcvas8fru/72m2U1amTuysbD/O9/lnXunBVWXLpkWS++GPc8+J3rFN+IcctxbdMmyzpzJmAP73XmRYmyaFFEDyJ33mkC67p1RpSRWtEea08DBw6Ur776ypa8L1iwwL78G00vl6lSpYrcxHrBZerXr2/3haEg/Pbbb6Vx48Z2ZpYViZaihAtVqphyCmtgKJ9YH/DSYQa9By1krBdxt0OHjKCKdegpU8JHXo+UHn8BJ+tCCMbaPtmYEsYMHmyCBh9KL4wnUoy3Ua5ZM8tasMD8XrOmZS1aZH6vVs2y1qyxwhLXnKEoyogRcalHgQKWdfx4il6T8+cta+hQk7w5D9OkiWWtXh1+L0PatJZVsaJlHT4c6r0JT2LcclyjivDWW5ZVpoz5QNaubT6kx44FN/NCpnt5yck+K0IXwZkRkvlkNBKKongDPlF0KsOBAyIVKhgxh5fQPtatm8iWLSK9eyNOMqp8WiG5nocMl5eBpWzW9PPkCfXeKKmCxkWaflnTokRAeYDeDxRISNVT6YbkdfBi3Q2V09mz5suAmhC5/JtviqhoT1H8AJ271OUBNRZf9hQ2QfFd5DuJkIuWGk55hw83og5iYzj0VOG0T7XJAUcOxskogWP37t0yfPhwmc6LnczyzsiRI2XChAm2yUOKaNxYBPcj2kI+/ND0eSCj5yQNeyZfsKIY16TXiuJJ795xtT9q9KlQL/z8s2VVrx73cFWqWNaPP4bPyz12rGWlSWNZDRta1r//hnpvIu+4duzYMeuee+6xihcvbl177bXWbbfdlujt3nzzTStbtmxW27ZtrTp16liFCxe21q9f7/tOrltnWS1bmg/lRx/59BA+SeX/+18dMKcoAYPUiSwMaODs1ctn9QUnt4xgwdAgXz4js6fNjEnHNAi7HSbKkE0uWuRVN4GSQi5evGh7yzKO6gYcYBLhzz//lFdeeUXGjh0r3333nS2kq1atmjzxxBMp+2co+z77zDjNoCrC7QJ1zoMP+vS++RS8yCzDpYauKGEJNT7s2AHDQwKajyBkZJ2athuceVD3ffONqdgw2dnNpUSOc6x/5c5thnbSHheO/WxuJU+ePNK2bVtJz6JpEhCwihYtKnfQcEzQSJtWunfvLj///LPsScIdJh54erLGxRoYo7YxxOU6atucmF02V08pao2pKG6FxWUsbQDTUJxtUwGZ16efmkysbl1zIsyxpHZtd/sl4qCF+IT9p68bR3oNYFcH43FPI3LainyBta4KFSpIGs56LlOxYsXYYcBJgvKGRmTWu+irwnWDYEdnPSWBVKLBS1HcDNGFdAm+/97YUKQSjLXJYiglouhjEAMZzpNPurcsxxxPrPI8A9ipU6HeK3dTqVKleEbkGJP7GgRzk/omyNggWeEGvV2MROADxptGmdHT2DKVaPBSFLczaJDxgAMMAJH+phKUw04p8eGHzZIaWRkn1MRIN4KDkBPAGjUyXqtK8hmTpxE5xuS+gB1fwvFRTtBK1hSib19T/sZ5GWj9IKD5abFVg5eiuB0izbJlRu/urIH5eBadEEy2UTATFKjwUNWhOolRLmp9NwYwTuQx9PWoYimJgPG4pxE5xuS+ULZsWVvQ4Ylzmb95Baac+HjyBtJjBZhT+yjW8Dl4YQLsjbO8oih+DGAMynNMTulEpoHLT2BCwElxnz6m4ZnlCtrMEIe5zWaKl8AJXJzMsxyofWCBA6HGli1bZBknUJf58ssvbcu+65CDXg3ONp5/XuTrr806roNTUkxu3czfwYsPS+nSPv0/RVF8hVl1NHdSNwPWEDh79RMMvXzjDaPOR9BBZYjSIgMwE5x4uwZKnuwzmaKPeoSoZ+TIkTJo0CDZvHmzbN++3f6dhmUHPGU7deokd955p/Tt21cefPBBGT9+vH07r5g1y8zuYXZXwlov5XAfnTa0bKgo4QQL3gQwmp9IiTgoMCvJjzAnjMnNGCFwrFmwwCxb4LPKGBY38eyzItmyicydK9KhgxlQraQMgtbGjRvtPq+bb77Z/v0vFkM9GD16tAwePNgeAFy+fHlZu3atbYbuFUhDc+Uyvyes9XKGRC+HL/jeIm1Zixdb1i23GL/FDh0s6513LGv2bMvat88KC9RhQwlbdu2yrKpVjUNBqVJmZlEA2LLFsho3jnPouPlmy9q2zXIV8+dbVqZMZv/uv9+yLlywopoYtzkHTZxoggTu0c89F+eosWqVZWXObFk+OnWkKvPCO436OCNSOEP79lszOLNQIZEyZVLzyIqiXHXhh1Eq1O+p6ZEa4VjgZ3h4Mi8qRAjL8FclM6Oq5Ja1MNbrJkwwxyKWVZjA4ZZ9U8QEiOzZTS2a5mQ+twg16tc3Py/3jKWUNEQwX+5IVz4f5hMnTCne83oap1mDa9fO3W/drl27pHjx4hITEyPX4DSsKOEGAQurndOnzQGCEiKqrgBAjKRKyfEHGFo+cmR8E91QMm6csb3iiMaAXpTa0cguNx7XWJAcOFBk6lQztw5neeq8rNsiRvIBnzMvznIYhhcTc+X1zNdze+BSlIgAtdfYsWYtgTNJvnwB6t4tVco4XbAWhuqadXiyMLIeN8CxkF41+mmbNQv13iixsBDJB+bFF81cLUakcAb0f/9nAhdTVH0gVWXDTz4x/qF796bmURRFSRVI7YYMMb9jOurDKBVv4ViDSOL3341QjKHPnKii+nODOwcn8ps2iTRoEOo9UWJhTDb2UIlBw95XX0nQgxdZFy7VnPzR+0WqzvjxnTtT86iKoqQY+mf4AsKOHSayBFAayDIFikT6wghoX35pLJy4LtR49qDSRkQDthJCKBHi57V9e/zr331X5PXXfT7TSFXwov6NqSeBlYVd3J85AytRQqR48ZQ91tKlS+1egpYtW8oLL7wgB65iW3/p0iX54osv5P7775fWrVvL66+/LicomyhKtMIiD6UYoOOYRakAwlo3PVaMK2GaOscm/Fb793eHUz0vATZSd90lsnJlqPcmiunaVeSBB8xIANa7gFEofHioPRNEfMFX9SOqxwwZLOvcufjXMzcPee3Uqd4/1qJFi6wMGTJYPXv2tCZMmGA1adLEKlu2rHXixIkk79O5c2eraNGi1ogRI6zJkydbt956q1W3bl3rPDsWrpJSRfEH99wTp20fNiwor+nRo5b10ENx/5bhkTt3WiHlzBnLatbM7E/Bgu6T+AeKGLce1x591ExG7dfPsnLkML1WqSBVfV70fGzYYKWaRo0a2RM6HY4fP25lz57d+iiJCZt79+6135yJ9A9c5uTJk1bOnDmtMWPGhP+brCippUcPc9ROm9b02QRx8jHHJf51njyW9f33Vkg5dixuknT58pZ16JAV8cS49bhGA96dd5oPyC+/pPrhfC4bUhZo00akSxdTYveVU6dOyeLFi2MHnUH27NmlefPmMod+gETYfzn1vPbaa2Ovw904f/78Mos0VFGiHeaAPfaYWfdq395MnQwCSNURczCD68gRkXvuEenRI3TWTRiSMDyXZQxMI9RGKkgwPJVmX8+NIZR4j6GMZX3JuZ75Xj6Q9PjMq3DunMgrr5j2Eta7WHOjB41F2xo1zH564/pBTwLrV8Ucw9HLcHkhutxEKFeunBQoUMD25KpVq5Y9JG3+/Pny999/S2GmdSYBw9g8B7IltPlXlIiBAwS6cfq+6DJmLhjfDQJZgOF4gF0dYg4M8JmKgUIaM3Hk9sGGPrQZM8wxCoU2a/VOd4ESIJo0ifPgvBrOuJ9gBS8alDn2czaDomf1avMT1dG+fWay81U0FzbniIKXZ8bEf/yssX9LCNb+48aNk4cfflhmzpwpefPmlTNnzkiTJk2SDUgMY3vNUWQpSqRD0+XEiUZNgY6dtAj7m5tvDvi/RsyBCpp/xUk2ggmGYHKSjYAi2ND+xpwyNCwcn2iFwxNRCRA33mi2AJIqtSGZFS0lHTsa8QgVO3q+2LCK8gZnIuehBI1qXHb+lhhNmza1Z8pMnz7ddkBes2aNnYEVQZaZBAxj8xzOxrA2RYlo6NjlrBLLeEqISJaT6rkJALTQcGLLpGbiJ2U7ZmmGwkCXxmWSUI5TGrgCTHITlv1x+0C5ynNyh9+YN1AeLFiwoKyiFurB8uXLpQb1x2TImDGjVK5cWWrXrm3L5JcsWWKvlSUFGZvncDaGtSlKxEPvyq+/mkyMqEF930/TbL2B9aaffjLNzUApkUASCnMDpPwZMsRdVoOFAIEMngXP5Br/Ll409Vzc6X1oVE5R8KKN6qabjEVMcrBPNCtzW2945JFHZMSIEbKPfF5Epk2bZlvuc73De++9J49SrL7M5MmTY7M1yotPPvmkvd7leRtFUS7DYjQHChZ6qJnh6xTEvkgCBrZSVDE5Z6Q3jDIia2GhAMEZ7kAM9lVThQAFL06SmOHFQudDD4n062fOXBBLMK6bKhmiIsx5sUYJ5JoXvp/du5v9YM2rdWvzAcQHlIoEI8QZtvnDD+bvCJ68oX///rJhwwYpU6aMPZmT+TIffvihPV/GgfkyZGMOZE516tSxFYYMUCtZsqTMnTvXVioqipIINImy6NSpk/F14kSP+r6Pxqi+wMk460+UD6nasyaGXyu91cEUUKDbIoAiXMb0HIGJlhL9vOj50kvG4p/PGAPXyGgoD+bNa6YgICjixfdMhVOCr81/X3xhWa1aWVbu3HGNifnzW9bdd1vWhAm+zdTZunWrtWTJEutQIs0YGzdutJYtWxbvurNnz1orVqywttAVHUn9EIoSSAYNsqx06cyX9tlnjbNAkDl+3LLat487dtC/evp0cPdh+3bLKlDA/P927ULyMgSEmCg5rvk8EsUTqhCcvLEmHE64cnSAogQDtOKUa4D6GXr2IMOR54MPjNk4lRt6wyZNMqPKggUZF+vzLAVS6ULeH+7sipLjml/qBZQIwy1wKUpUg9ccWnZnPIQPaw6phTLh888b9R+VJFYFCGBLlwZvH1iXHzzY/P7qqyIzZwbvfyupI3jFbkVR3AWRw2kQHTbMpB4hWoojcLEWxro54jP6RYMFmgFM+ckESUbdMNpFuToavBQlmvntN9PE7KQeX3wRkt1AkIaqmvV7xBQ0Nr/8ckCnusQD96wWLURGjxbJlSs4/zPiWbLETPoOEBq8FCWaofdr7VpTtwMUiCjDQgASelwwnHUnRi21bSty8mTg/zeDfikZelisKqkFPzAUhgFCg5eiRDu0lxDAsGijdkYPDMOwQgDCL6qXlA1RWyPgoLE4GD3VnlJ9er/434p7SVXwwnpwwgSRUaNMs6H63CpKmIJ7LU2aZGJ08JKChPALzdoTZghMRcalvl4943IVDKh00b/aoYPIihXB+Z9KkIMXDYfUpv/7X7PISq0Yh3tSfVJ+RVHCCBQTSP+YI8KcI77gSZhjBwN8XVEeVqiA/NsoA4Mx8YglQLI9njrHMvq5FR+ZNs1kN5yB+NnQMlXzvPggYbrJmQonadinYbrJ2dK8eX7dT0VRggGmg/PnG7sJvsTY6fBlDxHXXWfW/XHiwM0KtyGOhYEuHyLcYLQLMZyZhanvho1S1q0z9imkspSnUbci78RdA7EQM7WCHbyoLrDG6wiVKJeT2iM5HTJEg5eihC21axsTQsZGsOge4NEWV4PhErNnm1IivqkEEyYbBTKgYMaPqxHORZMnx/WCKSkEiyjOOshyhg41n6UNG0xnOvZ/qHRGjpSglw3xzf3uu9Q8gqIorgTdOGeiQBMWZoQhBPHGmDFGPg/9+5vdC2RSSJLg9HH37GmGACs+Zjo4IKNkpSEeWxOa6QhivKmYRAczeJ05IxITI/LUUwx5NOm1oigRBOkG0xuB9AOT1RBCOe+tt0zFCVXiZ5+JtGuXqsrTVeEpo11h/Uvn2PoR3kAWMxmQivu8Lw+Rmv9NSn3ttcbpnvIhU8ZbtRLp3dv0ayiKEuZMn24cwIGzZswIQwyTLaj40JtFTCVJPHo0sOtfHNO++SYw/yNi6dHDtF0ECL8Y8yIiYbwBUlZn27o1oM3VfiFaDCwVJVWQdqBeQPIH48aJtG8f8heVAZdkRUzZoCrFuhiDcKOdXVFyXPNLkzIZGB8eZPOcmCFScnvgUhQlBQtONDGjYgAUiC74gtOe8/PPJmBxwoyUfvv2wP5PBCMc4/75J7D/R7k66rChKMrVIXChGKOZk1IL6wMHD4b8leOkmfV/li22bDEBbOPGwP2/Z54xfsbM8wyW76KSOBq8FEXxjhIlTN9O8eKMNjdNV8EwHrwKGCMQwCpVMhlRo0aBc7dCoEZbEK1wCEeU0KHBS1EU72FSJO4ENF9hf0HkQHrsgt1iDYxe2AMHTFMzCn9/U768yLvvmt979RLZvNn//0MJw+C1e/duWb16tZygqc0L0Jrs3LlT/vjjDzmsHi6KEhxIcZzRKXv3mtqdC2po+fObjIje1yNHjFkI7hz+BsMIpi8j0ad8yDpYOLNnzx558803pVOnTvJ///d/Mm7cOLkYBk/KFcHr7Nmz0r59eyldurS0a9dOChUqJEOw6UiGP//8U66//nqpVauWPPzww7aqhsc444KzQEWJeNq0Me4JsGmTSJMm4paluTlzzO5gWYeMftEi//4P2oSQz2MOgSXe++9L2BITEyPVqlWTxYsXS9OmTe1jcI8ePaRr167ieiwX0KdPH6to0aLWrl277MsTJkyw0qRJYy1btizJ+zRo0MC69dZbrbNnz9qXt23bZuXMmdN6//33vf6/MTExtAnYPxVF8YH776fXxmz87hJOnrSs5s3NbmXNalkLF/r/f4waZR4/Rw7LOnLEcg0xKTiuDRkyxMqSJYt17ty52OuGDx9uZciQwTp//rzlZlyReY0cOdKO9MUoXIvIvffeK5UqVZJRyThw7tu3T+rWrSsZkfHaBp7XybXXXmtfryhKkBg71igk4Ouv47KxEJM1q8jUqSbzOnXK9MqyJuZPsMfDNgqxiNNFEG6ULVvWrnzRG+awdetW+3iaHlsnF5PeDetce/fulTp16sS7vl69evI7NvpJ0L9/f3nxxRelTJkyUqJECZkzZ44cP35cutN+ryhK8GDwFutgKBDfeUekcmXTCxZiUAXiwMFkF6YkE8DQmjDuxF/uG24uGR4/flz+pYP7MpkyZbI3T5o1ayYjRoyQm2++WSpXriyHDh2ybzMdZxWXE/LMyxFa5HXGkF8mX7589guZFC1atLAD3HPPPSdPP/20DB48WJ588kkp6djcJwJnGLyZzsabqyiKHxaB6AFz7C3+8x8WpV3xsmbObKzqbr3VZGC0pzE4NxDwEjCB2S1UqlRJcuXKFbsNwIQ2Afv375dBgwZJxYoVbb1B27Zt7cwL0YbbCXnmlQF7jsuBxZPTp0/H/i0xlWGrVq3sMiOZG2cK27dvl/r168v58+elN0ZkicCb95q6aypKYKIEwg2iAxI/DH1RM9AT5oJdIwPDSgr3H3ZxwQIz+cVfsMLx+OPmaTN/kaws1Kxfvz52KQYSZl3w/vvvy5EjR2Tp0qWxZUKCXps2baRjx462gMOthDzzwoMrbdq0dhDyhMuUAxODv61YsUK6desW+4aQcd1xxx0ymU9pErz88sty7Nix2I03V1EUP8EEZo7cFSuabuHq1Y3JqQughDhliun/clSIOF75C8ZUkYBSbUvmEBRUcuTIITlz5ozdEgteqA0JUJ7rW+XLl7cThH9c7oEV8uCVNWtWO2Oaxof+MqdOnZJ58+bZ9ViHbdu2yZrLbfOUGAl4CV9cglp+mj2SgDfP883kzVUUxY9Q/mdhiWjBkkCNGq6wkfIUcdSvb3ateXOzTOcPmO5B07IzRsXLVtWQU7t2bTvr+tvDq/Kbb76RzJkz22tgrsZyAQsWLLDSp09vvfLKK9b06dOtFi1aWCVLlrSOHTsWe5suXbpYlStXjr3ctWtXq0CBAtZnn31mzZ8/33rxxRdtef20adO8/r8qlVeUADFpkmWlSWO05IUKWdbp0655qQ8ftqzq1c2uFS9uWTt2+OdxT52yrFKlzOP27GmFjJgUSOVpNbrzzjut7Nmz28fdWrVq2S1HX375peV2/DISxR/8/PPP9sIhUveqVava61ZFixaNt15FY/JYpLnCBNULMnr0aJk9e7Yt7KDE+Nhjj0mDBg28/p/RMjpAUULCoEFGvAFlyxrHXGprLgALKVSHZF5YPtHIXKBA6h+XpJM1tXTpRFauNOYjwWaXD8e1LVu2yObNmyV79uy2+QMCD7fjmuAVCjR4KUqAQTzlqNxYGAqU1M8HmATPuS4/8URE8c+yXWphuvOECSY40lsWbPHGrig5KXfHaZCiKJHJW2/F9XyhQmzbVtwCQsi5c40n4qpVInffjeo59Y/74YciRYqYx3OB5WPEosFLUZTAMmaMccmFiRNRBLjmFadkSKkve3Yjn8c1I7UBh6DIUMxnnzXlQyUwaPBSFCXw4JZLZACs2LnsEmrVMo3MqMXpzcXyKbWLKZdd62yid2EmsGjwUhQl8CDUGDlSpEMHM4n5zjuNNbtLuOUWkc8/N78PHCjy0Uf+edwZM8x6mpucNyIFDV6KogTpaJPWzAGrV88MsOzSReSHH1zz6j/wgMh775nfn39eZNKk1D0eGReDK7GNevVVv+yi4oEGL0VRggf1NCwosmUzR/e77jITmV0CJUOGTbJrBLPU7BoqQycYfvmlyB9/+G03FQ1eiqIEncKFTRMUgYyJvYxU8ZfVRSoh4Hz8schtt5lJyczc9DCfSDEMy7jvPhMMX37Zn3uqaOalKEpoZH4//mjkeOfOGdXE3r2ueCcc4QbOVjQzY+ibmgEUb75pHpOxLPSSKf5Bg5eiKKHhhhtMCZF05+RJMwfMY/5UKEE6jw8i/VpMd7n/fpMk+kKZMiLdupnf8T/U3i//oMFLUZTQcfvtRoUIuOUio/c1SvgZzClwomekCrqS1AyJRrBBQFyxQmT+fH/uZfSiwUtRlNDy6KMin37KcD+TiT3xhGuao1izciT0TE1GeOELzOn84AMzMQY3eyX1aPBSFCX0dO9uFpqQ048YIdK+vbgFduWVV8zvDJxEa+IL3JdE0w2DKiMBDV6KoriDe+4RGT7c/P7dd2YssUtgADsKRNrT8Czcvz91j4cAxCXJZdiiwUtRFPdA4zLpCcyebRw5XAAJ4VdfiZQrZ1zokb9fuODbY+HgUbKkq/qzwxINXoqiuAsWhm66yfz+7bempOgCcuc2S3IILxh14pQSUwodAWhTyOY0+/IdDV6KorgPosP115vfhw51TYdvxYpxlozvvGPk9L64eGTNatbOtO/LdzR4KYriPqjTcXQvXdpcfvtts7kARpI984z5/eGHRbZtS9n9mdjsGOz7ywA4GtHgpSiKO8GWgg7hYsXM5X79XDOJmayLHutjx8zk5JQOsST4oTpk3cslzlhhR3pxCevWrZPhw4fLvn37pGrVqvKf//xHciYzk7tjx45yGvOxBNx6663yfzhrKooS/tAhvGGDGWa5fLlI69amy7d27ZDuFraM48eLVK9upjDTwJySLKpsWWM7RRM0Ao4hQwK5t5FJGssK/ZLhihUrpFGjRnL//ffLDTfcYAcxAtOyZcskMx/eRPjhhx/kgofcZ9u2bdKzZ08ZM2aMPOSMHb8Ku3btkuLFi0tMTIxcQzt9Ily6dEnO4b0WhWTIkEHS6ShYxQ2cOiXSqpXIzz8b5cSoUUazHmLInDDvdXQmjlDSG3gqjRub9S9EHDly+GefdnlxXIsEXBG8brnlFjtITePdF5EjR47YL/p7773ndRbVu3dvGTJkiOzevVuyZMnilzeZoPX333/bASxayZ07txQuXFjSaGelEmpojuJo//vvcTU3MrEQ8+yzJnvKl8+MPXGqnFeDIy+mvayhVajgv/3ZpcErOJw5c0ayZ88uI0aMkEecVUwhpb5DiKtOQEuOixcvyrXXXiv33HOPfPLJJ355k/nfO3fulPPnz0vRokUlLQvIUQTP/9SpU7J//347gBXBoVRRQs2OHUbyx5IB38k5c0xJMYSw3nXjjaZ82LSpyNy5ZtdCxa4oCV4hX/PiBSb48GJ7wuWfkMt6wcyZM+2M67HHHkv2dmfPnrU3h+PJzDmgJMnBm8CVlbw+CnEyWAJYwYIFtYSohJ4SJUzmVa2aiRotWpjRKk5fWAjIlMk4W7H+tWCByP/+F6dGTAlkYlrg8J6QpxNOMEkYIMjGyMq8YeTIkVK3bl253ukLSYIBAwZIrly5YrdKlSoleVsCKmRkZTaKcd4XMlBFcc0sMOzZnWGWTZqEfBozAowPPzS/I95AJOkt69ebkSv4EythFLwIIs46lyeHDh2SPHnyXPX+qBMRb1wt64KXX35Zjh07Frut51NzFaJ9rSfan7/iUqpUEfn1V+NEj3CLzAs1YgjBeJclOM7HH3zQe/k8t/vmG7MlOAwqbg5e1GTz5s0rf7DS6cHq1auvmkkB6kLEHh288EDLlCmTLb93thz+kvcoihJ8atYUWbTI9IMRwDAc3L07ZO8E53mMJnOEG//9r3f3Y2IzVVBEzQQwJUyCF2f2Dz74oF36c7KvBQsWyMqVK+NJ3gcPHiw9evS44v6jRo2ye74oMyqKEmXUq2fWvBAmbN9uSoh79oRsdwoXFhk2zPyOIQjLc97gaNWc2WFKGAQveOONN6RYsWJSvnx5u9/r9ttvl759+8rNN98ce5vff/9d5icYQbp48WLZuHGjVyVDRVEilAYNTAZ27bUimzaZBmakfyHi3nuN/J3luM6dWS+++n0eeMAkkFQ+160Lxl6GP64IXpTvfvzxR5k1a5a9LvXXX3/Ja1gue/DUU0/J/5DxeFCgQAFbSl+HcadK7BpghQoVZMmSJbZLSc2aNaV169byZ0pWkBUl3GDGCBkYxoGUDuvXN6KOEDFokEjevCx/iLz77tVvz247Dc6afYVR8HLKhxxoW7VqdYVsHqpXry5NaaLwgEyNLE2Jv1ZI8O/Vq5edxeJWglKwW7du+jIpkc1114l8/70IrjCkOzRfhUjEUaiQkczD668bRaE32RfMmhXYfYsUQt7nFS7Qg4FDTShAre6t6A/hC/1ZX375pVzHl9l2vn5YXkK/e5nvvvvObgXwRuSiKGEFqkMyMNa+nADG3JEQ9IEhf0eAMX26CEZB7EZy3+NGjYyBCD+15+vqaPDyEgJXqDQhJ06IZMvmffAie3UCF2zfvj3eZTJcVVoqEQuBCuNAogAqRNbOceJIULkJNAQqyoc0LuO3wCTm5GxXCxY0cVcJs7Kh4h8IXg1YwE5QSqyGFvcypUuXth0zFCViYV4JfWBOI/MttxhRRwiW4vr2Nb8//7z2cfkTDV4pKN2RAYVi89adCrcS1rtq0DiSTPDq1KlTouNkFCWiQHXImhf+TZhr33OPUVAEmeeeM3aM+/eL9Olz9dsfPuyasWWuRoNXCkoAlO5CsXm73sVMNDwZEbc4/Pvvv7YzvnPdyZMnZenSpV477ytKWIPRAWoJTugOHjRrYb/9FtRdIPn79FPz+9Chyav4//7bNDnjNZzSAZepgT5bxlGVKFHCXgvHc9btaPCKsJJhyZIl49lqcR1KTgZ8OrPTatWqFcK9VJQgU6qUUUsg3jh61KyJeaNf9yMsu3XsaIQYPXuan0mVGZHNE7hWrgzOvr344ov29txzz9ktNsxVfDfIr48vaPCKIBgjk9CJn4yLUqKTaTHgsx6uBIoSTeChimijTBmzBvbiiyK9egV1FwYMMBVMRBlJTXqiyuIsWQejdLhu3Tp7biItNe3atbPNIjiOJOypdSMavCKIfPny2XPNPEFVWIYv7GUoGeLAryhRBzV40pmiRc3l996L82UK0jQX1r8c8UZSA9odVf/ixYHfp++//942R7/zzjvDzpBbg1eUgYOJlg2VqCVnTpGtW0XKlTOXv/hC5NZbjaAjCNBuidB382az/pUYnplXaubcHz9+3F7zdjbPWYYOmzZtskdD4R2LM0+5cuVsT9kdDP10ORq8ogwCVwbGSChKtJI5s8iGDcZCChh9jKApqVTIjxA7cdwAHPCOHUvcLJ9dPHRI5K+/fP9flSpVije/kHmGCcGsYPny5fZyw+TJk+1M7MCBA9KsWTNb3OVmNHgpihJ9pE1r+sDuustcXruWRWORILSQdOkiUqGCkcR/8kni6kSnsp+a0uH69evjzS+k6pIQ+j2xj0NtSOZVpUoVGTp0qGzdutUWb7gZDV6KokQvkybh+m38EGfPFmne3EjqAwju8U7j8gcfJJ59PfOMyOjRIq1a+f5/cuTIEW9+IfMME4I8Pm3atPH+Fi7T0zV4KYoS3ZD+zJtnFIlkG9Tt8HQKIMzNpHEZ5f7HH1/597vvNlqSYsUCuhuCUIP2mldeecUOVmfOnJE+ffpIoUKF5EZaC1yMBi9FURQasVBIFCkiQoMuGVhiNT0/QaLnZF8ffmiCWCjInDmzzJw5026hYaAvPaKUG2fMmCG5c+cWN6PBS1EUBSpXFpkxw0jqkfk9/bRIAAfdtmuHqMKUDRPLvoJFuXLlZNGiRfa6GArFX375xTbvdjsavBRFURxQHW7fLnLNNebyiBEiDLsNgBKR7KtfP/M7wStUI5c8s7D0LMiFCRq8FEVRPMmf35gMNmxoLjORmcZmrvMz995rLKGOHBH5+mt9G8I2eJGyMnsqpSqXvXv3ytFQFY0VRYk8yECYCfbss+YyTVd4gq5Z4/fs68knze8ssaWmKTnacEXwwgmdMfX58+e3rYtQuowdO/aq91uwYIFUrFjRbsarXLmy7YZM3VZRFMUvoKb49lszl4j0iMZmpkr6kc6dRbAeJS6GYORY2OKK4PX222/LpEmTZO3atbJ//355//337ZlTa5I5y1m5cqU9MfjRRx+VgwcPyj///GMbSzL+I5o5ceKEPPPMM7J7926ZPn269O7d2zbZdHu3vKK4FnTtO3eKtGhhmpgZh4wBoZ+qPXnzijz4oPk9gALHiMMVwWvYsGHStWtXW/UCnTt3ts1kP/vssyTv8+qrr9ru6L169bKb7ODee++NN8sqGiHgf/zxx/LII4/YVi80HOIa3YW2fkVRfIMhW9Onx+nbHVk96kQ/8J//xPVMh8EoLVcQcmkJ61W7du2S+o7PmEfnN9lVYrAmRskQry5KjmRdhQsXTrSD3N8kl8BQv8aTzJvbEm8950EmdVtUuynBmd/Vo0cPue222+zrihYtKn2dL52iKL7BFxxDQvybXn1V5MwZEb5jnTqJjBplvtQ+wri9xo1FmGiEYe+bb+qb5PrM6xALobbAJ3+867lMOTAxuB6HZIIW3eENGza07U8YooboIym4j6fLcnK3TYrs2ZPeUA55gnt0UrdNaPuC4iix26UUgleDBg1iAxfwXBO+voqi+EifPmYcsjP0FWd6rDDWrUvVS/rEE3HZlxIGwSsdZzNCG8W5KwJNUj0HTpnw66+/tpvrdu7cKZs3b5bFixfLS8wcSAIyNU+XZYQekQbBC0doT1avXi3XMw5dURT/wPLE3r1xZ6H8TvpEZuYjTGZhjBaG97t36xvl+uDF5E7KXHv27LminHiN0yiYALIIGurat28v1113nX0dQxgfeOABmct4gyTAVdnTZRkblJRy4kTS28SJ8W+7f3/St505M/5t6YtM7HYpwbIsW/RSo0aNK4JXtWrVYi9funTJtn/55JNPkizNKopyFSgfsuaFGpH1AnTu/fubEkyC45m3wg3U+DB/vr76rg9eOB8zY2rWrFmx15GFzZs3T27Gb8wjmDlKQrI1/naYmQIJSpBkVEnBmpinyzL/O6WwBpXU5rnedbXbeq53JXfblLBlyxZbVegZvFgf3LBhQ6yQ5dSpU9KoUSN77AHXt23b1vWjDxTF9WrEfftEHnjA9Id9/73xfcIaPoXOHE7RRINXGAQveO211+y+rg8++MA+kLJ2RWb1hFMEFrFdj9u0aRN7uX///jJx4kQ7e1i1apUMGTJEvvjiC/mPI9uJQigZ5s2b185CHdatW2efDDiZ18CBA+2sE8doble7dm1b/KIoSiqnTNL/hRsH6ZNjF4+57aefev0w+AEDJvfasBwGwat169b2FM/Zs2dL9+7d7cDF+hUHYociRYpIqVKlYi8jk+f2ZGhI63FG/u677+Thhx+WaIUSKuO8PSG7/PTTT2MFG7/++qsdsHAkYStdunS8DFdRlFTASeJvv5mJkyxg0ReGhQb2UlOnXvXuDRpQIRL55x+RTZv0nUiONBYLJVEKEv3ixYtLTEzMFetrzLWhTElAIJhGCmSs8+fPl1tvvVUyZMhgT1Il+CdFpL4OihJwUF4wmOuvv+KuK11a5H//44w9ybs1bSqycKHIoEFx1lH+Oq5FEq7IvJTgQXM3PWCshZF5RfG5i6IEFqZNbtwoMmWKaWiGrVtNb9hdd4ksXpxobdApHeq6V/Jo5hVlmVdK0ddBUfzEyJEs3htZvUPZsmbj+htusK9autRYKLJcRqvr5W4ir9mlmZeiKIriN1gHQ0JPM3PXrkZOvHmzkdvfeKORK9euLXXG/EcezzxGchzdYfdCK4mjZUNFUZRggowe31YCGSNXUCrC2bM4jkvaTwfJsDOdZKeUlAxPBm6Sc7ijwUtRFCUU0GfKyBXGOG3ZIvL00yLly9vB7FIac2iOuVhU3xu3GvO6nWgXNET781eUoIAKkb6wyxw7InLh8L/SJt8lfQOSQIOXF56LWRLaYUQROHIAsnpFUYKD7fmb53I5UUkUDV5JgCkws7AOHDhgH7gdM+BoyrgIXAwHzZ07d2wwVxRFcQMavJIAs2BcPZDL79ixQ6IVAhez0hRFUdyEBq9kyJgxo5QtW/aKcS3RAhmnZlyKorgRDV5XgXJhNDcpK4qiuJHoWshRFEVRIgINXoqiKErYEdVlQyYKQ8IpzoqiKOHKnsvHM+f4FqlEdfDax/RTEalbt26od0VRFMXvx7drPQbTRhpR7Sp/4cIF+f3336VQoUJe93EdP35cKlWqJOvXr7cHPUYikf4cI/35RcNzjPTnl5rneOnSJTtw1ahRw+5XjVSiOnj5wr///iu5cuWSY8eOSU7HUDPCiPTnGOnPLxqeY6Q/v2h5jqlBBRuKoihK2KHBS1EURQk7NHilkEyZMkm/fv3sn5FKpD/HSH9+0fAcI/35RctzTA265qUoiqKEHZp5KYqiKGGHBi9FURQl7NDgpSiKooQdGrwSgREoNC9v3LgxoPcJJdu3b5cVK1bIiRMnvG7oplly69atcvHiRXE7PC+eH88zpXC/3377TdzOX3/9JatWrUrRyB4GjPI5ddxl3MyhQ4dk+fLlsnfv3hRZI61cuTJsZvCtWbPGfo7ewneP+6xduzbi7Z+uCk3KShzz5s2zChQoYF133XVWvnz5rGrVqlk7d+70+31CxYkTJ6xWrVpZ2bJls8qXL29lzZrVGjFiRJK3v3DhgtW3b1/7+VWqVMkqXry4VbJkSWvu3LmWWxk9enTs8+NnixYtrOPHj3t132+//dZKmzatlStXLsut7Nq1y6pRo4aVN29e+zOXP39+a/bs2Ve934ABA6zs2bNbVapUsUqVKmU99thj9vvrRvjMZcqUyf7M8bNLly7WxYsXk7z94cOHrWbNmlk5cuSwatWqZb82NWvWtP7++2/LjQwbNsyqWrWqlTt3bqtYsWJe3WfVqlVWiRIl7NsXLlzYKl26tLV27VorWtHg5cGRI0esPHnyWL1797Yvnz171mrYsKHVpEkTv94nlDz11FP2gevAgQP25S+//NI+WCf1JeCg/9prr1lHjx61L1+6dMl6/vnnrZw5c9rP3W2sW7fOSpcunTVmzBj78sGDB+0veffu3a96323bttkHhieffNLVwat58+b2Z+zMmTP25T59+tj7e+jQoSTvM3DgQDuQ//LLL7HXjRw50jp16pTlNiZPnmxlyJAhdl83btxoP7+PP/44yfs899xz9omV8xrwvAhe9957r+VGXnjhBeuPP/6wTyi8CV7nzp2zv7edOnWK/R62a9fOqlChQrJBPZLR4OXBqFGjrIwZM1rHjh2Lve6HH37APivJMzhf7hMqzp8/bwed999/P971nL337NnT68fZsmWL/fx++ukny2306tXLzgw94fmScXAASO61qVevnp2FfvTRR64NXmT0vPZ8xhz47JGdfPbZZ4nehxMqKgLOCZbbueOOO6yWLVvGu65r1652RSMpHnroITuoe0K21qhRI8vNeBu85syZY7/vfPccVq9ebV+3aNEiKxrRNS8PWAsoW7ZsPB8xx3Gev/nrPqFi27Zttl9arVq14l1fp06dFO0rNfo0adJIqVKlxG3wPBI+P94P1sC2bNmS5P369OkjRYsWlS5duoibcd4nz+fIZ698+fJJvod//PGHvX7Upk0b2b9/v71OduTIEXErSb2Hf/75p5w/fz7R+zz33HOybt06eeutt2T+/PnyySefyA8//CB9+/aVSIDXBJ/D0qVLx15XrVo1yZgxo+uOM8Eici2HfeDw4cOSL1++eNflzZs39m/+uk+ocPYn4f5yedOmTV49xu7du+0DxaOPPirXXHONuA2e43XXXRfvOuf5JvV+zJkzR8aOHWsf5N1Ocu9hUs+P9wzGjRtnb4ULF7bFHg8//LAMGTLE64kKwSKx7xSXEStw8pXwb4D7+kMPPSTvvvuufYD/+++/5a677oqYcUeJvSZXe98jHXd9akNMhgwZ5MyZM/Gucy5zhuOv+4QK9hUS7u/p06e92teDBw9KixYt7LP8QYMGiRtJ7P3g+UFiz5EzeQ7iXbt2lQ0bNsjixYvtAx8HSn53myrPl/fQuQ/PD/Xl6tWr7ez5q6++soNXuL+H0KNHD5k8ebKdXaM2jImJsZWxHTt2lEggsdckJd/dSESDlwclSpSQf/75J94L5FxOaqibL/cJFewrJLa/V9tXyk7Nmze3s0rKMVmyZBE3ktL3gxaAMmXKyLx58+Sll16yt2nTptkHBX5PiYzZre9hyZIl7Z+PPPKIZM6c2f69SpUqctNNN8miRYskXN7D3LlzJznXis9khw4dJH/+/PblbNmy2c935syZSZYawwleE04ePdsiTp48aY9LcdtxJlho8PLglltusb8krAk4TJkyxV5TqFevXuzBjjPyAwcOeH0ft8AXu3r16jJ16tTY61j7+Pnnn+3n4UBJiV4SB8oSBC5q7jNmzLAPDG6F58H747mmw/tRtWpVe+goUHriNqyDEYT53XN7+umnJXv27Pbvt99+u7gJ1id5HzzfQ9Y8yDQ830Oyq82bN9u/V6xY0T7AJRYQChQoIG6D58HnzLOfkPfQ8/mREfP+OL1OPI9du3bFexxeEwKek3mGG0uWLIl9Ts2aNbOD8KxZs2L/PnXqVLvk27RpU4lKQq0YcRtt2rSxypUrZ/f7DB482MqSJYv14Ycfxv4diTkvGxJzb+/jJmbMmGFLyfv162dLkpFc00tz+vTp2Nu0b9/eVt55So5RRM2aNctWNjmbI7d3E8jH6WO66aabrEmTJln9+/e3n++0adNib8O+8x4uX7480cdws9oQkIzzGfvkk0+s8ePH2/1srVu3jncblHmOrBrGjRtn9xTx+eR97Ny5sy2d37Bhg+U2du/ebRUsWNBq27atNXXqVKtbt252P6JnOwfKSt5Dp3+P3j7eZ95vlHl8/1CY8jl3IzwXPodPPPGE3UPpfKc8v4coSFEjOtDuQX8XbSCjR4+2FaS0CEQrKthIwPjx4+Wjjz6SESNG2GflI0eOjFc35yyuQYMGUrBgQa/v4yZatWolc+fOlaFDh9pnrmSHL774Ymw5CSpUqGCf3QNlCZ4Tpaf//ve/8R7rtddes88I3QTjI3766Sd5++23bcUZC9qzZ8+Ot588N97DpEpQxYoVkxtuuEHcCpkhWeQ333xjO2YgVEBE4wkj4FHBOrRv317y5MljfzZZG2LdEoGKp3rNLRQpUsR2OEF8wfeKrJEshFKnA6IT3sN06dLZlykR8r4hvOFzzfdz1KhR0rZtW3EjvA9OSbpcuXJ2iRq+/fZb+3kAz6948eKx9+HzjDDl66+/ttW+b7zxhjz++OMSrehIFEVRFCXs0DUvRVEUJezQ4KUoiqKEHRq8FEVRlLBDg5eiKIoSdmjwUhRFUcIODV6KoihK2KHBS1EURQk7NHgpiqIoYYcGL0XxI7/88ovtfuDPTVGUK1F7KEXxE5jEYmvEhHJFUQKLZl6K4ifw36tfv76+nooSBDR4KYqfIOtys6GvokQSGrwUxY9lQ+YrefL666/L2rVr7d9xOcfhHhiSiLO4oii+ocFLUfwA4+cZbZFw+nS/fv1ihyoyUmbPnj3278OGDbOHSCqK4hsavBTFD8yZMyfepF9gujbzxSpXrmxPdt6+fbs9ZwtWrlwpNWvW1NdeUXxEg5ei+MDBgwfjXT558qRky5btiuDFAEUGmJJlEcgYJsh9Ge/uBLIWLVrYGZpnIKTcqChK0mjwUpQUMmjQIOnQoUPsZbIqJjYnhIDlZFeegYysK2PGjPblffv2yYYNG2TcuHGx5cUFCxZIzpw59X1RlGTQ4KUoKeSpp56SEydOyNGjR2PFF61atbridps3b44d6e4ZyGbNmiXNmjWzAxmj4OvVqyc33nijHbRgxYoVUrt2bX1fFCUZNHgpig/cfvvtMn36dPt3RBhFihS54jZ58uSR+fPny+nTp+3MizLhvHnzZPjw4dKjR494gapdu3Yyfvx4+7o//vgjtqSoKEriaPBSFB+48847ZcqUKXL+/Hl7LSsx3n77bdm5c6cUKlRINm3aJL1795bOnTvbEnnWuTyDV/PmzWXhwoWyceNG+/YJ188URYlPGku9bBTFJ6pXry5vvfWWXHPNNXL99dcn2fs1evRo6datmyxbtszOqDz9CosWLSrr16+X3LlzS6dOnew+Mb6Sn3/+ub4ripIMmnkpio80bdpUBg8enGTgsr9gadPaZcMKFSrYa16egQvFYdasWe3ABZQOx4wZo+tdiuIFasyrKKkoHU6cOPGqt2O9K7GeLtbEZsyYEXuZUuLSpUulbNmy+p4oylXQsqGi+AjSdsQalA2Tg3UxMq706fVcUVH8hQYvRVEUJezQNS9FURQl7NDgpSiKooQdGrwURVGUsEODl6IoihJ2aPBSFEVRwg4NXoqiKErYocFLURRFCTs0eCmKoihhhwYvRVEURcKN/wfPHN/IOwbekQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pc.single_point(n_G_frac=0.85, Ti_av=8.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting against different axes\n", + "\n", + "Either axis takes any density or temperature label, so the same solve can be\n", + "drawn with the density on x. The seven names are listed in\n", + "`openpopcon.PLOT_AXES` and in the plotsettings file." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:38.303295Z", + "iopub.status.busy": "2026-08-04T20:20:38.303178Z", + "iopub.status.idle": "2026-08-04T20:20:38.459152Z", + "shell.execute_reply": "2026-08-04T20:20:38.457143Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['T_e_av', 'T_e_ax', 'T_i_av', 'T_i_ax', 'n20_av', 'n20_ax', 'nG']\n", + "Plotting Paux with levels [ 10. 20. 50. 73. 100. 200. 500.] and options ['r', 3, '$P_{aux}$', 12, '%.2d']\n", + "Plotting Pfusion with levels [ 50. 100. 200. 500. 1000. 2000.] and options ['k', 2, '$P_{fus}$', 12, '%.2d']\n", + "Plotting Prad with levels [ 10. 50. 100. 200.] and options ['purple', 2, '$P_{rad}$', 12, '%.2d']\n", + "Plotting Q with levels [ 1. 2. 5. 10. 20. 50. 100.] and options ['orange', 2, '$Q$', 12, '%.f']\n", + "Plotting H98 with levels [0.99 0.995 1. 1.005 1.01 ] and options ['blue', 2, '$H_{98y2}$', 12, '%.1f']\n", + "Plotting betaN with levels [1. 1.8 2.5 3. ] and options ['forestgreen', 2, '$\\\\beta_N$', 12, '%.2f']\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(sorted(op.PLOT_AXES))\n", + "\n", + "pc.plotsettings.xax = \"nG\"\n", + "pc.plotsettings.yax = \"T_i_av\"\n", + "fig, ax = pc.plot()\n", + "\n", + "pc.plotsettings.xax = \"T_i_av\"\n", + "pc.plotsettings.yax = \"nG\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Scanning the current and the confinement factor\n", + "\n", + "`POPCON_scan` runs a full POPCON at every combination of two machine\n", + "parameters. The ranges below come from the `scan:` block at the bottom of the\n", + "settings file; passing `scan=` to the constructor overrides it." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:38.460734Z", + "iopub.status.busy": "2026-08-04T20:20:38.460623Z", + "iopub.status.idle": "2026-08-04T20:20:45.817315Z", + "shell.execute_reply": "2026-08-04T20:20:45.816870Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Impurity fractions = [0.025 0.0079697 0. 0. 0. 0. ] calculated from Zeff_target.\n", + " [1/9] I_P=10, H_fac=0.8 2500/2500 points solved (0.6 s)\n", + " [2/9] I_P=10, H_fac=1 2400/2500 points solved (0.6 s)\n", + " [3/9] I_P=10, H_fac=1.2 2300/2500 points solved (0.6 s)\n", + " [4/9] I_P=13.5, H_fac=0.8 2350/2500 points solved (0.9 s)\n", + " [5/9] I_P=13.5, H_fac=1 2218/2500 points solved (0.7 s)\n", + " [6/9] I_P=13.5, H_fac=1.2 2088/2500 points solved (0.8 s)\n", + " [7/9] I_P=17, H_fac=0.8 2220/2500 points solved (0.7 s)\n", + " [8/9] I_P=17, H_fac=1 2052/2500 points solved (0.9 s)\n", + " [9/9] I_P=17, H_fac=1.2 1873/2500 points solved (1.7 s)\n" + ] + } + ], + "source": [ + "sc = op.POPCON_scan(settingsfile=settingsfile, plotsettingsfile=plotsettingsfile)\n", + "sc.run_scan()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:45.818857Z", + "iopub.status.busy": "2026-08-04T20:20:45.818757Z", + "iopub.status.idle": "2026-08-04T20:20:46.578488Z", + "shell.execute_reply": "2026-08-04T20:20:46.577958Z" + } + }, + "outputs": [], + "source": [ + "fig, axs = sc.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`plot_metric` reduces each cell to one number so the trend across the scan\n", + "reads at a glance. Anything in the output works, with any reduction." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:46.582063Z", + "iopub.status.busy": "2026-08-04T20:20:46.581964Z", + "iopub.status.idle": "2026-08-04T20:20:46.677067Z", + "shell.execute_reply": "2026-08-04T20:20:46.676557Z" + } + }, + "outputs": [], + "source": [ + "fig, ax = sc.plot_metric(\"Pfusion\", reduce=\"max\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The whole scan is also available as one xarray Dataset, with the two scanned\n", + "parameters as extra dimensions, for any analysis the plots do not cover." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-04T20:20:46.678566Z", + "iopub.status.busy": "2026-08-04T20:20:46.678461Z", + "iopub.status.idle": "2026-08-04T20:20:46.721743Z", + "shell.execute_reply": "2026-08-04T20:20:46.721190Z" + } + }, + "outputs": [], + "source": [ + "sc.output" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "openpopcon (3.12.7)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/openpopcon/resources/examples/ITER/POPCON_input_example.yaml b/openpopcon/resources/examples/ITER/POPCON_input_example.yaml new file mode 100644 index 0000000..7cf20e6 --- /dev/null +++ b/openpopcon/resources/examples/ITER/POPCON_input_example.yaml @@ -0,0 +1,137 @@ +#----------------------------------------------------------------------- +# OpenPOPCON input file: ITER +# +# The ITER baseline inductive scenario (Q = 10, 500 MW, 400 s burn). +# Geometry and engineering parameters from the ITER Physics Basis and +# Progress in the ITER Physics Basis, Nucl. Fusion 39 (1999) 2175 and +# Nucl. Fusion 47 (2007) -- reference [7] in the repository README. +# +# Parabolic profiles rather than a gEQDSK, deliberately: it keeps R, a, +# kappa, delta and I_P available to POPCON_scan, which the gEQDSK path +# overrides. +#----------------------------------------------------------------------- + +name: "ITER" + +#---------------------- +# Machine parameters +#---------------------- + +R: 6.2 # major radius, m +a: 2.0 # minor radius, m +kappa: 1.7 # elongation (95% flux surface) +delta: 0.33 # triangularity (95% flux surface) + +I_P: 15. # plasma current, MA +B_0: 5.3 # on-axis toroidal field, T + +tipeak_over_tepeak: 1.0 # Ti and Te are close to equilibrated at n_G ~ 0.85 + +#---------------------- +# Plasma composition +#---------------------- + +fuel: 2 # 1 D-D, 2 D-T, 3 D-He3 + +# He, Ne, Ar, Kr, Xe, W +impurityfractions: [0.025, 0., 0., 0., 0., 0.] + +# ITER's real mix is beryllium and tungsten, but the impurity list above has +# no beryllium. Neon is used as the low-Z carrier to reach the design Zeff, +# in the same way the SPARC example uses argon. Tungsten would nominally +# match the divertor, but Lz(W) is large enough that the implied trace +# fraction makes P_imprad extremely sensitive. +Zeff_target: 1.65 +impurity: 1 # 0 He, 1 Ne, 2 Ar, 3 Kr, 4 Xe, 5 W + +#---------------------- +# Confinement +#---------------------- + +scalinglaw: "H98y2" +H_fac: 1.0 # the baseline scenario is defined at H98(y,2) = 1 + +nr: 100 # number of radial points + +#---------------------- +# Profiles +#---------------------- + +gfilename: "" +profsfilename: "" + +# f(rho) = (1 - offset) * (1 - rho^alpha1)^alpha2 + offset +# +# ITER's H-mode density profile is nearly flat inside the pedestal. These +# shapes give a density peaking of 1.26 and a temperature peaking of 1.66, +# i.e. Ti(0) = 14.1 keV at = 8.5 keV, which puts the fusion power at +# the design point at 481 MW against the nominal 500 MW. Peaking is what +# the fusion power is most sensitive to, since it goes as the volume +# integral of n^2 (T). +j_alpha1: 2. +j_alpha2: 3. +j_offset: 0.01 + +ne_alpha1: 2. +ne_alpha2: 0.7 +ne_offset: 0.5 + +ni_alpha1: 2. +ni_alpha2: 0.7 +ni_offset: 0.5 + +Ti_alpha1: 2. +Ti_alpha2: 1.6 +Ti_offset: 0.35 + +Te_alpha1: 2. +Te_alpha2: 1.6 +Te_offset: 0.35 + +#---------------------- +# Algorithm settings +#---------------------- + +Nn: 50 # number of density points +NTi: 50 # number of temperature points + +# n_G = Ip / (pi a^2) = 1.19e20 m^-3; the baseline sits near 0.85 +nmax_frac: 1.0 +nmin_frac: 0.2 + +# the baseline burns at a volume-averaged T of roughly 8-9 keV +Tmax_keV: 20. +Tmin_keV: 3. + +resistivity_model: "Jardin" # Jardin, Paz-Soldan, or maximum + +verbosity: 1 +parallel: True + +#---------------------- +# Scan (used by POPCON_scan; ignored by a plain POPCON) +#---------------------- + +scan: + rows: + parameter: I_P + min: 10. + max: 17. + N: 3 + cols: + parameter: H_fac + values: [0.8, 1.0, 1.2] + +#----------------------------------------------------------------------- +# A note on agreement with the design point +# +# The machine is the ITER baseline exactly, and the profile shapes above +# put the fusion power at the design point near the nominal 500 MW. +# +# Q comes out higher than the nominal 10. That is expected and not a +# mistake: ITER's Q = 10 point is chosen with 50 MW of external heating +# for burn control and operational margin, not because 50 MW is the +# minimum needed. A 0-D scoping balance with parabolic profiles finds the +# ignition boundary close by, so it asks for less auxiliary power and +# reports a higher Q. Read the Q contours as optimistic. +#----------------------------------------------------------------------- diff --git a/openpopcon/resources/examples/ITER/plotsettings.yml b/openpopcon/resources/examples/ITER/plotsettings.yml new file mode 100644 index 0000000..486e605 --- /dev/null +++ b/openpopcon/resources/examples/ITER/plotsettings.yml @@ -0,0 +1,58 @@ +#----------------------------------------------------------------------- +# OpenPOPCON Plotting Settings: ITER +# +# Only the entries that differ from resources/default_plotsettings.yml are +# listed; anything left out falls back to the default. The defaults are +# already scaled for a ~500 MW device, so this is mostly a light touch. +#----------------------------------------------------------------------- + +yax: "nG" # nG, n20_av or n20_ax +xax: "T_i_av" # T_i_av, T_i_ax, T_e_av or T_e_ax; either axis takes either family +figsize: [8, 6] +fill_invalid: True + +plotoptions: + Paux: + plot: True + color: r + linewidth: 3 + label: $P_{aux}$ + fontsize: 12 + fmt: '%.2d' + spacing: manual + manuallevels: [10,20,50,73,100,200,500] # 73 MW is the baseline H&CD + scale: minmax + levels: 10 + Pfusion: + plot: True + color: k + linewidth: 2 + label: $P_{fus}$ + fontsize: 12 + fmt: '%.2d' + spacing: manual + manuallevels: [50,100,200,500,1000,2000] # design point is 500 MW + scale: minmax + levels: 10 + Q: + plot: True + color: orange + linewidth: 2 + label: $Q$ + fontsize: 12 + fmt: '%.f' + spacing: manual + manuallevels: [1,2,5,10,20,50,100] # design point is Q = 10 + scale: minmax + levels: 7 + betaN: + plot: True + color: forestgreen + linewidth: 2 + label: $\beta_N$ + fontsize: 12 + fmt: '%.2f' + spacing: manual + manuallevels: [1.0,1.8,2.5,3.0] # baseline is betaN = 1.8 + scale: minmax + levels: 5 diff --git a/pyproject.toml b/pyproject.toml index 70c9611..e7a89d4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "hatchling.build" [project] name = "openpopcon" -version = "2.1.0" +version = "2.2.0" description = "0-D tokamak scoping tool for Columbia's Fusion Reactor Design course" readme = "README.MD" requires-python = ">=3.10,<3.15" diff --git a/tests/helpers.py b/tests/helpers.py index b85e955..fa639a1 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -10,12 +10,19 @@ matplotlib.use("Agg") +import yaml + import openpopcon as op MANTA = op.example_dir("MANTA") SETTINGS = os.path.join(MANTA, "POPCON_input_example.yaml") PLOTSETTINGS = os.path.join(MANTA, "plotsettings.yml") +# SPARC has no gEQDSK, so its geometry settings are actually scannable +SPARC = op.example_dir("SPARC") +SPARC_SETTINGS = os.path.join(SPARC, "POPCON_input_example.yaml") +SPARC_PLOTSETTINGS = os.path.join(SPARC, "plotsettings.yml") + SMALL_GRID = dict(Nn=8, NTi=8, nr=60) GOLDEN_FIELDS = [ @@ -38,6 +45,22 @@ UNPHYSICAL = 99998.0 +def write_settings(tmp_path, base=SETTINGS, name="settings.yaml", **overrides): + """ + A settings file built from an example with some keys replaced, detached + from any gEQDSK/profile files so it is self-contained. + """ + with open(base) as fh: + data = yaml.safe_load(fh) + data["gfilename"] = "" + data["profsfilename"] = "" + data.update(overrides) + path = tmp_path / name + with open(path, "w") as fh: + yaml.safe_dump(data, fh) + return str(path) + + def solve_small_manta(parallel=False): """ Solve the MANTA example on the small grid. parallel=False keeps the run diff --git a/tests/test_axes.py b/tests/test_axes.py new file mode 100644 index 0000000..82f88df --- /dev/null +++ b/tests/test_axes.py @@ -0,0 +1,141 @@ +""" +Plot axes. The xax/yax settings resolve through one registry, and either +axis takes either family, so a density can go on x. The output arrays are +stored (n_index, T_index), so that case only works if they are transposed. +""" + +import matplotlib.pyplot as plt +import numpy as np +import pytest + +import openpopcon as op +from openpopcon.core import DIM_N, DIM_T, PLOT_AXES + +from helpers import PLOTSETTINGS, SETTINGS + +T_AXES = [k for k, v in PLOT_AXES.items() if v[1] == DIM_T] +N_AXES = [k for k, v in PLOT_AXES.items() if v[1] == DIM_N] + + +@pytest.fixture(autouse=True) +def restore_axes(solved_manta): + # solved_manta is session-scoped and these tests set xax/yax on it, so + # put them back or the next test inherits whatever the last one left + xax, yax = solved_manta.plotsettings.xax, solved_manta.plotsettings.yax + yield + solved_manta.plotsettings.xax = xax + solved_manta.plotsettings.yax = yax + plt.close("all") + + +def test_registry_covers_the_documented_axes(): + # the seven keys the plotsettings files have always accepted + assert set(PLOT_AXES) == { + "T_i_av", + "T_i_ax", + "T_e_av", + "T_e_ax", + "n20_av", + "n20_ax", + "nG", + } + # every one names a coordinate that build_dataset actually produces + for var, dim, label in PLOT_AXES.values(): + assert dim in (DIM_N, DIM_T) + assert label + + +@pytest.mark.parametrize("xax", T_AXES) +@pytest.mark.parametrize("yax", N_AXES) +def test_every_conventional_pairing_plots(solved_manta, xax, yax): + solved_manta.plotsettings.xax = xax + solved_manta.plotsettings.yax = yax + fig, ax = solved_manta.plot(show=False) + assert ax.collections + assert ax.get_xlabel() and ax.get_ylabel() + plt.close(fig) + + +@pytest.mark.parametrize("xax", N_AXES) +@pytest.mark.parametrize("yax", T_AXES) +def test_density_on_x_plots(solved_manta, xax, yax): + # the case that never ran before the registry: the 2-D arrays have to be + # transposed for this to line up with the meshgrid at all + solved_manta.plotsettings.xax = xax + solved_manta.plotsettings.yax = yax + fig, ax = solved_manta.plot(show=False) + assert ax.collections + plt.close(fig) + + +def test_swapping_axes_transposes_the_data(solved_manta): + solved_manta.plotsettings.xax = "T_i_av" + solved_manta.plotsettings.yax = "nG" + _, _, _, _, normal = solved_manta._resolve_axes() + a = solved_manta._grid("Q", normal) + + solved_manta.plotsettings.xax = "nG" + solved_manta.plotsettings.yax = "T_i_av" + _, _, _, _, swapped = solved_manta._resolve_axes() + b = solved_manta._grid("Q", swapped) + + assert normal == (DIM_N, DIM_T) + assert swapped == (DIM_T, DIM_N) + np.testing.assert_allclose(a, b.T) + + +@pytest.mark.parametrize( + "xax,yax", + [("nG", "n20_av"), ("T_i_av", "T_e_ax")], +) +def test_two_axes_on_one_dimension_rejected(solved_manta, xax, yax): + solved_manta.plotsettings.xax = xax + solved_manta.plotsettings.yax = yax + with pytest.raises(ValueError, match="both labels for"): + solved_manta.plot(show=False) + + +@pytest.mark.parametrize("which", ["xax", "yax"]) +def test_unknown_axis_reports_the_choices(solved_manta, which): + setattr(solved_manta.plotsettings, which, "not_an_axis") + with pytest.raises(ValueError, match="Available:"): + solved_manta.plot(show=False) + + +def test_plot_draws_into_a_supplied_ax(solved_manta): + fig, ax = plt.subplots() + before = len(plt.get_fignums()) + outfig, outax = solved_manta.plot(ax=ax, show=False) + # no new figure, and it drew into the one it was given + assert outax is ax + assert outfig is fig + assert len(plt.get_fignums()) == before + assert ax.collections + plt.close("all") + + +def test_plot_without_ax_is_unchanged(solved_manta): + fig, ax = solved_manta.plot(show=False) + assert fig is ax.get_figure() + # the legend and infobox are on by default + assert ax.get_legend() is not None + assert any(t.get_text().startswith("$I_p$") for t in ax.texts) + plt.close(fig) + + +def test_legend_and_infobox_can_be_turned_off(solved_manta): + fig, ax = plt.subplots() + solved_manta.plot(ax=ax, show=False, legend=False, infobox=False) + assert ax.get_legend() is None + assert not any(t.get_text().startswith("$I_p$") for t in ax.texts) + plt.close("all") + + +def test_savefig_writes_the_right_figure(solved_manta, tmp_path): + # plt.savefig would write whichever figure happens to be current + fig, ax = plt.subplots() + plt.figure() # make a different figure current + out = tmp_path / "p.png" + solved_manta.plot(ax=ax, show=False, savefig=str(out)) + assert out.exists() and out.stat().st_size > 0 + plt.close("all") diff --git a/tests/test_scan.py b/tests/test_scan.py new file mode 100644 index 0000000..1a9df04 --- /dev/null +++ b/tests/test_scan.py @@ -0,0 +1,333 @@ +""" +POPCON_scan: an N x M grid of POPCONs over two machine parameters. + +The failure mode worth guarding hardest is a scan that silently produces +identical cells, because it looks exactly like a scan that worked. +""" + +import matplotlib.pyplot as plt +import numpy as np +import pytest +import yaml + +import openpopcon as op +from openpopcon.core import DIM_N, DIM_T + +from helpers import ( + PLOTSETTINGS, + SETTINGS, + SMALL_GRID, + SPARC_PLOTSETTINGS, + SPARC_SETTINGS, + UNPHYSICAL, + write_settings, +) + +ROWS = [8.0, 10.0] +COLS = [11.0, 13.0] + + +def _scan_settings(tmp_path, base=SPARC_SETTINGS, **overrides): + return write_settings( + tmp_path, base=base, verbosity=0, parallel=False, **SMALL_GRID, **overrides + ) + + +@pytest.fixture(scope="module") +def scan(tmp_path_factory): + path = _scan_settings(tmp_path_factory.mktemp("scan")) + sc = op.POPCON_scan( + settingsfile=path, + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("I_P", ROWS), "cols": ("B_0", COLS)}, + ) + sc.run_scan(progress=False) + return sc + + +# ------------------------------------------------------------------- +# Running +# ------------------------------------------------------------------- + + +def test_shape_and_cells(scan): + assert scan.shape == (2, 2) + for row in scan.cells: + for cell in row: + assert dict(cell.output.sizes) == { + DIM_N: SMALL_GRID["Nn"], + DIM_T: SMALL_GRID["NTi"], + } + + +def test_scanned_values_actually_reach_the_solver(scan): + # the check that catches a scan silently doing nothing + for i, ip in enumerate(ROWS): + for j, b0 in enumerate(COLS): + assert scan.cells[i][j].algorithms.Ip == pytest.approx(ip) + assert scan.cells[i][j].algorithms.B0 == pytest.approx(b0) + + +def test_cells_differ(scan): + a = scan.cells[0][0].output.Paux.values + b = scan.cells[1][1].output.Paux.values + assert not np.allclose(a, b) + + +def test_cell_matches_a_standalone_run(tmp_path, scan): + # proves the raw-dict re-derivation reproduces an ordinary run exactly, + # and that nothing leaks between cells + path = _scan_settings(tmp_path, I_P=ROWS[1], B_0=COLS[0]) + pc = op.POPCON(settingsfile=path, plotsettingsfile=SPARC_PLOTSETTINGS) + pc.run_POPCON() + np.testing.assert_allclose( + scan.cells[1][0].output.Paux.values, pc.output.Paux.values, rtol=1e-12 + ) + + +def test_greenwald_axis_is_shared_but_absolute_density_is_not(scan): + # n_G = Ip / (pi a^2), so scanning I_P moves the absolute density axis + # while the Greenwald fraction stays pinned. The storage design rests on + # this, and so does the sharey decision in plot() + np.testing.assert_allclose( + scan.cells[0][0].output.n_G_frac.values, + scan.cells[1][0].output.n_G_frac.values, + ) + assert not np.allclose( + scan.cells[0][0].output.n_e_20_max.values, + scan.cells[1][0].output.n_e_20_max.values, + ) + + +def test_base_settings_are_not_mutated(tmp_path): + path = _scan_settings(tmp_path) + original = yaml.safe_load(open(path)) + sc = op.POPCON_scan( + settingsfile=path, + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("I_P", ROWS), "cols": ("B_0", COLS)}, + ) + sc.run_scan(progress=False) + assert sc.base_settings.Ip == pytest.approx(original["I_P"]) + assert sc.base_settings.B0 == pytest.approx(original["B_0"]) + + +# ------------------------------------------------------------------- +# Combined output +# ------------------------------------------------------------------- + + +def test_combined_dataset(scan): + ds = scan.output + assert ds.Paux.dims == ("scan_I_P", "scan_B_0", DIM_N, DIM_T) + assert ds.Paux.shape == (2, 2, SMALL_GRID["Nn"], SMALL_GRID["NTi"]) + np.testing.assert_allclose(ds.scan_I_P.values, ROWS) + np.testing.assert_allclose(ds.scan_B_0.values, COLS) + # a coordinate that differs per cell must be promoted, not collapsed + assert "scan_I_P" in ds.n_e_20_max.dims + + +def test_positional_indexing_matches_cells(scan): + for i in range(2): + for j in range(2): + np.testing.assert_allclose( + scan.output.Paux.values[i, j], scan.cells[i][j].output.Paux.values + ) + + +def test_metric_orientation(scan): + m = scan.metric("Q", "max") + assert m.dims == ("scan_I_P", "scan_B_0") + assert m.shape == (2, 2) + # reduced over valid points only, so the sentinel never leaks in + assert np.all(np.isfinite(m.values)) + assert float(m.max()) < UNPHYSICAL + + +def test_combine_before_running_is_an_error(tmp_path): + sc = op.POPCON_scan( + settingsfile=_scan_settings(tmp_path), + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("I_P", ROWS), "cols": ("B_0", COLS)}, + ) + with pytest.raises(RuntimeError, match="run_scan"): + sc.output + + +# ------------------------------------------------------------------- +# Specification and validation +# ------------------------------------------------------------------- + + +def test_yaml_scan_block_is_read(tmp_path): + path = _scan_settings( + tmp_path, + scan={ + "rows": {"parameter": "I_P", "min": 8.0, "max": 10.0, "N": 2}, + "cols": {"parameter": "B_0", "values": COLS}, + }, + ) + sc = op.POPCON_scan(settingsfile=path, plotsettingsfile=SPARC_PLOTSETTINGS) + assert sc.shape == (2, 2) + np.testing.assert_allclose(sc.row.values, [8.0, 10.0]) + np.testing.assert_allclose(sc.col.values, COLS) + + +def test_python_scan_overrides_the_yaml_block(tmp_path): + path = _scan_settings( + tmp_path, + scan={ + "rows": {"parameter": "I_P", "values": [1.0, 2.0]}, + "cols": {"parameter": "B_0", "values": [3.0, 4.0]}, + }, + ) + sc = op.POPCON_scan( + settingsfile=path, + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("I_P", ROWS), "cols": ("B_0", COLS)}, + ) + np.testing.assert_allclose(sc.row.values, ROWS) + + +def test_shipped_examples_with_scan_blocks_still_load_as_plain_popcons(): + # 'scan' is in KNOWN_SETTINGS_KEYS, so it must not be reported as a typo + for name in ("CENTAUR", "ITER"): + d = op.example_dir(name) + pc = op.POPCON( + settingsfile=f"{d}/POPCON_input_example.yaml", + plotsettingsfile=f"{d}/plotsettings.yml", + ) + assert pc.settings.scan + + +BAD_SCANS = { + "unknown_parameter": {"rows": ("Bfield", ROWS), "cols": ("B_0", COLS)}, + "unscannable_Nn": {"rows": ("Nn", [8, 16]), "cols": ("B_0", COLS)}, + "unscannable_gfilename": {"rows": ("gfilename", ["a", "b"]), "cols": ("B_0", COLS)}, + "same_parameter": {"rows": ("B_0", [9.0, 11.0]), "cols": ("B_0", COLS)}, + "only_one_axis": {"rows": ("I_P", ROWS)}, + "empty_values": {"rows": ("I_P", []), "cols": ("B_0", COLS)}, +} + + +@pytest.mark.parametrize("name", list(BAD_SCANS)) +def test_bad_scan_specifications_rejected(tmp_path, name): + with pytest.raises(ValueError): + op.POPCON_scan( + settingsfile=_scan_settings(tmp_path), + plotsettingsfile=SPARC_PLOTSETTINGS, + scan=BAD_SCANS[name], + ) + + +def test_no_scan_at_all_is_an_error(tmp_path): + with pytest.raises(ValueError, match="No scan specified"): + op.POPCON_scan( + settingsfile=_scan_settings(tmp_path), plotsettingsfile=SPARC_PLOTSETTINGS + ) + + +@pytest.mark.parametrize("parameter", ["R", "a", "kappa", "delta", "I_P", "qstar"]) +def test_geqdsk_geometry_scan_rejected(parameter): + # MANTA has a gfilename, and __get_geometry takes the geometry and the + # ohmic current from the equilibrium regardless of the settings + with pytest.raises(ValueError, match="gfilename"): + op.POPCON_scan( + settingsfile=SETTINGS, + plotsettingsfile=PLOTSETTINGS, + scan={"rows": (parameter, [1.0, 2.0]), "cols": ("B_0", COLS)}, + ) + + +@pytest.mark.parametrize("parameter", ["B_0", "H_fac"]) +def test_geqdsk_safe_parameters_accepted(parameter): + op.POPCON_scan( + settingsfile=SETTINGS, + plotsettingsfile=PLOTSETTINGS, + scan={"rows": (parameter, [1.0, 2.0]), "cols": ("Tmax_keV", [10.0, 12.0])}, + ) + + +def test_invalid_cell_settings_reported_up_front(tmp_path): + # a >= R at one corner: caught when the cells are built, before any solve + with pytest.raises(ValueError, match=r"scan cells have invalid settings"): + op.POPCON_scan( + settingsfile=_scan_settings(tmp_path), + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("a", [0.5, 90.0]), "cols": ("B_0", COLS)}, + ) + + +def test_shadowed_key_is_dropped(tmp_path): + # SPARC gives I_P, which shadows qstar in read(). Scanning qstar has to + # drop I_P or every cell comes out identical + path = _scan_settings(tmp_path) + sc = op.POPCON_scan( + settingsfile=path, + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("qstar", [2.0, 4.0]), "cols": ("B_0", COLS)}, + ) + assert sc.cells[0][0].settings.Ip != pytest.approx(sc.cells[1][0].settings.Ip) + + +def test_scanning_R_redrives_Ip_from_qstar(tmp_path): + # the case field mutation cannot express: with qstar given instead of + # I_P, changing R must change the derived Ip + path = _scan_settings(tmp_path, qstar=2.5) + # I_P shadows qstar in read(), so strip it to make qstar load-bearing + with open(path) as fh: + raw = yaml.safe_load(fh) + raw.pop("I_P") + with open(path, "w") as fh: + yaml.safe_dump(raw, fh) + + sc = op.POPCON_scan( + settingsfile=path, + plotsettingsfile=SPARC_PLOTSETTINGS, + scan={"rows": ("R", [1.6, 2.2]), "cols": ("B_0", COLS)}, + ) + assert sc.cells[0][0].settings.Ip != pytest.approx(sc.cells[1][0].settings.Ip) + + +# ------------------------------------------------------------------- +# Plotting and I/O +# ------------------------------------------------------------------- + + +def test_plot_grid(scan): + fig, axs = scan.plot(show=False) + assert axs.shape == (2, 2) + for row in axs: + for ax in row: + assert ax.collections + plt.close("all") + + +def test_plot_metric(scan): + fig, ax = scan.plot_metric("Q", show=False) + assert ax.images + plt.close("all") + + +def test_harmonized_levels_are_shared(scan): + scan._harmonize_levels(["Q"]) + bounds = { + (c.plotsettings.plotoptions["Q"]["min"], c.plotsettings.plotoptions["Q"]["max"]) + for row in scan.cells + for c in row + } + assert len(bounds) == 1 + + +def test_write_and_read_roundtrip(scan, tmp_path): + scan.write_output(name="rt", directory=str(tmp_path), archive=False) + back = op.POPCON_scan.read_output("rt", directory=str(tmp_path)) + assert back.shape == scan.shape + np.testing.assert_allclose(back.row.values, scan.row.values) + for i in range(2): + for j in range(2): + np.testing.assert_allclose( + back.cells[i][j].output.Paux.values, + scan.cells[i][j].output.Paux.values, + ) + plt.close("all") diff --git a/tests/test_validation.py b/tests/test_validation.py index 0479c8b..6e2d71b 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -13,7 +13,7 @@ import openpopcon as op from openpopcon.lib.openpopcon_util import package_resource -from helpers import PLOTSETTINGS, SETTINGS +from helpers import PLOTSETTINGS, SETTINGS, write_settings def _settings_file(example): @@ -32,17 +32,7 @@ def test_shipped_examples_validate(example): def _write_settings(tmp_path, **overrides): - with open(SETTINGS) as fh: - data = yaml.safe_load(fh) - # detach from the gEQDSK/profile files: validation doesn't need them and it - # keeps these settings self-contained - data["gfilename"] = "" - data["profsfilename"] = "" - data.update(overrides) - path = tmp_path / "bad.yaml" - with open(path, "w") as fh: - yaml.safe_dump(data, fh) - return str(path) + return write_settings(tmp_path, name="bad.yaml", **overrides) BAD_SETTINGS = { diff --git a/uv.lock b/uv.lock index 396f0b7..c36d4c1 100644 --- a/uv.lock +++ b/uv.lock @@ -14,10 +14,6 @@ resolution-markers = [ "python_full_version < '3.11'", ] -[options] -exclude-newer = "2026-07-15T00:47:28.213095Z" -exclude-newer-span = "P1W" - [[package]] name = "anyio" version = "4.14.2" @@ -379,7 +375,7 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } wheels = [ @@ -457,7 +453,7 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } wheels = [ @@ -595,7 +591,7 @@ name = "exceptiongroup" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } wheels = [ @@ -788,17 +784,17 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" }, - { name = "decorator", marker = "python_full_version < '3.11'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, - { name = "jedi", marker = "python_full_version < '3.11'" }, - { name = "matplotlib-inline", marker = "python_full_version < '3.11'" }, - { name = "pexpect", marker = "python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "prompt-toolkit", marker = "python_full_version < '3.11'" }, - { name = "pygments", marker = "python_full_version < '3.11'" }, - { name = "stack-data", marker = "python_full_version < '3.11'" }, - { name = "traitlets", marker = "python_full_version < '3.11'" }, - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "exceptiongroup" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/40/18/f8598d287006885e7136451fdea0755af4ebcbfe342836f24deefaed1164/ipython-8.39.0.tar.gz", hash = "sha256:4110ae96012c379b8b6db898a07e186c40a2a1ef5d57a7fa83166047d9da7624", size = 5513971, upload-time = "2026-03-27T10:02:13.94Z" } wheels = [ @@ -821,18 +817,18 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, - { name = "decorator", marker = "python_full_version >= '3.11'" }, - { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, - { name = "jedi", marker = "python_full_version >= '3.11'" }, - { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" }, - { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" }, - { name = "psutil", marker = "python_full_version >= '3.11' and sys_platform != 'cygwin' and sys_platform != 'emscripten'" }, - { name = "pygments", marker = "python_full_version >= '3.11'" }, - { name = "stack-data", marker = "python_full_version >= '3.11'" }, - { name = "traitlets", marker = "python_full_version >= '3.11'" }, - { name = "typing-extensions", marker = "python_full_version == '3.11.*'" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "psutil", marker = "sys_platform != 'cygwin' and sys_platform != 'emscripten'" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/53/59/165d3b4d75cc34add3122c4417ecb229085140ac573103c223cd01dde96f/ipython-9.15.0.tar.gz", hash = "sha256:da2819ce2aa83135257df830660b1176d986c3d2876db24df01974fa955b2756", size = 4442580, upload-time = "2026-06-26T11:03:35.913Z" } wheels = [ @@ -844,7 +840,7 @@ name = "ipython-pygments-lexers" version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pygments", marker = "python_full_version >= '3.11'" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } wheels = [ @@ -1374,15 +1370,15 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "cycler", marker = "python_full_version < '3.11'" }, - { name = "fonttools", marker = "python_full_version < '3.11'" }, - { name = "kiwisolver", marker = "python_full_version < '3.11'" }, - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "packaging", marker = "python_full_version < '3.11'" }, - { name = "pillow", marker = "python_full_version < '3.11'" }, - { name = "pyparsing", marker = "python_full_version < '3.11'" }, - { name = "python-dateutil", marker = "python_full_version < '3.11'" }, + { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" } }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, ] sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } wheels = [ @@ -1458,15 +1454,15 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "cycler", marker = "python_full_version >= '3.11'" }, - { name = "fonttools", marker = "python_full_version >= '3.11'" }, - { name = "kiwisolver", marker = "python_full_version >= '3.11'" }, - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "packaging", marker = "python_full_version >= '3.11'" }, - { name = "pillow", marker = "python_full_version >= '3.11'" }, - { name = "pyparsing", marker = "python_full_version >= '3.11'" }, - { name = "python-dateutil", marker = "python_full_version >= '3.11'" }, + { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" } }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1f/24/080c99d223d158d3a8902769269ab6da5b50f7a0e6e072513907e02b7a6c/matplotlib-3.11.0.tar.gz", hash = "sha256:68c0c7be01b30dcca3638934f7f591df73401235cbdbf0d1ab1c71e7db7f8b57", size = 33251176, upload-time = "2026-06-12T02:29:15.508Z" } wheels = [ @@ -1811,7 +1807,7 @@ wheels = [ [[package]] name = "openpopcon" -version = "2.0.0" +version = "2.2.0" source = { editable = "." } dependencies = [ { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, @@ -1881,10 +1877,10 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "python-dateutil", marker = "python_full_version < '3.11'" }, - { name = "pytz", marker = "python_full_version < '3.11'" }, - { name = "tzdata", marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, ] sdist = { url = "https://files.pythonhosted.org/packages/33/01/d40b85317f86cf08d853a4f495195c73815fdf205eef3993821720274518/pandas-2.3.3.tar.gz", hash = "sha256:e05e1af93b977f7eafa636d043f9f94c7ee3ac81af99c13508215942e64c993b", size = 4495223, upload-time = "2025-09-29T23:34:51.853Z" } wheels = [ @@ -1953,9 +1949,9 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "python-dateutil", marker = "python_full_version >= '3.11'" }, - { name = "tzdata", marker = "(python_full_version >= '3.11' and sys_platform == 'emscripten') or (python_full_version >= '3.11' and sys_platform == 'win32')" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" } wheels = [ @@ -2031,7 +2027,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess", marker = "(python_full_version < '3.11' and sys_platform == 'emscripten') or (python_full_version < '3.11' and sys_platform == 'win32') or (sys_platform != 'emscripten' and sys_platform != 'win32')" }, + { name = "ptyprocess" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ @@ -2731,7 +2727,7 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/0f/37/6964b830433e654ec7485e45a00fc9a27cf868d622838f6b6d9c5ec0d532/scipy-1.15.3.tar.gz", hash = "sha256:eae3cf522bc7df64b42cad3925c876e1b0b6c35c1337c93e12c0f366f55b0eaf", size = 59419214, upload-time = "2025-05-08T16:13:05.955Z" } wheels = [ @@ -2792,7 +2788,7 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } wheels = [ @@ -2871,7 +2867,7 @@ resolution-markers = [ "python_full_version >= '3.12' and python_full_version < '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/a7/25/c2700dfaf6442b4effaa91af24ebce5dc9d31bb4a69706313aae70d72cd0/scipy-1.18.0.tar.gz", hash = "sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378", size = 30774447, upload-time = "2026-06-19T15:01:43.456Z" } wheels = [ @@ -3144,9 +3140,9 @@ resolution-markers = [ "python_full_version < '3.11'", ] dependencies = [ - { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, - { name = "packaging", marker = "python_full_version < '3.11'" }, - { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } }, + { name = "packaging" }, + { name = "pandas", version = "2.3.3", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/19/ec/e50d833518f10b0c24feb184b209bb6856f25b919ba8c1f89678b930b1cd/xarray-2025.6.1.tar.gz", hash = "sha256:a84f3f07544634a130d7dc615ae44175419f4c77957a7255161ed99c69c7c8b0", size = 3003185, upload-time = "2025-06-12T03:04:09.099Z" } wheels = [ @@ -3169,9 +3165,9 @@ resolution-markers = [ "python_full_version == '3.11.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", ] dependencies = [ - { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "packaging", marker = "python_full_version >= '3.11'" }, - { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" } }, + { name = "packaging" }, + { name = "pandas", version = "3.0.3", source = { registry = "https://pypi.org/simple" } }, ] sdist = { url = "https://files.pythonhosted.org/packages/ea/96/3f7bdd00e505ec3698903415b30135024703e017b28c6b61f98da3193b0d/xarray-2026.7.0.tar.gz", hash = "sha256:361b495928fdbf5b58d0969bb6775339019da5e93ca74d61ddf4eb5edd6ce604", size = 3145348, upload-time = "2026-07-09T17:38:26.515Z" } wheels = [