{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Bootstrap Current Self-Consistency" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This tutorial demonstrates how to optimize a quasi-symmetric equilibrium to have a self-consistent bootstrap current profile. \n", "This is performed by minimizing the difference between the toroidal currents $\\langle J \\cdot B \\rangle$ computed from the MHD equilibrium and from the Redl formula. \n", "The Redl formula is only valid in the limit of perfect quasi-symmetry, so this procedure will not work for other configurations that are not quasi-symmetric. \n", "\n", "There are two methods that can be used, and both will be shown: \n", "\n", "1. Optimize the current profile for self-consistency\n", "2. Iteratively solve the equilibrium with new current profiles\n", "\n", "These methods should be equivalent, although one might be faster than the other depending on the particular problem. " ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import sys\n", "import os\n", "\n", "sys.path.insert(0, os.path.abspath(\".\"))\n", "sys.path.append(os.path.abspath(\"../../../\"))" ] }, { "cell_type": "markdown", "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, "metadata": {}, "outputs": [], "source": [ "# from desc import set_device\n", "# set_device(\"gpu\")" ] }, { "cell_type": "markdown", "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": 3, "metadata": {}, "outputs": [], "source": [ "# import jax\n", "\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": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "np.set_printoptions(linewidth=np.inf)\n", "import matplotlib.pyplot as plt\n", "\n", "plt.rcParams[\"font.size\"] = 14\n", "\n", "from desc.compat import rescale\n", "from desc.equilibrium import EquilibriaFamily\n", "from desc.examples import get\n", "from desc.grid import LinearGrid\n", "from desc.objectives import (\n", " BootstrapRedlConsistency,\n", " FixAtomicNumber,\n", " FixBoundaryR,\n", " FixBoundaryZ,\n", " FixCurrent,\n", " FixElectronDensity,\n", " FixElectronTemperature,\n", " FixIonTemperature,\n", " FixPsi,\n", " ForceBalance,\n", " ObjectiveFunction,\n", ")\n", "from desc.plotting import plot_1d\n", "from desc.profiles import PowerSeriesProfile, SplineProfile" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As an example, we will reproduce the QA results from [Landreman et al. (2022)](https://doi.org/10.1063/5.0098166). \n", "\n", "We will start with the \"precise QA\" example equilibrium, scaled to the ARIES-CS reactor size. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "eq0 = get(\"precise_QA\")\n", "eq0 = rescale(eq0, L=(\"R0\", 10), B=(\"B0\", 5.86))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This equilibrium has the vacuum profiles $p = 0 ~\\text{Pa}$ and $\\frac{2\\pi}{\\mu_0} I = 0 ~\\text{A}$. \n", "Calculating the bootstrap current requires knowledge of the temperature and density profiles for each species in the plasma. \n", "We replace the pressure profile with the following kinetic profiles corresponding to $\\langle\\beta\\rangle=2.5\\%$: \n", "\n", "$n_e = n_i = 2.38\\times10^{20} (1 - \\rho^{10}) ~\\text{m}^{-3}$\n", "\n", "$T_e = T_i = 9.45\\times10^{3} (1 - \\rho^{2}) ~\\text{eV}$\n", "\n", "The temperature profiles must be given for both ions and electrons, but only the electron density profile is specified. \n", "The ion density profile is given by the effective atomic number $Z_{eff}$ as $n_i = n_e / Z_{eff}$. \n", "The plasma pressure will then be computed as \n", "\n", "$p = e (n_e T_e + n_i T_i)$." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "eq0.pressure = None # must remove the pressure profile before setting kinetic profiles\n", "eq0.atomic_number = PowerSeriesProfile([1])\n", "eq0.electron_density = PowerSeriesProfile(params=[1, -1], modes=[0, 10]) * 2.38e20\n", "eq0.electron_temperature = PowerSeriesProfile(params=[1, -1], modes=[0, 2]) * 9.45e3\n", "eq0.ion_temperature = PowerSeriesProfile(params=[1, -1], modes=[0, 2]) * 9.45e3\n", "# the existing current profile is the vacuum case eq0.current = PowerSeriesProfile([0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to re-solve the equilibrium force balance with the new profiles. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 714 ms\n", "Timer: Objective build = 1.69 sec\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 773 ms\n", "Timer: LinearConstraintProjection build = 6.09 sec\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 8.71 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.431e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 1.138e-02 4.748e-02 \n", " 1 3 2.450e-03 8.927e-03 1.689e-01 1.805e-02 \n", " 2 4 1.003e-03 1.447e-03 2.762e-01 1.479e-02 \n", " 3 5 7.749e-04 2.284e-04 2.107e-01 1.472e-02 \n", " 4 6 2.205e-05 7.529e-04 5.663e-02 1.408e-03 \n", " 5 8 6.017e-06 1.603e-05 2.894e-02 6.948e-04 \n", " 6 9 3.382e-06 2.635e-06 2.959e-02 7.920e-04 \n", " 7 11 7.237e-07 2.658e-06 7.521e-03 6.954e-05 \n", " 8 12 7.116e-07 1.216e-08 1.528e-02 1.824e-04 \n", " 9 13 6.305e-07 8.108e-08 3.803e-03 1.213e-05 \n", " 10 14 6.235e-07 6.934e-09 7.823e-03 4.239e-05 \n", " 11 15 6.152e-07 8.309e-09 7.202e-03 4.238e-05 \n", " 12 16 6.104e-07 4.793e-09 7.663e-03 4.043e-05 \n", " 13 17 5.970e-07 1.342e-08 1.904e-03 2.954e-06 \n", " 14 18 5.928e-07 4.229e-09 3.800e-03 1.038e-05 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 5.928e-07\n", " Total delta_x: 6.427e-01\n", " Iterations: 14\n", " Function evaluations: 18\n", " Jacobian evaluations: 15\n", "Timer: Solution time = 16.1 sec\n", "Timer: Avg time per step = 1.07 sec\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 1.138e-02 --> 5.928e-07, \n", "Maximum absolute Force error: 5.309e+07 --> 1.983e+06 (N)\n", "Minimum absolute Force error: 1.261e+00 --> 2.978e+01 (N)\n", "Average absolute Force error: 5.121e+06 --> 5.254e+04 (N)\n", "Maximum absolute Force error: 1.512e-02 --> 5.649e-04 (normalized)\n", "Minimum absolute Force error: 3.591e-10 --> 8.483e-09 (normalized)\n", "Average absolute Force error: 1.459e-03 --> 1.496e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 3.846e-16 (m)\n", "Z boundary error: 0.000e+00 --> 2.326e-16 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 0.000e+00 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n" ] } ], "source": [ "eq0, _ = eq0.solve(objective=\"force\", optimizer=\"lsq-exact\", verbose=3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now we have our initial equilibrium, which does not have a self-consistent bootstrap current: " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined at rho=0, but grid has grid points at rho=0, note that on-axiscurrent will be NaN.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron density vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given ion temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# the Redl formula is undefined at rho=0.0 and where the profiles vanish, so\n", "# in our case here it is NaN at the axis and at rho=1.0\n", "fig, ax = plot_1d(\n", " eq0,\n", " \" Redl\",\n", " color=\"b\",\n", " lw=2,\n", " label=\"Redl\",\n", ")\n", "fig, ax = plot_1d(eq0, \"\", color=\"r\", lw=2, label=\"MHD\", ax=ax)\n", "ax.legend(loc=\"best\")\n", "ax.set_title(\"Initial Equilibrium\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We need to create a grid on which to evaluate the boootstrap current self-consistency. \n", "The bootstrap current is a radial profile, but the grid must have finite poloidal and toroidal resolution to accurately compute flux surface quantities. \n", "The Redl formula is undefined where the kinetic profiles vanish, so in our example we do not include points at $\\rho=0$ or $\\rho=1$. " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "grid = LinearGrid(\n", " M=eq0.M_grid,\n", " N=eq0.N_grid,\n", " NFP=eq0.NFP,\n", " sym=eq0.sym,\n", " rho=np.linspace(1 / eq0.L_grid, 1, eq0.L_grid) - 1 / (2 * eq0.L_grid),\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Our current profile will be represented as a power series of the form: \n", "\n", "$I = c_0 + c_1 \\rho + c_2 \\rho^2 + \\mathcal{O}(\\rho^3)$\n", "\n", "Physically, the current should vanish on the magnetic axis so $c_0 = 0$. \n", "And in order for the MHD equilibrium to be analytic, it should scale as $\\mathcal{O}(\\rho^2)$ near the magnetic axis so $c_1 = 0$ also. \n", "However, the Redl bootstrap current formula scales as $\\mathcal{O}(\\sqrt{\\rho})$ near the magnetic axis. \n", "This is incorrect, because the drift-kinetic equation from the Redl formula does not account for finite orbit width effects that become important near the axis. \n", "\n", "Typically, we use even power series with `sym=True` for all equilibrium profiles to give the desired analycity conditions. \n", "For bootstrap current optimizations, it is recommended to use the full power series with `sym=False` while also enforcing $c_0 = c_1 = 0$. \n", "This prevents getting good self-consistency near the magnetic axis, but allows for good agreement throughout the rest of the plasma volume and results in high quality equilibria overall. \n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "eq0.current = PowerSeriesProfile(np.zeros((eq0.L + 1,)), sym=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1. Optimization" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this method, we will optimize the current profile to minimize the self-consistency errors evaluated by the `BootstrapRedlConsistency` objective. \n", "This objective requires the helicity, which for QA is $(M, N) = (1, 0)$. \n", "\n", "In this example we will only optimize the current profile, so all other profiles and the plasma boundary are constrained to be fixed. \n", "It is recommended to use a very small value for `gtol` when optimizing the bootstrap current. " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "eq1 = eq0.copy()" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Building objective: Bootstrap current self-consistency (Redl)\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 1.06 sec\n", "Timer: Objective build = 1.94 sec\n", "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 75.2 ms\n", "Timer: Objective build = 136 ms\n", "Timer: Objective build = 20.0 ms\n", "Timer: Eq Update LinearConstraintProjection build = 3.74 sec\n", "Timer: Proximal projection build = 19.6 sec\n", "Building objective: fixed atomic number\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed Psi\n", "Timer: Objective build = 585 ms\n", "Timer: LinearConstraintProjection build = 1.66 sec\n", "Number of parameters: 7\n", "Number of objectives: 16\n", "Timer: Initializing the optimization = 21.9 sec\n", "\n", "Starting optimization\n", "Using method: proximal-lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 51\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.000e+00\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 2.763e-02 2.228e-01 \n", " 1 2 1.271e-04 2.751e-02 1.197e+07 1.221e-02 \n", " 2 3 4.028e-06 1.231e-04 2.418e+07 1.541e-03 \n", " 3 4 1.495e-06 2.533e-06 4.759e+07 5.865e-05 \n", " 4 30 1.495e-06 0.000e+00 0.000e+00 5.865e-05 \n", "Warning: A bad approximation caused failure to predict improvement.\n", " Current function value: 1.495e-06\n", " Total delta_x: 7.262e+07\n", " Iterations: 4\n", " Function evaluations: 30\n", " Jacobian evaluations: 4\n", "Timer: Solution time = 2.02 min\n", "Timer: Avg time per step = 24.3 sec\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 2.765e-02 --> 1.495e-06, \n", "Maximum absolute Bootstrap current self-consistency error: 3.106e+06 --> 3.873e+04 (T A m^-2)\n", "Minimum absolute Bootstrap current self-consistency error: 1.896e+05 --> 1.482e+01 (T A m^-2)\n", "Average absolute Bootstrap current self-consistency error: 1.954e+06 --> 1.252e+04 (T A m^-2)\n", "Maximum absolute Bootstrap current self-consistency error: 3.355e-01 --> 4.183e-03 (normalized)\n", "Minimum absolute Bootstrap current self-consistency error: 2.048e-02 --> 1.601e-06 (normalized)\n", "Average absolute Bootstrap current self-consistency error: 2.111e-01 --> 1.353e-03 (normalized)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "R boundary error: 3.846e-16 --> 1.154e-15 (m)\n", "Z boundary error: 2.326e-16 --> 6.979e-16 (m)\n", "Fixed current profile error: 0.000e+00 --> 0.000e+00 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Maximum absolute Force error: 1.983e+06 --> 1.794e+06 (N)\n", "Minimum absolute Force error: 2.978e+01 --> 7.962e+00 (N)\n", "Average absolute Force error: 5.254e+04 --> 8.691e+04 (N)\n", "Maximum absolute Force error: 5.649e-04 --> 5.109e-04 (normalized)\n", "Minimum absolute Force error: 8.483e-09 --> 2.268e-09 (normalized)\n", "Average absolute Force error: 1.496e-05 --> 2.475e-05 (normalized)\n", "==============================================================================================================\n", "\n" ] } ], "source": [ "objective = ObjectiveFunction(\n", " BootstrapRedlConsistency(eq=eq1, grid=grid, helicity=(1, 0)),\n", ")\n", "constraints = (\n", " FixAtomicNumber(eq=eq1),\n", " FixBoundaryR(eq=eq1),\n", " FixBoundaryZ(eq=eq1),\n", " FixCurrent(eq=eq1, indices=[0, 1]), # fix c_0=c_1=0 current profile coefficients\n", " FixElectronDensity(eq=eq1),\n", " FixElectronTemperature(eq=eq1),\n", " FixIonTemperature(eq=eq1),\n", " FixPsi(eq=eq1),\n", " ForceBalance(eq=eq1),\n", ")\n", "eq1, _ = eq1.optimize(\n", " objective=objective,\n", " constraints=constraints,\n", " optimizer=\"proximal-lsq-exact\",\n", " maxiter=10,\n", " verbose=3,\n", ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When plotting the bootstrap current profiles, we see the MHD equilibrium now has very good agreement with the Redl formula. " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined at rho=0, but grid has grid points at rho=0, note that on-axiscurrent will be NaN.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron density vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given ion temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plot_1d(eq1, \" Redl\", color=\"b\", lw=2, label=\"Redl\")\n", "fig, ax = plot_1d(eq1, \"\", color=\"r\", lw=2, label=\"MHD\", ax=ax)\n", "ax.legend(loc=\"best\")\n", "ax.set_title(\"Method 1: Optimization\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2. Iterative Solves" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this method, we iteratively solve the equilibrium with updated guesses for the current profile. \n", "The current profile is computed such that the parallel current is consistent with the Redl formula, according to Equation C3 in [Landreman & Catto (2012)](https://doi.org/10.1063/1.3693187). \n", "This is the same approach as STELLOPT VBOOT with SFINCS, and it usually converges in only a few iterations. " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "eq2 = eq0.copy()\n", "fam2 = EquilibriaFamily(eq2)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 72.1 ms\n", "Timer: Objective build = 134 ms\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 867 ms\n", "Timer: LinearConstraintProjection build = 274 ms\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 1.31 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.498e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 7.104e-03 8.999e-02 \n", " 1 2 3.466e-03 3.638e-03 2.023e-01 3.716e-02 \n", " 2 3 2.593e-04 3.206e-03 1.213e-01 8.056e-03 \n", " 3 4 1.499e-04 1.094e-04 9.481e-02 7.302e-03 \n", " 4 5 6.137e-05 8.857e-05 7.001e-02 3.921e-03 \n", " 5 6 2.461e-05 3.676e-05 5.578e-02 2.250e-03 \n", " 6 7 1.011e-05 1.450e-05 3.741e-02 1.271e-03 \n", " 7 8 8.362e-06 1.751e-06 3.246e-02 1.128e-03 \n", " 8 9 3.437e-06 4.926e-06 8.517e-03 1.869e-04 \n", " 9 10 3.406e-06 3.016e-08 1.767e-02 1.875e-04 \n", " 10 11 3.088e-06 3.187e-07 4.356e-03 7.847e-05 \n", " 11 12 3.021e-06 6.629e-08 4.618e-03 2.987e-05 \n", " 12 14 3.002e-06 1.981e-08 1.159e-03 8.202e-06 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 3.002e-06\n", " Total delta_x: 2.363e-01\n", " Iterations: 12\n", " Function evaluations: 14\n", " Jacobian evaluations: 13\n", "Timer: Solution time = 3.99 sec\n", "Timer: Avg time per step = 307 ms\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 7.104e-03 --> 3.002e-06, \n", "Maximum absolute Force error: 5.166e+07 --> 2.331e+06 (N)\n", "Minimum absolute Force error: 8.443e+01 --> 4.092e+00 (N)\n", "Average absolute Force error: 4.441e+06 --> 1.062e+05 (N)\n", "Maximum absolute Force error: 1.471e-02 --> 6.639e-04 (normalized)\n", "Minimum absolute Force error: 2.405e-08 --> 1.165e-09 (normalized)\n", "Average absolute Force error: 1.265e-03 --> 3.026e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 3.846e-16 (m)\n", "Z boundary error: 0.000e+00 --> 2.326e-16 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 6.664e-08 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n", "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 66.8 ms\n", "Timer: Objective build = 131 ms\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 743 ms\n", "Timer: LinearConstraintProjection build = 167 ms\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 1.06 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.514e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 5.842e-04 2.129e-02 \n", " 1 2 1.374e-05 5.704e-04 6.550e-02 2.012e-03 \n", " 2 3 2.646e-06 1.109e-05 2.354e-02 3.305e-04 \n", " 3 5 1.938e-06 7.084e-07 8.600e-03 6.146e-05 \n", " 4 7 1.904e-06 3.454e-08 4.618e-03 4.600e-05 \n", " 5 8 1.890e-06 1.359e-08 4.210e-03 1.932e-05 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 1.890e-06\n", " Total delta_x: 6.890e-02\n", " Iterations: 5\n", " Function evaluations: 8\n", " Jacobian evaluations: 6\n", "Timer: Solution time = 1.96 sec\n", "Timer: Avg time per step = 326 ms\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 5.842e-04 --> 1.890e-06, \n", "Maximum absolute Force error: 1.265e+07 --> 1.473e+06 (N)\n", "Minimum absolute Force error: 5.030e+02 --> 6.140e+00 (N)\n", "Average absolute Force error: 1.293e+06 --> 8.187e+04 (N)\n", "Maximum absolute Force error: 3.602e-03 --> 4.196e-04 (normalized)\n", "Minimum absolute Force error: 1.433e-07 --> 1.749e-09 (normalized)\n", "Average absolute Force error: 3.683e-04 --> 2.332e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 1.781e-15 (m)\n", "Z boundary error: 0.000e+00 --> 2.577e-17 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 0.000e+00 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n", "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 73.7 ms\n", "Timer: Objective build = 134 ms\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 732 ms\n", "Timer: LinearConstraintProjection build = 182 ms\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 1.06 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.497e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 2.391e-05 4.060e-03 \n", " 1 2 6.116e-06 1.780e-05 3.606e-02 7.476e-04 \n", " 2 3 1.856e-06 4.260e-06 1.124e-02 1.048e-04 \n", " 3 5 1.806e-06 5.084e-08 4.381e-03 2.417e-05 \n", " 4 7 1.800e-06 5.525e-09 2.266e-03 5.050e-06 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 1.800e-06\n", " Total delta_x: 4.496e-02\n", " Iterations: 4\n", " Function evaluations: 7\n", " Jacobian evaluations: 5\n", "Timer: Solution time = 1.66 sec\n", "Timer: Avg time per step = 332 ms\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 2.391e-05 --> 1.800e-06, \n", "Maximum absolute Force error: 3.586e+06 --> 1.489e+06 (N)\n", "Minimum absolute Force error: 9.634e+01 --> 4.893e+00 (N)\n", "Average absolute Force error: 2.651e+05 --> 8.232e+04 (N)\n", "Maximum absolute Force error: 1.021e-03 --> 4.240e-04 (normalized)\n", "Minimum absolute Force error: 2.744e-08 --> 1.394e-09 (normalized)\n", "Average absolute Force error: 7.550e-05 --> 2.344e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 1.781e-15 (m)\n", "Z boundary error: 0.000e+00 --> 2.571e-17 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 4.165e-09 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n" ] } ], "source": [ "niters = 3\n", "for k in range(niters):\n", " eq2 = eq2.copy()\n", " # compute new guess for the current profile, consistent with Redl formula\n", " data = eq2.compute(\"current Redl\", grid)\n", " current = grid.compress(data[\"current Redl\"])\n", " rho = grid.compress(data[\"rho\"])\n", " # fit the current profile to a power series, with c_0=c_1=0\n", " XX = np.fliplr(np.vander(rho, eq2.L + 1)[:, :-2])\n", " eq2.c_l = np.pad(np.linalg.lstsq(XX, current, rcond=None)[0], (2, 0))\n", " # re-solve the equilibrium\n", " eq2, _ = eq2.solve(objective=\"force\", optimizer=\"lsq-exact\", verbose=3)\n", " fam2.append(eq2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can plot the current profile at each iteration to visualize how it changed: " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plot_1d(fam2[0], \"current\", color=\"k\", lw=2, label=\"0\")\n", "fig, ax = plot_1d(fam2[1], \"current\", color=\"g\", lw=2, label=\"1\", ax=ax)\n", "fig, ax = plot_1d(fam2[2], \"current\", color=\"b\", lw=2, label=\"2\", ax=ax)\n", "fig, ax = plot_1d(fam2[3], \"current\", color=\"r\", lw=2, label=\"3\", ax=ax)\n", "ax.legend(loc=\"best\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With this method the MHD equilibrium also has very good agreement with the Redl formula. " ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined at rho=0, but grid has grid points at rho=0, note that on-axiscurrent will be NaN.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron density vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given ion temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plot_1d(eq2, \" Redl\", color=\"b\", lw=2, label=\"Redl\")\n", "fig, ax = plot_1d(eq2, \"\", color=\"r\", lw=2, label=\"MHD\", ax=ax)\n", "ax.legend(loc=\"best\")\n", "ax.set_title(\"Method 2: Iterative Solves\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comparison" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Even though both methods give good self-consistency for the bootstrap current, they do result in slightly different coefficients for the current profile: " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 0.00000000e+00 0.00000000e+00 1.15112878e+04 6.29171559e+06 3.58272704e+06 -3.59527414e+07 5.57512420e+07 -2.86198850e+07 1.35489797e+06]\n", "[ 0.00000000e+00 0.00000000e+00 4.66585405e+05 5.63752557e+05 3.00704695e+07 -9.56770096e+07 1.26451711e+08 -7.04331552e+07 1.09842316e+07]\n" ] } ], "source": [ "print(eq1.c_l)\n", "print(eq2.c_l)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this example, the first method of optimization gave better self-consistency but was noticeably slower than the second method of iterative solves. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Using Spline Profiles\n", "\n", "We can also use splines to describe the current profile. Due to the many DOFs of splines and their local nature, they can be difficult to use with the first method shown above. So, we recommend using the iterative solve method if a spline current profile is desired. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code for the iterative method with splines is slightly different, as now we do not need to re-fit the current profile with a power series in order to update our spline. Instead, we choose our spline profile knots carefully to include a knot at the axis which we will keep at 0 (in order to enforce zero on-axis net toroidal current), and choosing the rest to align with the grid we will be computing the Redl bootstrap current at.\n", "\n", "Remember that the Redl formula is not defined on-axis or on the boundary, so we must ensure we do not include a knot at $\\rho=1$, as we have no way of updating that value." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# Choose a denser grid for the spline profile so we can represent the bootstrap current profile well\n", "L_grid = 25\n", "\n", "grid = LinearGrid(\n", " M=eq0.M_grid,\n", " N=eq0.N_grid,\n", " NFP=eq0.NFP,\n", " sym=eq0.sym,\n", " rho=np.linspace(1 / L_grid, 1, L_grid) - 1 / (2 * L_grid),\n", ")\n", "\n", "eq2_spline = eq0.copy()\n", "fam2 = EquilibriaFamily(eq2_spline)\n", "# choose the rho values for the knots\n", "rho = np.concatenate([np.array([0.0]), grid.nodes[grid.unique_rho_idx, 0]])\n", "# make a SplineProfile for current, initially zero.\n", "eq2_spline.current = SplineProfile(values=np.zeros_like(rho), knots=rho)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 90.9 ms\n", "Timer: Objective build = 153 ms\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 893 ms\n", "Timer: LinearConstraintProjection build = 4.22 sec\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 5.36 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.498e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 7.098e-03 9.004e-02 \n", " 1 2 4.884e-03 2.214e-03 2.084e-01 4.057e-02 \n", " 2 3 3.192e-04 4.564e-03 1.226e-01 8.920e-03 \n", " 3 4 2.414e-04 7.784e-05 1.060e-01 8.235e-03 \n", " 4 5 4.900e-06 2.365e-04 2.610e-02 3.733e-04 \n", " 5 7 2.996e-06 1.904e-06 1.485e-02 1.100e-04 \n", " 6 9 2.819e-06 1.771e-07 6.102e-03 5.988e-05 \n", " 7 11 2.761e-06 5.803e-08 3.671e-03 1.419e-05 \n", " 8 12 2.721e-06 4.015e-08 6.525e-03 3.824e-05 \n", " 9 13 2.707e-06 1.398e-08 1.187e-02 1.058e-04 \n", " 10 14 2.629e-06 7.797e-08 3.109e-03 5.613e-06 \n", " 11 15 2.614e-06 1.448e-08 5.635e-03 2.405e-05 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 2.614e-06\n", " Total delta_x: 2.312e-01\n", " Iterations: 11\n", " Function evaluations: 15\n", " Jacobian evaluations: 12\n", "Timer: Solution time = 16.7 sec\n", "Timer: Avg time per step = 1.39 sec\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 7.098e-03 --> 2.614e-06, \n", "Maximum absolute Force error: 5.134e+07 --> 2.062e+06 (N)\n", "Minimum absolute Force error: 6.833e+01 --> 1.635e+01 (N)\n", "Average absolute Force error: 4.425e+06 --> 1.033e+05 (N)\n", "Maximum absolute Force error: 1.462e-02 --> 5.872e-04 (normalized)\n", "Minimum absolute Force error: 1.946e-08 --> 4.657e-09 (normalized)\n", "Average absolute Force error: 1.260e-03 --> 2.941e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 3.846e-16 (m)\n", "Z boundary error: 0.000e+00 --> 2.326e-16 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 4.800e-10 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n", "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 74.6 ms\n", "Timer: Objective build = 137 ms\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 740 ms\n", "Timer: LinearConstraintProjection build = 168 ms\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 1.06 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.488e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 5.723e-04 2.144e-02 \n", " 1 2 1.125e-05 5.611e-04 6.481e-02 1.773e-03 \n", " 2 3 2.081e-06 9.168e-06 1.462e-02 1.189e-04 \n", " 3 4 2.052e-06 2.892e-08 1.242e-02 9.357e-05 \n", " 4 6 1.983e-06 6.916e-08 3.906e-03 3.394e-05 \n", " 5 7 1.976e-06 6.929e-09 7.107e-03 2.043e-05 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 1.976e-06\n", " Total delta_x: 7.030e-02\n", " Iterations: 5\n", " Function evaluations: 7\n", " Jacobian evaluations: 6\n", "Timer: Solution time = 1.66 sec\n", "Timer: Avg time per step = 278 ms\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 5.723e-04 --> 1.976e-06, \n", "Maximum absolute Force error: 1.335e+07 --> 2.315e+06 (N)\n", "Minimum absolute Force error: 6.304e+01 --> 7.764e-01 (N)\n", "Average absolute Force error: 1.293e+06 --> 8.724e+04 (N)\n", "Maximum absolute Force error: 3.801e-03 --> 6.593e-04 (normalized)\n", "Minimum absolute Force error: 1.795e-08 --> 2.211e-10 (normalized)\n", "Average absolute Force error: 3.683e-04 --> 2.485e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 1.781e-15 (m)\n", "Z boundary error: 0.000e+00 --> 2.577e-17 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 2.671e-10 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n", "Building objective: force\n", "Precomputing transforms\n", "Timer: Precomputing transforms = 76.6 ms\n", "Timer: Objective build = 137 ms\n", "Building objective: lcfs R\n", "Building objective: lcfs Z\n", "Building objective: fixed Psi\n", "Building objective: fixed current\n", "Building objective: fixed electron density\n", "Building objective: fixed electron temperature\n", "Building objective: fixed ion temperature\n", "Building objective: fixed atomic number\n", "Building objective: fixed sheet current\n", "Building objective: self_consistency R\n", "Building objective: self_consistency Z\n", "Building objective: lambda gauge\n", "Building objective: axis R self consistency\n", "Building objective: axis Z self consistency\n", "Timer: Objective build = 730 ms\n", "Timer: LinearConstraintProjection build = 163 ms\n", "Number of parameters: 856\n", "Number of objectives: 5346\n", "Timer: Initializing the optimization = 1.04 sec\n", "\n", "Starting optimization\n", "Using method: lsq-exact\n", "Solver options:\n", "------------------------------------------------------------\n", "Maximum Function Evaluations : 501\n", "Maximum Allowed Total Δx Norm : inf\n", "Scaled Termination : True\n", "Trust Region Method : qr\n", "Initial Trust Radius : 1.464e+02\n", "Maximum Trust Radius : inf\n", "Minimum Trust Radius : 2.220e-16\n", "Trust Radius Increase Ratio : 2.000e+00\n", "Trust Radius Decrease Ratio : 2.500e-01\n", "Trust Radius Increase Threshold : 7.500e-01\n", "Trust Radius Decrease Threshold : 2.500e-01\n", "------------------------------------------------------------ \n", "\n", " Iteration Total nfev Cost Cost reduction Step norm Optimality \n", " 0 1 2.632e-05 4.461e-03 \n", " 1 2 2.064e-06 2.426e-05 1.606e-02 1.069e-04 \n", " 2 3 2.031e-06 3.265e-08 1.021e-02 7.220e-05 \n", " 3 5 1.989e-06 4.186e-08 3.607e-03 2.415e-05 \n", " 4 6 1.986e-06 3.878e-09 5.739e-03 2.184e-05 \n", "Optimization terminated successfully.\n", "`ftol` condition satisfied. (ftol=1.00e-02)\n", " Current function value: 1.986e-06\n", " Total delta_x: 2.328e-02\n", " Iterations: 4\n", " Function evaluations: 6\n", " Jacobian evaluations: 5\n", "Timer: Solution time = 1.47 sec\n", "Timer: Avg time per step = 295 ms\n", "==============================================================================================================\n", " Start --> End\n", "Total (sum of squares): 2.632e-05 --> 1.986e-06, \n", "Maximum absolute Force error: 2.524e+06 --> 2.346e+06 (N)\n", "Minimum absolute Force error: 5.917e+01 --> 4.723e+01 (N)\n", "Average absolute Force error: 2.785e+05 --> 8.965e+04 (N)\n", "Maximum absolute Force error: 7.188e-04 --> 6.680e-04 (normalized)\n", "Minimum absolute Force error: 1.685e-08 --> 1.345e-08 (normalized)\n", "Average absolute Force error: 7.933e-05 --> 2.553e-05 (normalized)\n", "R boundary error: 0.000e+00 --> 1.781e-15 (m)\n", "Z boundary error: 0.000e+00 --> 2.571e-17 (m)\n", "Fixed Psi error: 0.000e+00 --> 0.000e+00 (Wb)\n", "Fixed current profile error: 0.000e+00 --> 5.468e-10 (A)\n", "Fixed electron density profile error: 0.000e+00 --> 0.000e+00 (m^-3)\n", "Fixed electron temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed ion temperature profile error: 0.000e+00 --> 0.000e+00 (eV)\n", "Fixed atomic number profile error: 0.000e+00 --> 0.000e+00 (dimensionless)\n", "Fixed sheet current error: 0.000e+00 --> 0.000e+00 (~)\n", "==============================================================================================================\n", "\n" ] } ], "source": [ "from desc.backend import jnp\n", "\n", "niters = 3\n", "for k in range(niters):\n", " eq2_spline = eq2_spline.copy()\n", " # compute new guess for the current profile, consistent with Redl formula\n", " data = eq2_spline.compute(\"current Redl\", grid)\n", " current = grid.compress(data[\"current Redl\"])\n", " rho = grid.compress(data[\"rho\"])\n", " # add the rho=0 value which we enforce as zero current\n", " c_at_knots = np.concatenate([np.array([0.0]), current])\n", " eq2_spline.current.params = c_at_knots\n", " # re-solve the equilibrium\n", " eq2_spline, _ = eq2_spline.solve(\n", " objective=\"force\", optimizer=\"lsq-exact\", verbose=3\n", " )\n", " fam2.append(eq2_spline)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can plot the current profile at each iteration to visualize how it changed: " ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plot_1d(fam2[0], \"current\", color=\"k\", lw=2, label=\"0\")\n", "fig, ax = plot_1d(fam2[1], \"current\", color=\"g\", lw=2, label=\"1\", ax=ax)\n", "fig, ax = plot_1d(fam2[2], \"current\", color=\"b\", lw=2, label=\"2\", ax=ax)\n", "ax.legend(loc=\"best\");" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "With this method the MHD equilibrium also has very good agreement with the Redl formula, now with a ``SplineProfile``." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined at rho=0, but grid has grid points at rho=0, note that on-axiscurrent will be NaN.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron density vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given electron temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n", "/CODES/DESC/desc/utils.py:572: UserWarning: Redl formula is undefined where kinetic profiles vanish, but given ion temperature vanishes at at least one providedrho grid point.\n", " warnings.warn(msg, err)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig, ax = plot_1d(fam2[-1], \" Redl\", color=\"b\", lw=2, label=\"Redl\")\n", "fig, ax = plot_1d(fam2[-1], \"\", color=\"r\", lw=2, label=\"MHD\", ax=ax)\n", "ax.legend(loc=\"best\")\n", "ax.set_title(\"Method 2: Iterative Solves (splines)\");" ] } ], "metadata": { "kernelspec": { "display_name": "gpu", "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.12.11" } }, "nbformat": 4, "nbformat_minor": 4 }