diff --git a/CHANGELOG.md b/CHANGELOG.md index 812d767b32..56a93d27b0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,7 +1,52 @@ Changelog ========= -- Adds a bounding box to the `field_line_integrate` defined by `bounds_R` and `bounds_Z` keyword arguments, which form a hollow cylindrical bounding box. If the field line trajectory exits these bounds, the RHS will be multiplied by an exponentially decaying function of the distance to the box to stop the trajectory and prevent tracing the field line out to infinity, which is both costly and unnecessary when making a Poincare plot, the principle purpose of the function. + +New Features + +- Adds new objectives for free boundary equilibria: ``BoundaryError`` and +``VacuumBoundaryError``, along with a new tutorial notebook demonstrating their usage. +- Objectives ``Volume``, ``AspectRatio``, ``Elongation`` now work for +``FourierRZToroidalSurface`` objects as well as ``Equilibrium``. +- ``MagneticField`` objects now have a method ``save_mgrid`` for saving field data +in the MAKEGRID format for use with other codes. +- ``SplineMagneticField.from_mgrid`` now defaults to using ``extcur`` from the mgrid file. +- When converting a near axis solution from QSC/QIC to a desc ``Equilibrium``, the +least squares fit is now weighted inversely with the distance from the axis to improve +the accuracy for low aspect ratio. +- Adds a bounding box to the `field_line_integrate` defined by `bounds_R` and `bounds_Z` +keyword arguments, which form a hollow cylindrical bounding box. If the field line +trajectory exits these bounds, the RHS will be multiplied by an exponentially decaying +function of the distance to the box to stop the trajectory and prevent tracing the field +line out to infinity, which is both costly and unnecessary when making a Poincare plot, +the principle purpose of the function. + + +Speed Improvements + +- ``CoilSet`` is now more efficient when stellarator or field period symmetry is used. +- Improves the efficiency of ``proximal`` optimizers by reducing the number of objective +derivative evaluations. Optimization steps should now be 2-5x faster. +- Improved performance of Zernike polynomial evaluation. +- Adds a bounding box to the `field_line_integrate` defined by `bounds_R` and `bounds_Z` +keyword arguments, which form a hollow cylindrical bounding box. If the field line +trajectory exits these bounds, the RHS will be multiplied by an exponentially decaying +function of the distance to the box to stop the trajectory and prevent tracing the +field line out to infinity, which is both costly and unnecessary when making a Poincare +plot, the principle purpose of the function. + + +Bug Fixes + +- Fix bug causing NaN in ``ForceBalance`` objective when the grid contained nodes at +the magnetic axis. +- When saving VMEC output, ``buco`` and ``bvco`` are now correctly saved on the half +mesh. Previously they were saved on the full mesh. +- Fixed a bug where hdf5 files were not properly closed after reading. +- Fixed bugs relating to `Curve` objects not being optimizable. +- Fixed incorrect rotation matrix for `FourierPlanarCurve`. +- Fixed bug where ``plot_boundaries`` with a single ``phi`` value would return an +empty plot. - Renames the method for comparing equivalence between DESC objects from `eq` to `equiv` to avoid confusion with the common shorthand for `Equilibrium`. diff --git a/desc/equilibrium/equilibrium.py b/desc/equilibrium/equilibrium.py index 867def89de..5ee6632199 100644 --- a/desc/equilibrium/equilibrium.py +++ b/desc/equilibrium/equilibrium.py @@ -19,7 +19,6 @@ from desc.geometry import ( FourierRZCurve, FourierRZToroidalSurface, - Surface, ZernikeRZToroidalSection, ) from desc.grid import LinearGrid, QuadratureGrid, _Grid @@ -424,6 +423,9 @@ def _sort_args(self, args): "Za_n", "Rb_lmn", "Zb_lmn", + "I", + "G", + "Phi_mn", ) assert sorted(args) == sorted(arg_order) return [arg for arg in arg_order if arg in args] @@ -1132,14 +1134,12 @@ def surface(self): @surface.setter def surface(self, new): assert isinstance( - new, Surface - ), f"surfaces should be of type Surface or a subclass, got {new}" + new, FourierRZToroidalSurface + ), f"surface should be of type FourierRZToroidalSurface or subclass, got {new}" assert ( self.sym == new.sym ), "Surface and Equilibrium must have the same symmetry" - assert self.NFP == getattr( - new, "NFP", self.NFP - ), "Surface and Equilibrium must have the same NFP" + assert self.NFP == new.NFP, "Surface and Equilibrium must have the same NFP" new.change_resolution(self.L, self.M, self.N) self._surface = new @@ -1297,6 +1297,51 @@ def Zb_lmn(self): def Zb_lmn(self, Zb_lmn): self.surface.Z_lmn = Zb_lmn + @optimizable_parameter + @property + def I(self): # noqa: E743 + """float: Net toroidal current on the sheet current at the LCFS.""" + return self.surface.I if hasattr(self.surface, "I") else np.empty(0) + + @I.setter + def I(self, new): # noqa: E743 + errorif( + not hasattr(self.surface, "I"), + ValueError, + "Attempt to set I on an equilibrium without sheet current", + ) + self.surface.I = new + + @optimizable_parameter + @property + def G(self): + """float: Net poloidal current on the sheet current at the LCFS.""" + return self.surface.G if hasattr(self.surface, "G") else np.empty(0) + + @G.setter + def G(self, new): + errorif( + not hasattr(self.surface, "G"), + ValueError, + "Attempt to set G on an equilibrium without sheet current", + ) + self.surface.G = new + + @optimizable_parameter + @property + def Phi_mn(self): + """ndarray: coeffs of single-valued part of surface current potential.""" + return self.surface.Phi_mn if hasattr(self.surface, "Phi_mn") else np.empty(0) + + @Phi_mn.setter + def Phi_mn(self, new): + errorif( + not hasattr(self.surface, "Phi_mn"), + ValueError, + "Attempt to set Phi_mn on an equilibrium without sheet current", + ) + self.surface.Phi_mn = new + @optimizable_parameter @property def Ra_n(self): diff --git a/desc/objectives/_free_boundary.py b/desc/objectives/_free_boundary.py index 313db2298c..6fbc8bd8c4 100644 --- a/desc/objectives/_free_boundary.py +++ b/desc/objectives/_free_boundary.py @@ -321,7 +321,8 @@ class BoundaryError(_Objective): current potential on the LCFS. All residuals are weighted by the local area element ||𝐞_θ × 𝐞_ζ|| Δθ Δζ - The third equation is only included if a sheet current is supplied, otherwise it + The third equation is only included if a sheet current is supplied by making + the ``equilibrium.surface`` object a FourierCurrentPotentialField, otherwise it is trivially satisfied. If it is known that the external field accurately reproduces the target equilibrium with low normal field error and pressure at the edge is zero, then the sheet current will generally be negligible and can be omitted to save @@ -337,10 +338,6 @@ class BoundaryError(_Objective): Equilibrium that will be optimized to satisfy the Objective. ext_field : MagneticField External field produced by coils. - sheet_current : FourierCurrentPotentialField - Sheet current on the last closed flux surface. Not required for vacuum fields, - but generally needed to correctly solve at finite beta/current. Geometry will - be automatically constrained to be the same as the equilibrium LCFS. target : float, ndarray, optional Target value(s) of the objective. Only used if bounds is None. len(target) must be equal to Objective.dim_f @@ -381,6 +378,22 @@ class BoundaryError(_Objective): name : str Name of the objective function. + + Examples + -------- + Assigning a surface current to the equilibrium: + + .. code-block:: python + + from desc.magnetic_fields import FourierCurrentPotentialField + # turn the regular FourierRZToroidalSurface into a current potential on the + # last closed flux surface + eq.surface = FourierCurrentPotentialField.from_suface(eq.surface, + M_Phi=eq.M, + N_Phi=eq.N, + ) + objective = BoundaryError(eq, ext_field) + """ _scalar = False @@ -394,7 +407,6 @@ def __init__( self, eq, ext_field, - sheet_current=None, target=None, bounds=None, weight=1, @@ -419,11 +431,8 @@ def __init__( self._ext_field = ext_field self._field_grid = field_grid self._loop = loop - self._sheet_current = None + self._sheet_current = hasattr(eq.surface, "Phi_mn") things = [eq] - if sheet_current: - things += [sheet_current] - self._sheet_current = True super().__init__( things=things, @@ -550,19 +559,12 @@ def build(self, use_jit=True, verbose=1): } if self._sheet_current: - sheet_current = self.things[1] - assert ( - (sheet_current.M == eq.surface.M) - and (sheet_current.N == eq.surface.N) - and (sheet_current.NFP == eq.surface.NFP) - and (sheet_current.sym == eq.surface.sym) - ), "sheet current must have same resolution as eq.surface" self._sheet_data_keys = ["K"] sheet_eval_transforms = get_transforms( - self._sheet_data_keys, obj=sheet_current, grid=eval_grid + self._sheet_data_keys, obj=eq.surface, grid=eval_grid ) sheet_source_transforms = get_transforms( - self._sheet_data_keys, obj=sheet_current, grid=source_grid + self._sheet_data_keys, obj=eq.surface, grid=source_grid ) self._constants["sheet_eval_transforms"] = sheet_eval_transforms self._constants["sheet_source_transforms"] = sheet_source_transforms @@ -590,15 +592,13 @@ def build(self, use_jit=True, verbose=1): super().build(use_jit=use_jit, verbose=verbose) - def compute(self, eq_params, sheet_params=None, constants=None): + def compute(self, eq_params, constants=None): """Compute boundary force error. Parameters ---------- eq_params : dict Dictionary of equilibrium degrees of freedom, eg Equilibrium.params_dict - sheet_params : dict - Dictionary of sheet current degrees of freedom. constants : dict Dictionary of constant data, eg transforms, profiles etc. Defaults to self.constants @@ -628,10 +628,13 @@ def compute(self, eq_params, sheet_params=None, constants=None): profiles=constants["eval_profiles"], ) if self._sheet_current: - assert sheet_params is not None - # enforce that they're the same surface - sheet_params["R_lmn"] = eq_params["Rb_lmn"] - sheet_params["Z_lmn"] = eq_params["Zb_lmn"] + sheet_params = { + "R_lmn": eq_params["Rb_lmn"], + "Z_lmn": eq_params["Zb_lmn"], + "I": eq_params["I"], + "G": eq_params["G"], + "Phi_mn": eq_params["Phi_mn"], + } sheet_source_data = compute_fun( "desc.magnetic_fields.FourierCurrentPotentialField", self._sheet_data_keys, diff --git a/docs/notebooks/tutorials/free_boundary_equilibrium.ipynb b/docs/notebooks/tutorials/free_boundary_equilibrium.ipynb index 9738d162cc..2f511d74b2 100644 --- a/docs/notebooks/tutorials/free_boundary_equilibrium.ipynb +++ b/docs/notebooks/tutorials/free_boundary_equilibrium.ipynb @@ -54,8 +54,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "DESC version 0.10.4+389.g487b2ee2e,using JAX backend, jax version=0.4.13, jaxlib version=0.4.13, dtype=float64\n", - "Using device: CPU, with 16.99 GB available memory\n" + "DESC version 0.10.4+529.ge441ef0db,using JAX backend, jax version=0.4.13, jaxlib version=0.4.13, dtype=float64\n", + "Using device: CPU, with 13.64 GB available memory\n" ] } ], @@ -64,7 +64,11 @@ "import matplotlib.pyplot as plt\n", "\n", "import desc\n", - "from desc.magnetic_fields import SplineMagneticField, field_line_integrate\n", + "from desc.magnetic_fields import (\n", + " FourierCurrentPotentialField,\n", + " SplineMagneticField,\n", + " field_line_integrate,\n", + ")\n", "from desc.grid import LinearGrid\n", "from desc.geometry import FourierRZToroidalSurface\n", "from desc.equilibrium import Equilibrium\n", @@ -128,7 +132,9 @@ " -6.588300858364606e04,\n", " -3.560589388468855e05,\n", "]\n", - "ext_field = SplineMagneticField.from_mgrid(r\"../../../tests/inputs/mgrid_solovev.nc\", extcur=extcur)" + "ext_field = SplineMagneticField.from_mgrid(\n", + " r\"../../../tests/inputs/mgrid_solovev.nc\", extcur=extcur\n", + ")" ] }, { @@ -263,14 +269,32 @@ "\n", "$\\mu_0 \\nabla \\Phi = \\mathbf{n} \\times (\\mathbf{B}_{out} - \\mathbf{B}_{in})$\n", "\n", - "Where $\\Phi$ is the current potential on the surface.\n", - "\n", - "In our example, we know that the solution does not have a sheet current so we will ignore that term to simplify the problem. We can create our objective by passing in just the equilibrium and the source of the external field. The `BoundaryError` objective has a number of other options for where and how to evaluate the errors, but we'll stick with the defaults." + "Where $\\Phi$ is the current potential on the surface.\n" + ] + }, + { + "cell_type": "markdown", + "id": "26838736-24a7-407d-8dd9-9ee4c0ef0e1e", + "metadata": {}, + "source": [ + "The current potential is represented as a `FourierCurrentPotentialField` which is a subclass of the standard `FourierRZToroidalSurface`. To include it as part of the free boundary calculation, we set the equilibrium surface to be an instance of `FourierCurrentPotentialField` by converting the existing surface:" ] }, { "cell_type": "code", "execution_count": 7, + "id": "aca9234e-f099-4fca-be88-149984d26ac2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "eq2.surface = FourierCurrentPotentialField.from_surface(eq2.surface, M_Phi=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "id": "7dcacd9d-6d61-49a3-900a-890d99ed10a6", "metadata": { "tags": [] @@ -282,7 +306,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "e7f94a20-9fdd-457e-8023-cc3e301cae39", "metadata": { "tags": [] @@ -294,48 +318,46 @@ "text": [ "Building objective: Boundary error\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 306 ms\n", - "Timer: Objective build = 891 ms\n", + "Timer: Precomputing transforms = 616 ms\n", + "Timer: Objective build = 1.19 sec\n", "Building objective: force\n", "Precomputing transforms\n", - "Timer: Precomputing transforms = 193 ms\n", - "Timer: Objective build = 429 ms\n", - "Timer: Proximal projection build = 2.72 sec\n", - "Timer: Linear constraint projection build = 2.17 sec\n", + "Timer: Precomputing transforms = 198 ms\n", + "Timer: Objective build = 425 ms\n", + "Timer: Proximal projection build = 3.61 sec\n", + "Timer: Linear constraint projection build = 2.33 sec\n", "Compiling objective function and derivatives: ['Boundary error']\n", - "Timer: Objective compilation time = 3.59 sec\n", - "Timer: Jacobian compilation time = 14.7 sec\n", - "Timer: Total compilation time = 18.2 sec\n", + "Timer: Objective compilation time = 3.73 sec\n", + "Timer: Jacobian compilation time = 17.1 sec\n", + "Timer: Total compilation time = 20.8 sec\n", "Compiling objective function and derivatives: ['force']\n", - "Timer: Objective compilation time = 1.03 sec\n", - "Timer: Jacobian compilation time = 2.48 sec\n", - "Timer: Total compilation time = 3.52 sec\n", - "Number of parameters: 5\n", - "Number of objectives: 82\n", + "Timer: Objective compilation time = 933 ms\n", + "Timer: Jacobian compilation time = 2.42 sec\n", + "Timer: Total compilation time = 3.36 sec\n", + "Number of parameters: 18\n", + "Number of objectives: 123\n", "Starting optimization\n", "Using method: proximal-lsq-exact\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", - " 0 1 5.805e+00 3.235e+01 \n", - " 1 2 5.560e-01 5.249e+00 4.768e-01 7.013e+00 \n", - " 2 3 1.718e-02 5.388e-01 3.800e-01 9.063e-01 \n", - " 3 4 8.104e-03 9.079e-03 2.635e-01 7.473e-01 \n", - " 4 5 5.715e-05 8.047e-03 1.182e-01 5.642e-02 \n", - " 5 6 3.578e-06 5.357e-05 4.120e-02 5.960e-04 \n", - " 6 7 1.896e-06 1.682e-06 1.581e-02 2.454e-03 \n", - " 7 8 1.420e-06 4.758e-07 6.654e-03 3.497e-04 \n", - " 8 9 1.349e-06 7.151e-08 2.644e-03 4.124e-05 \n", - " 9 10 1.335e-06 1.341e-08 1.019e-03 6.804e-06 \n", - "Optimization terminated successfully.\n", - "`ftol` condition satisfied.\n", - " Current function value: 1.335e-06\n", - " Total delta_x: 5.908e-01\n", - " Iterations: 9\n", - " Function evaluations: 10\n", - " Jacobian evaluations: 10\n", - "Timer: Solution time = 1.02 min\n", - "Timer: Avg time per step = 6.12 sec\n", + " 0 1 8.196e+00 4.298e+01 \n", + " 1 2 4.526e-01 7.743e+00 4.091e+05 7.047e+00 \n", + " 2 3 3.272e-02 4.199e-01 3.758e+05 1.708e+00 \n", + " 3 4 7.583e-03 2.514e-02 4.438e+04 8.311e-01 \n", + " 4 5 3.290e-05 7.550e-03 2.265e+04 4.300e-02 \n", + " 5 6 9.756e-06 2.315e-05 2.037e+03 2.579e-02 \n", + " 6 7 3.308e-06 6.448e-06 1.496e+03 1.468e-04 \n", + " 7 12 3.101e-06 2.072e-07 1.742e+02 1.831e-04 \n", + " 8 44 3.101e-06 0.000e+00 0.000e+00 1.831e-04 \n", + "Warning: A bad approximation caused failure to predict improvement.\n", + " Current function value: 3.101e-06\n", + " Total delta_x: 4.514e+02\n", + " Iterations: 8\n", + " Function evaluations: 44\n", + " Jacobian evaluations: 8\n", + "Timer: Solution time = 2.06 min\n", + "Timer: Avg time per step = 13.7 sec\n", "Start of solver\n", - "Total (sum of squares): 5.805e+00, \n", + "Total (sum of squares): 8.196e+00, \n", "Maximum absolute Boundary normal field error: 1.420e-02 (T*m^2)\n", "Minimum absolute Boundary normal field error: 3.630e-08 (T*m^2)\n", "Average absolute Boundary normal field error: 8.348e-03 (T*m^2)\n", @@ -348,6 +370,12 @@ "Maximum absolute Boundary magnetic pressure error: 6.868e-01 (normalized)\n", "Minimum absolute Boundary magnetic pressure error: 4.128e-01 (normalized)\n", "Average absolute Boundary magnetic pressure error: 5.336e-01 (normalized)\n", + "Maximum absolute Boundary field jump error: 4.757e-01 (T*m^2)\n", + "Minimum absolute Boundary field jump error: 4.749e-01 (T*m^2)\n", + "Average absolute Boundary field jump error: 4.753e-01 (T*m^2)\n", + "Maximum absolute Boundary field jump error: 3.484e-01 (normalized)\n", + "Minimum absolute Boundary field jump error: 3.478e-01 (normalized)\n", + "Average absolute Boundary field jump error: 3.481e-01 (normalized)\n", "Maximum absolute Force error: 5.591e+00 (N)\n", "Minimum absolute Force error: 5.482e-04 (N)\n", "Average absolute Force error: 1.515e-01 (N)\n", @@ -360,25 +388,31 @@ "R boundary error: 0.000e+00 (m)\n", "Z boundary error: 0.000e+00 (m)\n", "End of solver\n", - "Total (sum of squares): 1.335e-06, \n", - "Maximum absolute Boundary normal field error: 1.074e-04 (T*m^2)\n", - "Minimum absolute Boundary normal field error: 5.431e-08 (T*m^2)\n", - "Average absolute Boundary normal field error: 4.119e-05 (T*m^2)\n", - "Maximum absolute Boundary normal field error: 7.865e-05 (normalized)\n", - "Minimum absolute Boundary normal field error: 3.978e-08 (normalized)\n", - "Average absolute Boundary normal field error: 3.017e-05 (normalized)\n", - "Maximum absolute Boundary magnetic pressure error: 2.021e-04 (T^2*m^2)\n", - "Minimum absolute Boundary magnetic pressure error: 6.068e-06 (T^2*m^2)\n", - "Average absolute Boundary magnetic pressure error: 1.042e-04 (T^2*m^2)\n", - "Maximum absolute Boundary magnetic pressure error: 4.335e-04 (normalized)\n", - "Minimum absolute Boundary magnetic pressure error: 1.302e-05 (normalized)\n", - "Average absolute Boundary magnetic pressure error: 2.236e-04 (normalized)\n", - "Maximum absolute Force error: 2.445e+01 (N)\n", - "Minimum absolute Force error: 6.449e-03 (N)\n", - "Average absolute Force error: 6.003e-01 (N)\n", - "Maximum absolute Force error: 6.678e-06 (normalized)\n", - "Minimum absolute Force error: 1.762e-09 (normalized)\n", - "Average absolute Force error: 1.640e-07 (normalized)\n", + "Total (sum of squares): 3.101e-06, \n", + "Maximum absolute Boundary normal field error: 1.732e-04 (T*m^2)\n", + "Minimum absolute Boundary normal field error: 1.772e-08 (T*m^2)\n", + "Average absolute Boundary normal field error: 8.328e-05 (T*m^2)\n", + "Maximum absolute Boundary normal field error: 1.268e-04 (normalized)\n", + "Minimum absolute Boundary normal field error: 1.297e-08 (normalized)\n", + "Average absolute Boundary normal field error: 6.100e-05 (normalized)\n", + "Maximum absolute Boundary magnetic pressure error: 2.158e-04 (T^2*m^2)\n", + "Minimum absolute Boundary magnetic pressure error: 9.790e-06 (T^2*m^2)\n", + "Average absolute Boundary magnetic pressure error: 1.137e-04 (T^2*m^2)\n", + "Maximum absolute Boundary magnetic pressure error: 4.630e-04 (normalized)\n", + "Minimum absolute Boundary magnetic pressure error: 2.100e-05 (normalized)\n", + "Average absolute Boundary magnetic pressure error: 2.439e-04 (normalized)\n", + "Maximum absolute Boundary field jump error: 6.167e-04 (T*m^2)\n", + "Minimum absolute Boundary field jump error: 2.258e-05 (T*m^2)\n", + "Average absolute Boundary field jump error: 3.258e-04 (T*m^2)\n", + "Maximum absolute Boundary field jump error: 4.517e-04 (normalized)\n", + "Minimum absolute Boundary field jump error: 1.654e-05 (normalized)\n", + "Average absolute Boundary field jump error: 2.386e-04 (normalized)\n", + "Maximum absolute Force error: 2.132e+01 (N)\n", + "Minimum absolute Force error: 3.488e-04 (N)\n", + "Average absolute Force error: 7.636e-01 (N)\n", + "Maximum absolute Force error: 5.824e-06 (normalized)\n", + "Minimum absolute Force error: 9.527e-11 (normalized)\n", + "Average absolute Force error: 2.086e-07 (normalized)\n", "Fixed-iota profile error: 0.000e+00 (dimensionless)\n", "Fixed-pressure profile error: 0.000e+00 (Pa)\n", "Fixed-Psi error: 0.000e+00 (Wb)\n", @@ -420,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "e4b1df9d-4fc9-4dae-8147-8266280f098d", "metadata": { "tags": [] @@ -428,21 +462,63 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(
,\n", - " array([],\n", - " dtype=object))" + "
" ] }, - "execution_count": 9, "metadata": {}, - "output_type": "execute_result" - }, + "output_type": "display_data" + } + ], + "source": [ + "VMECIO.plot_vmec_comparison(eq2, \"../../../tests/inputs/wout_solovev_freeb.nc\");" + ] + }, + { + "cell_type": "markdown", + "id": "e4758380-3fc5-43d1-8037-17dc5b6ad132", + "metadata": {}, + "source": [ + "We can examine what the surface current looks like by plotting it below, and we see it is indeed quite small, only a few tens of Amps, compared to the plasma current which is ~1000x larger. In this case we could probably get equivalent results without including the sheet current term." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "bc80bfcb-f3f9-46b2-bcc1-9027fcad050f", + "metadata": { + "tags": [] + }, + "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "desc.plotting.plot_2d(eq2.surface, \"K\");" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "540ce472-3b07-460b-b905-bd311ed80214", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -450,7 +526,7 @@ } ], "source": [ - "VMECIO.plot_vmec_comparison(eq2, \"../../../tests/inputs/wout_solovev_freeb.nc\")" + "desc.plotting.plot_1d(eq2, \"current\");" ] }, { @@ -479,7 +555,9 @@ "outputs": [], "source": [ "extcur = [4700.0, 1000.0]\n", - "ext_field = SplineMagneticField.from_mgrid(\"../../../tests/inputs/mgrid_test.nc\", extcur=extcur)" + "ext_field = SplineMagneticField.from_mgrid(\n", + " \"../../../tests/inputs/mgrid_test.nc\", extcur=extcur\n", + ")" ] }, { diff --git a/tests/test_objective_funs.py b/tests/test_objective_funs.py index ad1b968fa1..4f2920e558 100644 --- a/tests/test_objective_funs.py +++ b/tests/test_objective_funs.py @@ -444,12 +444,13 @@ def test_boundary_error_biestsc(self): coilset = CoilSet.linspaced_angular(coil, n=100) coil_grid = LinearGrid(N=20) eq = Equilibrium(L=3, M=3, N=3, Psi=np.pi) - sheet_current = FourierCurrentPotentialField() - sheet_current.change_resolution(M=eq.M, N=eq.N, NFP=eq.NFP, sym=eq.sym) + eq.surface = FourierCurrentPotentialField.from_surface( + eq.surface, M_Phi=eq.M, N_Phi=eq.N + ) eq.solve() - obj = BoundaryError(eq, coilset, sheet_current, field_grid=coil_grid) + obj = BoundaryError(eq, coilset, field_grid=coil_grid) obj.build() - f = obj.compute_scaled_error(*obj.xs(eq, sheet_current)) + f = obj.compute_scaled_error(*obj.xs(eq)) n = len(f) // 3 # first n should be B*n errors np.testing.assert_allclose(f[:n], 0, atol=1e-4) @@ -1251,17 +1252,16 @@ def test_boundary_error_print(capsys): ) assert out.out == corr_out - sheet_current = FourierCurrentPotentialField() - sheet_current.change_resolution(M=eq.M, N=eq.N, NFP=eq.NFP, sym=eq.sym) - obj = BoundaryError(eq, coilset, sheet_current, field_grid=coil_grid) + eq.surface = FourierCurrentPotentialField.from_surface(eq.surface) + obj = BoundaryError(eq, coilset, field_grid=coil_grid) obj.build() - f = np.abs(obj.compute_unscaled(*obj.xs(eq, sheet_current))) + f = np.abs(obj.compute_unscaled(*obj.xs(eq))) n = len(f) // 3 f1 = f[:n] f2 = f[n : 2 * n] f3 = f[2 * n :] - obj.print_value(*obj.xs(eq, sheet_current)) + obj.print_value(*obj.xs(eq)) out = capsys.readouterr() corr_out = str(