diff --git a/desc/coils.py b/desc/coils.py index e4ff53ee48..8547f3a044 100644 --- a/desc/coils.py +++ b/desc/coils.py @@ -949,6 +949,33 @@ def from_values(cls, current, coords, N=10, s=None, basis="xyz", name=""): name=name, ) + @classmethod + def from_simsopt(cls, coil_simsopt, name=""): + """Load a simsopt coil as a FourierXYZCoil. + + Parameters + ---------- + coil_simsopt : simsopt.field.Coil + A simsopt coil + name : str + Name for this coil. + + Returns + ------- + coil : FourierXYZCoil + A FourierXYZCoil. + """ + current = coil_simsopt.current.get_value() + curve = FourierXYZCurve.from_simsopt(coil_simsopt.curve) + return cls( + current=current, + X_n=curve.X_n, + Y_n=curve.Y_n, + Z_n=curve.Z_n, + modes=curve.X_basis.modes[:, 2], + name=name, + ) + class FourierPlanarCoil(_Coil, FourierPlanarCurve): """Coil that lies in a plane. diff --git a/desc/geometry/curve.py b/desc/geometry/curve.py index 01af58bb0b..2812a97a53 100644 --- a/desc/geometry/curve.py +++ b/desc/geometry/curve.py @@ -631,6 +631,47 @@ def from_values(cls, coords, N=10, s=None, basis="xyz", name=""): X_n=X_n, Y_n=Y_n, Z_n=Z_n, modes=basis.modes[:, 2], name=name ) + @classmethod + def from_simsopt(cls, curve_simsopt, name=""): + """Load a simsopt CurveXYZFourier as a FourierXYZCurve. + + Parameters + ---------- + coil_simsopt : simsopt.geo.CurveXYZFourier + A simsopt curve + name : str + Name for this curve. + + Returns + ------- + coil : FourierXYZCurve + A FourierXYZCurve. + """ + try: + from simsopt.geo import CurveXYZFourier + except ModuleNotFoundError: + raise ModuleNotFoundError("from_simsopt method requires simsopt package.") + if not isinstance(curve_simsopt, CurveXYZFourier): + raise AttributeError("The imput curve must be a Simsopt CurveXYZFourier") + dofs = curve_simsopt.get_dofs() + order = curve_simsopt.order + # [xc0, xs1, xc1, ....] + x = dofs[: 2 * order + 1] + y = dofs[2 * order + 1 : 4 * order + 2] + z = dofs[4 * order + 2 :] + + def convert_x(x): + xc = x[::2] + xs = x[1:][::2] + xn = np.concatenate((np.flip(xs), xc)) + return xn + + xn = convert_x(x) + yn = convert_x(y) + zn = convert_x(z) + modes = np.arange(-order, order + 1) + return cls(xn, yn, zn, modes=modes, name=name) + def _get_ess_scale(self, alpha=1.2, order=np.inf, min_value=1e-7): """Create x_scale using exponential spectral scaling. diff --git a/desc/io/optimizable_io.py b/desc/io/optimizable_io.py index e9a81b8648..9545eee2ea 100644 --- a/desc/io/optimizable_io.py +++ b/desc/io/optimizable_io.py @@ -92,7 +92,7 @@ def _make_hashable(x): def _unmake_hashable(x): # turn tuple of ints and shape to ndarray - if isinstance(x, tuple) and x[0] == "ndarray": + if isinstance(x, tuple) and len(x) and x[0] == "ndarray": return np.array(x[2]).reshape(x[1]) if isinstance(x, list): return [_unmake_hashable(y) for y in x] diff --git a/desc/objectives/__init__.py b/desc/objectives/__init__.py index 52ca059e98..a2971a1959 100644 --- a/desc/objectives/__init__.py +++ b/desc/objectives/__init__.py @@ -56,6 +56,7 @@ ) from ._power_balance import FusionPower, HeatingPowerISS04 from ._profiles import Pressure, RotationalTransform, Shear, ToroidalCurrent +from ._quadcoil import QuadcoilProxy from ._stability import BallooningStability, MagneticWell, MercierStability from .getters import ( get_equilibrium_objective, diff --git a/desc/objectives/_quadcoil.py b/desc/objectives/_quadcoil.py new file mode 100644 index 0000000000..22fc0db408 --- /dev/null +++ b/desc/objectives/_quadcoil.py @@ -0,0 +1,881 @@ +import warnings + +from desc.backend import jit, jnp +from desc.compute import get_profiles, get_transforms +from desc.grid import LinearGrid +from desc.objectives.normalization import compute_scaling_factors +from desc.objectives.objective_funs import _Objective, collect_docs +from desc.utils import Timer + +from ._quadcoil_utils import ( + _BCOIL_DATA_KEYS, + _BPLASMA_DATA_KEYS, + _compute_Bnormal, + _compute_Bnormal_ext, + _compute_Bnormal_plasma, + _compute_eval_data_coils, + _compute_G, + _create_source, + _ptolemy_identity_rev_compute, + _ptolemy_identity_rev_precompute, + _quadcoil_kwargs_to_field_kwargs, +) + +# ----- A QUADCOIL wrapper ----- +# A list of all inputs of quadoil.quadcoil +# that can be extracted from DESC. The +# rest cannot. These variables should not +# show up in quadcoil_kwargs. If they do, they will be ignored. +_DESC_DERIVED_ARGNAMES = [ + "nfp", + "stellsym", + "plasma_mpol", + "plasma_ntor", + "plasma_quadpoints_phi", + "plasma_quadpoints_theta", + "plasma_dofs", + "net_poloidal_current_amperes", + "Bnormal_plasma", + "metric_name", + "value_only", +] + +# A list of argnames that must be user-provided, +# but are considered differentiable by JAX. +# Variables here will be excluded when constructing +# nondiff_args, the non-differentiable argument of +# quadcoil.io.quadcoil_for_diff +_DIFF_USER_ARGNAMES = [ + "net_toroidal_current_amperes" + "plasma_coil_distance" + "objective_weight" + "constraint_value" +] + +_normalize_target_detail = ( + "Normalization options for a typical DESC Objective. Disabled by default. " + "When enabled, overrides the ``_unit`` in " + "``quadcoil_kwargs`` with scaling constants calculated from the parameteres " + "of the DESC equilibrium. Note that QUADCOIL usually works the best " + "when ``_unit`` are the same quantities measured from another " + "winding surface solution (either the solution of the same problem with " + "``_unit=1``, or the solution of a REGCOIL problem). This is " + "because coil metrics at a QUADCOIL optimum can differ by orders of " + "magnitudes from the DESC auto-calculated values. Setting " + "this to ``True`` may impact QUADCOIL's accuracy." +) + + +class QuadcoilProxy(_Objective): + """ + A QUADCOIL-based coil complexity proxy. + + Parameters + ---------- + eq : Equilibrium + Equilibrium that will be optimized to satisfy the Objective. + quadcoil_kwargs : dict + A dictionary containing all inputs for ``quadcoil.quadcoil`` (see the + `QUADCOIL documentation + `__). + The following quantities are automatically extracted from DESC and + will be ignored: + + .. code-block:: python + + nfp, + stellsym, + plasma_mpol, plasma_ntor, + plasma_quadpoints_phi, plasma_quadpoints_theta, + plasma_dofs, + net_poloidal_current_amperes, + Bnormal_plasma, + metric_name, + value_only, + verbose, + plasma_M_theta : int, optional + The plasma poloidal quadrature resolution. Determines the + resolution of QUADCOIL plasma surface integrals and point-wise + functions. + Unlike the winding surface quadrature points, which is a required input, + the plasma surface quadpoints is evaluated from a linear grid to make + sure that the grid points in DESC B calculations line up exactly + with the QUADCOIL grids. + Values lower than eq.M_grid will trigger interpolation truncation + warnings. Default = eq.M_grid. + plasma_N_phi : int, optional + The plasma toroidal quadrature resolution. Default = eq.N_grid. + metric_name : str or tuple of str + The coil property(ies) to measure as the value of the proxy. + We strongly advise using the default value to ensure accurate adjoint + differentiation. Default = "f_obj", which uses the normalized QUADCOIL + objective. + metric_target : scalar or ndarray + In addition to target, bounds and weight, + The QUADCOIL proxy objective allows the user to set weights and + targets for each objective terms individually besides using ``target`` + and ``bounds`` that comes with other DESC objectives. + Targets of each property. Default = 0.0. + metric_weight : scalar or ndarray + Weights of each property. Default = 1.0. + vacuum : bool, optional + Whether to enable Bnormal contributions from plasma current. + Default = False. + verbose : int, optional + Whether to enable verbose output. Default = 0. + source_grid : Grid, optional + Grid for evaluating vacuum casing and the required net poloidal coil + current. Default = None, which uses a + ``LinearGrid(M=eq.M_grid, N=eq.N_grid)``. + field : list or CoilSet, optional + Other coils to use in combinations with the winding surface. + Can be optimized. For combined filament-dipole modeling/optimization. + Default = []. + field_grid : Grid, optional + The grid for ``field``. Default = None. + enable_net_current_plasma : bool, optional + Whether to enable a net poloidal current in the winding surface. + Default = True. + eq_fixed : bool, optional + Whether to fix ``eq``, or make it optimizable degrees of freedom. + Default = False for quasi-single-stage optimization. + field_fixed : bool, optional + Whether to fix ``field``, or make it optimizable degrees of freedom. + Default = False for quasi-single-stage dipole/PM optimization with known + filament coils. + B_plasma_chunk_size : int or None + Size to split singular integral computation for B_plasma into chunks. + If no chunking should be done or the chunk size is the full input + then supply ``None``. Default = ``bs_chunk_size``. + bs_chunk_size : int, optional + Size to split Biot-Savart computation into chunks of evaluation points. + Default = None. + """ + + # ----- Setting and registering keyword arguments ----- + _static_attrs = _Objective._static_attrs + [ + # External-coils related + "_enable_net_current_plasma", + "_eq_fixed", + "_field_fixed", + # Free-boundary-related + "_bplasma_chunk_size", + "_vacuum", + # QUADCOIL-related + "metric_name", + "nfp", + "stellsym", + "_plasma_M_theta", + "_plasma_N_phi", + "_quadcoil_for_diff", + "_quadcoil_values", + "_Bnormal_shape", + # VMEC <=> DESC + "_surf_R_A", + "_surf_R_c_indices", + "_surf_R_s_indices", + "_surf_Z_A", + "_surf_Z_c_indices", + "_surf_Z_s_indices", + ] + + # Most of the documentation is shared among all objectives, so we just + # inherit the docstring from the base class and add a few details specific + # to this objective. + # See the documentation of `collect_docs` for more details. + __doc__ = __doc__.rstrip() + collect_docs( + target_default="``target=0``.", + bounds_default="``bound=None``.", + normalize_target_detail=_normalize_target_detail, + ) + + _coordinates = "" # What coordinates is this objective a function of, with + # r=rho, t=theta, z=zeta? i.e. if only a profile, it is "r" , while if all + # 3 coordinates it is "rtz" + _units = "N/A" # units of the output + # string with python string formatting for printing the value + _print_value_fmt = "QUADCOIL subproblem: " + + def __init__( # noqa: C901 + self, + eq, + quadcoil_kwargs, + plasma_M_theta=None, + plasma_N_phi=None, + target=None, + bounds=None, + weight=1, + metric_name="f_obj", + metric_weight=1.0, + metric_target=0.0, + vacuum: bool = False, + normalize=False, + normalize_target=False, + verbose=0, + name="QUADCOIL Proxy", + source_grid=None, + # External coils - no external coils by default + field=None, + field_grid=None, + enable_net_current_plasma=True, + eq_fixed=False, # Whether the equilibrium are fixed + field_fixed=False, # Whether the external fields are fixed + # misc + B_plasma_chunk_size=None, + jac_chunk_size=None, + bs_chunk_size=None, + ): + # Importing QUADCOIL + try: + from quadcoil.io import gen_quadcoil_for_diff + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + self._enable_net_current_plasma = enable_net_current_plasma + self._eq_fixed = eq_fixed + self._eq = eq + if field: # To be also tolerant on `False` and `None` as an input + self._field = [field] if not isinstance(field, list) else field + self._field_fixed = field_fixed + else: + self._field = [] + self._field_fixed = True + # Things initialization + things = [] + if not (self._eq_fixed or self._field_fixed): + warnings.warn( + "Both eq_fixed and field_fixed are True. things will be empty." + ) + if not self._eq_fixed: + things += [eq] + if not self._field_fixed: + things += [field] + + if not (enable_net_current_plasma or field): + warnings.warn( + "enable_net_current_plasma is false and field is empty. " + "The problem may be trivial." + ) + + if enable_net_current_plasma and field: + warnings.warn( + "There are both external coils and net current. " + "This is very uncommon (windowpane filaments + " + "winding surface with net current)." + ) + + quadcoil_kwargs = quadcoil_kwargs.copy() + if target is None and bounds is None: + target = 0 # default target value + # Uses LSE to smooth non-smooth problems rather than slack variables + # by default. + quadcoil_kwargs.setdefault("smoothing", "approx") + + # ----- Checking inputs ----- + # Checking whether all metrics have a weight and a target provided. + # By default, the metric is the quadcoil objective. This choice + # empirically has the most accurate adjoint gradients. + if isinstance(metric_name, str): + if (not jnp.isscalar(metric_target)) or (not jnp.isscalar(metric_weight)): + raise ValueError( + "When metric_name is a str, metric_target and " + "metric_target must both be scalar." + ) + # Makign them into iterables will make things easier when + # scaling in the end. + metric_name = (metric_name,) + metric_weight = jnp.array([metric_weight]) + metric_target = jnp.array([metric_target]) + elif isinstance(metric_name, tuple): + if len(metric_target) != len(metric_name): + raise KeyError( + "metric_name and metric_target have mismatching lengths!" + ) + if len(metric_weight) != len(metric_name): + raise KeyError( + "metric_name and metric_weight have mismatching lengths!" + ) + else: + raise ValueError("metric_name must be a tuple or a str.") + # Detect if the user has provided any arguments + # that will also-be extracted from DESC. + # If there are, these objectives will be discarded. + if normalize: + # When normalize is set to true, we + # use quantities from DESC to perform + # normalization instead. + overridden_argnames = _DESC_DERIVED_ARGNAMES + [ + "objective_unit", + "constraint_unit", + ] + else: + overridden_argnames = _DESC_DERIVED_ARGNAMES + redundant_arg_names = set(overridden_argnames) & quadcoil_kwargs.keys() + if redundant_arg_names: + warnings.warn( + f"Redundant arguments detected: {redundant_arg_names}. " + "These arguments are extracted from the equilibrium, " + "or specified by other parameters. The provided values " + "will be discarded." + ) + + # ----- Storing equilibrium-independent, differentiable variables ----- + # These are differentiable quantities that are not equilibrium-dependent. + # They can be user-provided, but they also all have default values, so + # we set them here. This is necessary because we are calling quadcoil + # through quadcoil.io.quadcoil_for_diff, which cannot see their default + # values in quadcoil.quadcoil. + self.net_toroidal_current_amperes = quadcoil_kwargs.pop( + "net_toroidal_current_amperes", 0.0 + ) + # A sign flip is necessary here since simsopt and DESC surfaces + # have different handedness. QUADCOIL uses the simsopt convention. + _plasma_coil_distance = quadcoil_kwargs.pop("plasma_coil_distance", None) + self.plasma_coil_distance = ( + -_plasma_coil_distance if _plasma_coil_distance is not None else None + ) + self.winding_dofs = quadcoil_kwargs.pop("winding_dofs", None) + self.objective_weight = quadcoil_kwargs.pop("objective_weight", None) + self.constraint_value = quadcoil_kwargs.pop("constraint_value", jnp.array([])) + + # ----- Setting attributes ----- + self.metric_name = metric_name + self.metric_target = metric_target + self.metric_weight = metric_weight + self._verbose = verbose + self._bplasma_chunk_size = B_plasma_chunk_size + self._bs_chunk_size = bs_chunk_size + self._vacuum = vacuum + if not plasma_M_theta: + plasma_M_theta = eq.M_grid + elif plasma_M_theta <= eq.M_grid: + warnings.warn( + f"plasma_M_theta = {plasma_M_theta} <= eq.M_grid = {eq.M_grid}. " + "An interpolation truncation warning may appear." + ) + if not plasma_N_phi: + plasma_N_phi = eq.N_grid + elif plasma_N_phi <= eq.N_grid: + warnings.warn( + f"plasma_N_phi = {plasma_N_phi} <= eq.N_grid = {eq.N_grid}. " + "An interpolation truncation warning may appear." + ) + self._plasma_M_theta = plasma_M_theta + self._plasma_N_phi = plasma_N_phi + self._constants = {} + # B_normal and G source grids + if source_grid is None: + self._constants["source_grid"] = LinearGrid( + M=eq.M_grid, + N=eq.N_grid, + # for axisymmetry we still need to know about toroidal effects, so its + # cheapest to pretend there are extra field periods + NFP=eq.NFP if eq.N > 0 else 64, + sym=False, + ) + else: + self._constants["source_grid"] = source_grid + self._constants["field_grid"] = field_grid + # These are differentiable quantities that are not equilibrium-dependent. + # They can be user-provided, but they also all have default values, so + # we set them here. This is necessary because we are calling quadcoil through + # quadcoil.io.quadcoil_for_diff, which cannot see their default value in + # quadcoil.quadcoil. + + # ----- Calculating DESC-derived, non-differentiable attrs ----- + # eval_grid is used to generate quadrature points. + # It is the same as "eval_grid" in desc.integrals.compute_B_plasma + # it is also used to calculate surface Bnormal_plasma + # when vacuum=False, along with surface_grid. + # because we the quadrature points must be calculated before generating + # quadcoil callable, it will be constructed here, instead of in the build(). + eval_grid = LinearGrid( + NFP=eq.NFP, + # If we set this to sym it will only evaluate + # theta from 0 to pi. + sym=False, + M=self._plasma_M_theta, # Poloidal grid resolution. + N=self._plasma_N_phi, + rho=1.0, + ) + eval_data_keys = [] + if self._field: + eval_data_keys = eval_data_keys + _BCOIL_DATA_KEYS + if not self._vacuum: + eval_data_keys = eval_data_keys + _BPLASMA_DATA_KEYS + eval_profiles = get_profiles(eval_data_keys, obj=eq, grid=eval_grid) + eval_transforms = get_transforms(eval_data_keys, obj=eq, grid=eval_grid) + self._constants["eval_grid"] = eval_grid + self._constants["eval_profiles"] = eval_profiles + self._constants["eval_transforms"] = eval_transforms + self.nfp = eq.NFP + self.stellsym = eq.sym + quadcoil_kwargs["metric_name"] = metric_name + quadcoil_kwargs["nfp"] = eq.NFP + quadcoil_kwargs["stellsym"] = eq.sym + quadcoil_kwargs["plasma_mpol"] = eq.surface.M + quadcoil_kwargs["plasma_ntor"] = eq.surface.N + quadcoil_kwargs["plasma_quadpoints_phi"] = ( + eval_grid.nodes[eval_grid.unique_zeta_idx, 2] / jnp.pi / 2 + ) + quadcoil_kwargs["plasma_quadpoints_theta"] = ( + eval_grid.nodes[eval_grid.unique_theta_idx, 1] / jnp.pi / 2 + ) + self._Bnormal_shape = ( + len(quadcoil_kwargs["plasma_quadpoints_phi"]), + len(quadcoil_kwargs["plasma_quadpoints_theta"]), + ) + # ----- Generating quadcoil partial and its jvp rule ----- + # quadcoil_kwargs is a mixture of static and traced arguments. + # Because we likely will not adjust quadcoil settings dynamically, + # here we treat all of them like staic using + # partial(quadcoil, **quadcoil_kwargs), implemented in gen_quadcoil_for_diff. + # The function also generates the custom_jvp rule based on the static arguments. + # We store the resulting function as a static attribute. + _quadcoil_values, _quadcoil_for_diff = gen_quadcoil_for_diff(**quadcoil_kwargs) + # Used later for Bnormal_plasma also + self._quadcoil_for_diff = jit(_quadcoil_for_diff) + self._quadcoil_values = jit(_quadcoil_values) + + # ----- Superclass ----- + super().__init__( + things=things, + target=target, + bounds=bounds, + weight=weight, + normalize=normalize, + normalize_target=normalize_target, + name=name, + jac_chunk_size=jac_chunk_size, + ) + + def build(self, use_jit=True, verbose=1): + """Build constant arrays. + + Parameters + ---------- + use_jit : bool, optional + Whether to just-in-time compile the objective and derivatives. + verbose : int, optional + Level of output. + + """ + # Importing QUADCOIL + try: + from quadcoil.io import generate_desc_scaling + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # ----- Starting and timing----- + # things is the list of things that will be optimized, + # we assigned things to be just eq in the init, so we know that the + # first (and only) element of things is the equilibrium + eq = self._eq + # dim_f = size of the output vector returned by self.compute. + # This is a scalar objective. + self._dim_f = 1 + # some helper code for profiling and logging + timer = Timer() + if verbose > 0: + print("Precomputing transforms") + timer.start("Precomputing transforms") + + # ----- Building the desc surf -> quadcoil (simsopt) surf map ----- + ( + self._surf_R_A, + self._surf_R_c_indices, + self._surf_R_s_indices, + ) = _ptolemy_identity_rev_precompute( + eq.surface.R_basis.modes[:, 1], eq.surface.R_basis.modes[:, 2] + ) + ( + self._surf_Z_A, + self._surf_Z_c_indices, + self._surf_Z_s_indices, + ) = _ptolemy_identity_rev_precompute( + eq.surface.Z_basis.modes[:, 1], eq.surface.Z_basis.modes[:, 2] + ) + + # ----- Building grids and transforms ----- + # source_grid for Bnormal_plasma, and eval_grid. + # Eval grid has a special role, in that it helps + # generate plasma_quadpoint_phi and theta. Therefore, + # it will be generated in init instead. + if self._enable_net_current_plasma: + net_poloidal_current_profiles = get_profiles( + ["G"], obj=eq, grid=self._constants["source_grid"] + ) + net_poloidal_current_transforms = get_transforms( + ["G"], obj=eq, grid=self._constants["source_grid"] + ) + # Storing transforms + # Attributes inside and outside _constants are not really treated + # differently, except that self._constants is traced. Because + # quadcoil_arg is a mixture of traced and static inputs, we want to + # individually register all the static inputs. Moreover, dicts are + # not hashable, so the static arguments in quadcoil_kwargs must all + # be stored as individual attributes. We might as well store + # everything in quadcoil_kwargs as individual attributes, + # and only store the transforms and profiles here in self._constants. + self._constants["net_poloidal_current_profiles"] = ( + net_poloidal_current_profiles + ) + self._constants["net_poloidal_current_transforms"] = ( + net_poloidal_current_transforms + ) + + # Mose DESC objectives are fields, so they + # hard-coded the superclass to ask for a weight + # to integrate the field over a quadrature... + + # source_grid will only be generated when self.vacuum == False. + # Here, eval_grid is not only used to define Bnormal_plasma, + # but also used to generate plasma_quadpoints_phi and theta. + # Therefore, it will be greated regardless self.vacuum == True. + if not self._vacuum: + ( + source_profiles, + source_transforms, + interpolator, + ) = _create_source( + eq=eq, + source_grid=self._constants["source_grid"], + eval_grid=self._constants["eval_grid"], + ) + self._constants["source_profiles"] = source_profiles + self._constants["source_transforms"] = source_transforms + self._constants["interpolator"] = interpolator + + if self._field: + from desc.magnetic_fields import SumMagneticField + + self._constants["sum_field"] = SumMagneticField(self._field) + + # ----- Precomputing quantities ----- + + # Now that all transforms are calculated, time to + # precompute quantities where applicable. + if self._eq_fixed: + # Plasma dofs + self._constants["plasma_dofs"] = self.compute_plasma_surface_dofs_simsopt( + eq.params_dict + ) + + # Net plasma current + if self._enable_net_current_plasma: + self._constants["G"] = _compute_G(eq.params_dict, self._constants) + + # B plasma + if not self._vacuum: + self._constants["Bnormal_plasma"] = _compute_Bnormal_plasma( + self._constants, eq.params_dict, self._bplasma_chunk_size + ) + + # Part of external field + if self._field: + coils_x, coils_n_rho = _compute_eval_data_coils( + self._constants, eq.params_dict + ) + self._constants["coils_x"] = coils_x + self._constants["coils_n_rho"] = coils_n_rho + if self._field_fixed: + self._constants["Bnormal_ext"] = _compute_Bnormal_ext( + self._constants, + self._constants["sum_field"].params_dict, + self._bs_chunk_size, + ) + + # ----- Normalization scales ----- + # We try to normalize things to order(1) by dividing things by some + # characteristic scale for a given quantity. + # See ``desc.objectives.compute_scaling_factors`` for examples. + # The unit for each objective is implemented as the attribute ``desc_unit`` + # of the corresponding function. These attributes are lambda functions + # that act on self.scales and returns a number. Example: + # K.desc_unit = lambda scales: scales["B"] / mu_0 # noqa: E800 + if self._normalize: + self.scales = compute_scaling_factors(eq) + obj_unit_new, cons_unit_new = generate_desc_scaling( + self.objective_name, self.constraint_name, self.scales + ) + self.objective_unit = obj_unit_new + self.constraint_unit = cons_unit_new + + # ----- Wrapping up and timing ----- + timer.stop("Precomputing transforms") + if verbose > 1: + timer.disp("Precomputing transforms") + + # ----- Fixing a key error ----- + # The QUADCOIL has np coordinates. To prevent a key error when DESC + # tries to execute `grid = self._constants["transforms"]["grid"]` + # during build() and cause a key error, we assign some dummy weights. + # This prevents the whole + # `if hasattr(self, "_constants") and ("quad_weights" not in self._constants):` + # from triggering. + self._constants["quad_weights"] = jnp.ones(self._dim_f) + + # finally, call ``super.build()`` + super().build(use_jit=use_jit, verbose=verbose) + + def compute(self, *all_params, constants=None): + """Computes the scalar value of the QUADCOIL proxy. + + Computes the scalar value of the QUADCOIL proxy. A wrapper for + ``solve_quadcoil``. + + Parameters + ---------- + *all_params : dict + Dictionaries of equilibrium/coils degrees of freedom, depending on + ``eq_fixed`` and ``field_fixed``. + constants : dict + (Dummy for now) Dictionary of constant data, eg transforms, + profiles etc. Defaults to self.constants + + Returns + ------- + The scalar quadcoil proxy. + + """ + _ = self._get_deprecated_constants(constants) + # We prohibit the user from providing constants + return self.solve_quadcoil(*all_params, full_mode=False) + + def solve_quadcoil(self, *all_params, full_mode=True): + """Calls QUADCOIL. + + Takes the same parameters as compute, but can either output the + full quadcoil results, or do what compute() is supposed to do. + compute() is a wrapper for solve_quadcoil. + + Parameters + ---------- + *all_params : dict + Dictionaries of equilibrium/coils degrees of freedom, depending on + ``eq_fixed`` and ``field_fixed``. + constants : dict + Dictionary of constant data, eg transforms, + profiles etc. Defaults to self.constants + full_mode : bool + When ``True``, returns the QUADCOIL standard outputs (see the + [QUADCOIL documentation]( + https://quadcoil.readthedocs.io/en/latest/tutorial_outputs.html) + ). When ``False``, returns the scalar QUADCOIL proxy. + + Returns + ------- + f : scalar + + """ + # Importing QUADCOIL + try: + from quadcoil import get_quantity + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # Loading constants + constants = self._constants + + # Load fixed params + if self._eq_fixed: + params_eq = self._eq.params_dict + params_field = all_params + else: + params_eq = all_params[0] + if self._field: + if self._field_fixed: + params_field = constants["sum_field"].params_dict + else: + params_field = all_params[1:] + else: + params_field = {} + + # ----- Quantities with pre-computation ----- + + # Plasma dofs + if self._eq_fixed: + plasma_dofs = constants["plasma_dofs"] + else: + plasma_dofs = self.compute_plasma_surface_dofs_simsopt(params_eq) + + Bnormal = _compute_Bnormal( + field=self._field, + constants=constants, + Bnormal_shape=self._Bnormal_shape, + vacuum=self._vacuum, + eq_fixed=self._eq_fixed, + field_fixed=self._field_fixed, + params_eq=params_eq, + params_field=params_field, + bs_chunk_size=self._bs_chunk_size, + bplasma_chunk_size=self._bplasma_chunk_size, + ) + + # ----- Calling the net poloidal current ----- + if self._enable_net_current_plasma: + if self._eq_fixed: + net_poloidal_current_amperes = constants["G"] + else: + net_poloidal_current_amperes = _compute_G(params_eq, constants) + else: + net_poloidal_current_amperes = 0.0 + + # ----- Calling the quadcoil wrapper with custom_vjp ----- + if full_mode: + out_dict, qp, cp_mn, solve_results = self._quadcoil_values( + plasma_dofs=plasma_dofs, + net_poloidal_current_amperes=net_poloidal_current_amperes, + net_toroidal_current_amperes=self.net_toroidal_current_amperes, + Bnormal_plasma=Bnormal, # Because DESC plasma surface is flipped. + plasma_coil_distance=self.plasma_coil_distance, + winding_dofs=self.winding_dofs, + objective_weight=self.objective_weight, + constraint_value=self.constraint_value, + ) + return out_dict, qp, cp_mn, solve_results + # ----- Calling the quadcoil wrapper with custom_vjp ----- + # If this can't show then the error is before this + metric_dict = self._quadcoil_for_diff( + plasma_dofs=plasma_dofs, + net_poloidal_current_amperes=net_poloidal_current_amperes, + net_toroidal_current_amperes=self.net_toroidal_current_amperes, + Bnormal_plasma=Bnormal, + plasma_coil_distance=self.plasma_coil_distance, + winding_dofs=self.winding_dofs, + objective_weight=self.objective_weight, + constraint_value=self.constraint_value, + ) + + # ----- Thresholding and weighing ----- + f_out = 0.0 + for i in range(len(self.metric_name)): + # Set during the loop through quadcoil_kwargs + f_name = self.metric_name[i] + f_weight = self.metric_weight[i] + f_target_eff = self.metric_target[i] + f_val_eff = metric_dict[f_name] + # MEY NOT BE LOWERABLE? + if self._normalize or self._normalize_target: + f_unit = get_quantity(f_name + "_desc_unit")(self.scales) + if self._normalize: + f_val_eff = f_val_eff / f_unit + if self._normalize_target: + f_target_eff = f_target_eff / f_unit + f_out = f_out + f_weight * jnp.where( + f_val_eff > f_target_eff, f_val_eff - f_target_eff, 0.0 + ) + + return f_out + + def compute_plasma_surface_dofs_simsopt(self, params_eq): + """Computes the plasma surface dofs in the Simsopt convention. + + Computes the plasma surface dofs in the Simsopt convention. + + Parameters + ---------- + *all_params : dict + Dictionaries of equilibrium/coils degrees of freedom, depending on + ``eq_fixed`` and ``field_fixed``. + + Returns + ------- + plasma_dofs : ndarray + The plasma surface dofs in the Simsopt SurfaceRZFourier convention. + """ + rs_raw, rc_raw = _ptolemy_identity_rev_compute( + self._surf_R_A, + self._surf_R_c_indices, + self._surf_R_s_indices, + params_eq["Rb_lmn"], + ) + zs_raw, zc_raw = _ptolemy_identity_rev_compute( + self._surf_Z_A, + self._surf_Z_c_indices, + self._surf_Z_s_indices, + params_eq["Zb_lmn"], + ) + # Stellsym SurfaceRZFourier dofs consists of + # [rc, zs] # noqa: E800 + # Non-stellsym SurfaceRZFourier dofs consists of + # [rc, rs, zc, zs] # noqa: E800 + # Because rs, zs from ptolemy_identity_rev shares the same m, n + # arrays as rc, zc, they both have a zero as the first element + # that need to be removed. + rc = rc_raw.flatten() + rs = rs_raw.flatten()[1:] + zc = zc_raw.flatten() + zs = zs_raw.flatten()[1:] + if self.stellsym: + plasma_dofs = jnp.concatenate([rc, zs]) + else: + plasma_dofs = jnp.concatenate([rc, rs, zc, zs]) + return plasma_dofs + + def solve_quadcoil_surface_current(self, *all_params): + """Calls QUADCOIL and returns the solution as a FourierCurrentPotentialField. + + Calls QUADCOIL and returns the solution as a FourierCurrentPotentialField. + For use with DESC's built-in REGCOIL and coil-cutting features. + + Parameters + ---------- + params_eq : dict + Dictionary of equilibrium degrees of freedom, eg + Equilibrium.params_dict. + + Returns + ------- + A FourierCurrentPotentialField containing the QUADCOIL solution. + """ + # Prevents circular import + from desc.magnetic_fields import FourierCurrentPotentialField + + _, quadcoil_qp, quadcoil_dofs, _ = self.solve_quadcoil( + *all_params, full_mode=True + ) + quadcoil_kwargs_temp = { + "winding_stellsym": quadcoil_qp.winding_surface.stellsym, + "winding_mpol": quadcoil_qp.winding_surface.mpol, + "winding_ntor": quadcoil_qp.winding_surface.ntor, + "stellsym": quadcoil_qp.stellsym, + "mpol": quadcoil_qp.mpol, + "ntor": quadcoil_qp.ntor, + "net_poloidal_current_amperes": quadcoil_qp.net_poloidal_current_amperes, + "net_toroidal_current_amperes": quadcoil_qp.net_toroidal_current_amperes, + } + # This helper function converts information in a quadcoil object into + # a kwargs for DESC FourierCurrentPotentialField. + filtered = _quadcoil_kwargs_to_field_kwargs( + quadcoil_kwargs_temp, + quadcoil_dofs, + self._eq.sym, + FourierCurrentPotentialField, + self._verbose, + ) + winding_surface = quadcoil_qp.winding_surface.to_desc() + R_lmn = winding_surface.R_lmn + Z_lmn = winding_surface.Z_lmn + modes_R = winding_surface._R_basis.modes[:, 1:] + modes_Z = winding_surface._Z_basis.modes[:, 1:] + return FourierCurrentPotentialField( + # Phi_mn is already in filtered + # modes_Phi is already in filtered + # I is already in filtered + # G is already in filtered + # sym_Phi is already in filtered + # M_Phi is already in filtered + # N_Phi is already in filtered + R_lmn=R_lmn, + Z_lmn=Z_lmn, + modes_R=modes_R, + modes_Z=modes_Z, + NFP=self.nfp, + sym=self._eq.sym, # Symmetry of the plasma + # M is already in filtered + # N is already in filtered + name="QUADCOIL Proxy Output", + check_orientation=True, + **filtered, + ) diff --git a/desc/objectives/_quadcoil_utils.py b/desc/objectives/_quadcoil_utils.py new file mode 100644 index 0000000000..0355f17a10 --- /dev/null +++ b/desc/objectives/_quadcoil_utils.py @@ -0,0 +1,438 @@ +import inspect +from functools import partial + +import numpy as np +from scipy.constants import mu_0 + +from desc.backend import jit, jnp +from desc.compute import get_profiles, get_transforms +from desc.compute.utils import _compute as compute_fun +from desc.integrals import DFTInterpolator, FFTInterpolator, virtual_casing_biot_savart +from desc.utils import warnif +from desc.vmec_utils import ptolemy_identity_fwd, ptolemy_linear_transform + +# Used in create_source_grid only +from ..integrals.singularities import best_params, best_ratio + +# Data keys needed to calculate Bnormal_plasma. +_BPLASMA_DATA_KEYS = [ + "K_vc", + "B", + "R", + "phi", + "Z", + "e^rho", + "n_rho", + "|e_theta x e_zeta|", +] +# Data keys needed to calculate Bnormal from external coils. +_BCOIL_DATA_KEYS = ["R", "Z", "n_rho", "phi", "|e_theta x e_zeta|"] + + +# ----- Helper functions ----- +def _compute_Bnormal_plasma(constants, params_eq, _bplasma_chunk_size): + # Using the stored transforms to calculate B_normal_plasma + source_data = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + _BPLASMA_DATA_KEYS, + params=params_eq, + transforms=constants["source_transforms"], + profiles=constants["source_profiles"], + ) + eval_data = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + _BPLASMA_DATA_KEYS, + params=params_eq, + transforms=constants["eval_transforms"], + profiles=constants["eval_profiles"], + ) + Bplasma = virtual_casing_biot_savart( + eval_data, + source_data, + constants["interpolator"], + chunk_size=_bplasma_chunk_size, + ) + # need extra factor of B/2 bc we're evaluating on plasma surface + Bplasma = Bplasma + eval_data["B"] / 2 + Bnormal_plasma = jnp.sum(Bplasma * eval_data["n_rho"], axis=1) + return Bnormal_plasma + + +def _compute_eval_data_coils(constants, params_eq): + eval_data_coils = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + _BCOIL_DATA_KEYS, + params=params_eq, + transforms=constants["eval_transforms"], + profiles=constants["eval_profiles"], + ) + coils_x = jnp.array( + [eval_data_coils["R"], eval_data_coils["phi"], eval_data_coils["Z"]] + ).T + coils_n_rho = eval_data_coils["n_rho"] + return coils_x, coils_n_rho + + +def _compute_Bnormal_ext(constants, params_field, _bs_chunk_size): + # Computes the magnetic field from a coilset using magnetic field parameters. + coils_nrho = constants["coils_n_rho"] + coils_x = constants["coils_x"] + B_ext = constants["sum_field"].compute_magnetic_field( + coils_x, + source_grid=constants["field_grid"], + basis="rpz", + params=params_field, + chunk_size=_bs_chunk_size, + ) + B_ext = jnp.sum(B_ext * coils_nrho, axis=-1) + return B_ext + + +def _compute_G(params_eq, constants): + # Computes the net poloidal current G using equilibrium parameters. + G_data = compute_fun( + "desc.equilibrium.equilibrium.Equilibrium", + ["G"], + params=params_eq, + transforms=constants["net_poloidal_current_transforms"], + profiles=constants["net_poloidal_current_profiles"], + ) + net_poloidal_current_amperes = -G_data["G"][0] / mu_0 * 2 * jnp.pi + return net_poloidal_current_amperes + + +def _ptolemy_identity_rev_precompute(m_1, n_1): + """First half of ``ptolemy_identity_rev``. + + We have split ``ptolemy_identity_rev`` into two parts: + ``ptolemy_identity_rev_precompute`` and + ``ptolemy_identity_rev_compute``. The original ``ptolemy_identity_rev`` + relies on numpy boolean indexing. Even when we set m_1, n_1 to static, + they will still be converted to traced arrays once jit happens, and the + numpy boolean indexing will break. Because of that, we perform all numpy + operations in ``ptolemy_identity_rev_precompute`` during ``build()``, + store the results as static, and then perform all jaxable operations in + ``ptolemy_identity_rev_compute`` during ``compute()``. + + .. code-block:: python + + desc_to_vmec_surf_R = ptolemy_identity_rev_jit_precomputation( + tuple(eq.surface.R_basis.modes[:,1]), + tuple(eq.surface.R_basis.modes[:,2]) + ) + desc_to_vmec_surf_Z = ptolemy_identity_rev_jit_precomputation( + tuple(eq.surface.Z_basis.modes[:,1]), + tuple(eq.surface.Z_basis.modes[:,2]) + ) + rs_raw, rc_raw = desc_to_vmec_surf_R(eq.surface.R_lmn) + # Stellsym SurfaceRZFourier's dofs consists of + zs_raw, zc_raw = desc_to_vmec_surf_Z(eq.surface.Z_lmn) + # [rc, zs] # noqa: E800 + # Non-stellsym SurfaceRZFourier's dofs consists of + # [rc, rs, zc, zs] # noqa: E800 + # Because rs, zs from ptolemy_identity_rev shares the same m, n + # arrays as rc, zc, they both have a zero as the first element + # that need to be removed. + rc = rc_raw.flatten() + rs = rs_raw.flatten()[1:] + zc = zc_raw.flatten() + zs = zs_raw.flatten()[1:] + if eq.sym: + dofs = jnp.concatenate([rc, zs]) + else: + dofs = jnp.concatenate([rc, rs, zc, zs]) + + Converts from a double Fourier series of the form: + ss * sin(m𝛉) * sin(nπ›Ÿ) + sc * sin(m𝛉) * cos(nπ›Ÿ) + + cs * cos(m𝛉) * sin(nπ›Ÿ) + cc * cos(m𝛉) * cos(nπ›Ÿ) + to the double-angle form: + s * sin(m𝛉-nπ›Ÿ) + c * cos(m𝛉-nπ›Ÿ) + using Ptolemy's sum and difference formulas. + + Parameters + ---------- + m_1 : ndarray, shape(num_modes,) + n_1 : ndarray, shape(num_modes,) + ``R_basis_modes[:,1], R_basis_modes[:,2]`` + or ``Z_basis_modes[:,1], Z_basis_modes[:,2]`` + + Returns + ------- + A, c_indices, s_indices : tuples + .. code-block:: python + + # For calculating rs_raw, rc_raw, + x = np.atleast_2d(desc_surf.R_lmn) + y = (A @ x.T).T + rs_raw, rc_raw = _modes_x_to_mnsc(vmec_modes, y) + + """ + # Precomputing linear operators + m_1, n_1 = map(np.atleast_1d, (m_1, n_1)) + desc_modes = np.vstack([np.zeros_like(m_1), m_1, n_1]).T + A, vmec_modes = ptolemy_linear_transform(desc_modes) + cmask = vmec_modes[:, 0] == 1 + smask = vmec_modes[:, 0] == -1 + c_indices = np.where(cmask)[0] + s_indices = np.where(smask)[0] + # A is 2d, and this converts 2d arr to tuple. + A = tuple(map(tuple, A.tolist())) + c_indices = tuple(c_indices.tolist()) + s_indices = tuple(s_indices.tolist()) + return A, c_indices, s_indices + + +@partial( + jit, + static_argnames=[ + "A", + "c_indices", + "s_indices", + ], +) +def _ptolemy_identity_rev_compute(A, c_indices, s_indices, x): + # Second half of ptolemy_identity_rev + A = jnp.array(A) + y = (A @ x.T).T + if len(c_indices): + c = (y.T[jnp.array(c_indices)]).T + if len(s_indices): + s = (y.T[jnp.array(s_indices)]).T + # if there are sin terms, add a zero for the m=n=0 mode + s = jnp.concatenate([jnp.zeros_like(s.T[:1]), s.T]).T + + if not len(s_indices): + s = jnp.zeros_like(c) + if not len(c_indices): + c = jnp.zeros_like(s) + assert len(s.T) == len(c.T) + return s, c + + +# For interpolating quadpoints_theta and quadpoints_phi +def _interpolate_array(x, k: int, period): + x_roll = jnp.append(x, period + x[0]) + # differences between adjacent values + dx = jnp.diff(x_roll) + # interpolation weights: 0, 1/k, 2/k, ..., (k-1)/k + w = jnp.linspace(0, 1, k, endpoint=False) + # broadcast and add + blocks = x[:, None] + dx[:, None] * w[None, :] + # flatten and append the last element + return blocks.ravel() + + +def _compute_Bnormal( + field, + constants, + Bnormal_shape, + vacuum, + eq_fixed, + field_fixed, + params_eq, + params_field, + bs_chunk_size, + bplasma_chunk_size, +): + + Bnormal = jnp.zeros(Bnormal_shape) + + if field: + if eq_fixed: + if field_fixed: + Bnormal += constants["Bnormal_ext"].reshape( + Bnormal.shape + ) # eq and field fixed + else: + Bnormal += _compute_Bnormal_ext( + constants, params_field, bs_chunk_size + ).reshape( + Bnormal.shape + ) # neither fixed, field fixed only. + else: + coils_x, coils_n_rho = _compute_eval_data_coils(constants, params_eq) + constants["coils_x"] = coils_x + constants["coils_n_rho"] = coils_n_rho + Bnormal += _compute_Bnormal_ext( + constants, params_field, bs_chunk_size + ).reshape( + Bnormal.shape + ) # neither fixed, field fixed only. + + # Plasma fields + if not vacuum: + if eq_fixed: + Bnormal += constants["Bnormal_plasma"].reshape(Bnormal.shape) + else: + Bnormal += _compute_Bnormal_plasma( + constants, params_eq, bplasma_chunk_size + ).reshape(Bnormal.shape) + + return Bnormal + + +# Flipping the current potential of a quadcoil +# phi Fourier array in the toroidal direction +def _toroidal_flip(phi, m, n): + m = np.array(m) + n = np.array(n) + phi_swapped = np.array(phi) + index_map = {(mi, ni): i for i, (mi, ni) in enumerate(zip(m, n))} + for i, (mi, ni) in enumerate(zip(m, n)): + # skip n=0 (it’s its own opposite) + if ni == 0: + continue + if mi != 0: + j = index_map.get((mi, -ni)) + if j is not None: + phi_swapped[i] = phi[j] + else: + phi_swapped[i] = -phi[i] + return phi_swapped + + +def _quadcoil_phi_to_desc_phi(phi_mn_quadcoil, stellsym, mpol, ntor): + # Importing QUADCOIL + try: + from quadcoil import make_rzfourier_mc_ms_nc_ns + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # Converts quadcoil phi to desc phi. + if stellsym: + # The dofs contain rc, zs, and rc has one more element than zs. + phis = phi_mn_quadcoil + phic = jnp.zeros(len(phis) + 1) + else: + # The dofs contain rc, zs, and rc has one more element than zs. + len_sin = len(phi_mn_quadcoil) // 2 + phis = phi_mn_quadcoil[-len_sin:] + phic = phi_mn_quadcoil[:-len_sin] + + phis = jnp.insert(phis, 0, 0.0) + mc, _, nc, _ = make_rzfourier_mc_ms_nc_ns(mpol, ntor) + modes_M, modes_N, Phi_mn = ptolemy_identity_fwd(mc, nc, phis, phic) + Phi_mn = Phi_mn.flatten() + return Phi_mn, modes_M, modes_N + + +def _create_source(eq, source_grid, eval_grid): + # Creating interpolator for Bnormal_plasma + ratio_data = eq.compute( + ["|e_theta x e_zeta|", "e_theta", "e_zeta"], grid=source_grid + ) + st, sz, q = best_params(source_grid, best_ratio(ratio_data)) + try: + interpolator = FFTInterpolator(eval_grid, source_grid, st, sz, q) + except AssertionError as e: + warnif( + True, + msg="Could not build fft interpolator, switching to dft which is slow." + "\nReason: " + str(e), + ) + interpolator = DFTInterpolator(eval_grid, source_grid, st, sz, q) + # Creating source grids + source_profiles = get_profiles(_BPLASMA_DATA_KEYS, obj=eq, grid=source_grid) + source_transforms = get_transforms(_BPLASMA_DATA_KEYS, obj=eq, grid=source_grid) + return (source_profiles, source_transforms, interpolator) + + +def _quadcoil_kwargs_to_field_kwargs( # noqa: C901 + quadcoil_kwargs, quadcoil_dofs, sym_default, target_type, verbose, flip_phi=False +): + # This helper function converts information in a quadcoil object into + # a kwargs for DESC FourierCurrentPotentialField. + # Importing QUADCOIL + try: + from quadcoil import QuadcoilParams + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + # Converts a kwargs for quadcoil into a kwargs for QuadcoilField or + # FourierCurrentPotentialField + filtered = {} + source_kwargs = quadcoil_kwargs.copy() + winding_stellsym = source_kwargs.get("winding_stellsym", sym_default) + + # Importing QUADCOIL + try: + from quadcoil import SurfaceRZFourierJAX + except ModuleNotFoundError: + raise ModuleNotFoundError("QuadcoilProxy requires a QUADCOIL installation.") + + # Reading winding surface information. + if "winding_dofs" in source_kwargs.keys(): + winding_dofs = source_kwargs.pop("winding_dofs") + quadcoil_winding_surface = SurfaceRZFourierJAX( + nfp=source_kwargs["nfp"], + stellsym=winding_stellsym, + mpol=source_kwargs["winding_mpol"], + ntor=source_kwargs["winding_ntor"], + quadpoints_phi=source_kwargs["winding_quadpoints_phi"], + quadpoints_theta=source_kwargs["winding_quadpoints_theta"], + dofs=winding_dofs, + ) + filtered["winding_surface"] = quadcoil_winding_surface.to_desc() + + stellsym = source_kwargs.get("stellsym", sym_default and winding_stellsym) + if stellsym: + filtered["sym_Phi"] = "sin" + else: + filtered["sym_Phi"] = False + filtered["smoothing"] = "approx" + filtered["smoothing_params"] = {"lse_epsilon": 1e-3} + # Initialize using a Quadcoil initial guess + if quadcoil_dofs is not None: + try: + aux_dofs_vals = quadcoil_dofs.copy() + phi_pre_flip = aux_dofs_vals.pop("phi") + mpol = quadcoil_kwargs["mpol"] + ntor = quadcoil_kwargs["ntor"] + # TODO: This seems necessary when loading some winding surfaces + # from simsopt, but not necessary if the winding surface is + # auto-generated. Make this more robust later. + if flip_phi: + m, n = QuadcoilParams.make_mn_helper(mpol, ntor, stellsym) + phi_flipped = _toroidal_flip(phi_pre_flip, m, n) + else: + phi_flipped = phi_pre_flip + Phi_mn, modes_M, modes_N = _quadcoil_phi_to_desc_phi( + phi_mn_quadcoil=phi_flipped, stellsym=stellsym, mpol=mpol, ntor=ntor + ) + modes_Phi = np.stack((modes_M, modes_N)).T.astype(np.int32) + filtered["aux_dofs_vals"] = aux_dofs_vals + filtered["Phi_mn"] = Phi_mn + filtered["modes_Phi"] = modes_Phi + + except KeyError: + raise KeyError( + "When an initial guess is provided via quadcoil_dofs, " + "mpol and ntor (mode numbers of the current potential) " + "must also be provided." + ) + + # Renaming arguments (quadcoil and FourierCurrentPotential + # have some different naming conventions) + rename_map = { + "winding_mpol": "M", + "winding_ntor": "N", + "mpol": "M_Phi", + "ntor": "N_Phi", + "net_poloidal_current_amperes": "G", + "net_toroidal_current_amperes": "I", + } + + # Rename keys as needed + source_kwargs = {rename_map.get(k, k): v for k, v in source_kwargs.items()} + + # Filter only parameters accepted by target_func + target_params = inspect.signature(target_type).parameters + filtered = filtered | source_kwargs + filtered = {k: v for k, v in filtered.items() if k in target_params.keys()} + discarded_kwargs = [k for k, v in filtered.items() if k not in target_params.keys()] + if discarded_kwargs and verbose > 1: + print( + "The following items in quadcoil_kwargs will be ignored " + "because they will be automatically calculated by or has alternative " + "definitions in " + str(target_type) + ": " + str(discarded_kwargs) + ) + return filtered diff --git a/devtools/dev-requirements.txt b/devtools/dev-requirements.txt index e131231905..3d7693581f 100644 --- a/devtools/dev-requirements.txt +++ b/devtools/dev-requirements.txt @@ -37,6 +37,7 @@ pytest-split >= 0.8.2, <= 0.11.0 qicna @ git+https://github.com/rogeriojorge/pyQIC/ qsc <= 0.1.3 shapely >= 1.8.2, <= 2.1.2 +quadcoil >= 0.1.0 # building build diff --git a/docs/api_objectives.rst b/docs/api_objectives.rst index 72b6468e78..f7a8e50e46 100644 --- a/docs/api_objectives.rst +++ b/docs/api_objectives.rst @@ -133,6 +133,7 @@ Coil Optimization desc.objectives.ToroidalFlux desc.objectives.SurfaceCurrentRegularization desc.objectives.LinkingCurrentConsistency + desc.objectives.QuadcoilProxy Profiles diff --git a/docs/index.rst b/docs/index.rst index 2096b112f6..574bddeee1 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -44,6 +44,7 @@ notebooks/tutorials/basic_optimization.ipynb notebooks/tutorials/advanced_optimization.ipynb notebooks/tutorials/coil_optimization_REGCOIL.ipynb + notebooks/tutorials/coil_optimization_QUADCOIL.ipynb notebooks/tutorials/omnigenity.ipynb notebooks/tutorials/bootstrap_current.ipynb notebooks/tutorials/coil_stage_two_optimization.ipynb diff --git a/docs/notebooks/tutorials/coil_optimization_QUADCOIL.ipynb b/docs/notebooks/tutorials/coil_optimization_QUADCOIL.ipynb new file mode 100644 index 0000000000..e954a2af53 --- /dev/null +++ b/docs/notebooks/tutorials/coil_optimization_QUADCOIL.ipynb @@ -0,0 +1,1786 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1d92f237", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "# QUADCOIL coil and equilibrium optimization\n", + "\n", + "## What is QUADCOIL\n", + "QUADCOIL [1] is a new differentiable winding surface code. Unlike REGCOIL, QUADCOIL can solve a general QCQP:\n", + "\n", + "$$\\min f(\\Phi_{sv})$$\n", + "$$g_i(\\Phi_{sv})\\leq 0$$\n", + "$$h_j(\\Phi_{sv}) =0 $$\n", + "\n", + "where $f$, $g_i$, and $h_j$ can be any quadratic functions. It also includes a winding surface generator that automatically removes self-intersections. QUADCOIL is a standalone code built on the same numerical tools as DESC. To use the QUADCOIL integrations, please first [install QUADCOIL here](https://quadcoil.readthedocs.io/en/latest/index.html).\n", + "\n", + "Compared to REGCOIL, it can:\n", + "\n", + "1) Models more realistic quantites, such as:\n", + " - Magnetic field errors (including $\\chi^2_B$, which REGCOIL uses).\n", + " - Sheet current density and topology (including $\\chi^2_K$, which REGCOIL uses).\n", + " - Dipole density and sparsity.\n", + " - Lorentz force.\n", + " - Filament coil curvature.\n", + "2) Generate better-behaved winding surfaces.\n", + "3) Supports inequality and equality constraints.\n", + "4) (Using constraints) directly specify target values instead of scanning\n", + "a regularization weight $\\lambda_{regularization}$.\n", + "5) Serve as a coil complexity metric in DESC equilibrium optimization. " + ] + }, + { + "cell_type": "markdown", + "id": "87a71626-adab-4c66-8357-cc1ad9744d99", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-27T19:02:05.483793Z", + "iopub.status.busy": "2026-02-27T19:02:05.483611Z", + "iopub.status.idle": "2026-02-27T19:02:05.487748Z", + "shell.execute_reply": "2026-02-27T19:02:05.487294Z", + "shell.execute_reply.started": "2026-02-27T19:02:05.483780Z" + } + }, + "source": [ + "## Outline\n", + "\n", + "This tutorial shows how to use QUADCOIL for the following:\n", + "\n", + "1) Solving a NESCOIL problem.\n", + "2) Solving a REGCOIL-like constrained problem.\n", + "3) Solving a force minimization problem.\n", + "4) Performing equilibrium optimization using QUADCOIL as a coil complexity proxy. We will reproduce the numerical example in [2] and show how to use QUADCOIL to create a ARIES-CS-like equilibrium with low coil forces." + ] + }, + { + "cell_type": "markdown", + "id": "656f3b3a", + "metadata": {}, + "source": [ + "If you have access to a GPU, uncomment the following two lines before any DESC or JAX related imports. You should see about an order of magnitude speed improvement with only these two lines of code!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "80d07827", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:30.821201Z", + "iopub.status.busy": "2026-08-12T20:03:30.821124Z", + "iopub.status.idle": "2026-08-12T20:03:32.139602Z", + "shell.execute_reply": "2026-08-12T20:03:32.138992Z", + "shell.execute_reply.started": "2026-08-12T20:03:30.821191Z" + } + }, + "outputs": [], + "source": [ + "# from desc import set_device\n", + "\n", + "# set_device(\"gpu\")" + ] + }, + { + "cell_type": "markdown", + "id": "ec75629c-2486-4a4d-ad73-2abc797fb20a", + "metadata": {}, + "source": [ + "Importing libraries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6bcd497-0c81-480d-a7b5-315d2a32706e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:32.140343Z", + "iopub.status.busy": "2026-08-12T20:03:32.140197Z", + "iopub.status.idle": "2026-08-12T20:03:38.475829Z", + "shell.execute_reply": "2026-08-12T20:03:38.475449Z", + "shell.execute_reply.started": "2026-08-12T20:03:32.140324Z" + } + }, + "outputs": [], + "source": [ + "import desc\n", + "import time\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from desc.backend import jnp\n", + "from desc.grid import LinearGrid\n", + "from desc.plotting import plot_2d, plot_comparison\n", + "from desc.objectives import (\n", + " QuadcoilProxy,\n", + " QuadraticFlux,\n", + " SurfaceCurrentRegularization,\n", + " QuasisymmetryTripleProduct,\n", + " Volume,\n", + " ForceBalance,\n", + " FixBoundaryR,\n", + " FixBoundaryZ,\n", + " FixPsi,\n", + " FixPressure,\n", + " FixIota,\n", + " ObjectiveFunction,\n", + ")\n", + "from desc.optimize import Optimizer\n", + "from desc.magnetic_fields import solve_regularized_surface_current\n", + "from desc.equilibrium import EquilibriaFamily\n", + "from quadcoil.quantity import f_B, f_K, Phi_with_net_current, K, f_l1_force_cyl" + ] + }, + { + "cell_type": "markdown", + "id": "397e841d", + "metadata": {}, + "source": [ + "As mentioned in [DESC Documentation on performance tips](https://desc-docs.readthedocs.io/en/latest/performance_tips.html), one can use compilation cache directory to reduce the compilation overhead time. Note: One needs to create `jax-caches` folder manually." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa8f61eb", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:38.476299Z", + "iopub.status.busy": "2026-08-12T20:03:38.476135Z", + "iopub.status.idle": "2026-08-12T20:03:38.478153Z", + "shell.execute_reply": "2026-08-12T20:03:38.477820Z", + "shell.execute_reply.started": "2026-08-12T20:03:38.476290Z" + } + }, + "outputs": [], + "source": [ + "# import jax\n", + "# jax.config.update(\"jax_compilation_cache_dir\", \"../jax-caches\")\n", + "# jax.config.update(\"jax_persistent_cache_min_entry_size_bytes\", -1)\n", + "# jax.config.update(\"jax_persistent_cache_min_compile_time_secs\", 0)" + ] + }, + { + "cell_type": "markdown", + "id": "18df206f", + "metadata": {}, + "source": [ + "We use the AREIS-CS equilibrium for this example. ARIES-CS is also used as the\n", + "initial state in the QUADCOIL quasi-single-stage paper [2]." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06611983", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:38.478442Z", + "iopub.status.busy": "2026-08-12T20:03:38.478370Z", + "iopub.status.idle": "2026-08-12T20:03:39.435326Z", + "shell.execute_reply": "2026-08-12T20:03:39.434812Z", + "shell.execute_reply.started": "2026-08-12T20:03:38.478434Z" + } + }, + "outputs": [], + "source": [ + "aries_eq = desc.examples.get(\"ARIES-CS\")\n", + "# The original ARIES-CS equilibrium has very high resolution\n", + "# (L=24, M=12, N=8) and requires ~7GB VRAM to perform basic equilibrium\n", + "# optimization. Here, we reduce the resolution to reduce VRAM usage to ~2GB.\n", + "aries_eq.change_resolution(L=6, M=6, N=6)" + ] + }, + { + "cell_type": "markdown", + "id": "f11c97f7", + "metadata": {}, + "source": [ + "## General settings\n", + "First, define some QUADCOIL settings." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "754dd316", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:39.435780Z", + "iopub.status.busy": "2026-08-12T20:03:39.435695Z", + "iopub.status.idle": "2026-08-12T20:03:39.490076Z", + "shell.execute_reply": "2026-08-12T20:03:39.489682Z", + "shell.execute_reply.started": "2026-08-12T20:03:39.435770Z" + } + }, + "outputs": [], + "source": [ + "# Settings\n", + "mpol = 8 # Num. poloidal modes for the current potential\n", + "ntor = 8 # Num. toroidal modes for the current potential\n", + "# Controls the resolution of the plasma surface integration.\n", + "# Integration in quadcoil is naively performed using summation\n", + "# so we recommend at least 16 here.\n", + "# This corresponds to a (33 x 33) grid.\n", + "plasma_coil_distance = (\n", + " 1.3 # 1.64 is the Wiedman value # 1.5 m is a common rule-of-thumb value\n", + ")\n", + "coil_coil_distance = 0.77 # 1.10 is the Wiedman value\n", + "coil_per_half_fp = 3 # 3 is the Wiedman value\n", + "curvature_target = 0.88 # 0.88 is the Wiedman value\n", + "# f_B_target_norm = 1e-4\n", + "# radius_of_curvature = 0.5 # 0.5m is the infinity two value\n", + "# Resolution for sampling objectives\n", + "quadpoints_phi = jnp.linspace(0, 1 / aries_eq.NFP, 33, endpoint=False)\n", + "quadpoints_theta = jnp.linspace(0, 1, 33, endpoint=False)" + ] + }, + { + "cell_type": "markdown", + "id": "fbce3873", + "metadata": {}, + "source": [ + "The QUADCOIL objective is mostly controlled using a dictionary, `quadcoil_kwargs`\n", + "that contains arguments that would otherwise be passed into a call of `quadcoil.quadcoil()`.\n", + "For a tutorial on `quadcoil.quadcoil()`, \n", + "[see here](https://quadcoil.readthedocs.io/en/latest/tutorial_inputs.html). \n", + "\n", + "\n", + "If your `quadcoil_kwargs` is good for directly calling `quadcoil.quadcoil(**quadcoil_kwargs)`, it will also work here.\n", + "\n", + "\n", + "Because a `QuadcoilProxy` is attached to an `Equilibrium`, the following arguments\n", + "will instead be calculated from the `Equilibrium`. Their values will be ignored if provided.\n", + "\n", + "```\n", + "\"nfp\" # Num. field period\n", + "\"stellsym\", # Stellarator symmetry\n", + "\"plasma_mpol\", # Plasma poloidal Fourier mode number \n", + "\"plasma_ntor\", # Plasma toroidal Fourier mode number \n", + "\"plasma_quadpoints_phi\", # Plasma integral quadrature points. Will be \n", + "\"plasma_quadpoints_theta\", # auto-generated from plasma_M_theta and plasma_N_phi.\n", + "\"plasma_dofs\", # Plasma surface Fourier coefficients\n", + "\"net_poloidal_current_amperes\", # Net poloidal current required on the winding surface\n", + "\"Bnormal_plasma\", # B normal on the plasma boundary \n", + "\"metric_name\", # What coil properties to output. Will be controlled \n", + " # by an identically named argument to QuadcoilProxy\n", + "\"value_only\" # Controls whether to skip adjoint differentiation.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "113b1b28", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:39.490450Z", + "iopub.status.busy": "2026-08-12T20:03:39.490368Z", + "iopub.status.idle": "2026-08-12T20:03:39.492187Z", + "shell.execute_reply": "2026-08-12T20:03:39.491892Z", + "shell.execute_reply.started": "2026-08-12T20:03:39.490441Z" + } + }, + "outputs": [], + "source": [ + "quadcoil_kwargs_basic = {\n", + " \"mpol\": mpol,\n", + " \"ntor\": ntor,\n", + " # Resolutions for evaluating winding-surface\n", + " # pointwise objectives and plotting.\n", + " # Note that this does not control the resolution\n", + " # for evaluating winding surface integrals.\n", + " # The integral resolution is controlled using\n", + " # winding_quadpoints_phi and winding_quadpoints_theta.\n", + " # Here, we use the default value of 33x(32xnfp), which\n", + " # is often good enough.\n", + " \"quadpoints_phi\": quadpoints_phi,\n", + " \"quadpoints_theta\": quadpoints_theta,\n", + " \"plasma_coil_distance\": plasma_coil_distance,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "4bd8b5be", + "metadata": {}, + "source": [ + "## 1. Solving the NESCOIL problem\n", + "As a first example, we solve the NESCOIL problem:\n", + "$$\\min_{\\Phi'} \\chi^2_B.$$\n", + "Here $\\chi^2_B$ is the squared flux at the plasma boundary." + ] + }, + { + "cell_type": "markdown", + "id": "c6bfc903-edc6-4ed0-af2f-26fea7a2b231", + "metadata": {}, + "source": [ + "The objectives and constraints in quadcoil are chosen\n", + "by feeding strings representing the name of the \n", + "quantities as arguments. The first example, the NESCOIL\n", + "problem, has one objective term (the squared flux \n", + "`\"f_B\"`) and no constraints." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e3c81118", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:39.731947Z", + "iopub.status.busy": "2026-08-12T20:03:39.731865Z", + "iopub.status.idle": "2026-08-12T20:03:39.733656Z", + "shell.execute_reply": "2026-08-12T20:03:39.733351Z", + "shell.execute_reply.started": "2026-08-12T20:03:39.731940Z" + } + }, + "outputs": [], + "source": [ + "quadcoil_kwargs_nescoil = quadcoil_kwargs_basic | {\n", + " # The NESCOIL problem only contains the squared\n", + " # flux objective. In QUADCOIL, this quantity is called\n", + " # f_B.\n", + " \"objective_name\": \"f_B\",\n", + " # The NESCOIL problem is simple enough to need no normalization\n", + " # constants. In the next example we will discuss how to choose\n", + " # this constant.\n", + " \"objective_unit\": None,\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "c6991fc7", + "metadata": {}, + "source": [ + "QUADCOIL is integrated into DESC as an objective function. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "eee7ebea", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:39.733916Z", + "iopub.status.busy": "2026-08-12T20:03:39.733846Z", + "iopub.status.idle": "2026-08-12T20:03:42.556882Z", + "shell.execute_reply": "2026-08-12T20:03:42.556312Z", + "shell.execute_reply.started": "2026-08-12T20:03:39.733909Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "# Define a QuadcoilProxy with the simplest possible\n", + "# signature.\n", + "objective_nescoil = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_nescoil,\n", + " vacuum=False,\n", + " # If you have additional filament/planar coils, put the CoilSet here.\n", + " # field=[],\n", + ")\n", + "objective_nescoil.build()" + ] + }, + { + "cell_type": "markdown", + "id": "f6336b32", + "metadata": {}, + "source": [ + "### Calling QUADCOIL (outputting QUADCOIL types)\n", + "To call QUADCOIL, use `QuadcoilProxy.solve_quadcoil()`. The signature of this function is the same as `Objective.compute()` or `Objective.compute_scalar()`. The output is the same as `quadcoil.quadcoil()`. See [here](https://quadcoil.readthedocs.io/en/latest/tutorial_outputs.html) for a tutorial for interpreting QUADCOIL outputs.\n", + "\n", + "Note that calling `QuadcoilProxy` in DESC is slightly more costly than directly calling `quadcoil.quadcoil()`. This is because `QuadcoilProxy` also calculates $B_\\text{normal}$ and the net poloidal current." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d66c7642", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:42.557286Z", + "iopub.status.busy": "2026-08-12T20:03:42.557203Z", + "iopub.status.idle": "2026-08-12T20:03:55.043965Z", + "shell.execute_reply": "2026-08-12T20:03:55.043572Z", + "shell.execute_reply.started": "2026-08-12T20:03:42.557279Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The squared flux is 1.2214940896466382 T^2m^2\n" + ] + } + ], + "source": [ + "# The outputs are:\n", + "# - out_dict: a dictionary storing the value and gradients of the\n", + "# metrics chosen in metric_name. By default the chosen metric\n", + "# f_obj, the exact same function that QUADCOIL uses as the\n", + "# objective function.\n", + "# - qp: a quadcoil container for the winding surface, plasma surface\n", + "# and plasma B normal. One of the 2 arguments required to evaluate\n", + "# any quantity in QUADCOIL\n", + "# - dofs: a dict containing the current potential's Fourier coefficients\n", + "# and additional slack variables (if any). The other one of the 2\n", + "# arguments required to evaluate any quantity in QUADCOIL\n", + "# - status: a dict containing some status of the optimizer.\n", + "out_dict_nescoil, qp_nescoil, dofs_nescoil, status_nescoil = (\n", + " objective_nescoil.solve_quadcoil(\n", + " # Like Objective.compute(), the xs of the equilibrium\n", + " # must be passed in as the *arg.\n", + " *objective_nescoil.xs(aries_eq)\n", + " )\n", + ")\n", + "print(\"The squared flux is\", f_B(qp_nescoil, dofs_nescoil), \"T^2m^2\")" + ] + }, + { + "cell_type": "markdown", + "id": "11db0a61-aad9-443b-a1bf-66843abc474b", + "metadata": {}, + "source": [ + "Plotting the current contours using QUADCOIL.\n", + "The full Phi (with both single-valued and secular\n", + "components) is called Phi_with_net_current.\n", + "Physical quantities in QUADCOIL are all stored \n", + "in `quadcoil.quantity`. All quantities take the following\n", + "two arguments:\n", + "- `qp` This is an object storing the plasma surface, winding \n", + "surface, and $B_\\text{norm}$.\n", + "- `dofs` (a dictionary\n", + "storing $\\Phi$ and any slack variables)\n", + "\n", + "These are the second and third outputs of `quadcoil.quadcoil()`\n", + "or `QuadcoilProxy.solve_quadcoil()`." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c1724458", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:55.044339Z", + "iopub.status.busy": "2026-08-12T20:03:55.044253Z", + "iopub.status.idle": "2026-08-12T20:03:55.221416Z", + "shell.execute_reply": "2026-08-12T20:03:55.220971Z", + "shell.execute_reply.started": "2026-08-12T20:03:55.044331Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4, 4))\n", + "# Phi_with_net_current is imported from quadcoil.quantity\n", + "plt.contour(Phi_with_net_current(qp_nescoil, dofs_nescoil), levels=20)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2e41c1ec", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:55.221846Z", + "iopub.status.busy": "2026-08-12T20:03:55.221750Z", + "iopub.status.idle": "2026-08-12T20:03:59.757392Z", + "shell.execute_reply": "2026-08-12T20:03:59.757035Z", + "shell.execute_reply.started": "2026-08-12T20:03:55.221837Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extracting and plotting the winding surface\n", + "aries_ws = qp_nescoil.winding_surface.to_desc()\n", + "plot_comparison(\n", + " [aries_ws, aries_eq],\n", + " labels=[\"Winding surface\", \"Plasma surface\"],\n", + " theta=0,\n", + " rho=np.array(1.0),\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "ac499a4b", + "metadata": {}, + "source": [ + "### Calling QUADCOIL (outputting DESC REGCOIL types)\n", + "Alternatively, one can also run\n", + "```QuadcoilProxy.solve_quadcoil_surface_current()``` \n", + "to call QUADCOIL and output the result as a DESC object (see the DESC REGCOIL tutorial)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4efeb443", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:03:59.757746Z", + "iopub.status.busy": "2026-08-12T20:03:59.757663Z", + "iopub.status.idle": "2026-08-12T20:04:01.549879Z", + "shell.execute_reply": "2026-08-12T20:04:01.549458Z", + "shell.execute_reply.started": "2026-08-12T20:03:59.757737Z" + } + }, + "outputs": [], + "source": [ + "scf_nescoil = objective_nescoil.solve_quadcoil_surface_current(\n", + " # Like Objective.compute(), the xs of the equilibrium\n", + " # must be passed in as the *arg.\n", + " *objective_nescoil.xs(aries_eq)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "fdafc3ab-d1d8-41cd-a8b6-90a498db4d2c", + "metadata": {}, + "source": [ + "### Consistency with DESC's built-in REGCOIL\n", + "We now demonstrate the consistency between QUADCOIL and DESC's built-in REGCOIL." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a4c3dcf1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:01.550331Z", + "iopub.status.busy": "2026-08-12T20:04:01.550246Z", + "iopub.status.idle": "2026-08-12T20:04:28.349437Z", + "shell.execute_reply": "2026-08-12T20:04:28.349055Z", + "shell.execute_reply.started": "2026-08-12T20:04:01.550323Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##########################################################\n", + "Calculating Phi_SV for lambda_regularization = 0.00000e+00\n", + "##########################################################\n", + "chi^2 B = 2.44216e+00\n", + "min Bnormal = 7.28504e-15 (T)\n", + "Max Bnormal = 2.14959e-01 (T)\n", + "Avg Bnormal = 3.21799e-02 (T)\n", + "min Bnormal = 1.19235e-15 (unitless)\n", + "Max Bnormal = 3.51825e-02 (unitless)\n", + "Avg Bnormal = 5.26690e-03 (unitless)\n" + ] + } + ], + "source": [ + "# Solving the NESCOIL problem using DESC's built in REGCOIL.\n", + "# Please see the REGCOIL-like coil optimization tutorial\n", + "fields, data = solve_regularized_surface_current(\n", + " scf_nescoil, # the surface current field whose geometry and Phi resolution will be used\n", + " eq=aries_eq, # the Equilibrium object to minimize Bn on the surface of\n", + " source_grid=objective_nescoil._constants[\"source_grid\"], # source grid\n", + " eval_grid=objective_nescoil._constants[\"eval_grid\"], # evaluation grid\n", + " current_helicity=(1, 0),\n", + " lambda_regularization=jnp.array([0]),\n", + " vacuum=False,\n", + " regularization_type=\"regcoil\",\n", + " chunk_size=30,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d8eeebb", + "metadata": {}, + "outputs": [], + "source": [ + "def compare_desc_regcoil_quadcoil(quadcoil, regcoil):\n", + " fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", + " plot_2d(quadcoil, \"Phi\", levels=10, filled=False, ax=axs[0])\n", + " axs[0].set_title(\"The QuadcoilProxy sln\")\n", + " plot_2d(regcoil, \"Phi\", levels=10, filled=False, ax=axs[1])\n", + " axs[1].set_title(\"The DESC-REGCOIL sln\")\n", + " axs[2].plot(quadcoil.Phi_mn, label=\"QuadcoilProxy\")\n", + " axs[2].plot(regcoil.Phi_mn, label=\"DESC-REGCOIL\", linestyle=\"dashed\")\n", + " axs[2].legend()\n", + " axs[2].set_title(\"Phi Fourier coefficients\")\n", + " norm = jnp.max(jnp.abs(regcoil.Phi_mn))\n", + " err_phi = jnp.abs(quadcoil.Phi_mn - regcoil.Phi_mn)\n", + " print(\n", + " \"Difference between Phi coefficients of DESC \"\n", + " \"REGCOIL and QUADCOIL Fourier coefficients\"\n", + " )\n", + " print(\"Maximum absolute: \", jnp.max(err_phi))\n", + " print(\"Mininum absolute: \", jnp.min(err_phi))\n", + " print(\"Average absolute: \", jnp.average(err_phi))\n", + " print(\"Maximum normalized (by max Phi): \", jnp.max(err_phi) / norm)\n", + " print(\"Mininum normalized (by max Phi): \", jnp.min(err_phi) / norm)\n", + " print(\"Average normalized (by max Phi): \", jnp.average(err_phi) / norm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "48de0762", + "metadata": {}, + "outputs": [], + "source": [ + "# Call this instead\n", + "# compare_desc_regcoil_quadcoil(scf_nescoil, fields[0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3509c4aa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:28.349933Z", + "iopub.status.busy": "2026-08-12T20:04:28.349845Z", + "iopub.status.idle": "2026-08-12T20:04:29.634681Z", + "shell.execute_reply": "2026-08-12T20:04:29.634173Z", + "shell.execute_reply.started": "2026-08-12T20:04:28.349924Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between Phi coefficients of DESC REGCOIL and QUADCOIL Fourier coefficients\n", + "Maximum absolute: 243026.23914023372\n", + "Mininum absolute: 45.23734664553194\n", + "Average absolute: 21162.2865072585\n", + "Maximum normalized (by max Phi): 0.05227779081695198\n", + "Mininum normalized (by max Phi): 9.731083167873232e-06\n", + "Average normalized (by max Phi): 0.004552255719994439\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", + "plot_2d(scf_nescoil, \"Phi\", levels=10, filled=False, ax=axs[0])\n", + "axs[0].set_title(\"The QuadcoilProxy sln\")\n", + "plot_2d(fields[0], \"Phi\", levels=10, filled=False, ax=axs[1])\n", + "axs[1].set_title(\"The DESC-REGCOIL sln\")\n", + "axs[2].plot(scf_nescoil.Phi_mn, label=\"QuadcoilProxy\")\n", + "axs[2].plot(fields[0].Phi_mn, label=\"DESC-REGCOIL\", linestyle=\"dashed\")\n", + "axs[2].legend()\n", + "axs[2].set_title(\"Phi Fourier coefficients\")\n", + "norm = jnp.max(jnp.abs(fields[0].Phi_mn))\n", + "err_phi = jnp.abs(scf_nescoil.Phi_mn - fields[0].Phi_mn)\n", + "print(\n", + " \"Difference between Phi coefficients of DESC \"\n", + " \"REGCOIL and QUADCOIL Fourier coefficients\"\n", + ")\n", + "print(\"Maximum absolute: \", jnp.max(err_phi))\n", + "print(\"Mininum absolute: \", jnp.min(err_phi))\n", + "print(\"Average absolute: \", jnp.average(err_phi))\n", + "print(\"Maximum normalized (by max Phi): \", jnp.max(err_phi) / norm)\n", + "print(\"Mininum normalized (by max Phi): \", jnp.min(err_phi) / norm)\n", + "print(\"Average normalized (by max Phi): \", jnp.average(err_phi) / norm)" + ] + }, + { + "cell_type": "markdown", + "id": "9a72e54b-d8a4-4011-a674-c80a6ca90cbf", + "metadata": { + "execution": { + "iopub.execute_input": "2026-02-28T01:05:48.750553Z", + "iopub.status.busy": "2026-02-28T01:05:48.750429Z", + "iopub.status.idle": "2026-02-28T01:05:48.753208Z", + "shell.execute_reply": "2026-02-28T01:05:48.752935Z", + "shell.execute_reply.started": "2026-02-28T01:05:48.750544Z" + } + }, + "source": [ + "## 2. Solving a simple REGCOIL-like constrained problem\n", + "As a second example, we solve a REGCOIL-like constrained problem:\n", + "$$\\min_{\\Phi'} \\chi^2_K,$$\n", + "$$\\chi^2_B\\leq C_B.$$\n", + "Compared to the REGCOIL problem:\n", + "$$\\min_{\\Phi'} \\chi^2_B+ \\lambda \\chi^2_K,$$\n", + "One can specify a $\\chi^2_B$ target rather than sweeping the regularization\n", + "parameter $\\lambda$. This saves times and makes it easier to construct coil complexity\n", + "proxies." + ] + }, + { + "cell_type": "markdown", + "id": "69905d60-e8de-4cf1-a30d-3b51b86da165", + "metadata": {}, + "source": [ + "First, let's solve a REGCOIL problem in DESC to obtain a threshold \n", + "value $C_B$. In a real study, the threshold values\n", + "can be based on real engineering requirements." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d2a6280-2472-4c13-849b-68b1f8882ad3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:29.634984Z", + "iopub.status.busy": "2026-08-12T20:04:29.634901Z", + "iopub.status.idle": "2026-08-12T20:04:37.881998Z", + "shell.execute_reply": "2026-08-12T20:04:37.881610Z", + "shell.execute_reply.started": "2026-08-12T20:04:29.634975Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##########################################################\n", + "Calculating Phi_SV for lambda_regularization = 1.00000e-15\n", + "##########################################################\n", + "chi^2 B = 6.49999e+00\n", + "min Bnormal = 6.71265e-15 (T)\n", + "Max Bnormal = 3.81864e-01 (T)\n", + "Avg Bnormal = 5.05451e-02 (T)\n", + "min Bnormal = 1.09866e-15 (unitless)\n", + "Max Bnormal = 6.25000e-02 (unitless)\n", + "Avg Bnormal = 8.27276e-03 (unitless)\n" + ] + } + ], + "source": [ + "# Solving the NESCOIL problem using DESC's built in REGCOIL.\n", + "# Please see the REGCOIL-like coil optimization tutorial\n", + "fields_regcoil, data_regcoil = solve_regularized_surface_current(\n", + " scf_nescoil, # the surface current field whose geometry and Phi resolution will be used\n", + " eq=aries_eq, # the Equilibrium object to minimize Bn on the surface of\n", + " source_grid=objective_nescoil._constants[\"source_grid\"], # source grid\n", + " eval_grid=objective_nescoil._constants[\"eval_grid\"], # evaluation grid\n", + " current_helicity=(\n", + " 1,\n", + " 0,\n", + " ),\n", + " lambda_regularization=jnp.array([1e-15]),\n", + " vacuum=False,\n", + " regularization_type=\"regcoil\",\n", + " chunk_size=40,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "9d547391-964d-46a6-97db-9550c56df312", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:37.882447Z", + "iopub.status.busy": "2026-08-12T20:04:37.882364Z", + "iopub.status.idle": "2026-08-12T20:04:40.170894Z", + "shell.execute_reply": "2026-08-12T20:04:40.170485Z", + "shell.execute_reply.started": "2026-08-12T20:04:37.882439Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "obj_flux = QuadraticFlux(\n", + " field=fields[0], # the field to be optimized\n", + " eq=aries_eq, # the equilibrium upon which the quadratic flux is being evaluated\n", + " eval_grid=objective_nescoil.constants[\"eval_grid\"],\n", + " field_grid=objective_nescoil.constants[\"source_grid\"],\n", + " vacuum=False,\n", + " bs_chunk_size=10,\n", + " normalize=False,\n", + " normalize_target=False, # don't use normalizations, to match the REGCOIL problem exactly\n", + ")\n", + "obj_flux.build()\n", + "chi_2_B_regcoil = obj_flux.compute_scalar(*obj_flux.xs(fields_regcoil[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "da68dcae-4248-4baf-9660-3bc06d79313e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:40.171306Z", + "iopub.status.busy": "2026-08-12T20:04:40.171224Z", + "iopub.status.idle": "2026-08-12T20:04:40.510260Z", + "shell.execute_reply": "2026-08-12T20:04:40.509750Z", + "shell.execute_reply.started": "2026-08-12T20:04:40.171298Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "obj_regularization = SurfaceCurrentRegularization(\n", + " surface_current_field=fields[0],\n", + " source_grid=objective_nescoil.constants[\"source_grid\"],\n", + " weight=1,\n", + " normalize=False,\n", + " normalize_target=False, # don't use normalizations, to match the REGCOIL problem exactly\n", + ") # we will set it to the sqrt of optimal weight from above,\n", + "# since DESC will square the weight when making the overall cost fxn\n", + "obj_regularization.build()\n", + "chi_2_K_regcoil = obj_regularization.compute_scalar(\n", + " *obj_regularization.xs(fields_regcoil[0])\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "c448087b-d5ba-448f-ac70-ad58c6732f75", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:40.510628Z", + "iopub.status.busy": "2026-08-12T20:04:40.510547Z", + "iopub.status.idle": "2026-08-12T20:04:40.515678Z", + "shell.execute_reply": "2026-08-12T20:04:40.515266Z", + "shell.execute_reply.started": "2026-08-12T20:04:40.510620Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Target f_B is: 3.2499952170553645 T^2m^2\n", + "Target f_K is: 2.1197998634548396e+16 T^2m^2\n" + ] + } + ], + "source": [ + "# There is a factor of 4pi difference between\n", + "# QUADCOIL and DESC as of Mar. 2026, since\n", + "# QUADCOIL is calibrated against simsopt's REGCOIL\n", + "# implementation. This may change with later versions.\n", + "C_B = chi_2_B_regcoil / (4 * jnp.pi**2)\n", + "C_K = chi_2_K_regcoil / (4 * jnp.pi**2)\n", + "print(\"Target f_B is:\", C_B, \"T^2m^2\")\n", + "print(\"Target f_K is:\", C_K, \"T^2m^2\")" + ] + }, + { + "cell_type": "markdown", + "id": "08dd0af9-a104-4824-a740-bc46ab0ff293", + "metadata": {}, + "source": [ + "### Calling QUADCOIL (outputting DESC REGCOIL types)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "3a45cc85-cb73-4450-880d-8e9caaccee5c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:40.516187Z", + "iopub.status.busy": "2026-08-12T20:04:40.516061Z", + "iopub.status.idle": "2026-08-12T20:04:40.535872Z", + "shell.execute_reply": "2026-08-12T20:04:40.535413Z", + "shell.execute_reply.started": "2026-08-12T20:04:40.516174Z" + } + }, + "outputs": [], + "source": [ + "quadcoil_kwargs_regcoil = quadcoil_kwargs_basic | {\n", + " # The NESCOIL problem only contains the squared\n", + " # flux objective. In QUADCOIL, this quantity is called\n", + " # f_B.\n", + " \"objective_name\": \"f_K\",\n", + " # For a constrained REGCOIL problem, we advise\n", + " # normaizing the objectives and constraints using\n", + " # values measured from known QUADCOIL solution.\n", + " # Empirically this gives much better accuracy than\n", + " # normalizing using equilibrium parameters.\n", + " \"objective_unit\": C_K,\n", + " # Quantities to constrain. Must be a tuple.\n", + " \"constraint_name\": (\"f_B\",),\n", + " # Types of constraints. Must be a tuple.\n", + " # Here, we define a \"<=\" inequality constraint.\n", + " \"constraint_type\": (\"<=\",),\n", + " # Threshold of the constraints. Must be an ndarray.\n", + " \"constraint_value\": jnp.array([C_B]),\n", + " # Normalizing constants of the constraints.\n", + " # We advise directly using the constraint thresholds\n", + " # if they are non-zero for best numerical behavior.\n", + " # A good alternative choice is f_K(qp_nescoil, dofs_nescoil).\n", + " \"constraint_unit\": jnp.array([C_B]),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "85fb4b08-8129-41d5-b9da-709cab127b59", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:40.536403Z", + "iopub.status.busy": "2026-08-12T20:04:40.536276Z", + "iopub.status.idle": "2026-08-12T20:04:40.704257Z", + "shell.execute_reply": "2026-08-12T20:04:40.703878Z", + "shell.execute_reply.started": "2026-08-12T20:04:40.536391Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "# Define a QuadcoilProxy with the simplest possible\n", + "# signature.\n", + "objective_regcoil = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_regcoil,\n", + " vacuum=False,\n", + " # If you have additional filament/planar coils, put the CoilSet here.\n", + " # field=[],\n", + ")\n", + "objective_regcoil.build()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "da5d50cc-2cc3-4622-b49c-e20f9a6af417", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:40.704733Z", + "iopub.status.busy": "2026-08-12T20:04:40.704614Z", + "iopub.status.idle": "2026-08-12T20:04:58.569965Z", + "shell.execute_reply": "2026-08-12T20:04:58.569378Z", + "shell.execute_reply.started": "2026-08-12T20:04:40.704724Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "scf_regcoil = objective_regcoil.solve_quadcoil_surface_current(\n", + " # Like Objective.compute(), the xs of the equilibrium\n", + " # must be passed in as the *arg.\n", + " *objective_regcoil.xs(aries_eq)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ca9a2be1-26cb-44ad-9b74-79e4fb64159d", + "metadata": {}, + "source": [ + "### Consistency with DESC's built-in REGCOIL\n", + "Here, we show that the QUADCOIL solution is a close reproduction\n", + "of the REGCOIL solution. This is achieved by directly targeting \n", + "its $\\chi^2_B$ value with an inequality constraint." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "66ed98d4", + "metadata": {}, + "outputs": [], + "source": [ + "# Call this instead\n", + "# compare_desc_regcoil_quadcoil(scf_nescoil, fields_regcoil[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "905e13b0-f2bc-414c-bca0-d51e8ca49054", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:58.570376Z", + "iopub.status.busy": "2026-08-12T20:04:58.570296Z", + "iopub.status.idle": "2026-08-12T20:04:58.908120Z", + "shell.execute_reply": "2026-08-12T20:04:58.907752Z", + "shell.execute_reply.started": "2026-08-12T20:04:58.570367Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference between Phi coefficients of DESC REGCOIL and QUADCOIL Fourier coefficients\n", + "Maximum absolute: 520.9692322547198\n", + "Mininum absolute: 2.8411076003685594\n", + "Average absolute: 154.61426980536842\n", + "Maximum normalized (by max Phi): 0.00010660662303641803\n", + "Mininum normalized (by max Phi): 5.813796059462957e-07\n", + "Average normalized (by max Phi): 3.1638922524954185e-05\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n", + "plot_2d(scf_regcoil, \"Phi\", levels=10, filled=False, ax=axs[0])\n", + "axs[0].set_title(\"The QuadcoilProxy sln\")\n", + "plot_2d(fields_regcoil[0], \"Phi\", levels=10, filled=False, ax=axs[1])\n", + "axs[1].set_title(\"The DESC-REGCOIL sln\")\n", + "axs[2].plot(scf_regcoil.Phi_mn, label=\"QuadcoilProxy\")\n", + "axs[2].plot(fields_regcoil[0].Phi_mn, label=\"DESC-REGCOIL\", linestyle=\"dashed\")\n", + "axs[2].legend()\n", + "axs[2].set_title(\"Phi Fourier coefficients\")\n", + "norm = jnp.max(jnp.abs(fields_regcoil[0].Phi_mn))\n", + "err_phi = jnp.abs(scf_regcoil.Phi_mn - fields_regcoil[0].Phi_mn)\n", + "print(\n", + " \"Difference between Phi coefficients of DESC \"\n", + " \"REGCOIL and QUADCOIL Fourier coefficients\"\n", + ")\n", + "print(\"Maximum absolute: \", jnp.max(err_phi))\n", + "print(\"Mininum absolute: \", jnp.min(err_phi))\n", + "print(\"Average absolute: \", jnp.average(err_phi))\n", + "print(\"Maximum normalized (by max Phi): \", jnp.max(err_phi) / norm)\n", + "print(\"Mininum normalized (by max Phi): \", jnp.min(err_phi) / norm)\n", + "print(\"Average normalized (by max Phi): \", jnp.average(err_phi) / norm)" + ] + }, + { + "cell_type": "markdown", + "id": "4cf4f2f9-394b-4b05-8629-17e21a950e56", + "metadata": {}, + "source": [ + "## 3. A force minimization problem\n", + "This section solves a QUADCOIL problem that minimizes the Lorentz force that\n", + "the coilset experiences satisfying some required field accuracy $\\chi^2_B$." + ] + }, + { + "cell_type": "markdown", + "id": "7232c1a4-f817-44e6-9780-edaa403aa670", + "metadata": {}, + "source": [ + "First, we calculate `K_target`, a target value for current density $|K|$ \n", + "based on the net poloidal currents and coil-coil distance:\n", + "$$K_\\text{target}\\equiv\\frac{G}{(\\text{coil count})d_{cc}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "420bee1e-f2b8-4fe1-b5c3-badbdf49a67b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:58.908642Z", + "iopub.status.busy": "2026-08-12T20:04:58.908548Z", + "iopub.status.idle": "2026-08-12T20:04:58.910475Z", + "shell.execute_reply": "2026-08-12T20:04:58.910171Z", + "shell.execute_reply.started": "2026-08-12T20:04:58.908633Z" + } + }, + "outputs": [], + "source": [ + "net_poloidal_current_amperes = qp_nescoil.net_poloidal_current_amperes\n", + "coil_count = coil_per_half_fp * 2 * aries_eq.NFP\n", + "K_target = net_poloidal_current_amperes / coil_count / coil_coil_distance" + ] + }, + { + "cell_type": "markdown", + "id": "5f09a2c9-c30c-49a5-88d6-bacd8b283041", + "metadata": {}, + "source": [ + "### Defining QUADCOIL problems\n", + "To perform force optimization, we define two problems.\n", + "1. A problem finding the best achievable field\n", + "error for a filament coil set with maximum current density\n", + "squared $K^2_\\text{target}$.\n", + "$$\\min_{\\Phi'} \\chi^2_B$$\n", + "$$K_\\theta\\leq0$$\n", + "$$|K|^2\\leq K^2_\\text{target}$$\n", + "This problem will be used to calculate normalization constants\n", + "and a target value for $\\chi^2_B$, $C_{B0}$\n", + "3. A filament coil force minimization problem\n", + "$$\\min_{\\Phi'} \\int_\\text{winding surface}\\|L\\|_1 dA$$\n", + "$$\\chi^2_B\\leq C_{B0}$$\n", + "$$K_\\theta\\leq0$$\n", + "$$|K|^2\\leq K^2_\\text{target}$$\n", + "This problem will be used to calculate normalization constants.\n", + "Here, $L$ is the Lorentz force. We used the L-1 norm of forces\n", + "as a proxy of its L-2 norm, since the L-1 norm is quadratic and\n", + "bounds the L-2 norm via norm equivalence." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6474674-f938-413f-b9f6-53b4a8de00f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:58.910828Z", + "iopub.status.busy": "2026-08-12T20:04:58.910757Z", + "iopub.status.idle": "2026-08-12T20:04:59.133991Z", + "shell.execute_reply": "2026-08-12T20:04:59.133587Z", + "shell.execute_reply.started": "2026-08-12T20:04:58.910820Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "# Defining problem 1\n", + "quadcoil_kwargs_best_case = quadcoil_kwargs_basic | {\n", + " \"objective_name\": \"f_B\",\n", + " \"objective_unit\": f_B(qp_nescoil, dofs_nescoil),\n", + " \"constraint_name\": (\"K_theta\", \"f_max_K2\"),\n", + " \"constraint_type\": (\"<=\", \"<=\"),\n", + " \"constraint_unit\": (K_target, K_target**2),\n", + " \"constraint_value\": jnp.array([0, K_target**2]),\n", + "}\n", + "quadcoil_objective_best_case = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_best_case,\n", + " metric_name=(\"f_max_force_cyl\",),\n", + " metric_target=jnp.array([0.0]),\n", + " metric_weight=jnp.array([1.0]),\n", + " enable_net_current_plasma=True,\n", + " vacuum=False,\n", + ")\n", + "quadcoil_objective_best_case.build()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "5a1158cf-2e0d-426e-9214-e5705c7978b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:04:59.134376Z", + "iopub.status.busy": "2026-08-12T20:04:59.134286Z", + "iopub.status.idle": "2026-08-12T20:06:02.210633Z", + "shell.execute_reply": "2026-08-12T20:06:02.210248Z", + "shell.execute_reply.started": "2026-08-12T20:04:59.134367Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Solving problem 1\n", + "out_dict_best_case, qp_best_case, dofs_best_case, status_best_case = (\n", + " quadcoil_objective_best_case.solve_quadcoil(\n", + " *quadcoil_objective_best_case.xs(aries_eq)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "ded3e89c-d72e-4ca3-98f4-07b52e0d6ce9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:06:02.211046Z", + "iopub.status.busy": "2026-08-12T20:06:02.210938Z", + "iopub.status.idle": "2026-08-12T20:06:04.147335Z", + "shell.execute_reply": "2026-08-12T20:06:04.146923Z", + "shell.execute_reply.started": "2026-08-12T20:06:02.211038Z" + } + }, + "outputs": [], + "source": [ + "# Calculating normalization constants.\n", + "f_l1_force_cyl_unit = f_l1_force_cyl(qp_best_case, dofs_best_case)\n", + "# Defining chi^2_B target. Here, we relax it to be\n", + "# 2x the best-achievable value.\n", + "f_B_target = f_B(qp_best_case, dofs_best_case) * 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "e09dcad7-f083-463a-97d2-d372d79f0076", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:06:04.147771Z", + "iopub.status.busy": "2026-08-12T20:06:04.147677Z", + "iopub.status.idle": "2026-08-12T20:06:04.150151Z", + "shell.execute_reply": "2026-08-12T20:06:04.149919Z", + "shell.execute_reply.started": "2026-08-12T20:06:04.147763Z" + } + }, + "outputs": [], + "source": [ + "# Defining problem 2\n", + "quadcoil_kwargs_force_l1 = quadcoil_kwargs_basic | {\n", + " \"objective_name\": \"f_l1_force_cyl\",\n", + " \"objective_unit\": f_l1_force_cyl_unit,\n", + " \"constraint_name\": (\"f_B\", \"K_theta\", \"f_max_K2\"),\n", + " \"constraint_type\": (\"<=\", \"<=\", \"<=\"),\n", + " \"constraint_unit\": (f_B_target, K_target, K_target**2),\n", + " \"constraint_value\": jnp.array([f_B_target, 0, K_target**2]),\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11968dcc-76f8-4954-9e05-5291efe457b8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:06:04.150570Z", + "iopub.status.busy": "2026-08-12T20:06:04.150391Z", + "iopub.status.idle": "2026-08-12T20:06:04.315063Z", + "shell.execute_reply": "2026-08-12T20:06:04.314792Z", + "shell.execute_reply.started": "2026-08-12T20:06:04.150563Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Precomputing transforms\n" + ] + } + ], + "source": [ + "quadcoil_objective_force_l1 = QuadcoilProxy(\n", + " eq=aries_eq,\n", + " quadcoil_kwargs=quadcoil_kwargs_force_l1,\n", + " metric_name=(\"f_l1_force_cyl\",),\n", + " metric_target=jnp.array([0.0]),\n", + " metric_weight=jnp.array([1.0]),\n", + " enable_net_current_plasma=True,\n", + " vacuum=False,\n", + ")\n", + "quadcoil_objective_force_l1.build()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "b8980f93-4526-4d6f-83a9-c51528a30d98", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:06:04.315564Z", + "iopub.status.busy": "2026-08-12T20:06:04.315372Z", + "iopub.status.idle": "2026-08-12T20:08:51.440069Z", + "shell.execute_reply": "2026-08-12T20:08:51.439619Z", + "shell.execute_reply.started": "2026-08-12T20:06:04.315555Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/quadcoil/src/quadcoil/wrapper.py:37: UserWarning: Bnormal_plasma provided, inputs for plasma_quadpoints_phi and plasma_quadpoints_theta will be ignored.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "# Solving problem 2\n", + "out_dict_force_l1, qp_force_l1, dofs_force_l1, status_force_l1 = (\n", + " quadcoil_objective_force_l1.solve_quadcoil(\n", + " *quadcoil_objective_force_l1.xs(aries_eq)\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "ebd2e599-d8ba-477a-b1d8-3f5763afec85", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:08:51.440507Z", + "iopub.status.busy": "2026-08-12T20:08:51.440405Z", + "iopub.status.idle": "2026-08-12T20:08:51.608974Z", + "shell.execute_reply": "2026-08-12T20:08:51.608529Z", + "shell.execute_reply.started": "2026-08-12T20:08:51.440499Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reference case chi^2_B: 5.361016448461273\n", + "Low-force filament chi^2_B: 5.23576810733246\n", + "Reference case L-1 force: 34240642840.77218\n", + "Low-force filament L-1 force: 34347655664.978073\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1, 2, figsize=(8, 4))\n", + "axs[0].contour(Phi_with_net_current(qp_best_case, dofs_best_case), levels=20)\n", + "axs[0].set_title(r\"Lowest $\\chi^2_B$ filament\")\n", + "axs[1].contour(Phi_with_net_current(qp_force_l1, dofs_force_l1), levels=20)\n", + "axs[1].set_title(r\"Low force filament\")\n", + "print(\"Reference case chi^2_B: \", f_B(qp_best_case, dofs_best_case))\n", + "print(\"Low-force filament chi^2_B:\", f_B(qp_force_l1, dofs_force_l1))\n", + "print(\"Reference case L-1 force: \", f_l1_force_cyl(qp_best_case, dofs_best_case))\n", + "print(\"Low-force filament L-1 force:\", f_l1_force_cyl(qp_force_l1, dofs_force_l1))" + ] + }, + { + "cell_type": "markdown", + "id": "be00683e-24ec-43e9-8071-ef4ae5acfc95", + "metadata": {}, + "source": [ + "## 4. Quasi-single-stage optimization\n", + "This is a reproduction of the quasi-single-stage force optimization\n", + "in [2]." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "cb749359-3ae3-4bed-a5e7-4e53d04dfe1a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:08:51.609342Z", + "iopub.status.busy": "2026-08-12T20:08:51.609258Z", + "iopub.status.idle": "2026-08-12T20:08:53.279408Z", + "shell.execute_reply": "2026-08-12T20:08:53.278956Z", + "shell.execute_reply.started": "2026-08-12T20:08:51.609334Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/lf2869/Documents/Codes/DESC/desc/utils.py:563: UserWarning: Setting rotational transform profile on an equilibrium with fixed toroidal current, removing existing toroidal current profile.\n", + " warnings.warn(msg, err)\n" + ] + } + ], + "source": [ + "aries_eq.iota = aries_eq.get_profile(\"iota\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce98a4e4-f26d-45bc-90a7-810bb492547c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-12T20:08:53.279813Z", + "iopub.status.busy": "2026-08-12T20:08:53.279726Z", + "iopub.status.idle": "2026-08-12T20:08:53.287002Z", + "shell.execute_reply": "2026-08-12T20:08:53.286617Z", + "shell.execute_reply.started": "2026-08-12T20:08:53.279805Z" + } + }, + "outputs": [], + "source": [ + "# Quasi-single-stage with continuation\n", + "def quasi_single_stage(\n", + " init_eq,\n", + " file_name,\n", + " quadcoil_kwargs_obj,\n", + " quadcoil_unit, # unit of metric\n", + " metric_name,\n", + " quadcoil_weight=0.0,\n", + " vol_weight=0.0,\n", + " qs_weight=1.0,\n", + " maxiter=30, # Maximum iteration per Fourier continuation\n", + " max_k=None, # Maximum continuation boundary mode number\n", + " printout=False, # Whether to run dummy optimization even when data exists for printout.\n", + "):\n", + "\n", + " # ----- Calculating targets -----\n", + " # Equilibrium optimization targets in this examples are\n", + " # calculated from the initial state, so that the QUADCOIL\n", + " # proxy is minimized while maintaining other plasma parameters.\n", + " # Building grids\n", + " # Volume\n", + " vol = init_eq.compute([\"V\"])[\"V\"]\n", + " eqfam = EquilibriaFamily(init_eq)\n", + " # # Triple product QS\n", + " qs_objective_init = QuasisymmetryTripleProduct(\n", + " init_eq,\n", + " )\n", + " qs_objective_init.build()\n", + " qs_bound = jnp.abs(\n", + " qs_objective_init.compute(*qs_objective_init.xs(init_eq))\n", + " / qs_objective_init.normalization\n", + " )\n", + "\n", + " out_list = []\n", + "\n", + " # ----- Fourier continuation -----\n", + " if not max_k:\n", + " max_k = init_eq.M + 1\n", + " else:\n", + " max_k = min(max_k, init_eq.M + 1)\n", + " k_list = range(3, init_eq.M + 1)\n", + " print(\"Boundary mode steps:\", k_list)\n", + " for i in range(len(k_list)):\n", + " k = k_list[i]\n", + " filename_eq = file_name + \"_eq_\" + str(k) + \".h5\"\n", + " filename_qf = file_name + \"_qf_\" + str(k) + \".h5\"\n", + " filename_time = file_name + \"_time_\" + str(k) + \".npy\"\n", + " filename_history = file_name + \"_history_\" + str(k) + \".pickle\"\n", + " filename_log = file_name + \"_log_\" + str(k) + \".txt\"\n", + "\n", + " # ----- Objectives -----\n", + " init_eq_k = eqfam[-1].copy()\n", + " qs_objective = QuasisymmetryTripleProduct(\n", + " eq=init_eq_k,\n", + " bounds=(-qs_bound, qs_bound),\n", + " normalize_target=False,\n", + " weight=qs_weight,\n", + " )\n", + " qs_objective.build()\n", + " obj_list_base = [\n", + " Volume(\n", + " eq=init_eq_k,\n", + " target=vol,\n", + " weight=vol_weight,\n", + " ),\n", + " qs_objective,\n", + " ]\n", + " # ----- Constraints -----\n", + " # as opposed to SIMSOPT and STELLOPT where variables are assumed fixed, in DESC\n", + " # we assume variables are free. Here we decide which ones to fix, starting with\n", + " # the major radius (R mode = [0,0,0]) and all modes with m,n > k\n", + " R_modes = np.vstack(\n", + " (\n", + " [0, 0, 0],\n", + " init_eq.surface.R_basis.modes[\n", + " np.max(np.abs(init_eq.surface.R_basis.modes), 1) > k, :\n", + " ],\n", + " )\n", + " )\n", + " Z_modes = init_eq.surface.Z_basis.modes[\n", + " np.max(np.abs(init_eq.surface.Z_basis.modes), 1) > k, :\n", + " ]\n", + " # next we create the constraints, using the mode number arrays just created\n", + " # if we didn't pass those in, it would fix all the modes (like for the profiles)\n", + " constraints_base = [\n", + " ForceBalance(eq=init_eq_k),\n", + " FixBoundaryR(eq=init_eq_k, modes=R_modes),\n", + " FixBoundaryZ(eq=init_eq_k, modes=Z_modes),\n", + " FixPsi(init_eq_k),\n", + " FixPressure(init_eq_k),\n", + " # Equilibrium is now loaded with fixed iota because we don't\n", + " # care about enforcing vacuum field any more.\n", + " FixIota(init_eq_k),\n", + " ]\n", + " # QS objective\n", + " # Mostly used in quasi-single-stage but also\n", + " # used to get single-stage init guess\n", + " quadcoil_objective_new = QuadcoilProxy(\n", + " eq=init_eq_k,\n", + " quadcoil_kwargs=quadcoil_kwargs_obj,\n", + " metric_name=(metric_name,),\n", + " metric_target=np.array([0.0]),\n", + " metric_weight=np.array([quadcoil_weight / quadcoil_unit]),\n", + " normalize=False,\n", + " normalize_target=False,\n", + " name=\"QUADCOIL Proxy\",\n", + " enable_net_current_plasma=True,\n", + " vacuum=False,\n", + " jac_chunk_size=1, # Need to adjust memory usage with jac_chunk_size\n", + " )\n", + " quadcoil_objective_new.build()\n", + " objective = ObjectiveFunction(obj_list_base + [quadcoil_objective_new])\n", + " constraints = constraints_base\n", + " # ----- Performing optimization -----\n", + " try:\n", + " # Run continuation step if the save file does not exist\n", + " if not (os.path.exists(filename_history) and os.path.exists(filename_eq)):\n", + " print(\"\\n==================================\")\n", + " print(\"Optimizing boundary modes M,N <= {}\".format(k))\n", + " print(\"====================================\")\n", + " time1 = time.time()\n", + " optimizer = Optimizer(\"proximal-lsq-auglag\")\n", + " eq_new, out = init_eq_k.optimize(\n", + " objective=objective,\n", + " constraints=constraints,\n", + " optimizer=optimizer,\n", + " maxiter=maxiter,\n", + " verbose=3,\n", + " ftol=1e-5,\n", + " copy=True,\n", + " )\n", + " # Printing continuation stage result\n", + " qs_objective1 = qs_objective.compute_scalar(*qs_objective.xs(init_eq_k))\n", + " quadcoil_objective_new1 = quadcoil_objective_new.compute_scalar(\n", + " *quadcoil_objective_new.xs(init_eq_k)\n", + " )\n", + " qs_objective2 = qs_objective.compute_scalar(*qs_objective.xs(eq_new))\n", + " quadcoil_objective_new2 = quadcoil_objective_new.compute_scalar(\n", + " *quadcoil_objective_new.xs(eq_new)\n", + " )\n", + " print(\"Pre-optimization QS value:\", qs_objective1)\n", + " print(\"Pre-optimization quadcoil value:\", quadcoil_objective_new1)\n", + " print(\"Post-optimization QS value:\", qs_objective2)\n", + " print(\"Post-optimization quadcoil value:\", quadcoil_objective_new2)\n", + " time2 = time.time()\n", + " jnp.save(filename_time, time2 - time1)\n", + " eq_new.save(filename_eq)\n", + " # Its important to use binary mode\n", + " with open(filename_history, \"wb\") as dbfile: # 'wb' = write binary\n", + " pickle.dump(out, dbfile)\n", + " with open(filename_log, \"w\") as f:\n", + " f.write(\"Pre-optimization QS value:\" + str(qs_objective1))\n", + " f.write(\n", + " \"Pre-optimization quadcoil value:\"\n", + " + str(quadcoil_objective_new1)\n", + " )\n", + " f.write(\"Post-optimization QS value:\" + str(qs_objective2))\n", + " f.write(\n", + " \"Post-optimization quadcoil value:\"\n", + " + str(quadcoil_objective_new2)\n", + " )\n", + " f.write(\"=== Optimization Result ===\\n\")\n", + " f.write(pformat(dict(out), indent=2))\n", + " f.write(\"\\n\")\n", + " # Load continuation step if the save file exists\n", + " else:\n", + " print(\"Step\", k, \"exists.\")\n", + " if printout and i == len(k_list) - 1:\n", + " print(\"Still running a dummy optimization to print out stuff.\")\n", + " optimizer = Optimizer(\"proximal-lsq-auglag\")\n", + " eq_new, out = init_eq_k.optimize(\n", + " objective=objective,\n", + " constraints=constraints,\n", + " optimizer=optimizer,\n", + " maxiter=1,\n", + " verbose=3,\n", + " ftol=1e-5,\n", + " copy=True,\n", + " )\n", + " eq_new = desc.io.load(filename_eq, file_format=\"hdf5\")\n", + " with open(filename_history, \"rb\") as dbfile: # 'wb' = write binary\n", + " out = pickle.load(dbfile)\n", + "\n", + " eqfam.append(eq_new)\n", + " out_list.append(out)\n", + " eqfam.save(file_name + \"_eqfam_\" + \".h5\")\n", + " except KeyboardInterrupt:\n", + " break\n", + " _, _, dofs_init, status_init = quadcoil_objective_new.solve_quadcoil(\n", + " *quadcoil_objective_new.xs(eq_new)\n", + " )\n", + "\n", + " return eqfam, out_list, quadcoil_objective_new" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20aa06ba-14dc-4d95-8470-424e8cedcd3f", + "metadata": {}, + "outputs": [], + "source": [ + "# Directory for saving data\n", + "data_dir = \"data_aries_force\"\n", + "os.makedirs(data_dir, exist_ok=True)\n", + "init_eq = aries_eq.copy()\n", + "\n", + "# Weights\n", + "quadcoil_weight = 10.0 # 5. # 50. -> 90% improvement, 10x degradation in QS\n", + "qs_weight = 500 # Good for muse: 5000.\n", + "vol_weight = 30.0\n", + "\n", + "# Running fourier continuation\n", + "eqfam_force_l1, out_list_force_l1, quadcoil_objective_force_l1 = quasi_single_stage(\n", + " init_eq=init_eq,\n", + " file_name=data_dir + \"/\" + \"f_force_l1\",\n", + " quadcoil_kwargs_obj=quadcoil_kwargs_force_l1,\n", + " quadcoil_unit=f_l1_force_cyl_unit, # unit of metric\n", + " metric_name=\"f_l1_force_cyl\",\n", + " quadcoil_weight=quadcoil_weight,\n", + " qs_weight=qs_weight,\n", + " vol_weight=vol_weight,\n", + ")\n", + "new_eq = eqfam_force_l1[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ce1214e-f4ed-4b81-9b6b-a00b1ab8c2f3", + "metadata": { + "execution": { + "iopub.status.busy": "2026-08-12T20:14:14.420463Z", + "iopub.status.idle": "2026-08-12T20:14:14.420574Z", + "shell.execute_reply": "2026-08-12T20:14:14.420513Z", + "shell.execute_reply.started": "2026-08-12T20:14:14.420508Z" + } + }, + "outputs": [], + "source": [ + "# Compute quadcoil solution and compare with\n", + "out_dict_aries_l1, qp_aries_l1, dofs_aries_l1, status_aries_l1 = (\n", + " quadcoil_objective_force_l1.solve_quadcoil(\n", + " *quadcoil_objective_force_l1.xs(aries_eq)\n", + " )\n", + ")\n", + "out_dict_d, qp_d, dofs_d, status_d = quadcoil_objective_force_l1.solve_quadcoil(\n", + " *quadcoil_objective_force_l1.xs(new_eq)\n", + ")\n", + "print(\"ARIES-CS L1 force: \", out_dict_aries_l1[\"f_l1_force_cyl\"])\n", + "print(\"New equilibrium L1 force:\", out_dict_d[\"f_l1_force_cyl\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e781867-a1ff-472b-874b-495bdf6fced6", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cpu", + "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.13.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test_objective_funs.py b/tests/test_objective_funs.py index f97bc93a27..1370136b90 100644 --- a/tests/test_objective_funs.py +++ b/tests/test_objective_funs.py @@ -40,6 +40,7 @@ SplineMagneticField, ToroidalMagneticField, VerticalMagneticField, + solve_regularized_surface_current, ) from desc.objectives import ( AspectRatio, @@ -81,6 +82,7 @@ PlasmaVesselDistance, Pressure, PrincipalCurvature, + QuadcoilProxy, QuadraticFlux, QuasisymmetryBoozer, QuasisymmetryTripleProduct, @@ -495,6 +497,163 @@ def test(eq): test(Equilibrium(iota=PowerSeriesProfile(0))) test(Equilibrium(current=PowerSeriesProfile(0))) + @pytest.mark.unit + def test_quadcoil(self): + """Test the QUADCOIL proxy.""" + # Setting testing thresholds + # 5% normalized error in Phi Fourier coefficients + thres_phi = 0.01 + thres_G = 0.001 # to be decreased + + # ----- Test 1: NESCOIL, value only ----- + def run_regcoil(vacuum): + # Loading equilibrium and resolutions + # ARIES-CS + if not vacuum: + quadcoil_test_eq = desc.examples.get("ARIES-CS") + else: + quadcoil_test_eq = desc.examples.get("precise_QA") + + # Settings + mpol = 8 # Num. poloidal modes in the current potential + ntor = 8 # Num. toroidal modes in the current potential + # Controls the resolution of the plasma surface integration. + # Integration in quadcoil is naively performed using summation + # so we recommend at least 16 here. + # This corresponds to a (33 x 33) grid. + minor_radius = quadcoil_test_eq.compute("a")["a"] + plasma_coil_distance = minor_radius * 0.75 + # Resolution for sampling objectives + quadpoints_phi = jnp.linspace( + 0, 1 / quadcoil_test_eq.NFP, 33, endpoint=False + ) + quadpoints_theta = jnp.linspace(0, 1, 33, endpoint=False) + quadcoil_kwargs_basic = { + "mpol": mpol, + "ntor": ntor, + "quadpoints_phi": quadpoints_phi, + "quadpoints_theta": quadpoints_theta, + "plasma_coil_distance": plasma_coil_distance, + } + quadcoil_kwargs_nescoil = quadcoil_kwargs_basic | { + "objective_name": "f_B", # The NESCOIL problem only contains + # The NESCOIL problem is simple enough to need no normalization + # constants. In the next example we will discuss how to choose + # this constant. + "objective_unit": None, + } + from desc.objectives import QuadcoilProxy + + # Define a QuadcoilProxy with the simplest possible + # signature + objective_nescoil = QuadcoilProxy( + eq=quadcoil_test_eq, + quadcoil_kwargs=quadcoil_kwargs_nescoil, + vacuum=vacuum, + ) + objective_nescoil.build() + scf_nescoil = objective_nescoil.solve_quadcoil_surface_current( + # Like Objective.compute(), the xs of the equilibrium + # must be passed in as the *arg. + *objective_nescoil.xs(quadcoil_test_eq) + ) + source_grid = objective_nescoil._constants["source_grid"] + eval_grid = objective_nescoil._constants["eval_grid"] + fields, data = solve_regularized_surface_current( + scf_nescoil, + eq=quadcoil_test_eq, + source_grid=source_grid, + eval_grid=eval_grid, + current_helicity=( + 1, + 0, + ), + lambda_regularization=jnp.array([0]), + vacuum=vacuum, + regularization_type="regcoil", + chunk_size=40, + ) + # Comparing Phi coefficients + phi1 = fields[0].compute("Phi")["Phi"] + phi2 = scf_nescoil.compute("Phi")["Phi"] + norm_error = jnp.average(jnp.abs(phi1 - phi2)) / jnp.max(jnp.abs(phi1)) + assert norm_error <= thres_phi + # Testing net poloidal current + assert np.abs(scf_nescoil.G - fields[0].G) <= np.abs(thres_G * fields[0].G) + # Solving the NESCOIL problem using DESC's built in REGCOIL. + # Please see the REGCOIL-like coil optimization tutorial + fields_regcoil, data_regcoil = solve_regularized_surface_current( + scf_nescoil, + eq=quadcoil_test_eq, + source_grid=source_grid, + eval_grid=eval_grid, + current_helicity=( + 1, + 0, + ), + lambda_regularization=jnp.array([1e-15]), + vacuum=vacuum, + regularization_type="regcoil", + chunk_size=40, + ) + obj_flux = QuadraticFlux( + field=fields[0], + eq=quadcoil_test_eq, + eval_grid=eval_grid, + field_grid=source_grid, + vacuum=False, + bs_chunk_size=10, + normalize=False, + normalize_target=False, + ) + obj_flux.build() + chi_2_B_regcoil = obj_flux.compute_scalar(*obj_flux.xs(fields_regcoil[0])) + obj_regularization = SurfaceCurrentRegularization( + surface_current_field=fields[0], + source_grid=source_grid, + weight=1, + normalize=False, + # don't use normalizations, to match the REGCOIL problem exactly + normalize_target=False, + ) # we will set it to the sqrt of optimal weight from above, + # since DESC will square the weight when making the overall cost fxn + obj_regularization.build() + chi_2_K_regcoil = obj_regularization.compute_scalar( + *obj_regularization.xs(fields_regcoil[0]) + ) + C_B = chi_2_B_regcoil / (4 * jnp.pi**2) + C_K = chi_2_K_regcoil / (4 * jnp.pi**2) + quadcoil_kwargs_regcoil = quadcoil_kwargs_basic | { + "objective_name": "f_K", + "objective_unit": C_K, + "constraint_name": ("f_B",), + "constraint_type": ("<=",), + "constraint_value": jnp.array([C_B]), + "constraint_unit": jnp.array([C_B]), + } + # Define a QuadcoilProxy with the simplest possible + # signature. + objective_regcoil = QuadcoilProxy( + eq=quadcoil_test_eq, + quadcoil_kwargs=quadcoil_kwargs_regcoil, + vacuum=vacuum, + ) + objective_regcoil.build() + scf_regcoil = objective_regcoil.solve_quadcoil_surface_current( + # Like Objective.compute(), the xs of the equilibrium + # must be passed in as the *arg. + *objective_regcoil.xs(quadcoil_test_eq) + ) + phi1_regcoil = fields_regcoil[0].compute("Phi")["Phi"] + phi2_regcoil = scf_regcoil.compute("Phi")["Phi"] + norm_error = jnp.average(jnp.abs(phi1_regcoil - phi2_regcoil)) / jnp.max( + jnp.abs(phi1_regcoil) + ) + assert norm_error <= thres_phi + + run_regcoil(True) + run_regcoil(False) + @pytest.mark.unit def test_isodynamicity(self): """Test calculation of isodynamicity metric.""" @@ -3351,6 +3510,7 @@ class TestComputeScalarResolution: PlasmaCoilSetMinDistance, PlasmaVesselDistance, QuadraticFlux, + QuadcoilProxy, SurfaceQuadraticFlux, ToroidalFlux, SurfaceCurrentRegularization, @@ -3873,6 +4033,7 @@ class TestObjectiveNaNGrad: PlasmaCoilSetMinDistance, PlasmaVesselDistance, QuadraticFlux, + QuadcoilProxy, SurfaceCurrentRegularization, SurfaceQuadraticFlux, ToroidalFlux,