Fusion-Power-Plant-Framework
diff --git a/‎.github/workflows/examples.yml‎
Lines changed: 1 addition & 0 deletions b/‎.github/workflows/examples.yml‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎bluemira/base/parameter_frame/_frame.py‎
Lines changed: 17 additions & 0 deletions b/‎bluemira/base/parameter_frame/_frame.py‎
Lines changed: 17 additions & 0 deletions
diff --git a/‎bluemira/builders/coil_supports.py‎
Lines changed: 8 additions & 2 deletions b/‎bluemira/builders/coil_supports.py‎
Lines changed: 8 additions & 2 deletions
diff --git a/‎bluemira/codes/_freecadapi.py‎
Lines changed: 2 additions & 0 deletions b/‎bluemira/codes/_freecadapi.py‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎bluemira/codes/interface.py‎
Lines changed: 4 additions & 2 deletions b/‎bluemira/codes/interface.py‎
Lines changed: 4 additions & 2 deletions
diff --git a/‎bluemira/codes/params.py‎
Lines changed: 11 additions & 5 deletions b/‎bluemira/codes/params.py‎
Lines changed: 11 additions & 5 deletions
diff --git a/‎bluemira/codes/plasmod/params.py‎
Lines changed: 2 additions & 2 deletions b/‎bluemira/codes/plasmod/params.py‎
Lines changed: 2 additions & 2 deletions
@@ -35,6 +35,7 @@ jobs:
           # to the CI runners
           python ./scripts/run_examples.py \
             -e 'plasmod_example' \
+            -e 'process_example' \
             -e 'solver_example' \
             -e 'equilibria/fem_fixed_boundary' \
             -e 'codes/ext_code_script'
@@ -405,6 +405,20 @@ def _validate_parameter_field(field, member_type: Type) -> Tuple[Type, ...]:
 def _validate_units(param_data: Dict, value_type: Iterable[Type]):
     try:
         quantity = pint.Quantity(param_data["value"], param_data["unit"])
+    except ValueError:
+        try:
+            quantity = pint.Quantity(f'{param_data["value"]}*{param_data["unit"]}')
+        except pint.errors.PintError as pe:
+            if param_data["value"] is None:
+                quantity = pint.Quantity(
+                    1 if param_data["unit"] in (None, "") else param_data["unit"]
+                )
+                param_data["source"] = f"{param_data.get('source', '')}\nMAD UNIT 🤯 😭:"
+            else:
+                raise ValueError("Unit conversion failed") from pe
+        else:
+            param_data["value"] = quantity.magnitude
+        param_data["unit"] = quantity.units
     except KeyError as ke:
         raise ValueError("Parameters need a value and a unit") from ke
     except TypeError:
@@ -434,6 +448,9 @@ def _validate_units(param_data: Dict, value_type: Iterable[Type]):
 
     param_data["unit"] = f"{unit:~P}"
 
+    if "MAD UNIT" in param_data.get("source", ""):
+        param_data["source"] += f"{quantity.magnitude}{param_data['unit']}"
+
 
 def _remake_units(dimensionality: Union[Dict, pint.util.UnitsContainer]) -> pint.Unit:
     """Reconstruct unit from its dimensionality"""
 
@@ -28,6 +28,7 @@
 from typing import Dict, List, Optional, Tuple, Type, Union
 
 import numpy as np
+import numpy.typing as npt
 
 from bluemira.base.builder import Builder
 from bluemira.base.components import Component, PhysicalComponent
@@ -38,7 +39,7 @@
 from bluemira.builders.tools import apply_component_display_options
 from bluemira.display.palettes import BLUE_PALETTE
 from bluemira.geometry.compound import BluemiraCompound
-from bluemira.geometry.constants import VERY_BIG
+from bluemira.geometry.constants import D_TOLERANCE, VERY_BIG
 from bluemira.geometry.coordinates import Coordinates, get_intersect
 from bluemira.geometry.error import GeometryError
 from bluemira.geometry.face import BluemiraFace
@@ -621,7 +622,9 @@ def bounds() -> Tuple[np.ndarray, np.ndarray]:
         return np.array([0, 0]), np.array([1, 1])
 
     @staticmethod
-    def f_L_to_wire(wire: BluemiraWire, x_norm: List[float]):  # noqa: N802
+    def f_L_to_wire(  # noqa: N802
+        wire: BluemiraWire, x_norm: Union[List[float], npt.NDArray]
+    ):
         """
         Convert a pair of normalised L values to a wire
         """
