cfspopcon 4.0.0__tar.gz

cfspopcon-4.0.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2023 Commonwealth Fusion Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the “Software”), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cfspopcon-4.0.0/PKG-INFO

@@ -0,0 +1,38 @@
+Metadata-Version: 2.1
+Name: cfspopcon
+Version: 4.0.0
+Summary: Empirically-derived scoping of tokamak operational space.
+Author: Commonwealth Fusion Systems
+Requires-Python: >=3.9,<3.12
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Dist: click (>=8.1.0,<9.0.0)
+Requires-Dist: ipdb (>=0.13.13,<0.14.0)
+Requires-Dist: numpy (>=1.22.4,<2.0.0)
+Requires-Dist: pandas (>=1.4,<2.0)
+Requires-Dist: pint (>=0.22,<0.23)
+Requires-Dist: pint-xarray (>=0.3,<0.4)
+Requires-Dist: pyyaml (>=6.0,<7.0)
+Requires-Dist: scipy (>=1.8,<2.0)
+Requires-Dist: seaborn (>=0.12,<0.13)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: typing-extensions (>=4.0.1,<5.0.0)
+Requires-Dist: xarray (>=2023.4.1,<2024.0.0)
+Description-Content-Type: text/markdown
+
+cfspopcon: 0D Plasma Calculations & Plasma OPerating CONtours
+--------------------------------------------------------------
+
+[![Build Status](https://github.com/cfs-energy/cfspopcon/actions/workflows/workflow_actions.yml/badge.svg)](https://github.com/cfs-energy/cfspopcon/actions)
+[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![Documentation Status](https://readthedocs.org/projects/cfspopcon/badge/?version=latest)](https://cfspopcon.readthedocs.io/en/latest/?badge=latest)
+
+For more information please have a look at our [documentation](https://cfspopcon.readthedocs.io/en/latest/).
+

cfspopcon-4.0.0/README.md

@@ -0,0 +1,8 @@
+cfspopcon: 0D Plasma Calculations & Plasma OPerating CONtours
+--------------------------------------------------------------
+
+[![Build Status](https://github.com/cfs-energy/cfspopcon/actions/workflows/workflow_actions.yml/badge.svg)](https://github.com/cfs-energy/cfspopcon/actions)
+[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
+[![Documentation Status](https://readthedocs.org/projects/cfspopcon/badge/?version=latest)](https://cfspopcon.readthedocs.io/en/latest/?badge=latest)
+
+For more information please have a look at our [documentation](https://cfspopcon.readthedocs.io/en/latest/).

cfspopcon-4.0.0/cfspopcon/__init__.py

@@ -0,0 +1,49 @@
+"""Physics calculations & lumped-parameter models."""
+from importlib.metadata import metadata
+
+__version__ = metadata(__package__)["Version"]
+__author__ = metadata(__package__)["Author"]
+
+from . import algorithms, file_io, formulas, helpers, named_options, unit_handling
+from .algorithms.algorithm_class import Algorithm, CompositeAlgorithm
+from .input_file_handling import read_case
+from .plotting import read_plot_style
+from .point_selection import find_coords_of_maximum, find_coords_of_minimum
+from .unit_handling import (
+    Quantity,
+    Unit,
+    convert_to_default_units,
+    convert_units,
+    default_unit,
+    magnitude,
+    magnitude_in_default_units,
+    set_default_units,
+    ureg,
+    wraps_ufunc,
+)
+
+# export main classes users should need as well as the option enums
+__all__ = [
+    "helpers",
+    "named_options",
+    "algorithms",
+    "formulas",
+    "unit_handling",
+    "ureg",
+    "Quantity",
+    "Unit",
+    "wraps_ufunc",
+    "magnitude_in_default_units",
+    "set_default_units",
+    "default_unit",
+    "convert_to_default_units",
+    "convert_units",
+    "magnitude",
+    "read_case",
+    "read_plot_style",
+    "find_coords_of_maximum",
+    "find_coords_of_minimum",
+    "Algorithm",
+    "CompositeAlgorithm",
+    "file_io",
+]

cfspopcon-4.0.0/cfspopcon/algorithms/__init__.py

@@ -0,0 +1,74 @@
+"""POPCON algorithms."""
+from typing import Union
+
+from ..named_options import Algorithms
+from .algorithm_class import Algorithm, CompositeAlgorithm
+from .beta import calc_beta
+from .composite_algorithm import predictive_popcon
+from .core_radiated_power import calc_core_radiated_power
+from .extrinsic_core_radiator import calc_extrinsic_core_radiator
+from .fusion_gain import calc_fusion_gain
+from .geometry import calc_geometry
+from .heat_exhaust import calc_heat_exhaust
+from .ohmic_power import calc_ohmic_power
+from .peaked_profiles import calc_peaked_profiles
+from .plasma_current_from_q_star import calc_plasma_current_from_q_star
+from .power_balance_from_tau_e import calc_power_balance_from_tau_e
+from .q_star_from_plasma_current import calc_q_star_from_plasma_current
+from .single_functions import SINGLE_FUNCTIONS
+from .two_point_model_fixed_fpow import two_point_model_fixed_fpow
+from .two_point_model_fixed_qpart import two_point_model_fixed_qpart
+from .two_point_model_fixed_tet import two_point_model_fixed_tet
+from .use_LOC_tau_e_below_threshold import use_LOC_tau_e_below_threshold
+from .zeff_and_dilution_from_impurities import calc_zeff_and_dilution_from_impurities
+
+ALGORITHMS: dict[Algorithms, Union[Algorithm, CompositeAlgorithm]] = {
+    Algorithms["calc_beta"]: calc_beta,
+    Algorithms["calc_core_radiated_power"]: calc_core_radiated_power,
+    Algorithms["calc_extrinsic_core_radiator"]: calc_extrinsic_core_radiator,
+    Algorithms["calc_fusion_gain"]: calc_fusion_gain,
+    Algorithms["calc_geometry"]: calc_geometry,
+    Algorithms["calc_heat_exhaust"]: calc_heat_exhaust,
+    Algorithms["calc_ohmic_power"]: calc_ohmic_power,
+    Algorithms["calc_peaked_profiles"]: calc_peaked_profiles,
+    Algorithms["calc_plasma_current_from_q_star"]: calc_plasma_current_from_q_star,
+    Algorithms["calc_power_balance_from_tau_e"]: calc_power_balance_from_tau_e,
+    Algorithms["predictive_popcon"]: predictive_popcon,
+    Algorithms["calc_q_star_from_plasma_current"]: calc_q_star_from_plasma_current,
+    Algorithms["two_point_model_fixed_fpow"]: two_point_model_fixed_fpow,
+    Algorithms["two_point_model_fixed_qpart"]: two_point_model_fixed_qpart,
+    Algorithms["two_point_model_fixed_tet"]: two_point_model_fixed_tet,
+    Algorithms["calc_zeff_and_dilution_from_impurities"]: calc_zeff_and_dilution_from_impurities,
+    Algorithms["use_LOC_tau_e_below_threshold"]: use_LOC_tau_e_below_threshold,
+    **SINGLE_FUNCTIONS,
+}
+
+
+def get_algorithm(algorithm: Union[Algorithms, str]) -> Union[Algorithm, CompositeAlgorithm]:
+    """Accessor for algorithms."""
+    if isinstance(algorithm, str):
+        algorithm = Algorithms[algorithm]
+
+    return ALGORITHMS[algorithm]
+
+
+__all__ = [
+    "calc_beta",
+    "calc_core_radiated_power",
+    "calc_extrinsic_core_radiator",
+    "calc_fusion_gain",
+    "calc_geometry",
+    "calc_heat_exhaust",
+    "calc_ohmic_power",
+    "calc_peaked_profiles",
+    "calc_plasma_current_from_q_star",
+    "calc_power_balance_from_tau_e",
+    "predictive_popcon",
+    "calc_q_star_from_plasma_current",
+    "two_point_model_fixed_fpow",
+    "two_point_model_fixed_qpart",
+    "two_point_model_fixed_tet",
+    "calc_zeff_and_dilution_from_impurities",
+    "ALGORITHMS",
+    "get_algorithm",
+]

cfspopcon-4.0.0/cfspopcon/algorithms/algorithm_class.py

@@ -0,0 +1,413 @@
+"""Defines a class for different POPCON algorithms."""
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable, Sequence
+from functools import wraps
+from typing import Any, Optional, Union
+from warnings import warn
+
+import xarray as xr
+
+from ..unit_handling import convert_to_default_units
+
+FunctionType = Callable[..., dict[str, Any]]
+
+
+class Algorithm:
+    """A class which handles the input and output of POPCON algorithms."""
+
+    def __init__(self, function: FunctionType, return_keys: list[str], name: Optional[str] = None):
+        """Initialise an Algorithm.
+
+        Args:
+            function: a callable function
+            return_keys: the arguments which are returned from the function
+            name: Descriptive name for algorithm
+        """
+        self._function = function
+        self._name = self._function.__name__ if name is None else name
+
+        self._signature = inspect.signature(function)
+        for p in self._signature.parameters.values():
+            if p.kind not in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+                inspect.Parameter.VAR_KEYWORD,
+            ):
+                raise ValueError(
+                    f"Algorithm only supports functions with keyword arguments, but {function}, has {p.kind} parameter {p.name}"
+                )
+        self.input_keys = list(self._signature.parameters.keys())
+        self.return_keys = return_keys
+
+        self.default_values = {
+            key: val.default for key, val in self._signature.parameters.items() if val.default is not inspect.Parameter.empty
+        }
+        self.default_keys = list(self.default_values.keys())
+
+        self.required_input_keys = [key for key in self.input_keys if key not in self.default_keys]
+
+        self.__doc__ = self._make_docstring()
+
+        self.run = self._make_run(self._function)
+
+    def _make_docstring(self) -> str:
+        """Makes a doc-string detailing the function inputs and outputs."""
+        return_string = (
+            f"Algorithm: {self._name}\n" + "Inputs:\n" + ", ".join(self.input_keys) + "\n" + "Outputs:\n" + ", ".join(self.return_keys)
+        )
+        return return_string
+
+    def __repr__(self) -> str:
+        """Return a simple string description of the Algorithm."""
+        return f"Algorithm: {self._name}"
+
+    @classmethod
+    def _make_run(cls, func: FunctionType) -> Callable[..., xr.Dataset]:
+        """Helper to create the `run()` function with correct doc string.
+
+        Args:
+            func: function to be wrapped
+
+        Returns: a xarray DataSet of the result
+        """
+
+        @wraps(func)
+        def run(**kwargs: Any) -> xr.Dataset:
+            result = func(**kwargs)
+            dataset = xr.Dataset(result)
+            return dataset
+
+        return run
+
+    def update_dataset(self, dataset: xr.Dataset, in_place: bool = False) -> Optional[xr.Dataset]:
+        """Retrieve inputs from passed dataset and return a new dataset combining input and output quantities.
+
+        Specifying in_place=True modifies the dataset in place (changing the input), whereas in_place=False will
+        return a copy of the dataset with the outputs appended.
+
+        Args:
+            dataset: input dataset
+            in_place: modify the dataset in place, otherwise return a modified dataset keeping the input unchanged.
+
+        Returns: modified dataset
+        """
+        if not in_place:
+            dataset = dataset.copy(deep=True)
+
+        input_values = {}
+        for key in self.input_keys:
+            if key in dataset.keys():
+                input_values[key] = dataset[key]
+            elif key in self.default_keys:
+                input_values[key] = self.default_values[key]
+            else:
+                sorted_dataset_keys = ", ".join(sorted(dataset.keys()))  # type:ignore[arg-type]
+                sorted_default_keys = ", ".join(sorted(self.default_keys))
+                raise KeyError(f"Key '{key}' not in dataset keys [{sorted_dataset_keys}] or default values [{sorted_default_keys}]")
+
+        result = self._function(**input_values)
+
+        for key, val in result.items():
+            dataset[key] = val
+
+        if not in_place:
+            return dataset
+        else:
+            return None
+
+    def __add__(self, other: Union[Algorithm, CompositeAlgorithm]) -> CompositeAlgorithm:
+        """Build a CompositeAlgorithm composed of this Algorithm and another Algorithm or CompositeAlgorithm."""
+        if isinstance(other, CompositeAlgorithm):
+            return CompositeAlgorithm(algorithms=[self, *other.algorithms])
+        else:
+            return CompositeAlgorithm(algorithms=[self, other])
+
+    @classmethod
+    def from_single_function(
+        cls, func: Callable, return_keys: list[str], name: Optional[str] = None, skip_unit_conversion: bool = False
+    ) -> Algorithm:
+        """Build an Algorithm which wraps a single function."""
+
+        @wraps(func)
+        def wrapped_function(**kwargs: Any) -> dict:
+            result = func(**kwargs)
+
+            if not isinstance(result, tuple):
+                result = (result,)
+
+            result_dict = {}
+            for i, key in enumerate(return_keys):
+                if skip_unit_conversion:
+                    result_dict[key] = result[i]
+                else:
+                    result_dict[key] = convert_to_default_units(result[i], key)
+
+            return result_dict
+
+        return cls(wrapped_function, return_keys, name=name)
+
+    def validate_inputs(
+        self, configuration: Union[dict, xr.Dataset], quiet: bool = False, raise_error_on_missing_inputs: bool = False
+    ) -> bool:
+        """Check that all required inputs are defined, and warn if inputs are unused."""
+        return _validate_inputs(self, configuration, quiet=quiet, raise_error_on_missing_inputs=raise_error_on_missing_inputs)
+
+
+class CompositeAlgorithm:
+    """A class which combined multiple Algorithms into a single object which behaves like an Algorithm."""
+
+    def __init__(self, algorithms: Sequence[Union[Algorithm, CompositeAlgorithm]], name: Optional[str] = None):
+        """Initialise a CompositeAlgorithm, combining several other Algorithms.
+
+        Args:
+            algorithms: a list of Algorithms, in the order that they should be executed.
+            name: a name used to refer to the composite algorithm.
+        """
+        if not (isinstance(algorithms, Sequence) and all(isinstance(alg, (Algorithm, CompositeAlgorithm)) for alg in algorithms)):
+            raise TypeError("Should pass a list of algorithms or composites to CompositeAlgorithm.")
+
+        self.algorithms: list[Algorithm] = []
+
+        # flattens composite algorithms into their respective list of plain Algorithms
+        for alg in algorithms:
+            if isinstance(alg, Algorithm):
+                self.algorithms.append(alg)
+            else:
+                self.algorithms.extend(alg.algorithms)
+
+        self.input_keys: list[str] = []
+        self.required_input_keys: list[str] = []
+        self.return_keys: list[str] = []
+        pars: list[inspect.Parameter] = []
+
+        # traverse list of algorithms in order.
+        # If an ouput from the set of previous algorithms provides an input to a following algorithm
+        # the input is not turned into an input to the CompositeAlgorithm
+        for alg in self.algorithms:
+            alg_sig = inspect.signature(alg.run)
+            for key in alg.default_keys:
+                if key not in self.return_keys:
+                    self.input_keys.append(key)
+                    pars.append(alg_sig.parameters[key])
+            for key in alg.required_input_keys:
+                if key not in self.return_keys:
+                    self.input_keys.append(key)
+                    self.required_input_keys.append(key)
+                    pars.append(alg_sig.parameters[key])
+
+            for key in alg.return_keys:
+                if key not in self.return_keys:
+                    self.return_keys.append(key)
+
+        # create a signature for the run() function
+        # This is a purely aesthetic change, that ensures the run() function
+        # has a helpful tooltip in editors and in the documentation
+
+        # 1. make sure the list of pars doesn't have any duplicates, if there are duplicates
+        # we pick the first one. We don't assert that the types of two parameters are compatible
+        # that's not easy to do.
+        seen_pars: dict[str, int] = {}
+        pars = [p for i, p in enumerate(pars) if seen_pars.setdefault(p.name, i) == i]
+
+        # ensure POSITIONAL_OR_KEYWORD are before kw only
+        pars = sorted(pars, key=lambda p: p.kind)
+
+        def_pars = [p for p in pars if p.default != inspect.Parameter.empty]
+        non_def_pars = [p for p in pars if p.default == inspect.Parameter.empty]
+
+        # methods are immutable and we don't want to set a signature on the class' run() method
+        # thus we wrap the original run method and then assign the __signature__ to the wrapped
+        # wrapper function
+        def _wrap(f: Callable[..., xr.Dataset]) -> Callable[..., xr.Dataset]:
+            def wrapper(**kwargs: Any) -> xr.Dataset:
+                return f(**kwargs)
+
+            wrapper.__doc__ = f.__doc__
+
+            return wrapper
+
+        self.run = _wrap(self._run)
+        # ignore due to mypy bug/missing feature https://github.com/python/mypy/issues/3482
+        self.run.__signature__ = inspect.Signature(  # type:ignore[attr-defined]
+            non_def_pars + def_pars, return_annotation=xr.Dataset
+        )
+        self._name = name
+        self.__doc__ = self._make_docstring()
+
+    def _make_docstring(self) -> str:
+        """Makes a doc-string detailing the function inputs and outputs."""
+        components = f"[{', '.join(alg._name for alg in self.algorithms)}]"
+
+        return_string = (
+            f"CompositeAlgorithm: {self._name}\n"
+            if self._name is not None
+            else "CompositeAlgorithm\n"
+            f"Composed of {components}\n"
+            f"Inputs:\n{', '.join(self.input_keys)}\n"
+            f"Outputs:\n{', '.join(self.return_keys)}"
+        )
+        return return_string
+
+    def __repr__(self) -> str:
+        """Return a simple string description of the CompositeAlgorithm."""
+        return f"CompositeAlgorithm: {self._name}"
+
+    def _run(self, **kwargs: Any) -> xr.Dataset:
+        """Run the sub-Algorithms, one after the other and return a xarray.Dataset of the results.
+
+        Will throw a warning if parameters are not used by any sub-Algorithm.
+        """
+        result = kwargs
+
+        parameters_extra = set(kwargs) - set(self.required_input_keys)
+        parameters_missing = set(self.required_input_keys) - set(kwargs)
+        if parameters_missing:
+            raise TypeError(f"CompositeAlgorithm.run() missing arguments: {', '.join(parameters_missing)}")
+        if parameters_extra:
+            warn(f"Not all input parameters were used. Unused parameters: [{', '.join(parameters_extra)}]", stacklevel=3)
+
+        for alg in self.algorithms:
+
+            alg_kwargs = {key: result[key] for key in result.keys() if key in alg.input_keys}
+
+            alg_result = alg.run(**alg_kwargs)
+            result.update(alg_result)  # type:ignore[arg-type]  # dict.update() doesn't like KeysView[Hashable]
+
+        return xr.Dataset(result)
+
+    def update_dataset(self, dataset: xr.Dataset, in_place: bool = False) -> Optional[xr.Dataset]:
+        """Retrieve inputs from passed dataset and return a new dataset combining input and output quantities.
+
+        Specifying in_place=True modifies the dataset in place (changing the input), whereas in_place=False will
+        return a copy of the dataset with the outputs appended.
+
+        N.b. will not throw a warning if the dataset contains unused elements.
+
+        Args:
+            dataset: input dataset
+            in_place: modify the dataset in place, otherwise return a modified dataset keeping the input unchanged.
+
+        Returns: modified dataset
+        """
+        if not in_place:
+            dataset = dataset.copy(deep=True)
+
+        for alg in self.algorithms:
+            # We've already used copy on the dataset, so can now call update_dataset with
+            # in_place = True for each of the algorithms.
+            alg.update_dataset(dataset, in_place=True)
+
+        if not in_place:
+            return dataset
+        else:
+            return None
+
+    def __add__(self, other: Union[Algorithm, CompositeAlgorithm]) -> CompositeAlgorithm:
+        """Build a CompositeAlgorithm composed of this CompositeAlgorithm and another Algorithm or CompositeAlgorithm."""
+        if isinstance(other, Algorithm):
+            return CompositeAlgorithm(algorithms=[*self.algorithms, other])
+        else:
+            return CompositeAlgorithm(algorithms=[*self.algorithms, *other.algorithms])
+
+    def validate_inputs(  # noqa: PLR0912
+        self,
+        configuration: Union[dict, xr.Dataset],
+        quiet: bool = False,
+        raise_error_on_missing_inputs: bool = True,
+        warn_for_overridden_variables: bool = False,
+    ) -> bool:
+        """Check that all required inputs are defined, and warn if inputs are unused."""
+        # Check if variables are being silently internally overwritten
+        config_keys = list(configuration.keys())
+        key_setter = {key: ["INPUT"] for key in config_keys}
+
+        for algorithm in self.algorithms:
+            for key in algorithm.return_keys:
+                if key not in key_setter.keys():
+                    key_setter[key] = [algorithm._name]
+                else:
+                    key_setter[key].append(algorithm._name)
+
+        overridden_variables = []
+        for variable, algs in key_setter.items():
+            if len(algs) > 1:
+                overridden_variables.append(f"{variable}: ({', '.join(algs)})")
+
+        if warn_for_overridden_variables and len(overridden_variables) > 0:
+            warn(
+                f"The following variables were overridden internally (given as variable: (list of algorithms setting variable)): {', '.join(overridden_variables)}",
+                stacklevel=3,
+            )
+
+        # Check that algorithms are ordered such that dependent algorithms follow those setting their required input keys
+        available_parameters = config_keys.copy()
+        out_of_order_parameters = {}
+        for algorithm in self.algorithms:
+            for key in algorithm.required_input_keys:
+                if key not in available_parameters:
+                    out_of_order_parameters[key] = algorithm
+            for key in algorithm.return_keys:
+                available_parameters.append(key)
+
+        if len(out_of_order_parameters) > 0:
+            message = ""
+            for key, algorithm in out_of_order_parameters.items():
+                if key in key_setter and len(key_setter.get(key, [])) > 0:
+                    message += f"{key} needed by {algorithm} defined by output of {key_setter[key]}."
+            if len(message) > 0:
+                message = f"Algorithms out of order. {message}. Rearrange the list of algorithms so that dependent algorithm are after algorithms setting their inputs."
+                if raise_error_on_missing_inputs:
+                    raise RuntimeError(message)
+                if not quiet:
+                    warn(message, stacklevel=3)
+
+            _validate_inputs(self, configuration, quiet=quiet, raise_error_on_missing_inputs=raise_error_on_missing_inputs)
+
+            return False
+        else:
+            return _validate_inputs(self, configuration, quiet=quiet, raise_error_on_missing_inputs=raise_error_on_missing_inputs)
+
+
+def _validate_inputs(
+    algorithm: Union[Algorithm, CompositeAlgorithm],
+    configuration: Union[dict, xr.Dataset],
+    quiet: bool = False,
+    raise_error_on_missing_inputs: bool = False,
+) -> bool:
+    """Check that all required inputs are defined, and warn if inputs are unused."""
+    config_keys = list(configuration.keys())
+
+    unused_config_keys = config_keys.copy()
+    missing_input_keys = set(algorithm.required_input_keys)
+
+    for key in config_keys:
+        if key in missing_input_keys:
+            missing_input_keys.remove(key)
+
+        if key in algorithm.input_keys:
+            # required_input_keys gives the list of keys which must
+            # be provided, while input_puts gives the list of keys
+            # which can be provided (but which might have default values).
+            unused_config_keys.remove(key)
+
+    if len(missing_input_keys) == 0 and len(unused_config_keys) == 0:
+        return True
+
+    elif len(missing_input_keys) > 0 and len(unused_config_keys) > 0:
+        message = f"Missing input parameters [{', '.join(missing_input_keys)}]. Also had unused input parameters [{', '.join(unused_config_keys)}]."
+        if raise_error_on_missing_inputs:
+            raise RuntimeError(message)
+
+    elif len(missing_input_keys) > 0:
+        message = f"Missing input parameters [{', '.join(missing_input_keys)}]."
+        if raise_error_on_missing_inputs:
+            raise RuntimeError(message)
+
+    else:
+        message = f"Unused input parameters [{', '.join(unused_config_keys)}]."
+
+    if not quiet:
+        warn(message, stacklevel=3)
+    return False

cfspopcon-4.0.0/cfspopcon/algorithms/beta.py

@@ -0,0 +1,50 @@
+"""Calculate toroidal, poloidal, total and normalized beta."""
+from .. import formulas
+from ..unit_handling import Unitfull, convert_to_default_units
+from .algorithm_class import Algorithm
+
+RETURN_KEYS = [
+    "beta_toroidal",
+    "beta_poloidal",
+    "beta",
+    "normalized_beta",
+]
+
+
+def run_calc_beta(
+    average_electron_density: Unitfull,
+    average_electron_temp: Unitfull,
+    average_ion_temp: Unitfull,
+    magnetic_field_on_axis: Unitfull,
+    plasma_current: Unitfull,
+    minor_radius: Unitfull,
+) -> dict[str, Unitfull]:
+    """Calculate toroidal, poloidal, total and normalized beta.
+
+    Args:
+        average_electron_density: :term:`glossary link<average_electron_density>`
+        average_electron_temp: :term:`glossary link<average_electron_temp>`
+        average_ion_temp: :term:`glossary link<average_ion_temp>`
+        magnetic_field_on_axis: :term:`glossary link<magnetic_field_on_axis>`
+        plasma_current: :term:`glossary link<plasma_current>`
+        minor_radius: :term:`glossary link<minor_radius>`
+
+    Returns:
+        :term:`beta_toroidal`, :term:`beta_poloidal`, :term:`beta_total`, :term:`beta_N`
+    """
+    beta_toroidal = formulas.calc_beta_toroidal(average_electron_density, average_electron_temp, average_ion_temp, magnetic_field_on_axis)
+    beta_poloidal = formulas.calc_beta_poloidal(
+        average_electron_density, average_electron_temp, average_ion_temp, plasma_current, minor_radius
+    )
+
+    beta = formulas.calc_beta_total(beta_toroidal=beta_toroidal, beta_poloidal=beta_poloidal)
+    normalized_beta = formulas.calc_beta_normalised(beta, minor_radius, magnetic_field_on_axis, plasma_current)
+
+    local_vars = locals()
+    return {key: convert_to_default_units(local_vars[key], key) for key in RETURN_KEYS}
+
+
+calc_beta = Algorithm(
+    function=run_calc_beta,
+    return_keys=RETURN_KEYS,
+)