signed curvature

desc/objectives/_coils.py

@@ -202,8 +202,8 @@ def compute(self, params, constants=None):
         if constants is None:
             constants = self._constants
 
-        coils = self.things[0]
-        data = coils.compute(
+        coil = self.things[0]
+        data = coil.compute(
             self._data_keys,
             params=params,
             transforms=constants["transforms"],
@@ -261,7 +261,7 @@ class CoilLength(_CoilObjective):
 
     def __init__(
         self,
-        coils,
+        coil,
         target=None,
         bounds=None,
         weight=1,
@@ -272,12 +272,11 @@ def __init__(
         grid=None,
         name="coil length",
     ):
-        self._coils = coils
         if target is None and bounds is None:
             target = 2 * np.pi
 
         super().__init__(
-            coils,
+            coil,
             ["length"],
             target=target,
             bounds=bounds,
@@ -703,8 +702,8 @@ class CoilSetMinDistance(_Objective):
 
     Parameters
     ----------
-    coils : CoilSet
-        Coils that are to be optimized.
+    coil : CoilSet
+        Coil(s) that are to be optimized.
     target : float, ndarray, optional
         Target value(s) of the objective. Only used if bounds is None.
         Must be broadcastable to Objective.dim_f. If array, it has to
@@ -746,7 +745,7 @@ class CoilSetMinDistance(_Objective):
 
     def __init__(
         self,
-        coils,
+        coil,
         target=None,
         bounds=None,
         weight=1,
@@ -761,7 +760,7 @@ def __init__(
             bounds = (1, np.inf)
         self._grid = grid
         super().__init__(
-            things=coils,
+            things=coil,
             target=target,
             bounds=bounds,
             weight=weight,
@@ -854,8 +853,8 @@ class PlasmaCoilSetMinDistance(_Objective):
     eq : Equilibrium or FourierRZToroidalSurface
         Equilibrium (or FourierRZToroidalSurface) that will be optimized
         to satisfy the Objective.
-    coils : CoilSet
-        Coils that are to be optimized.
+    coil : CoilSet
+        Coil(s) that are to be optimized.
     target : float, ndarray, optional
         Target value(s) of the objective. Only used if bounds is None.
         Must be broadcastable to Objective.dim_f. If array, it has to
@@ -893,15 +892,15 @@ class PlasmaCoilSetMinDistance(_Objective):
     eq_fixed: bool, optional
         Whether the equilibrium is fixed or not. If True, the last closed flux surface
         is fixed and its coordinates are precomputed, which saves on computation time
-        during optimization, and self.things = [coils] only.
+        during optimization, and self.things = [coil] only.
         If False, the surface coordinates are computed at every iteration.
-        False by default, so that self.things = [coils, eq].
+        False by default, so that self.things = [coil, eq].
     coils_fixed: bool, optional
         Whether the coils are fixed or not. If True, the coils
         are fixed and their coordinates are precomputed, which saves on computation time
         during optimization, and self.things = [eq] only.
         If False, the coil coordinates are computed at every iteration.
-        False by default, so that self.things = [coils, eq].
+        False by default, so that self.things = [coil, eq].
     name : str, optional
         Name of the objective function.
 
@@ -914,7 +913,7 @@ class PlasmaCoilSetMinDistance(_Objective):
     def __init__(
         self,
         eq,
-        coils,
+        coil,
         target=None,
         bounds=None,
         weight=1,
@@ -931,17 +930,17 @@ def __init__(
         if target is None and bounds is None:
             bounds = (1, np.inf)
         self._eq = eq
-        self._coils = coils
+        self._coil = coil
         self._plasma_grid = plasma_grid
         self._coil_grid = coil_grid
         self._eq_fixed = eq_fixed
         self._coils_fixed = coils_fixed
-        errorif(eq_fixed and coils_fixed, ValueError, "Cannot fix both eq and coils")
+        errorif(eq_fixed and coils_fixed, ValueError, "Cannot fix both eq and coil")
         things = []
         if not eq_fixed:
             things.append(eq)
         if not coils_fixed:
-            things.append(coils)
+            things.append(coil)
         super().__init__(
             things=things,
             target=target,
@@ -967,13 +966,13 @@ def build(self, use_jit=True, verbose=1):
         """
         if self._eq_fixed:
             eq = self._eq
-            coils = self.things[0]
+            coil = self.things[0]
         elif self._coils_fixed:
             eq = self.things[0]
-            coils = self._coils
+            coil = self._coil
         else:
             eq = self.things[0]
-            coils = self.things[1]
+            coil = self.things[1]
         plasma_grid = self._plasma_grid or LinearGrid(M=eq.M_grid, N=eq.N_grid)
         coil_grid = self._coil_grid or None
         warnif(
@@ -982,15 +981,15 @@ def build(self, use_jit=True, verbose=1):
             "Plasma/Surface grid includes interior points, should be rho=1.",
         )
 
-        self._dim_f = coils.num_coils
+        self._dim_f = coil.num_coils
         self._eq_data_keys = ["R", "phi", "Z"]
 
         eq_profiles = get_profiles(self._eq_data_keys, obj=eq, grid=plasma_grid)
         eq_transforms = get_transforms(self._eq_data_keys, obj=eq, grid=plasma_grid)
 
         self._constants = {
             "eq": eq,
-            "coils": coils,
+            "coil": coil,
             "coil_grid": coil_grid,
             "eq_profiles": eq_profiles,
             "eq_transforms": eq_transforms,
@@ -1009,9 +1008,7 @@ def build(self, use_jit=True, verbose=1):
             plasma_pts = rpz2xyz(jnp.array([data["R"], data["phi"], data["Z"]]).T)
             self._constants["plasma_coords"] = plasma_pts
         if self._coils_fixed:
-            coils_pts = coils._compute_position(
-                params=coils.params_dict, grid=coil_grid
-            )
+            coils_pts = coil._compute_position(params=coil.params_dict, grid=coil_grid)
             self._constants["coil_coords"] = coils_pts
 
         if self._normalize:
@@ -1057,7 +1054,7 @@ def compute(self, params_1, params_2=None, constants=None):
         if self._coils_fixed:
             coils_pts = constants["coil_coords"]
         else:
-            coils_pts = constants["coils"]._compute_position(
+            coils_pts = constants["coil"]._compute_position(
                 params=coils_params, grid=constants["coil_grid"]
             )