@@ -667,6 +670,9 @@ def constrain_koz(self, x_norm: np.ndarray) -> np.ndarray:
         -------
         KOZ constraint array
         """
+        if np.isnan(x_norm).any():
+            bluemira_warn(f"NaN in x_norm {x_norm}")
+            x_norm = np.array([0, D_TOLERANCE])
         straight_line = self.f_L_to_wire(self.wire, x_norm)
         straight_points = straight_line.discretize(ndiscr=self.n_koz_discr).xz.T
         return signed_distance_2D_polygon(straight_points, self.koz_points)
 
@@ -595,6 +595,8 @@ def offset_wire(
         raise FreeCADError(msg) from None
 
     fix_wire(wire)
+    if not wire.isClosed() and not open_wire:
+        raise FreeCADError("offset failed to close wire")
     return wire
 
 
 
@@ -236,9 +236,11 @@ def _map_external_outputs_to_bluemira_params(
         for bm_name, mapping in self.params.mappings.items():
             if not (mapping.recv or recv_all):
                 continue
-            output_value = self._get_output_or_raise(external_outputs, mapping.name)
+            output_value = self._get_output_or_raise(external_outputs, mapping.out_name)
             if mapping.unit is None:
-                bluemira_warn(f"{mapping.name} from code {self._name} has no known unit")
+                bluemira_warn(
+                    f"{mapping.out_name} from code {self._name} has no known unit"
+                )
                 value = output_value
             elif output_value is None:
                 value = output_value
 
@@ -47,7 +47,9 @@ def defaults(self) -> Dict:
         """
 
     @classmethod
-    def from_defaults(cls, data: Dict) -> MappedParameterFrame:
+    def from_defaults(
+        cls, data: Dict, source: str = "bluemira codes default"
+    ) -> MappedParameterFrame:
         """
         Create ParameterFrame with default values for external codes.
 
@@ -62,7 +64,7 @@ def from_defaults(cls, data: Dict) -> MappedParameterFrame:
             new_param_dict[bm_map_name] = {
                 "value": data.get(param_map.name, None),
                 "unit": param_map.unit,
-                "source": "bluemira codes default",
+                "source": source,
             }
 
         return cls.from_dict(new_param_dict)
@@ -130,6 +132,7 @@ class ParameterMapping:
     """
 
     name: str
+    out_name: Optional[str] = None
     send: bool = True
     recv: bool = True
     unit: Optional[str] = None
@@ -140,14 +143,17 @@ def __post_init__(self):
         """
         Freeze the dataclass
         """
-        self._frozen = ("name", "unit", "_frozen")
+        if self.out_name is None:
+            self.out_name = self.name
+        self._frozen = ("name", "out_name", "unit", "_frozen")
 
     def to_dict(self) -> Dict:
         """
         Convert this object to a dictionary with attributes as values.
         """
         return {
             "name": self.name,
+            "out_name": self.out_name,
             "send": self.send,
             "recv": self.recv,
             "unit": self.unit,
@@ -179,10 +185,10 @@ def __setattr__(self, attr: str, value: Union[bool, str]):
             Value of attribute
         """
         if (
-            attr not in ["send", "recv", "name", "unit", "_frozen"]
+            attr not in ["send", "recv", "name", "out_name", "unit", "_frozen"]
             or attr in self._frozen
         ):
-            raise KeyError(f"{attr} cannot be set for a {self.__class__.__name__}")
+            raise KeyError(f"{attr} cannot be set for a {type(self).__name__}")
         if attr in ["send", "recv"] and not isinstance(value, bool):
             raise ValueError(f"{attr} must be a bool")
         super().__setattr__(attr, value)
@@ -25,7 +25,7 @@
 from copy import deepcopy
 from dataclasses import asdict, dataclass
 from enum import Enum
-from typing import ClassVar, Dict, Union
+from typing import Dict, Union
 
 from bluemira.base.parameter_frame import Parameter
 from bluemira.codes.params import MappedParameterFrame
@@ -126,7 +126,7 @@ class PlasmodSolverParams(MappedParameterFrame):
     v_burn: Parameter[float]
     """Target loop voltage (if lower than -1e-3, ignored)-> plasma loop voltage [V]."""
 
-    _mappings: ClassVar = deepcopy(mappings)
+    _mappings = deepcopy(mappings)
     _defaults = PlasmodInputs()
 
     @property