From 6dc1950724c40437ddec659c96937a824592eb0e Mon Sep 17 00:00:00 2001 From: kpentland Date: Thu, 19 Jun 2025 10:36:16 +0100 Subject: [PATCH 01/13] adding dIy_dtheta jacobian --- freegsnke/nonlinear_solve.py | 525 ++++++++++++++++++++++++++--------- 1 file changed, 393 insertions(+), 132 deletions(-) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index 2c2b2aa7..ca550156 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -202,6 +202,7 @@ def __init__( self.dt_step = full_timestep self.max_internal_timestep = max_internal_timestep self.set_plasma_resistivity(plasma_resistivity) + self.target_dIy = target_dIy # prepare for mode selection if max_mode_frequency is None: @@ -362,6 +363,42 @@ def __init__( self.approved_target_dIy = np.concatenate( (self.approved_target_dIy, [target_dIy]) ) + + # need to build this + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + # + + # self.approved_target_dItheta 1e-3*np.ones(nonlinear_solver.n_profiles_parameters) # This solves the system of circuit eqs based on an assumption # for the direction of the plasma current distribution at time t+dt @@ -692,134 +729,266 @@ def set_linear_solution(self, active_voltage_vec, d_profiles_pars_dt=None): self.assign_currents_solve_GS(self.trial_currents, self.rtol_NK) self.trial_plasma_psi = np.copy(self.eq2.plasma_psi) - # # not used atm, used when building the Jacobian of the plasma current distribution with respect to the coefficients of the profiles object - # def prepare_build_dIydpars(self, profiles, rtol_NK, target_dIy, starting_dpars): - # """Prepares to compute the term d(Iy)/d(alpha_m, alpha_n, profifile_par) - # where profiles_par = paxis or betap. - # It infers the value of delta(indep_variable) corresponding to a change delta(I_y) - # with norm(delta(I_y))=target_dIy. + def prepare_build_dIydtheta( + self, + profiles, + rtol_NK, + target_dIy, + starting_dthetas): + """ + + Prepares to compute the term d(Iy)/d(theta) where theta is a vector of the parameters + that define the plasma current density profile being used. + It infers the value of delta(indep_variable) corresponding to a change delta(I_y) + with norm(delta(I_y))=target_dIy. - # Parameters - # ---------- - # profiles : FreeGS4E profiles object - # The profiles object of the initial condition equilibrium, i.e. the linearization point. - # rtol_NK : float - # Relative tolerance to be used in the static GS problems. - # target_dIy : float - # Target value for the norm of delta(I_y), on which th finite difference derivative is calculated. - # starting_dpars : tuple (d_alpha_m, d_alpha_n, relative_d_profiles_par) - # Initial value to be used as delta(indep_variable) to infer the slope of norm(delta(I_y))/delta(indep_variable). - # Note that the first two values in the tuple are absolute deltas, - # while the third value is relative, d_profiles_par = relative_d_profiles_par * profiles_par - # """ + Parameters + ---------- + profiles : FreeGS4E profiles object + The profiles object of the initial condition equilibrium, i.e. the linearization point. + rtol_NK : float + Relative tolerance to be used in the static GS problems. + target_dIy : float + Target value for the norm of delta(I_y), on which th finite difference derivative is calculated. + starting_dthetas : tuple (d_alpha_m, d_alpha_n, relative_d_profiles_par) + Initial value to be used as delta(indep_variable) to infer the slope of norm(delta(I_y))/delta(indep_variable). + Note that the first two values in the tuple are absolute deltas, + while the third value is relative, d_profiles_par = relative_d_profiles_par * profiles_par + """ - # current_ = np.copy(self.currents_vec) + current_ = np.copy(self.currents_vec) - # # vary alpha_m - # self.check_and_change_profiles( - # profiles_coefficients=( - # profiles.alpha_m + starting_dpars[0], - # profiles.alpha_n, - # ) - # ) - # self.assign_currents_solve_GS(current_, rtol_NK) - # dIy_0 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - # rel_ndIy_0 = np.linalg.norm(dIy_0) / self.nIy - # self.final_dpars_record[0] = starting_dpars[0] * target_dIy / rel_ndIy_0 - - # # vary alpha_n - # self.check_and_change_profiles( - # profiles_coefficients=( - # profiles.alpha_m, - # profiles.alpha_n + starting_dpars[1], - # ) - # ) - # self.assign_currents_solve_GS(current_, rtol_NK) - # dIy_0 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - # rel_ndIy_0 = np.linalg.norm(dIy_0) / self.nIy - # self.final_dpars_record[1] = starting_dpars[1] * target_dIy / rel_ndIy_0 - - # # vary paxis or betap - # self.check_and_change_profiles( - # profiles_coefficients=(profiles.alpha_m, profiles.alpha_n), - # profiles_parameter=(1 + starting_dpars[2]) * profiles.profiles_parameter, - # ) - # self.assign_currents_solve_GS(current_, rtol_NK) - # dIy_0 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - # rel_ndIy_0 = np.linalg.norm(dIy_0) / self.nIy - # self.final_dpars_record[2] = ( - # starting_dpars[2] * profiles.profiles_parameter * target_dIy / rel_ndIy_0 - # ) + # for setting profile parameters + if self.profiles_type == "ConstrainPaxisIp": + param = "paxis" + elif self.profiles_type == "ConstrainBetapIp": + param = "betap" + elif self.profiles_type == "Fiesta_Topeol": + param = "beta0" + else: + param = None - # # not used atm, builds the Jacobian of the plasma current distribution with respect to the coefficients of the profiles object - # # can only handle ConstrainPaxisIp and ConstrainBetapIp profiles families. - # def build_dIydIpars(self, profiles, rtol_NK, verbose=False): - # """Compute the matrix d(Iy)/d(alpha_m, alpha_n, profifile_par) as a finite difference derivative, - # using the value of delta(indep_viriable) inferred earlier by self.prepare_build_dIypars. + # carry out the initial perturbations + if param is not None: - # Parameters - # ---------- - # profiles : FreeGS4E profiles object - # The profiles object of the initial condition equilibrium, i.e. the linearization point. - # rtol_NK : float - # Relative tolerance to be used in the static GS problems. + dIy_0 = np.zeros(len(self.dIy),3) + rel_ndIy_0 = np.zeros(3) - # """ + # vary alpha_m + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m + starting_dthetas[0], + "alpha_n": profiles.alpha_n, + param: getattr(profiles, param), + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_0[:,0] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,0]) / self.nIy + self.final_dtheta_record[0] = starting_dthetas[0] * target_dIy / rel_ndIy_0[i] + + # vary alpha_n + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m, + "alpha_n": profiles.alpha_n + starting_dthetas[1], + param: getattr(profiles, param), + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_0[:,1] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,1]) / self.nIy + self.final_dtheta_record[1] = starting_dthetas[1] * target_dIy / rel_ndIy_0[i] + + # vary paxis, betap or beta0 + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m, + "alpha_n": profiles.alpha_n, + param: getattr(profiles, param) * (1 + starting_dthetas[2]), + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_0[:,2] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,2]) / self.nIy + self.final_dtheta_record[2] = ( + starting_dthetas[2] * getattr(profiles, param) * target_dIy / rel_ndIy_0[i] + ) + + else: # this is particular to the Lao profile coefficients (which there may be few or many of) + + dIy_0 = np.zeros((len(self.Iy),self.n_profiles_parameters)) + rel_ndIy_0 = np.zeros(self.n_profiles_parameters) + + # for each alpha coefficient + alpha_base = profiles.alpha.copy() + alpha_n = len(profiles.alpha) + for i in range(0,alpha_n): + alpha_shift = alpha_base.copy() + alpha_shift[i] += starting_dthetas[i] + self.check_and_change_profiles( + profiles_parameters={ + "alpha": alpha_shift, + "beta": profiles.beta, + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_0[:,i] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,i]) / self.nIy + self.final_dtheta_record[i] = starting_dthetas[i] * target_dIy / rel_ndIy_0[i] + + # for each beta coefficient + beta_base = profiles.beta.copy() + beta_n = len(profiles.beta) + for i in range(0,beta_n): + beta_shift = beta_base.copy() + beta_shift[i] += starting_dthetas[i + alpha_n] + self.check_and_change_profiles( + profiles_parameters={ + "alpha": profiles.alpha, + "beta": beta_shift, + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_0[:,i+alpha_n] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + rel_ndIy_0[i+alpha_n] = np.linalg.norm(dIy_0[:,i+alpha_n]) / self.nIy + self.final_dtheta_record[i+alpha_n] = starting_dthetas[i+alpha_n] * target_dIy / rel_ndIy_0[i+alpha_n] - # current_ = np.copy(self.currents_vec) + return dIy_0 / starting_dthetas, rel_ndIy_0 + + def build_dIydtheta(self, profiles, rtol_NK, verbose=False): + """ + + Compute the matrix d(Iy)/d(theta) as a finite difference derivative, + using the value of delta(indep_viriable) inferred earlier by self.prepare_build_dIypars. + + Parameters + ---------- + profiles : FreeGS4E profiles object + The profiles object of the initial condition equilibrium, i.e. the linearization point. + rtol_NK : float + Relative tolerance to be used in the static GS problems. + + """ + + current_ = np.copy(self.currents_vec) + + # for setting profile parameters + if self.profiles_type == "ConstrainPaxisIp": + param = "paxis" + elif self.profiles_type == "ConstrainBetapIp": + param = "betap" + elif self.profiles_type == "Fiesta_Topeol": + param = "beta0" + else: + param = None + + # carry out the initial perturbations + if param is not None: + + # vary alpha_m + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m + self.final_dtheta_record[0], + "alpha_n": profiles.alpha_n, + param: getattr(profiles, param), + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + self.dIydtheta[:, 0] = dIy_1 / self.final_dtheta_record[0] + if verbose: + print( + "alpha_m gradient calculated on the finite difference: delta_alpha_m =", + self.final_dtheta_record[0], + ", norm(deltaIy) =", + np.linalg.norm(dIy_1), + ) + + # vary alpha_n + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m, + "alpha_n": profiles.alpha_n + self.final_dtheta_record[1], + param: getattr(profiles, param), + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + self.dIydtheta[:, 1] = dIy_1 / self.final_dtheta_record[1] + if verbose: + print( + "alpha_n gradient calculated on the finite difference: delta_alpha_n =", + self.final_dtheta_record[1], + ", norm(deltaIy) =", + np.linalg.norm(dIy_1), + ) + + # vary paxis, betap or beta0 + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m, + "alpha_n": profiles.alpha_n, + param: getattr(profiles, param) + self.final_dtheta_record[2], + } ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + self.dIydtheta[:, 2] = dIy_1 / self.final_dtheta_record[2] + if verbose: + print( + f"{param} gradient calculated on the finite difference: delta_{param} =", + self.final_dtheta_record[2], + ", norm(deltaIy) =", + np.linalg.norm(dIy_1), + ) + + else: # this is particular to the Lao profile coefficients (which there may be few or many of) + + # for each alpha coefficient + n_alpha = len(profiles.alpha) + alpha_base = profiles.alpha.copy() + for i in range(0,n_alpha): + alpha_shift = alpha_base.copy() + alpha_shift[i] += self.final_dtheta_record[i] + self.check_and_change_profiles( + profiles_parameters={ + "alpha": alpha_shift, + "beta": profiles.beta, + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + self.dIydtheta[:, i] = dIy_1 / self.final_dtheta_record[i] + if verbose: + print(f"dIy/d(alpha_{i}) gradient:") + print(f" norm(dIy) = {np.linalg.norm(dIy_1)}") + print(f" finite difference d(alpha_{i}) = {self.final_dtheta_record[i]}") + print(f" norm(dIy)/norm(Iy) = {np.linalg.norm(dIy_1)/self.nIy} (vs. target_dIy = {self.target_dIy})") + + # for each beta coefficient + n_beta = len(profiles.beta) + beta_base = profiles.beta.copy() + for i in range(0,n_beta): + beta_shift = beta_base.copy() + beta_shift[i] += self.final_dtheta_record[i + n_alpha] + self.check_and_change_profiles( + profiles_parameters={ + "alpha": profiles.alpha, + "beta": beta_shift, + } + ) + self.assign_currents_solve_GS(current_, rtol_NK) + dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + self.dIydtheta[:, i + n_alpha] = dIy_1 / self.final_dtheta_record[i + n_alpha] + if verbose: + print(f"dIy/d(beta_{i}) gradient:") + print(f" norm(dIy) = {np.linalg.norm(dIy_1)}") + print(f" finite difference d(alpha_{i}) = {self.final_dtheta_record[i+n_alpha]}") + print(f" norm(dIy)/norm(Iy) = {np.linalg.norm(dIy_1)/self.nIy} (vs. target_dIy = {self.target_dIy})") + +### NEED SOME OUTPUTS HERE (check build_linearization below) + return dIy_0 / starting_dthetas, rel_ndIy_0 - # # vary alpha_m - # self.check_and_change_profiles( - # profiles_coefficients=( - # profiles.alpha_m + self.final_dpars_record[0], - # profiles.alpha_n, - # ), - # profiles_parameter=profiles.profiles_parameter, - # ) - # self.assign_currents_solve_GS(current_, rtol_NK) - # dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - # self.dIydpars[:, 0] = dIy_1 / self.final_dpars_record[0] - # if verbose: - # print( - # "alpha_m gradient calculated on the finite difference: delta_alpha_m =", - # self.final_dpars_record[0], - # ", norm(deltaIy) =", - # np.linalg.norm(dIy_1), - # ) - - # # vary alpha_n - # self.check_and_change_profiles( - # profiles_coefficients=( - # profiles.alpha_m, - # profiles.alpha_n + self.final_dpars_record[1], - # ) - # ) - # self.assign_currents_solve_GS(current_, rtol_NK) - # dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - # self.dIydpars[:, 1] = dIy_1 / self.final_dpars_record[1] - # if verbose: - # print( - # "alpha_n gradient calculated on the finite difference: delta_alpha_n =", - # self.final_dpars_record[1], - # ", norm(deltaIy) =", - # np.linalg.norm(dIy_1), - # ) - - # # vary paxis or betap - # self.check_and_change_profiles( - # profiles_coefficients=(profiles.alpha_m, profiles.alpha_n), - # profiles_parameter=profiles.profiles_parameter + self.final_dpars_record[2], - # ) - # self.assign_currents_solve_GS(current_, rtol_NK) - # dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - # self.dIydpars[:, 2] = dIy_1 / self.final_dpars_record[2] - # if verbose: - # print( - # "profiles_par gradient calculated on the finite difference: delta_profiles_par =", - # self.final_dpars_record[2], - # ", norm(deltaIy) =", - # np.linalg.norm(dIy_1), - # ) def prepare_build_dIydI_j( self, @@ -913,11 +1082,12 @@ def build_linearization( eq, profiles, dIydI, + # dIydtheta, target_relative_tolerance_linearization, force_core_mask_linearization, verbose, ): - """Builds the Jacobian d(Iy)/dI to set up the solver of the linearised problem. + """Builds the Jacobians d(Iy)/dI and d(Iy)/dtheta to set up the solver of the linearised problem. Parameters ---------- @@ -926,11 +1096,13 @@ def build_linearization( profiles : FreeGS4E profiles Object profiles properties of the equilibrium around which to linearise. dIydI : np.array - input Jacobian, enter where available, otherwise this will be calculated here - rtol_NK : float + input Jacobian of plasma current density to metal currents, enter where available, otherwise this will be calculated here + dIydtheta : np.array + input Jacobian of plasma current density to pasma current density profile parameters, enter where available, otherwise this will be calculated here + target_relative_tolerance_linearization : float Relative tolerance to be used in the static GS problems. - target_dIy : float, by default 0.001. - Target relative value for the norm of delta(I_y), on which the finite difference derivative is calculated. + force_core_mask_linearization : bool + Forces the perturbed plasma core mask to remain the same as the original when calculating the dIydI Jacobian. """ if (dIydI is None) and (self.dIydI is None): @@ -1084,6 +1256,91 @@ def build_linearization( self.dIydI = dIydI self.dIydI_ICs = np.copy(self.dIydI) + # compose the vector of initial delta_theta (profile parameters) to be used for the finite difference calculation + # - this uses the variation to Jtor caused by the parameter's contribution to the change in poloidal flux, ignoring the response of the plasma + + # # build/update dIydtheta + # if dIydtheta is None and force_core_mask_linearization is False: + # if self.dIydtheta_ICs is None: + # print( + # f"Building the {self.plasma_domain_size} x {self.n_profiles_parameters} Jacobian (dIy/dtheta)", + # "of plasma current density (inside the LCFS)", + # "with respect to all plasma current density profile parameters within Jtor.", + # ) + + # self.dIydtheta = np.zeros((self.plasma_domain_size, self.n_profiles_parameters)) + # self.ddIyddtheta = np.zeros(self.n_profiles_parameters) + # self.final_dtheta_record = np.zeros(self.n_profiles_parameters) + + # # prepare to build the Jacobian by finding appropriate step size + # dIydItheta, ndIy = self.prepare_build_dIydtheta( + # profiles=profiles, + # rtol_NK=target_relative_tolerance_linearization, + # target_dIy=?, self.approved_target_dIy[j] + # starting_dthetas=?, self.starting_dI[j] + # ) + + # if verbose: + # print(f"Prepping dIy/d(thetas) gradients:") + # print(f" Starting_dthetas = {self.starting_dthetas}") + # print(f" Final_dthetas = {self.final_dtheta_record}") + + # if ( + # np.abs(np.log10(self.final_dI_record[j] / self.starting_dI[j])) + # > 0.5 + # ): + # dIydIj, rel_ndIy = self.build_dIydI_j( + # j, + # target_relative_tolerance_linearization, + # ) + # core_check = ( + # np.sum( + # np.abs( + # self.profiles1.diverted_core_mask.astype(float) + # - self.profiles2.diverted_core_mask.astype(float) + # ) + # ) + # == 0 + # ) + # else: + # self.final_dI_record[j] = 1.0 * self.starting_dI[j] + + # if verbose: + # print( + # "Final current shift=", + # self.final_dI_record[j], + # ) + # print( + # "Final relative Iy change=", + # rel_ndIy, + # "; core_check=", + # core_check, + # ) + # print( + # "Initial residual=", + # self.NK.initial_rel_residual, + # ". Final residual=", + # self.NK.relative_change, + # ) + # print(" ") + + # self.dIydI[:, j] = np.copy(dIydIj) + # R0 = self.eq2.Rcurrent() + # Z0 = self.eq2.Zcurrent() + # self.dRZdI[0, j] = (R0 - self.R0) / self.final_dI_record[j] + # self.dRZdI[1, j] = (Z0 - self.Z0) / self.final_dI_record[j] + + + # self.dIydI_ICs = np.copy(self.dIydI) + # else: + # self.dIydI = np.copy(self.dIydI_ICs) + # else: + # self.dIydI = dIydI + # self.dIydI_ICs = np.copy(self.dIydI) + + + + def set_plasma_resistivity(self, plasma_resistivity): """Function to set the resistivity of the plasma. self.plasma_resistance_1d is the diagonal of the matrix R_yy, the plasma resistance matrix. @@ -1215,25 +1472,32 @@ def get_profiles_values(self, profiles): # note the parameters here are the same that should be provided # to the stepper if these are time evolving if self.profiles_type == "ConstrainPaxisIp": + self.n_profiles_parameters = 3 self.profiles_parameters = { - "paxis": profiles.paxis, "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, + "paxis": profiles.paxis, } elif self.profiles_type == "ConstrainBetapIp": + self.n_profiles_parameters = 3 self.profiles_parameters = { - "betap": profiles.betap, "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, + "betap": profiles.betap, } elif self.profiles_type == "Fiesta_Topeol": + self.n_profiles_parameters = 3 self.profiles_parameters = { - "beta0": profiles.beta0, "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, + "beta0": profiles.beta0, } elif self.profiles_type == "Lao85": - self.profiles_parameters = {"alpha": profiles.alpha, "beta": profiles.beta} + self.n_profiles_parameters = len(profiles.alpha) + len(profiles.beta) + self.profiles_parameters = { + "alpha": profiles.alpha, + "beta": profiles.beta + } def get_vessel_currents(self, eq): """Uses the input equilibrium to extract values for all metal currents, @@ -1246,9 +1510,6 @@ def get_vessel_currents(self, eq): Initial equilibrium. eq.tokamak is used to extract current values. """ self.vessel_currents_vec = eq.tokamak.getCurrentsVec() - # eq_currents = eq.tokamak.getCurrents() - # for i, labeli in enumerate(self.coils_order): - # self.vessel_currents_vec[i] = eq_currents[labeli] def build_current_vec(self, eq, profiles): """Builds the vector of currents in which the dynamics is actually solved, self.currents_vec From ce6a0f41a01ebd8107edb677f6c52185168b019f Mon Sep 17 00:00:00 2001 From: kpentland Date: Thu, 19 Jun 2025 15:33:11 +0100 Subject: [PATCH 02/13] added infracstructure to calculate profile Jacobian --- freegsnke/nonlinear_solve.py | 474 +++++++++++++++++++---------------- 1 file changed, 254 insertions(+), 220 deletions(-) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index ca550156..1e582d77 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -61,6 +61,7 @@ def __init__( mode_removal=True, linearize=True, dIydI=None, + dIydtheta=None, target_relative_tolerance_linearization=1e-8, target_dIy=1e-3, force_core_mask_linearization=False, @@ -114,6 +115,11 @@ def __init__( This is the jacobian of the plasma current distribution Iy with respect to all independent metal currents (both active and vessel modes) and to the total plasma current This is provided if known, otherwise calculated here at the linearization eq + dIydtheta : np.array of size (np.sum(plasma_domain_mask), n_profile_parameters, optional + dIydtheta(i,j) = d(Iy_i)/d(theta_j) + This is the jacobian of the plasma current distribution Iy with respect to all + plasma current desnity profile parameters + This is provided if known, otherwise calculated here at the linearization eq automatic_timestep : (float, float) or False, optional, by default False If not False, this overrides inputs full_timestep and max_internal_timestep: the timescales of the linearised problem are used to set the size of the timestep. @@ -363,42 +369,30 @@ def __init__( self.approved_target_dIy = np.concatenate( (self.approved_target_dIy, [target_dIy]) ) - - # need to build this - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - # - - # self.approved_target_dItheta 1e-3*np.ones(nonlinear_solver.n_profiles_parameters) + + # starting dtheta values for Jacobian calculation + self.approved_target_dtheta = target_dIy * np.ones(self.n_profiles_parameters) + self.starting_dtheta = np.zeros(self.n_profiles_parameters) + self.final_dtheta_record = np.zeros(self.n_profiles_parameters) + + # for setting profile parameters starting shifts (for Jacobians) + if self.profiles_param is not None: + # alpha_m + self.starting_dtheta[0] = (profiles.alpha_m + 1e-10) * target_dIy + # alpha_n + self.starting_dtheta[1] = (profiles.alpha_n + 1e-10) * target_dIy + # paxis/betap/beta0 + self.starting_dtheta[2] = ( + getattr(profiles, self.profiles_param) + 1e-10 + ) * target_dIy + + else: # lao + # alpha coeffs + n_alpha = len(profiles.alpha) + self.starting_dtheta[0:n_alpha] = (profiles.alpha + 1e-10) * target_dIy + + # beta coeffs + self.starting_dtheta[n_alpha:] = (profiles.beta + 1e-10) * target_dIy # This solves the system of circuit eqs based on an assumption # for the direction of the plasma current distribution at time t+dt @@ -466,6 +460,11 @@ def __init__( self.dIydI_ICs = dIydI self.dIydI = dIydI + # self.dIydtheta is the Jacobian of the plasma current distribution + # with respect to the plasma current density profile parameters + self.dIydtheta_ICs = dIydtheta + self.dIydtheta = dIydtheta + # initialize and set up the linearization # input value for dIydI is used when available if automatic_timestep == False: @@ -484,6 +483,7 @@ def __init__( profiles, target_relative_tolerance_linearization=target_relative_tolerance_linearization, dIydI=dIydI, + dIydtheta=dIydtheta, verbose=verbose, force_core_mask_linearization=force_core_mask_linearization, ) @@ -730,15 +730,17 @@ def set_linear_solution(self, active_voltage_vec, d_profiles_pars_dt=None): self.trial_plasma_psi = np.copy(self.eq2.plasma_psi) def prepare_build_dIydtheta( - self, - profiles, - rtol_NK, - target_dIy, - starting_dthetas): + self, + profiles, + rtol_NK, + target_dIy, + starting_dtheta, + verbose=False, + ): """ - + Prepares to compute the term d(Iy)/d(theta) where theta is a vector of the parameters - that define the plasma current density profile being used. + that define the plasma current density profile being used. It infers the value of delta(indep_variable) corresponding to a change delta(I_y) with norm(delta(I_y))=target_dIy. @@ -748,84 +750,107 @@ def prepare_build_dIydtheta( The profiles object of the initial condition equilibrium, i.e. the linearization point. rtol_NK : float Relative tolerance to be used in the static GS problems. - target_dIy : float - Target value for the norm of delta(I_y), on which th finite difference derivative is calculated. - starting_dthetas : tuple (d_alpha_m, d_alpha_n, relative_d_profiles_par) + target_dIy : array + Target values for the norm of delta(I_y), on which the finite difference derivative is calculated. + starting_dtheta : array Initial value to be used as delta(indep_variable) to infer the slope of norm(delta(I_y))/delta(indep_variable). - Note that the first two values in the tuple are absolute deltas, - while the third value is relative, d_profiles_par = relative_d_profiles_par * profiles_par + verbose : bool + Print some intermediate values, default is Flase. """ current_ = np.copy(self.currents_vec) - # for setting profile parameters - if self.profiles_type == "ConstrainPaxisIp": - param = "paxis" - elif self.profiles_type == "ConstrainBetapIp": - param = "betap" - elif self.profiles_type == "Fiesta_Topeol": - param = "beta0" - else: - param = None + # storage + dIy_0 = np.zeros((len(self.Iy), self.n_profiles_parameters)) + rel_ndIy_0 = np.zeros(self.n_profiles_parameters) # carry out the initial perturbations - if param is not None: - - dIy_0 = np.zeros(len(self.dIy),3) - rel_ndIy_0 = np.zeros(3) + if self.profiles_param is not None: # vary alpha_m self.check_and_change_profiles( profiles_parameters={ - "alpha_m": profiles.alpha_m + starting_dthetas[0], + "alpha_m": profiles.alpha_m + starting_dtheta[0], "alpha_n": profiles.alpha_n, - param: getattr(profiles, param), + self.profiles_param: getattr(profiles, self.profiles_param), } ) self.assign_currents_solve_GS(current_, rtol_NK) - dIy_0[:,0] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,0]) / self.nIy - self.final_dtheta_record[0] = starting_dthetas[0] * target_dIy / rel_ndIy_0[i] + dIy_0[:, 0] = ( + self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + ) + rel_ndIy_0[0] = np.linalg.norm(dIy_0[:, 0]) / self.nIy + self.final_dtheta_record[0] = ( + starting_dtheta[0] * target_dIy[0] / rel_ndIy_0[0] + ) + + if verbose: + print("") + print("Profile parameter: alpha_m:") + print(f" Initial delta parameter = {starting_dtheta[0]}") + print(f" Initial relative Iy change = {rel_ndIy_0[0]}") + print(f" Final delta parameter = {self.final_dtheta_record[0]}") # vary alpha_n self.check_and_change_profiles( profiles_parameters={ "alpha_m": profiles.alpha_m, - "alpha_n": profiles.alpha_n + starting_dthetas[1], - param: getattr(profiles, param), + "alpha_n": profiles.alpha_n + starting_dtheta[1], + self.profiles_param: getattr(profiles, self.profiles_param), } ) self.assign_currents_solve_GS(current_, rtol_NK) - dIy_0[:,1] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,1]) / self.nIy - self.final_dtheta_record[1] = starting_dthetas[1] * target_dIy / rel_ndIy_0[i] + dIy_0[:, 1] = ( + self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + ) + rel_ndIy_0[1] = np.linalg.norm(dIy_0[:, 1]) / self.nIy + self.final_dtheta_record[1] = ( + starting_dtheta[1] * target_dIy[1] / rel_ndIy_0[1] + ) + + if verbose: + print("") + print("Profile parameter: alpha_n:") + print(f" Initial delta parameter = {starting_dtheta[1]}") + print(f" Initial relative Iy change = {rel_ndIy_0[1]}") + print(f" Final delta parameter = {self.final_dtheta_record[1]}") # vary paxis, betap or beta0 self.check_and_change_profiles( profiles_parameters={ "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, - param: getattr(profiles, param) * (1 + starting_dthetas[2]), + self.profiles_param: getattr(profiles, self.profiles_param) + * (1 + starting_dtheta[2]), } ) self.assign_currents_solve_GS(current_, rtol_NK) - dIy_0[:,2] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,2]) / self.nIy + dIy_0[:, 2] = ( + self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + ) + rel_ndIy_0[2] = np.linalg.norm(dIy_0[:, 2]) / self.nIy self.final_dtheta_record[2] = ( - starting_dthetas[2] * getattr(profiles, param) * target_dIy / rel_ndIy_0[i] + starting_dtheta[2] + * getattr(profiles, self.profiles_param) + * target_dIy[2] + / rel_ndIy_0[2] ) - - else: # this is particular to the Lao profile coefficients (which there may be few or many of) - dIy_0 = np.zeros((len(self.Iy),self.n_profiles_parameters)) - rel_ndIy_0 = np.zeros(self.n_profiles_parameters) + if verbose: + print("") + print(f"Profile parameter: {self.profiles_param}:") + print(f" Initial delta parameter = {starting_dtheta[2]}") + print(f" Initial relative Iy change = {rel_ndIy_0[2]}") + print(f" Final delta parameter = {self.final_dtheta_record[2]}") + + else: # this is particular to the Lao profile coefficients (which there may be few or many of) # for each alpha coefficient alpha_base = profiles.alpha.copy() alpha_n = len(profiles.alpha) - for i in range(0,alpha_n): + for i in range(0, alpha_n): alpha_shift = alpha_base.copy() - alpha_shift[i] += starting_dthetas[i] + alpha_shift[i] += starting_dtheta[i] self.check_and_change_profiles( profiles_parameters={ "alpha": alpha_shift, @@ -833,16 +858,27 @@ def prepare_build_dIydtheta( } ) self.assign_currents_solve_GS(current_, rtol_NK) - dIy_0[:,i] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - rel_ndIy_0[i] = np.linalg.norm(dIy_0[:,i]) / self.nIy - self.final_dtheta_record[i] = starting_dthetas[i] * target_dIy / rel_ndIy_0[i] + dIy_0[:, i] = ( + self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + ) + rel_ndIy_0[i] = np.linalg.norm(dIy_0[:, i]) / self.nIy + self.final_dtheta_record[i] = ( + starting_dtheta[i] * target_dIy[i] / rel_ndIy_0[i] + ) + + if verbose: + print("") + print(f"Profile parameter: alpha_{i}:") + print(f" Initial delta parameter = {starting_dtheta[i]}") + print(f" Initial relative Iy change = {rel_ndIy_0[i]}") + print(f" Final delta parameter = {self.final_dtheta_record[i]}") # for each beta coefficient beta_base = profiles.beta.copy() beta_n = len(profiles.beta) - for i in range(0,beta_n): + for i in range(0, beta_n): beta_shift = beta_base.copy() - beta_shift[i] += starting_dthetas[i + alpha_n] + beta_shift[i] += starting_dtheta[i + alpha_n] self.check_and_change_profiles( profiles_parameters={ "alpha": profiles.alpha, @@ -850,15 +886,32 @@ def prepare_build_dIydtheta( } ) self.assign_currents_solve_GS(current_, rtol_NK) - dIy_0[:,i+alpha_n] = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - rel_ndIy_0[i+alpha_n] = np.linalg.norm(dIy_0[:,i+alpha_n]) / self.nIy - self.final_dtheta_record[i+alpha_n] = starting_dthetas[i+alpha_n] * target_dIy / rel_ndIy_0[i+alpha_n] + dIy_0[:, i + alpha_n] = ( + self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy + ) + rel_ndIy_0[i + alpha_n] = ( + np.linalg.norm(dIy_0[:, i + alpha_n]) / self.nIy + ) + self.final_dtheta_record[i + alpha_n] = ( + starting_dtheta[i + alpha_n] + * target_dIy[i] + / rel_ndIy_0[i + alpha_n] + ) + + if verbose: + print("") + print(f"Profile parameter: beta_{i}:") + print(f" Initial delta parameter = {starting_dtheta[i+alpha_n]}") + print(f" Initial relative Iy change = {rel_ndIy_0[i+alpha_n]}") + print( + f" Final delta parameter = {self.final_dtheta_record[i+alpha_n]}" + ) - return dIy_0 / starting_dthetas, rel_ndIy_0 + return dIy_0 / starting_dtheta, rel_ndIy_0 def build_dIydtheta(self, profiles, rtol_NK, verbose=False): """ - + Compute the matrix d(Iy)/d(theta) as a finite difference derivative, using the value of delta(indep_viriable) inferred earlier by self.prepare_build_dIypars. @@ -873,36 +926,33 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): current_ = np.copy(self.currents_vec) - # for setting profile parameters - if self.profiles_type == "ConstrainPaxisIp": - param = "paxis" - elif self.profiles_type == "ConstrainBetapIp": - param = "betap" - elif self.profiles_type == "Fiesta_Topeol": - param = "beta0" - else: - param = None + # storage + dIydtheta = np.zeros((len(self.Iy), self.n_profiles_parameters)) + rel_ndIy = np.zeros(self.n_profiles_parameters) # carry out the initial perturbations - if param is not None: + if self.profiles_param is not None: # vary alpha_m self.check_and_change_profiles( profiles_parameters={ "alpha_m": profiles.alpha_m + self.final_dtheta_record[0], "alpha_n": profiles.alpha_n, - param: getattr(profiles, param), + self.profiles_param: getattr(profiles, self.profiles_param), } ) + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - self.dIydtheta[:, 0] = dIy_1 / self.final_dtheta_record[0] + dIydtheta[:, 0] = dIy_1 / self.final_dtheta_record[0] + rel_ndIy[0] = np.linalg.norm(dIy_1) / self.nIy if verbose: + print("") + print(f"Profile parameter: alpha_m:") + print(f" Final relative Iy change = {rel_ndIy[0]}") print( - "alpha_m gradient calculated on the finite difference: delta_alpha_m =", - self.final_dtheta_record[0], - ", norm(deltaIy) =", - np.linalg.norm(dIy_1), + f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) # vary alpha_n @@ -910,18 +960,21 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): profiles_parameters={ "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n + self.final_dtheta_record[1], - param: getattr(profiles, param), + self.profiles_param: getattr(profiles, self.profiles_param), } ) + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - self.dIydtheta[:, 1] = dIy_1 / self.final_dtheta_record[1] + dIydtheta[:, 1] = dIy_1 / self.final_dtheta_record[1] + rel_ndIy[1] = np.linalg.norm(dIy_1) / self.nIy if verbose: + print("") + print(f"Profile parameter: alpha_n:") + print(f" Final relative Iy change = {rel_ndIy[1]}") print( - "alpha_n gradient calculated on the finite difference: delta_alpha_n =", - self.final_dtheta_record[1], - ", norm(deltaIy) =", - np.linalg.norm(dIy_1), + f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) # vary paxis, betap or beta0 @@ -929,25 +982,30 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): profiles_parameters={ "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, - param: getattr(profiles, param) + self.final_dtheta_record[2], - } ) + self.profiles_param: getattr(profiles, self.profiles_param) + + self.final_dtheta_record[2], + } + ) + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - self.dIydtheta[:, 2] = dIy_1 / self.final_dtheta_record[2] + dIydtheta[:, 2] = dIy_1 / self.final_dtheta_record[2] + rel_ndIy[2] = np.linalg.norm(dIy_1) / self.nIy if verbose: + print("") + print(f"Profile parameter: {self.profiles_param}:") + print(f" Final relative Iy change = {rel_ndIy[2]}") print( - f"{param} gradient calculated on the finite difference: delta_{param} =", - self.final_dtheta_record[2], - ", norm(deltaIy) =", - np.linalg.norm(dIy_1), + f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) - else: # this is particular to the Lao profile coefficients (which there may be few or many of) + else: # this is particular to the Lao profile coefficients (which there may be few or many of) # for each alpha coefficient n_alpha = len(profiles.alpha) alpha_base = profiles.alpha.copy() - for i in range(0,n_alpha): + for i in range(0, n_alpha): alpha_shift = alpha_base.copy() alpha_shift[i] += self.final_dtheta_record[i] self.check_and_change_profiles( @@ -956,19 +1014,24 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): "beta": profiles.beta, } ) + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - self.dIydtheta[:, i] = dIy_1 / self.final_dtheta_record[i] + dIydtheta[:, i] = dIy_1 / self.final_dtheta_record[i] + rel_ndIy[i] = np.linalg.norm(dIy_1) / self.nIy if verbose: - print(f"dIy/d(alpha_{i}) gradient:") - print(f" norm(dIy) = {np.linalg.norm(dIy_1)}") - print(f" finite difference d(alpha_{i}) = {self.final_dtheta_record[i]}") - print(f" norm(dIy)/norm(Iy) = {np.linalg.norm(dIy_1)/self.nIy} (vs. target_dIy = {self.target_dIy})") + print("") + print(f"Profile parameter: alpha_{i}:") + print(f" Final relative Iy change = {rel_ndIy[i]}") + print( + f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" + ) # for each beta coefficient n_beta = len(profiles.beta) beta_base = profiles.beta.copy() - for i in range(0,n_beta): + for i in range(0, n_beta): beta_shift = beta_base.copy() beta_shift[i] += self.final_dtheta_record[i + n_alpha] self.check_and_change_profiles( @@ -977,18 +1040,24 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): "beta": beta_shift, } ) + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - self.dIydtheta[:, i + n_alpha] = dIy_1 / self.final_dtheta_record[i + n_alpha] - if verbose: - print(f"dIy/d(beta_{i}) gradient:") - print(f" norm(dIy) = {np.linalg.norm(dIy_1)}") - print(f" finite difference d(alpha_{i}) = {self.final_dtheta_record[i+n_alpha]}") - print(f" norm(dIy)/norm(Iy) = {np.linalg.norm(dIy_1)/self.nIy} (vs. target_dIy = {self.target_dIy})") + dIydtheta[:, i + n_alpha] = ( + dIy_1 / self.final_dtheta_record[i + n_alpha] + ) + rel_ndIy[i + n_alpha] = np.linalg.norm(dIy_1) / self.nIy -### NEED SOME OUTPUTS HERE (check build_linearization below) - return dIy_0 / starting_dthetas, rel_ndIy_0 + if verbose: + print("") + print(f"Profile parameter: beta_{i}:") + print(f" Final relative Iy change = {rel_ndIy[i+n_alpha]}") + print( + f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" + ) + return dIydtheta, rel_ndIy def prepare_build_dIydI_j( self, @@ -1082,7 +1151,7 @@ def build_linearization( eq, profiles, dIydI, - # dIydtheta, + dIydtheta, target_relative_tolerance_linearization, force_core_mask_linearization, verbose, @@ -1127,7 +1196,6 @@ def build_linearization( ) self.dIydI = np.zeros((self.plasma_domain_size, self.n_metal_modes + 1)) - self.ddIyddI = np.zeros(self.n_metal_modes + 1) self.final_dI_record = np.zeros(self.n_metal_modes + 1) for j in self.arange_currents: @@ -1259,87 +1327,49 @@ def build_linearization( # compose the vector of initial delta_theta (profile parameters) to be used for the finite difference calculation # - this uses the variation to Jtor caused by the parameter's contribution to the change in poloidal flux, ignoring the response of the plasma - # # build/update dIydtheta - # if dIydtheta is None and force_core_mask_linearization is False: - # if self.dIydtheta_ICs is None: - # print( - # f"Building the {self.plasma_domain_size} x {self.n_profiles_parameters} Jacobian (dIy/dtheta)", - # "of plasma current density (inside the LCFS)", - # "with respect to all plasma current density profile parameters within Jtor.", - # ) - - # self.dIydtheta = np.zeros((self.plasma_domain_size, self.n_profiles_parameters)) - # self.ddIyddtheta = np.zeros(self.n_profiles_parameters) - # self.final_dtheta_record = np.zeros(self.n_profiles_parameters) - - # # prepare to build the Jacobian by finding appropriate step size - # dIydItheta, ndIy = self.prepare_build_dIydtheta( - # profiles=profiles, - # rtol_NK=target_relative_tolerance_linearization, - # target_dIy=?, self.approved_target_dIy[j] - # starting_dthetas=?, self.starting_dI[j] - # ) - - # if verbose: - # print(f"Prepping dIy/d(thetas) gradients:") - # print(f" Starting_dthetas = {self.starting_dthetas}") - # print(f" Final_dthetas = {self.final_dtheta_record}") - - # if ( - # np.abs(np.log10(self.final_dI_record[j] / self.starting_dI[j])) - # > 0.5 - # ): - # dIydIj, rel_ndIy = self.build_dIydI_j( - # j, - # target_relative_tolerance_linearization, - # ) - # core_check = ( - # np.sum( - # np.abs( - # self.profiles1.diverted_core_mask.astype(float) - # - self.profiles2.diverted_core_mask.astype(float) - # ) - # ) - # == 0 - # ) - # else: - # self.final_dI_record[j] = 1.0 * self.starting_dI[j] - - # if verbose: - # print( - # "Final current shift=", - # self.final_dI_record[j], - # ) - # print( - # "Final relative Iy change=", - # rel_ndIy, - # "; core_check=", - # core_check, - # ) - # print( - # "Initial residual=", - # self.NK.initial_rel_residual, - # ". Final residual=", - # self.NK.relative_change, - # ) - # print(" ") - - # self.dIydI[:, j] = np.copy(dIydIj) - # R0 = self.eq2.Rcurrent() - # Z0 = self.eq2.Zcurrent() - # self.dRZdI[0, j] = (R0 - self.R0) / self.final_dI_record[j] - # self.dRZdI[1, j] = (Z0 - self.Z0) / self.final_dI_record[j] - - - # self.dIydI_ICs = np.copy(self.dIydI) - # else: - # self.dIydI = np.copy(self.dIydI_ICs) - # else: - # self.dIydI = dIydI - # self.dIydI_ICs = np.copy(self.dIydI) + # build/update dIydtheta + if dIydtheta is None and force_core_mask_linearization is False: + if self.dIydtheta_ICs is None: + print( + f"Building the {self.plasma_domain_size} x {self.n_profiles_parameters} Jacobian (dIy/dtheta)", + "of plasma current density (inside the LCFS)", + "with respect to all plasma current density profile parameters within Jtor.", + ) + + self.dIydtheta = np.zeros( + (self.plasma_domain_size, self.n_profiles_parameters) + ) + self.final_dtheta_record = np.zeros(self.n_profiles_parameters) + + # prepare to build the Jacobian by finding appropriate step size + dIydtheta, ndIy = self.prepare_build_dIydtheta( + profiles=profiles, + rtol_NK=target_relative_tolerance_linearization, + target_dIy=self.approved_target_dtheta, + starting_dtheta=self.starting_dtheta, + verbose=verbose, + ) + if ( + np.abs(np.log10(self.final_dtheta_record / self.starting_dtheta)) + > 0.5 + ).any(): + dIydtheta, rel_ndIy = self.build_dIydtheta( + profiles=self.profiles1, + rtol_NK=target_relative_tolerance_linearization, + verbose=False, + ) + else: + self.final_dtheta_record = 1.0 * self.starting_dtheta + self.dIydtheta = np.copy(dIydtheta) + self.dIydtheta_ICs = np.copy(self.dIydtheta) + else: + self.dIydtheta = np.copy(self.dIydtheta_ICs) + else: + self.dIydtheta = dIydtheta + self.dIydtheta_ICs = np.copy(self.dIydtheta) def set_plasma_resistivity(self, plasma_resistivity): """Function to set the resistivity of the plasma. @@ -1478,6 +1508,7 @@ def get_profiles_values(self, profiles): "alpha_n": profiles.alpha_n, "paxis": profiles.paxis, } + self.profiles_param = "paxis" elif self.profiles_type == "ConstrainBetapIp": self.n_profiles_parameters = 3 self.profiles_parameters = { @@ -1485,6 +1516,7 @@ def get_profiles_values(self, profiles): "alpha_n": profiles.alpha_n, "betap": profiles.betap, } + self.profiles_param = "betap" elif self.profiles_type == "Fiesta_Topeol": self.n_profiles_parameters = 3 self.profiles_parameters = { @@ -1492,12 +1524,12 @@ def get_profiles_values(self, profiles): "alpha_n": profiles.alpha_n, "beta0": profiles.beta0, } + self.profiles_param = "beta0" + elif self.profiles_type == "Lao85": self.n_profiles_parameters = len(profiles.alpha) + len(profiles.beta) - self.profiles_parameters = { - "alpha": profiles.alpha, - "beta": profiles.beta - } + self.profiles_parameters = {"alpha": profiles.alpha, "beta": profiles.beta} + self.profiles_param = None def get_vessel_currents(self, eq): """Uses the input equilibrium to extract values for all metal currents, @@ -1543,6 +1575,7 @@ def initialize_from_ICs( profiles, target_relative_tolerance_linearization=1e-7, dIydI=None, + dIydtheta=None, force_core_mask_linearization=False, verbose=False, ): @@ -1621,6 +1654,7 @@ def initialize_from_ICs( self.eq1, self.profiles1, dIydI=dIydI, + dIydtheta=dIydtheta, target_relative_tolerance_linearization=target_relative_tolerance_linearization, force_core_mask_linearization=force_core_mask_linearization, verbose=verbose, From 2d7ce24b1d3e00f8ac7ce89bf950c7e00fb7b540 Mon Sep 17 00:00:00 2001 From: kpentland Date: Thu, 19 Jun 2025 17:03:42 +0100 Subject: [PATCH 03/13] linearisation of profiles added to linear solver, needs testing --- freegsnke/linear_solve.py | 50 +++++++++++++++++++++-------------- freegsnke/nonlinear_solve.py | 51 ++++++++++++++++++++++++++---------- 2 files changed, 67 insertions(+), 34 deletions(-) diff --git a/freegsnke/linear_solve.py b/freegsnke/linear_solve.py index 623abd83..495bffc2 100644 --- a/freegsnke/linear_solve.py +++ b/freegsnke/linear_solve.py @@ -39,7 +39,6 @@ def __init__( Pm1, Rm1, Mey, - # limiter_handler, plasma_norm_factor, plasma_resistance_1d, max_internal_timestep=0.0001, @@ -131,7 +130,7 @@ def reset_plasma_resistivity(self, plasma_resistance_1d): Vector of 2pi resistivity R/dA for all domain grid points in the reduced plasma domain """ self.plasma_resistance_1d = plasma_resistance_1d - self.set_linearization_point(None, None, None) + self.set_linearization_point(None, None, None, None) def reset_timesteps(self, max_internal_timestep, full_timestep): """Resets the integration timesteps, calling self.solver.set_timesteps @@ -149,7 +148,7 @@ def reset_timesteps(self, max_internal_timestep, full_timestep): full_timestep=full_timestep, max_internal_timestep=max_internal_timestep ) - def set_linearization_point(self, dIydI, hatIy0, Myy_hatIy0): + def set_linearization_point(self, dIydI, dIydtheta, hatIy0, Myy_hatIy0): """Initialises an implicit-Euler solver with the appropriate matrices for the linearised dynamic problem. Parameters @@ -159,6 +158,9 @@ def set_linearization_point(self, dIydI, hatIy0, Myy_hatIy0): (active coil currents, vessel normal modes, total plasma current divided by plasma_norm_factor). These would typically come from having solved the forward Grad-Shafranov problem. Finite difference Jacobian. Calculated by the nl_solver object + dIydtheta : np.array + partial derivatives of plasma-cell currents on the reduced plasma domain with respect to all plasma current density + profile parameters hatIy0 : np.array Plasma current distribution on the reduced plasma domain (1d) of the equilibrium around which the dynamics is linearised. This is normalised by the total plasma current, so that this vector sums to 1. @@ -168,6 +170,8 @@ def set_linearization_point(self, dIydI, hatIy0, Myy_hatIy0): """ if dIydI is not None: self.dIydI = dIydI + if dIydtheta is not None: + self.dIydtheta = dIydtheta if hatIy0 is not None: self.hatIy0 = hatIy0 if Myy_hatIy0 is not None: @@ -201,9 +205,6 @@ def build_Mmatrix( where A = dIy/dId B = dIy/dIp C = dIy/plasmapars - Here we take C=0, that is the linearised dynamics does not account for evolving - plasma parameters atm. - Parameters ---------- @@ -249,13 +250,19 @@ def build_Mmatrix( # build necessary terms to incorporate forcing term from variations of the profile parameters # MIdot + RI = V - self.Vm1Rm12Mey_plus@self.dIydpars@d_profiles_pars_dt - # if self.dIydpars is not None: - # Pm1Rm1Mey_plus = np.concatenate( - # (self.Pm1Rm1Mey, JMyy[np.newaxis] / nRp), axis=0 - # ) - # self.forcing_pars_matrix = np.matmul(Pm1Rm1Mey_plus, self.dIydpars) - - def stepper(self, It, active_voltage_vec, d_profiles_pars_dt=None): + self.forcing_pars_matrix = None + if self.dIydtheta is not None: + Pm1Rm1Mey_plus = np.concatenate( + (self.Pm1Rm1Mey, self.Myy_hatIy0[np.newaxis] / nRp), axis=0 + ) + self.forcing_pars_matrix = np.matmul(Pm1Rm1Mey_plus, self.dIydtheta) + + def stepper( + self, + It, + active_voltage_vec, + profile_parameters_vec, + ): """Executes the time advancement. Uses the implicit_euler instance. Parameters @@ -265,19 +272,22 @@ def stepper(self, It, active_voltage_vec, d_profiles_pars_dt=None): (active currents, vessel normal modes, total plasma current divided by normalisation factor) active_voltage_vec : np.array voltages applied to the active coils - d_profiles_pars_dt : np.array - time derivative of the profile parameters, not used atm - other parameters are passed in as object attributes + profile_parameters_vec : np.array + Vector of plasma current density profile parameters at the current timestep. """ + + # baseline forcing term (from the active coil voltages) self.empty_U[: self.n_active_coils] = active_voltage_vec self.forcing[:-1] = np.dot(self.Pm1Rm1, self.empty_U) self.forcing[-1] = 0.0 - - # add forcing term from time derivative of profile parameters - if d_profiles_pars_dt is not None: - self.forcing -= np.dot(self.forcing_pars_matrix, d_profiles_pars_dt) + print(self.forcing) + # additional forcing due to the time derivative of profile parameters + if self.forcing_pars_matrix is not None: + self.forcing -= np.dot(self.forcing_pars_matrix, profile_parameters_vec) + print(self.forcing) Itpdt = self.solver.full_stepper(It, self.forcing) + return Itpdt def calculate_linear_growth_rate( diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index 1e582d77..dfe747b7 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -378,21 +378,21 @@ def __init__( # for setting profile parameters starting shifts (for Jacobians) if self.profiles_param is not None: # alpha_m - self.starting_dtheta[0] = (profiles.alpha_m + 1e-10) * target_dIy + self.starting_dtheta[0] = (profiles.alpha_m + 1e-10) * 0.01 # alpha_n - self.starting_dtheta[1] = (profiles.alpha_n + 1e-10) * target_dIy + self.starting_dtheta[1] = (profiles.alpha_n + 1e-10) * 0.01 # paxis/betap/beta0 self.starting_dtheta[2] = ( getattr(profiles, self.profiles_param) + 1e-10 - ) * target_dIy + ) * 0.01 else: # lao # alpha coeffs n_alpha = len(profiles.alpha) - self.starting_dtheta[0:n_alpha] = (profiles.alpha + 1e-10) * target_dIy + self.starting_dtheta[0:n_alpha] = (profiles.alpha + 1e-10) * 0.01 # beta coeffs - self.starting_dtheta[n_alpha:] = (profiles.beta + 1e-10) * target_dIy + self.starting_dtheta[n_alpha:] = (profiles.beta + 1e-10) * 0.01 # This solves the system of circuit eqs based on an assumption # for the direction of the plasma current distribution at time t+dt @@ -702,12 +702,19 @@ def remove_modes(self, eq, selected_modes_mask): ) self.linearised_sol.set_linearization_point( - dIydI=self.dIydI, hatIy0=self.blended_hatIy, Myy_hatIy0=self.Myy_hatIy0 + dIydI=self.dIydI, + dIydtheta=self.dIydtheta, + hatIy0=self.blended_hatIy, + Myy_hatIy0=self.Myy_hatIy0, ) self.build_current_vec(self.eq1, self.profiles1) - def set_linear_solution(self, active_voltage_vec, d_profiles_pars_dt=None): + def set_linear_solution( + self, + active_voltage_vec, + profile_parameters_vec, + ): """Uses the solver of the linearised problem to set up an initial guess for the nonlinear solver for the currents at time t+dt. Uses self.currents_vec as I(t). Solves GS at time t+dt using the currents derived from the linearised dynamics. @@ -716,15 +723,14 @@ def set_linear_solution(self, active_voltage_vec, d_profiles_pars_dt=None): ---------- active_voltage_vec : np.array Vector of external voltage applied to the active coils during the timestep. - d_profiles_pars_dt : None - Does not currently use d_profiles_pars_dt - The evolution of the profiles coefficient is not accounted by the linearised dynamical evolution. + profile_parameters_vec : np.array + Vector of plasma current density profile parameters at the current timestep. """ self.trial_currents = self.linearised_sol.stepper( It=self.currents_vec, active_voltage_vec=active_voltage_vec, - d_profiles_pars_dt=d_profiles_pars_dt, + profile_parameters_vec=profile_parameters_vec, ) self.assign_currents_solve_GS(self.trial_currents, self.rtol_NK) self.trial_plasma_psi = np.copy(self.eq2.plasma_psi) @@ -1509,6 +1515,9 @@ def get_profiles_values(self, profiles): "paxis": profiles.paxis, } self.profiles_param = "paxis" + self.profiles_parameters_vec = np.array( + [profiles.alpha_m, profiles.alpha_n, profiles.paxis] + ) elif self.profiles_type == "ConstrainBetapIp": self.n_profiles_parameters = 3 self.profiles_parameters = { @@ -1517,6 +1526,9 @@ def get_profiles_values(self, profiles): "betap": profiles.betap, } self.profiles_param = "betap" + self.profiles_parameters_vec = np.array( + [profiles.alpha_m, profiles.alpha_n, profiles.betap] + ) elif self.profiles_type == "Fiesta_Topeol": self.n_profiles_parameters = 3 self.profiles_parameters = { @@ -1525,11 +1537,16 @@ def get_profiles_values(self, profiles): "beta0": profiles.beta0, } self.profiles_param = "beta0" - + self.profiles_parameters_vec = np.array( + [profiles.alpha_m, profiles.alpha_n, profiles.beta0] + ) elif self.profiles_type == "Lao85": self.n_profiles_parameters = len(profiles.alpha) + len(profiles.beta) self.profiles_parameters = {"alpha": profiles.alpha, "beta": profiles.beta} self.profiles_param = None + self.profiles_parameters_vec = np.concatenate( + (profiles.alpha, profiles.beta) + ) def get_vessel_currents(self, eq): """Uses the input equilibrium to extract values for all metal currents, @@ -1666,7 +1683,10 @@ def initialize_from_ICs( # transfer linearization to linear solver: self.Myy_hatIy0 = self.handleMyy.dot(self.hatIy) self.linearised_sol.set_linearization_point( - dIydI=self.dIydI_ICs, hatIy0=self.blended_hatIy, Myy_hatIy0=self.Myy_hatIy0 + dIydI=self.dIydI_ICs, + dIydtheta=self.dIydtheta_ICs, + hatIy0=self.blended_hatIy, + Myy_hatIy0=self.Myy_hatIy0, ) def step_complete_assign(self, working_relative_tol_GS, from_linear=False): @@ -2198,7 +2218,10 @@ def nlstepper( # solves the linearised problem for the currents and assigns # results in preparation for the nonlinear calculations # Solution and GS equilibrium are assigned to self.trial_currents and self.trial_plasma_psi - self.set_linear_solution(active_voltage_vec) + self.set_linear_solution( + active_voltage_vec=active_voltage_vec, + profile_parameters_vec=self.profiles_parameters_vec, + ) # check Matrix is still applicable myy_flag = self.handleMyy.check_Myy(self.hatIy) From 7f68c2535cd4135ef8b3b76ac5ef61f7c6da8c43 Mon Sep 17 00:00:00 2001 From: kpentland Date: Fri, 20 Jun 2025 08:39:28 +0100 Subject: [PATCH 04/13] ready for testing --- freegsnke/linear_solve.py | 8 ++++---- freegsnke/nonlinear_solve.py | 21 ++++++++++++++++----- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/freegsnke/linear_solve.py b/freegsnke/linear_solve.py index 495bffc2..0a64356b 100644 --- a/freegsnke/linear_solve.py +++ b/freegsnke/linear_solve.py @@ -261,7 +261,7 @@ def stepper( self, It, active_voltage_vec, - profile_parameters_vec, + dtheta_dt, ): """Executes the time advancement. Uses the implicit_euler instance. @@ -272,8 +272,8 @@ def stepper( (active currents, vessel normal modes, total plasma current divided by normalisation factor) active_voltage_vec : np.array voltages applied to the active coils - profile_parameters_vec : np.array - Vector of plasma current density profile parameters at the current timestep. + dtheta_dt : np.array + Vector of plasma current density profile parameters derivateives with respect to t. """ # baseline forcing term (from the active coil voltages) @@ -283,7 +283,7 @@ def stepper( print(self.forcing) # additional forcing due to the time derivative of profile parameters if self.forcing_pars_matrix is not None: - self.forcing -= np.dot(self.forcing_pars_matrix, profile_parameters_vec) + self.forcing -= np.dot(self.forcing_pars_matrix, dtheta_dt) print(self.forcing) Itpdt = self.solver.full_stepper(It, self.forcing) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index dfe747b7..1cf468f7 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -713,7 +713,7 @@ def remove_modes(self, eq, selected_modes_mask): def set_linear_solution( self, active_voltage_vec, - profile_parameters_vec, + dtheta_dt, ): """Uses the solver of the linearised problem to set up an initial guess for the nonlinear solver for the currents at time t+dt. Uses self.currents_vec as I(t). @@ -723,14 +723,14 @@ def set_linear_solution( ---------- active_voltage_vec : np.array Vector of external voltage applied to the active coils during the timestep. - profile_parameters_vec : np.array - Vector of plasma current density profile parameters at the current timestep. + dtheta_dt : np.array + Vector of plasma current density profile parameters derivateives with respect to t. """ self.trial_currents = self.linearised_sol.stepper( It=self.currents_vec, active_voltage_vec=active_voltage_vec, - profile_parameters_vec=profile_parameters_vec, + dtheta_dt=dtheta_dt, ) self.assign_currents_solve_GS(self.trial_currents, self.rtol_NK) self.trial_plasma_psi = np.copy(self.eq2.plasma_psi) @@ -2203,12 +2203,23 @@ def nlstepper( NK iterations are interrupted when this limit is surpassed. """ + # retrieve the old profile parameter values + self.get_profiles_values(self.profiles1) + old_params = self.profiles_parameters_vec + # check if profiles parameters are being evolved # and action the change where necessary self.check_and_change_profiles( profiles_parameters=profiles_parameters, ) + # retrieve the old profile parameter values + self.get_profiles_values(self.profiles1) + new_params = self.profiles_parameters_vec + + # calculate change in profiles across timestep: (profiles(t+dt)-profiles(t))/dt + dtheta_dt = (new_params - old_params) / self.dt_step + # check if plasma resistivity is being evolved # and action the change where necessary self.check_and_change_plasma_resistivity( @@ -2220,7 +2231,7 @@ def nlstepper( # Solution and GS equilibrium are assigned to self.trial_currents and self.trial_plasma_psi self.set_linear_solution( active_voltage_vec=active_voltage_vec, - profile_parameters_vec=self.profiles_parameters_vec, + dtheta_dt=dtheta_dt, ) # check Matrix is still applicable From c088c045f42cf908f3699858bd49c1a499e7e58c Mon Sep 17 00:00:00 2001 From: kpentland Date: Mon, 23 Jun 2025 15:39:20 +0100 Subject: [PATCH 05/13] remove duplicate examples --- freegsnke/nonlinear_solve.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index 511e9a2d..bb402ec1 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -2317,11 +2317,13 @@ def nlstepper( profiles_parameters=profiles_parameters, ) - # retrieve the old profile parameter values + # retrieve the new profile parameter values (if present) self.get_profiles_values(self.profiles1) new_params = self.profiles_parameters_vec # calculate change in profiles across timestep: (profiles(t+dt)-profiles(t))/dt + # should be zero if no change + print(dtheta_dt) dtheta_dt = (new_params - old_params) / self.dt_step # check if plasma resistivity is being evolved From 2ba2ab17a950331422a7b351c82578890c568ea6 Mon Sep 17 00:00:00 2001 From: kpentland Date: Thu, 26 Jun 2025 14:13:58 +0100 Subject: [PATCH 06/13] linearisation now works for paxis, betap, beta0 profiles --- freegsnke/linear_solve.py | 3 +- freegsnke/nonlinear_solve.py | 206 +++++++++++++++++++++-------------- 2 files changed, 125 insertions(+), 84 deletions(-) diff --git a/freegsnke/linear_solve.py b/freegsnke/linear_solve.py index dbea21ba..8399c68b 100644 --- a/freegsnke/linear_solve.py +++ b/freegsnke/linear_solve.py @@ -284,11 +284,10 @@ def stepper( self.empty_U[: self.n_active_coils] = active_voltage_vec self.forcing[:-1] = np.dot(self.Pm1Rm1, self.empty_U) self.forcing[-1] = 0.0 - print(self.forcing) + # additional forcing due to the time derivative of profile parameters if self.forcing_pars_matrix is not None: self.forcing -= np.dot(self.forcing_pars_matrix, dtheta_dt) - print(self.forcing) Itpdt = self.solver.full_stepper(It, self.forcing) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index bb402ec1..63f112ab 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -440,21 +440,33 @@ def __init__( # for setting profile parameters starting shifts (for Jacobians) if self.profiles_param is not None: # alpha_m - self.starting_dtheta[0] = (profiles.alpha_m + 1e-10) * 0.01 + self.starting_dtheta[0] = max(profiles.alpha_m * 1e-2, 1e-2) # alpha_n - self.starting_dtheta[1] = (profiles.alpha_n + 1e-10) * 0.01 - # paxis/betap/beta0 - self.starting_dtheta[2] = ( - getattr(profiles, self.profiles_param) + 1e-10 - ) * 0.01 + self.starting_dtheta[1] = max(profiles.alpha_n * 1e-2, 1e-2) + # paxis/betap/Beta0 + if self.profiles_param == "paxis": + self.starting_dtheta[2] = max( + getattr(profiles, self.profiles_param) * 1e-2, 1e1 + ) + elif self.profiles_param == "betap": + self.starting_dtheta[2] = max( + getattr(profiles, self.profiles_param) * 1e-2, 1e-4 + ) + elif self.profiles_param == "Beta0": + self.starting_dtheta[2] = max( + getattr(profiles, self.profiles_param) * 1e-2, 1e-4 + ) - else: # lao + else: # lao ( try normalising all the coeffs wrt either alpha_0 or beta_0, also need to normalise the dtheta_dt term too) + # or perhaps normalise wrt pressure at centre )given all alphas and betas) # alpha coeffs n_alpha = len(profiles.alpha) - self.starting_dtheta[0:n_alpha] = (profiles.alpha + 1e-10) * 0.01 + self.starting_dtheta[0:n_alpha] = max( + profiles.alpha * target_dIy, target_dIy + ) # beta coeffs - self.starting_dtheta[n_alpha:] = (profiles.beta + 1e-10) * 0.01 + self.starting_dtheta[n_alpha:] = max(profiles.beta * target_dIy, target_dIy) # This solves the system of circuit eqs based on an assumption # for the direction of the plasma current distribution at time t+dt @@ -726,15 +738,15 @@ def build_dIydI_noGS( else: starting_dI[j] = 1.0 * self.final_dI_record[j] - if verbose: - print("mode", j, "; approved starting_dI=", starting_dI[j]) - print( - "approved relative dIy change=", - rel_ndIy, - "; core_check=", - core_check, - ) - print(" ") + # if verbose: + # print("mode", j, "; approved starting_dI=", starting_dI[j]) + # print( + # "approved relative dIy change=", + # rel_ndIy, + # "; core_check=", + # core_check, + # ) + # print(" ") self.dIydI_noGS[:, j] = dIydInoGS self.rel_ndIy[j] = rel_ndIy # self.final_dI_record[j] = starting_dI[j] * self.accepted_target_dIy[j] / rel_ndIy @@ -871,6 +883,9 @@ def prepare_build_dIydtheta( self.profiles_param: getattr(profiles, self.profiles_param), } ) + + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_0[:, 0] = ( self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy @@ -895,6 +910,9 @@ def prepare_build_dIydtheta( self.profiles_param: getattr(profiles, self.profiles_param), } ) + + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_0[:, 1] = ( self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy @@ -911,25 +929,25 @@ def prepare_build_dIydtheta( print(f" Initial relative Iy change = {rel_ndIy_0[1]}") print(f" Final delta parameter = {self.final_dtheta_record[1]}") - # vary paxis, betap or beta0 + # vary paxis, betap or Beta0 self.check_and_change_profiles( profiles_parameters={ "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, self.profiles_param: getattr(profiles, self.profiles_param) - * (1 + starting_dtheta[2]), + + starting_dtheta[2], } ) + + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_0[:, 2] = ( self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy ) rel_ndIy_0[2] = np.linalg.norm(dIy_0[:, 2]) / self.nIy self.final_dtheta_record[2] = ( - starting_dtheta[2] - * getattr(profiles, self.profiles_param) - * target_dIy[2] - / rel_ndIy_0[2] + starting_dtheta[2] * target_dIy[2] / rel_ndIy_0[2] ) if verbose: @@ -939,6 +957,15 @@ def prepare_build_dIydtheta( print(f" Initial relative Iy change = {rel_ndIy_0[2]}") print(f" Final delta parameter = {self.final_dtheta_record[2]}") + # reset profiles in profiles1 and profiles2 objects + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m, + "alpha_n": profiles.alpha_n, + self.profiles_param: getattr(profiles, self.profiles_param), + } + ) + else: # this is particular to the Lao profile coefficients (which there may be few or many of) # for each alpha coefficient @@ -953,6 +980,9 @@ def prepare_build_dIydtheta( "beta": profiles.beta, } ) + + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_0[:, i] = ( self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy @@ -981,6 +1011,9 @@ def prepare_build_dIydtheta( "beta": beta_shift, } ) + + # reset plasma flux map to original + self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_0[:, i + alpha_n] = ( self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy @@ -1003,6 +1036,14 @@ def prepare_build_dIydtheta( f" Final delta parameter = {self.final_dtheta_record[i+alpha_n]}" ) + # reset profiles in profiles1 and profiles2 objects + self.check_and_change_profiles( + profiles_parameters={ + "alpha": profiles.alpha, + "beta": profiles.beta, + } + ) + return dIy_0 / starting_dtheta, rel_ndIy_0 def build_dIydtheta(self, profiles, rtol_NK, verbose=False): @@ -1020,6 +1061,9 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): """ + # the final perturbations to calc the Jacobian with + final_theta = 1.0 * self.final_dtheta_record + current_ = np.copy(self.currents_vec) # storage @@ -1032,7 +1076,7 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): # vary alpha_m self.check_and_change_profiles( profiles_parameters={ - "alpha_m": profiles.alpha_m + self.final_dtheta_record[0], + "alpha_m": profiles.alpha_m + final_theta[0], "alpha_n": profiles.alpha_n, self.profiles_param: getattr(profiles, self.profiles_param), } @@ -1041,8 +1085,8 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - dIydtheta[:, 0] = dIy_1 / self.final_dtheta_record[0] rel_ndIy[0] = np.linalg.norm(dIy_1) / self.nIy + dIydtheta[:, 0] = dIy_1 / final_theta[0] if verbose: print("") print(f"Profile parameter: alpha_m:") @@ -1055,7 +1099,7 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): self.check_and_change_profiles( profiles_parameters={ "alpha_m": profiles.alpha_m, - "alpha_n": profiles.alpha_n + self.final_dtheta_record[1], + "alpha_n": profiles.alpha_n + final_theta[1], self.profiles_param: getattr(profiles, self.profiles_param), } ) @@ -1063,8 +1107,8 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - dIydtheta[:, 1] = dIy_1 / self.final_dtheta_record[1] rel_ndIy[1] = np.linalg.norm(dIy_1) / self.nIy + dIydtheta[:, 1] = dIy_1 / final_theta[1] if verbose: print("") print(f"Profile parameter: alpha_n:") @@ -1073,21 +1117,21 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) - # vary paxis, betap or beta0 + # vary paxis, betap or Beta0 self.check_and_change_profiles( profiles_parameters={ "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, self.profiles_param: getattr(profiles, self.profiles_param) - + self.final_dtheta_record[2], + + final_theta[2], } ) # reset plasma flux map to original self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - dIydtheta[:, 2] = dIy_1 / self.final_dtheta_record[2] rel_ndIy[2] = np.linalg.norm(dIy_1) / self.nIy + dIydtheta[:, 2] = dIy_1 / final_theta[2] if verbose: print("") print(f"Profile parameter: {self.profiles_param}:") @@ -1096,6 +1140,15 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) + # reset profiles in profiles1 and profiles2 objects + self.check_and_change_profiles( + profiles_parameters={ + "alpha_m": profiles.alpha_m, + "alpha_n": profiles.alpha_n, + self.profiles_param: getattr(profiles, self.profiles_param), + } + ) + else: # this is particular to the Lao profile coefficients (which there may be few or many of) # for each alpha coefficient @@ -1103,7 +1156,7 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): alpha_base = profiles.alpha.copy() for i in range(0, n_alpha): alpha_shift = alpha_base.copy() - alpha_shift[i] += self.final_dtheta_record[i] + alpha_shift[i] += final_theta[i] self.check_and_change_profiles( profiles_parameters={ "alpha": alpha_shift, @@ -1114,8 +1167,8 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - dIydtheta[:, i] = dIy_1 / self.final_dtheta_record[i] rel_ndIy[i] = np.linalg.norm(dIy_1) / self.nIy + dIydtheta[:, i] = dIy_1 / final_theta[i] if verbose: print("") print(f"Profile parameter: alpha_{i}:") @@ -1129,7 +1182,7 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): beta_base = profiles.beta.copy() for i in range(0, n_beta): beta_shift = beta_base.copy() - beta_shift[i] += self.final_dtheta_record[i + n_alpha] + beta_shift[i] += final_theta[i + n_alpha] self.check_and_change_profiles( profiles_parameters={ "alpha": profiles.alpha, @@ -1140,10 +1193,8 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - dIydtheta[:, i + n_alpha] = ( - dIy_1 / self.final_dtheta_record[i + n_alpha] - ) rel_ndIy[i + n_alpha] = np.linalg.norm(dIy_1) / self.nIy + dIydtheta[:, i + n_alpha] = dIy_1 / final_theta[i + n_alpha] if verbose: print("") @@ -1153,6 +1204,14 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) + # reset profiles in profiles1 and profiles2 objects + self.check_and_change_profiles( + profiles_parameters={ + "alpha": profiles.alpha, + "beta": profiles.beta, + } + ) + return dIydtheta, rel_ndIy def prepare_build_dIydI_j( @@ -1252,7 +1311,9 @@ def build_linearization( force_core_mask_linearization, verbose, ): - """Builds the Jacobians d(Iy)/dI and d(Iy)/dtheta to set up the solver of the linearised problem. + """ + + Builds the Jacobians d(Iy)/dI and d(Iy)/dtheta to set up the solver of the linearised problem. Parameters ---------- @@ -1270,10 +1331,10 @@ def build_linearization( Forces the perturbed plasma core mask to remain the same as the original when calculating the dIydI Jacobian. """ - if (dIydI is None) and (self.dIydI is None): - self.build_current_vec(eq, profiles) - self.Iy = self.limiter_handler.Iy_from_jtor(profiles.jtor).copy() - self.nIy = np.linalg.norm(self.Iy) + # if (dIydI is None) and (self.dIydI is None): + self.build_current_vec(eq, profiles) + self.Iy = self.limiter_handler.Iy_from_jtor(profiles.jtor).copy() + self.nIy = np.linalg.norm(self.Iy) self.R0 = eq.Rcurrent() self.Z0 = eq.Zcurrent() @@ -1283,6 +1344,7 @@ def build_linearization( # this uses the variation to Jtor caused by the coil's contribution to the flux, ignoring the response of the plasma # build/update dIydI + # dIydI = 1 if dIydI is None: if self.dIydI_ICs is None: print( @@ -1337,19 +1399,6 @@ def build_linearization( == 0 ) - if verbose: - print("mode", j) - print( - "Initial delta_current=", - self.starting_dI[j], - ) - print( - "Initial relative Iy change=", - ndIy, - "; core_check=", - core_check, - ) - if ( np.abs(np.log10(self.final_dI_record[j] / self.starting_dI[j])) > 0.5 @@ -1391,27 +1440,16 @@ def build_linearization( self.final_dI_record[j] = 1.0 * self.starting_dI[j] if verbose: + print("") + print(f"Mode: {j}") + print(f" Initial delta_current = {self.starting_dI[j]}") + print(f" Initial relative Iy change = {ndIy}") + print(f" Final delta_current = {self.final_dI_record[j]}") + print("") + print(f" Final relative Iy change = {rel_ndIy}") print( - "Final current shift=", - self.final_dI_record[j], - ) - if force_core_mask_linearization: - try: - print( - "Final relative Iy change=", - rel_ndIy, - "; core_check=", - core_check, - ) - except: - print("failed printout!") - print( - "Initial residual=", - self.NK.initial_rel_residual, - ". Final residual=", - self.NK.relative_change, + f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) - print(" ") self.dIydI[:, j] = np.copy(dIydIj) self.psideltaI[j] = np.copy(self.eq2.psi()) @@ -1442,11 +1480,12 @@ def build_linearization( self.dIydtheta = np.zeros( (self.plasma_domain_size, self.n_profiles_parameters) ) - self.final_dtheta_record = np.zeros(self.n_profiles_parameters) + + profiles_copy = deepcopy(profiles) # prepare to build the Jacobian by finding appropriate step size dIydtheta, ndIy = self.prepare_build_dIydtheta( - profiles=profiles, + profiles=profiles_copy, rtol_NK=target_relative_tolerance_linearization, target_dIy=self.approved_target_dtheta, starting_dtheta=self.starting_dtheta, @@ -1459,10 +1498,11 @@ def build_linearization( ).any(): dIydtheta, rel_ndIy = self.build_dIydtheta( - profiles=self.profiles1, + profiles=profiles_copy, rtol_NK=target_relative_tolerance_linearization, - verbose=False, + verbose=verbose, ) + else: self.final_dtheta_record = 1.0 * self.starting_dtheta @@ -1631,11 +1671,11 @@ def get_profiles_values(self, profiles): self.profiles_parameters = { "alpha_m": profiles.alpha_m, "alpha_n": profiles.alpha_n, - "beta0": profiles.beta0, + "Beta0": profiles.Beta0, } - self.profiles_param = "beta0" + self.profiles_param = "Beta0" self.profiles_parameters_vec = np.array( - [profiles.alpha_m, profiles.alpha_n, profiles.beta0] + [profiles.alpha_m, profiles.alpha_n, profiles.Beta0] ) elif self.profiles_type == "Lao85": self.n_profiles_parameters = len(profiles.alpha) + len(profiles.beta) @@ -2310,6 +2350,7 @@ def nlstepper( # retrieve the old profile parameter values self.get_profiles_values(self.profiles1) old_params = self.profiles_parameters_vec + # print(f"old_params = {old_params}") # check if profiles parameters are being evolved # and action the change where necessary @@ -2320,11 +2361,12 @@ def nlstepper( # retrieve the new profile parameter values (if present) self.get_profiles_values(self.profiles1) new_params = self.profiles_parameters_vec + # print(f"new_params = {new_params}") # calculate change in profiles across timestep: (profiles(t+dt)-profiles(t))/dt # should be zero if no change - print(dtheta_dt) dtheta_dt = (new_params - old_params) / self.dt_step + # print(f"dtheta_dt = {dtheta_dt}") # check if plasma resistivity is being evolved # and action the change where necessary From 43121999f91b06f0981043fbb6f5574e296de51a Mon Sep 17 00:00:00 2001 From: kpentland Date: Tue, 15 Jul 2025 11:50:47 +0100 Subject: [PATCH 07/13] setting starting_dthetas for lao profiles --- freegsnke/nonlinear_solve.py | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index 63f112ab..157685ce 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -457,16 +457,14 @@ def __init__( getattr(profiles, self.profiles_param) * 1e-2, 1e-4 ) - else: # lao ( try normalising all the coeffs wrt either alpha_0 or beta_0, also need to normalise the dtheta_dt term too) - # or perhaps normalise wrt pressure at centre )given all alphas and betas) + else: # lao # alpha coeffs - n_alpha = len(profiles.alpha) - self.starting_dtheta[0:n_alpha] = max( - profiles.alpha * target_dIy, target_dIy - ) + self.starting_dtheta[0:self.n_profiles_parameters_alpha] = self.profiles_parameters_vec[self.profiles_alpha_indices] * 1e-3 + self.starting_dtheta[0:self.n_profiles_parameters_alpha][ self.starting_dtheta[0:self.n_profiles_parameters_alpha] == 0] = 1e-3 # beta coeffs - self.starting_dtheta[n_alpha:] = max(profiles.beta * target_dIy, target_dIy) + self.starting_dtheta[self.n_profiles_parameters_alpha:] = self.profiles_parameters_vec[self.profiles_beta_indices] * 1e-3 + self.starting_dtheta[self.n_profiles_parameters_alpha:][ self.starting_dtheta[self.n_profiles_parameters_alpha:] == 0] = 1e-3 # This solves the system of circuit eqs based on an assumption # for the direction of the plasma current distribution at time t+dt @@ -1678,7 +1676,21 @@ def get_profiles_values(self, profiles): [profiles.alpha_m, profiles.alpha_n, profiles.Beta0] ) elif self.profiles_type == "Lao85": - self.n_profiles_parameters = len(profiles.alpha) + len(profiles.beta) + self.n_profiles_parameters_alpha = len(profiles.alpha) + self.n_profiles_parameters_beta = len(profiles.beta) + if profiles.alpha_logic: + self.n_profiles_parameters_alpha -= 1 + if profiles.beta_logic: + self.n_profiles_parameters_beta -= 1 + self.n_profiles_parameters = self.n_profiles_parameters_alpha + self.n_profiles_parameters_beta + + self.profiles_alpha_indices = slice(0, self.n_profiles_parameters_alpha) + alpha_shift = 0 + if profiles.alpha_logic: + alpha_shift += 1 + + self.profiles_beta_indices = slice(self.n_profiles_parameters_alpha+alpha_shift, self.n_profiles_parameters_alpha+alpha_shift+self.n_profiles_parameters_beta) + self.profiles_parameters = {"alpha": profiles.alpha, "beta": profiles.beta} self.profiles_param = None self.profiles_parameters_vec = np.concatenate( From 4796ebeb00c9e38ddb782e5da42dcc37b44703e7 Mon Sep 17 00:00:00 2001 From: kpentland Date: Mon, 21 Jul 2025 08:54:44 +0100 Subject: [PATCH 08/13] finalising time-dep Lao linearisation --- freegsnke/nonlinear_solve.py | 130 ++++++++++++++++++++++++----------- 1 file changed, 91 insertions(+), 39 deletions(-) diff --git a/freegsnke/nonlinear_solve.py b/freegsnke/nonlinear_solve.py index 157685ce..1894fe6a 100644 --- a/freegsnke/nonlinear_solve.py +++ b/freegsnke/nonlinear_solve.py @@ -457,14 +457,22 @@ def __init__( getattr(profiles, self.profiles_param) * 1e-2, 1e-4 ) - else: # lao + else: # lao # alpha coeffs - self.starting_dtheta[0:self.n_profiles_parameters_alpha] = self.profiles_parameters_vec[self.profiles_alpha_indices] * 1e-3 - self.starting_dtheta[0:self.n_profiles_parameters_alpha][ self.starting_dtheta[0:self.n_profiles_parameters_alpha] == 0] = 1e-3 + self.starting_dtheta[0 : self.n_profiles_parameters_alpha] = ( + self.profiles_parameters_vec[self.profiles_alpha_indices] * 1e-3 + ) + self.starting_dtheta[0 : self.n_profiles_parameters_alpha][ + self.starting_dtheta[0 : self.n_profiles_parameters_alpha] == 0 + ] = 1e-3 # beta coeffs - self.starting_dtheta[self.n_profiles_parameters_alpha:] = self.profiles_parameters_vec[self.profiles_beta_indices] * 1e-3 - self.starting_dtheta[self.n_profiles_parameters_alpha:][ self.starting_dtheta[self.n_profiles_parameters_alpha:] == 0] = 1e-3 + self.starting_dtheta[self.n_profiles_parameters_alpha :] = ( + self.profiles_parameters_vec[self.profiles_beta_indices] * 1e-3 + ) + self.starting_dtheta[self.n_profiles_parameters_alpha :][ + self.starting_dtheta[self.n_profiles_parameters_alpha :] == 0 + ] = 1e-3 # This solves the system of circuit eqs based on an assumption # for the direction of the plasma current distribution at time t+dt @@ -968,10 +976,14 @@ def prepare_build_dIydtheta( # for each alpha coefficient alpha_base = profiles.alpha.copy() - alpha_n = len(profiles.alpha) - for i in range(0, alpha_n): + for i in range(0, self.n_profiles_parameters_alpha): alpha_shift = alpha_base.copy() - alpha_shift[i] += starting_dtheta[i] + alpha_shift[i] += starting_dtheta[i] # perturb the term + if profiles.alpha_logic: + alpha_shift[-1] -= starting_dtheta[ + i + ] # final alpha term needs perturbing too + self.check_and_change_profiles( profiles_parameters={ "alpha": alpha_shift, @@ -999,10 +1011,15 @@ def prepare_build_dIydtheta( # for each beta coefficient beta_base = profiles.beta.copy() - beta_n = len(profiles.beta) - for i in range(0, beta_n): + for i in range(0, self.n_profiles_parameters_beta): beta_shift = beta_base.copy() - beta_shift[i] += starting_dtheta[i + alpha_n] + beta_shift[i] += starting_dtheta[ + i + self.n_profiles_parameters_alpha + ] # perturb the term required + if profiles.beta_logic: + beta_shift[-1] -= starting_dtheta[ + i + self.n_profiles_parameters_alpha + ] # final beta term needs perturbing too self.check_and_change_profiles( profiles_parameters={ "alpha": profiles.alpha, @@ -1013,25 +1030,30 @@ def prepare_build_dIydtheta( # reset plasma flux map to original self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) - dIy_0[:, i + alpha_n] = ( + dIy_0[:, i + self.n_profiles_parameters_alpha] = ( self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy ) - rel_ndIy_0[i + alpha_n] = ( - np.linalg.norm(dIy_0[:, i + alpha_n]) / self.nIy + rel_ndIy_0[i + self.n_profiles_parameters_alpha] = ( + np.linalg.norm(dIy_0[:, i + self.n_profiles_parameters_alpha]) + / self.nIy ) - self.final_dtheta_record[i + alpha_n] = ( - starting_dtheta[i + alpha_n] + self.final_dtheta_record[i + self.n_profiles_parameters_alpha] = ( + starting_dtheta[i + self.n_profiles_parameters_alpha] * target_dIy[i] - / rel_ndIy_0[i + alpha_n] + / rel_ndIy_0[i + self.n_profiles_parameters_alpha] ) if verbose: print("") print(f"Profile parameter: beta_{i}:") - print(f" Initial delta parameter = {starting_dtheta[i+alpha_n]}") - print(f" Initial relative Iy change = {rel_ndIy_0[i+alpha_n]}") print( - f" Final delta parameter = {self.final_dtheta_record[i+alpha_n]}" + f" Initial delta parameter = {starting_dtheta[i+self.n_profiles_parameters_alpha]}" + ) + print( + f" Initial relative Iy change = {rel_ndIy_0[i+self.n_profiles_parameters_alpha]}" + ) + print( + f" Final delta parameter = {self.final_dtheta_record[i+self.n_profiles_parameters_alpha]}" ) # reset profiles in profiles1 and profiles2 objects @@ -1150,11 +1172,16 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): else: # this is particular to the Lao profile coefficients (which there may be few or many of) # for each alpha coefficient - n_alpha = len(profiles.alpha) + alpha_base = profiles.alpha.copy() - for i in range(0, n_alpha): + for i in range(0, self.n_profiles_parameters_alpha): alpha_shift = alpha_base.copy() - alpha_shift[i] += final_theta[i] + alpha_shift[i] += final_theta[i] # perturb the term + if profiles.alpha_logic: + alpha_shift[-1] -= final_theta[ + i + ] # final alpha term needs perturbing too + self.check_and_change_profiles( profiles_parameters={ "alpha": alpha_shift, @@ -1176,11 +1203,16 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): ) # for each beta coefficient - n_beta = len(profiles.beta) beta_base = profiles.beta.copy() - for i in range(0, n_beta): + for i in range(0, self.n_profiles_parameters_beta): beta_shift = beta_base.copy() - beta_shift[i] += final_theta[i + n_alpha] + beta_shift[i] += final_theta[ + i + self.n_profiles_parameters_alpha + ] # perturb the term required + if profiles.beta_logic: + beta_shift[-1] -= final_theta[ + i + self.n_profiles_parameters_alpha + ] # final beta term needs perturbing too self.check_and_change_profiles( profiles_parameters={ "alpha": profiles.alpha, @@ -1191,13 +1223,19 @@ def build_dIydtheta(self, profiles, rtol_NK, verbose=False): self.eq2.plasma_psi = np.copy(self.eq1.plasma_psi) self.assign_currents_solve_GS(current_, rtol_NK) dIy_1 = self.limiter_handler.Iy_from_jtor(self.profiles2.jtor) - self.Iy - rel_ndIy[i + n_alpha] = np.linalg.norm(dIy_1) / self.nIy - dIydtheta[:, i + n_alpha] = dIy_1 / final_theta[i + n_alpha] + rel_ndIy[i + self.n_profiles_parameters_alpha] = ( + np.linalg.norm(dIy_1) / self.nIy + ) + dIydtheta[:, i + self.n_profiles_parameters_alpha] = ( + dIy_1 / final_theta[i + self.n_profiles_parameters_alpha] + ) if verbose: print("") print(f"Profile parameter: beta_{i}:") - print(f" Final relative Iy change = {rel_ndIy[i+n_alpha]}") + print( + f" Final relative Iy change = {rel_ndIy[i+self.n_profiles_parameters_alpha]}" + ) print( f" Initial vs. Final GS residual: {self.NK.initial_rel_residual} vs. {self.NK.relative_change}" ) @@ -1682,14 +1720,21 @@ def get_profiles_values(self, profiles): self.n_profiles_parameters_alpha -= 1 if profiles.beta_logic: self.n_profiles_parameters_beta -= 1 - self.n_profiles_parameters = self.n_profiles_parameters_alpha + self.n_profiles_parameters_beta + self.n_profiles_parameters = ( + self.n_profiles_parameters_alpha + self.n_profiles_parameters_beta + ) self.profiles_alpha_indices = slice(0, self.n_profiles_parameters_alpha) alpha_shift = 0 if profiles.alpha_logic: alpha_shift += 1 - - self.profiles_beta_indices = slice(self.n_profiles_parameters_alpha+alpha_shift, self.n_profiles_parameters_alpha+alpha_shift+self.n_profiles_parameters_beta) + + self.profiles_beta_indices = slice( + self.n_profiles_parameters_alpha + alpha_shift, + self.n_profiles_parameters_alpha + + alpha_shift + + self.n_profiles_parameters_beta, + ) self.profiles_parameters = {"alpha": profiles.alpha, "beta": profiles.beta} self.profiles_param = None @@ -2246,9 +2291,9 @@ def check_and_change_profiles(self, profiles_parameters=None): for par in profiles_parameters: setattr(self.profiles1, par, profiles_parameters[par]) setattr(self.profiles2, par, profiles_parameters[par]) - if self.profiles_type == "Lao85": - self.profiles1.initialize_profile() - self.profiles2.initialize_profile() + if self.profiles_type == "Lao85": + self.profiles1.initialize_profile() + self.profiles2.initialize_profile() self.profiles_change_flag = 1 def nlstepper( @@ -2362,7 +2407,6 @@ def nlstepper( # retrieve the old profile parameter values self.get_profiles_values(self.profiles1) old_params = self.profiles_parameters_vec - # print(f"old_params = {old_params}") # check if profiles parameters are being evolved # and action the change where necessary @@ -2373,12 +2417,20 @@ def nlstepper( # retrieve the new profile parameter values (if present) self.get_profiles_values(self.profiles1) new_params = self.profiles_parameters_vec - # print(f"new_params = {new_params}") # calculate change in profiles across timestep: (profiles(t+dt)-profiles(t))/dt # should be zero if no change - dtheta_dt = (new_params - old_params) / self.dt_step - # print(f"dtheta_dt = {dtheta_dt}") + if self.profiles_type == "Lao85": + old_alphas = old_params[self.profiles_alpha_indices] + old_betas = old_params[self.profiles_beta_indices] + new_alphas = new_params[self.profiles_alpha_indices] + new_betas = new_params[self.profiles_beta_indices] + dtheta_dt = ( + np.concatenate((new_alphas, new_betas)) + - np.concatenate((old_alphas, old_betas)) + ) / self.dt_step + else: + dtheta_dt = (new_params - old_params) / self.dt_step # check if plasma resistivity is being evolved # and action the change where necessary From a71346bd850a85ba8479963f230876e695a942a1 Mon Sep 17 00:00:00 2001 From: kpentland Date: Mon, 21 Jul 2025 10:48:42 +0100 Subject: [PATCH 09/13] adding time-dep profiles to example05 --- .../example05 - evolutive_forward_solve.ipynb | 384 +++++++++++------- 1 file changed, 240 insertions(+), 144 deletions(-) diff --git a/examples/example05 - evolutive_forward_solve.ipynb b/examples/example05 - evolutive_forward_solve.ipynb index 5b1f20e4..8529eea0 100644 --- a/examples/example05 - evolutive_forward_solve.ipynb +++ b/examples/example05 - evolutive_forward_solve.ipynb @@ -11,13 +11,11 @@ "To do this, we need to:\n", "- build the tokamak machine.\n", "- instatiate a GS equilibrium (to be used as an initial condition for the evolutive solver).\n", - "- calculate a vertical instability growth rate for this equilibrium and carry out passive structure mode removal via a normal mode decomposition (i.e. removing modes that have little effect on the evolution). \n", - "- define time-dependent plasma current density profile parameters and coil voltages.\n", + "- calculate a vertical instability growth rate for this equilibrium and carry out passive structure mode removal via a normal mode decomposition (i.e. removing modes that have little effect on the evolution). More details on this in a later notebook. \n", + "- define time-dependent coil voltages, plasma current density profile parameters, and plasma resistivity.\n", "- evolve the active coil currents, the total plasma current, and the equilbirium using these profile parameters and voltages by solving the circuit equations alongside the GS equation.\n", "\n", - "Refer to the paper by [Amorisco et al. (2024)](https://pubs.aip.org/aip/pop/article/31/4/042517/3286904/FreeGSNKE-A-Python-based-dynamic-free-boundary) for more details. \n", - "\n", - "We should note that here we will use **fixed** (time-independent) profile parameters and voltages to simulate a VDE, however, truly time-dependent parameters would be required to simulate a plasma shot (see future notebooks). \n" + "Refer to the paper by [Amorisco et al. (2024)](https://pubs.aip.org/aip/pop/article/31/4/042517/3286904/FreeGSNKE-A-Python-based-dynamic-free-boundary) for more details." ] }, { @@ -37,7 +35,8 @@ "import matplotlib.pyplot as plt\n", "from copy import deepcopy\n", "from IPython.display import display, clear_output\n", - "import pickle" + "import pickle\n", + "import copy" ] }, { @@ -220,11 +219,11 @@ "- `min_dIy_dI`: threshold value below which passive structure normal modes are dropped. Modes with norm(d(Iy)/dI)<`min_dIy_dI` are dropped, which filters out modes that do not actually couple with the plasma.\n", "- `max_mode_frequency`: threshold value for characteristic frequencies above which passive structure normal modes are dropped (i.e. the fast modes).\n", "\n", - "Other customisable inputs are available, do see the documentation for more details. For example, one may explicitly set your own resistance and inductance matries for the tokamak machine. \n", + "Other customisable inputs are available, do see the documentation or the later notebook on \"Growth Rates\" for more details. For example, one may explicitly set your own resistance and inductance matries for the tokamak, rather than the geometrical value calculated internally in FreeGSNKE.\n", "\n", "The solver can be used on different equilibria and/or profiles, but these need to have the same machine, domain, and limiter as the one used at the time of the solver instantiation. For different machines, a new time-evolutive solver should be created.\n", "\n", - "The input equilibrium and profile functions are also used as the expansion point around which the dynamics are linearised." + "The input equilibrium and profile functions are also used as the expansion point around which the dynamics are linearised (when using the linear solver or calculating linear growth rates). " ] }, { @@ -245,44 +244,6 @@ ")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Set active coil voltages\n", - "\n", - "In this example, we will evolve a plasma in absence of any control policy or current drive.\n", - "\n", - "Just as an example, the following calculates active voltages to be applied to the poloidal field coils (and Solenoid) using $V = RI$, with current values as defined by the initial equilibrium (i.e. we have constant voltages).\n", - "\n", - "In most FreeGSNKE use cases, these active voltages will be determined by a control policy." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "voltages = (stepping.vessel_currents_vec*stepping.evol_metal_curr.R)[:stepping.evol_metal_curr.n_active_coils] " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To start, the solver is prepared by setting the initial conditions." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "stepping.initialize_from_ICs(eq, profiles)" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -312,8 +273,27 @@ "history_triangularity = [stepping.eq1.triangularity()]\n", "history_squareness = [stepping.eq1.squareness()[1]]\n", "history_area = [stepping.eq1.separatrix_area()]\n", - "history_length = [stepping.eq1.separatrix_length()]\n", - "\n" + "history_length = [stepping.eq1.separatrix_length()]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Set time-dependent active coil voltages, profile parameters, and plasma resistivity\n", + "\n", + "To simulate the VDE in the example, we will evolve a plasma in absence of any control policy or current drive. The following calculates active voltages to be applied to the poloidal field coils (and Solenoid) using $V = RI$, with current values as defined by the initial equilibrium (i.e. we have constant voltages over time). For more realistic plasma simulation, these active voltages would be truly time-dependent and determined by a control policy.\n", + "\n", + "In this example, the profile parameters and the plasma resistivity will also remain constant over time. In the next example, we will show how to vary these." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "voltages = (stepping.vessel_currents_vec*stepping.evol_metal_curr.R)[:stepping.evol_metal_curr.n_active_coils] " ] }, { @@ -323,7 +303,7 @@ "#### Call the solver (linear)\n", "Finally, we call the time-evolutive solver with `stepping.nlstepper()` sequentially until we reach the preset end time.\n", "\n", - "The following demonstrates a solely linear evolution of the plasma by setting `linear_only=True`." + "The following demonstrates a solely linear evolution of the plasma by setting `linear_only=True`. This makes use of the Jacobians calculated when the nonlinear solver object was initialised. Note that the linear solution will only hold for equilibrium \"close to\" that which was used to initialise the nonlinear solver object. " ] }, { @@ -332,15 +312,20 @@ "metadata": {}, "outputs": [], "source": [ + "# initialise the solver with the initial equilibrium/profiles\n", + "stepping.initialize_from_ICs(eq, profiles)\n", + "\n", "# loop over time steps\n", "while counter" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# instatiate new equilibrium object\n", + "eq_general = deepcopy(eq)\n", + "\n", + "# call solver with new profile object\n", + "GSStaticSolver.solve(eq=eq_general, \n", + " profiles=profiles_general, \n", + " constrain=None, \n", + " target_relative_tolerance=1e-9)\n", + "\n", + "\n", + "# plot the resulting equilbria \n", + "fig1, ax1 = plt.subplots(1, 1, figsize=(4, 8), dpi=80)\n", + "ax1.grid(True, which='both')\n", + "eq_general.plot(axis=ax1, show=False)\n", + "eq_general.tokamak.plot(axis=ax1, show=False)\n", + "ax1.set_xlim(0.1, 2.15)\n", + "ax1.set_ylim(-2.25, 2.25)\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "metadata": {}, diff --git a/examples/example03 - extracting_equilibrium_quantites.ipynb b/examples/example03 - extracting_equilibrium_quantites.ipynb index 5f54f242..7cfa0f9c 100644 --- a/examples/example03 - extracting_equilibrium_quantites.ipynb +++ b/examples/example03 - extracting_equilibrium_quantites.ipynb @@ -906,7 +906,7 @@ "metadata": {}, "outputs": [], "source": [ - "# plot the input p' and FF' profiles\n", + "# plot the p' and FF' profiles\n", "\n", "psi_n = eq.psiN_1D(N=65)\n", "\n", @@ -929,15 +929,21 @@ "metadata": {}, "outputs": [], "source": [ - "# plot q profile\n", + "# plot the p and F profiles\n", "\n", - "psi_n = np.linspace(0.01,0.99,65) # values of q at 0 and 1 can be problematic\n", + "psi_n = eq.psiN_1D(N=65)\n", "\n", - "fig1, ax1 = plt.subplots(1, 1, figsize=(6,6), dpi=80)\n", + "fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(15,6), dpi=80)\n", "ax1.grid(zorder=0, alpha=0.75)\n", - "ax1.plot(psi_n, eq.q(psi_n), color='k', linewidth=1, marker='x', markersize=2, zorder=10)\n", + "ax1.plot(psi_n, profiles.pressure(psi_n), color='k', linewidth=1, marker='x', markersize=2, zorder=10)\n", "ax1.set_xlabel(r'$\\hat{\\psi}$')\n", - "ax1.set_ylabel(r\"$q(\\hat{\\psi})$\")\n" + "ax1.set_ylabel(r\"$p(\\hat{\\psi})$\")\n", + "ax1.ticklabel_format(axis='y', scilimits=(0,0))\n", + "\n", + "ax2.grid(zorder=0, alpha=0.75)\n", + "ax2.plot(psi_n, profiles.fpol(psi_n), color='k', linewidth=1, marker='x', markersize=2, zorder=10)\n", + "ax2.set_xlabel(r'$\\hat{\\psi}$')\n", + "ax2.set_ylabel(r\"$F(\\hat{\\psi})$\")\n" ] }, { @@ -946,14 +952,15 @@ "metadata": {}, "outputs": [], "source": [ - "# plot fpol\n", + "# plot q profile\n", + "\n", + "psi_n = np.linspace(0.01,0.99,65) # values of q at 0 and 1 can be problematic\n", "\n", "fig1, ax1 = plt.subplots(1, 1, figsize=(6,6), dpi=80)\n", "ax1.grid(zorder=0, alpha=0.75)\n", - "ax1.plot(psi_n, eq.fpol(psi_n), color='k', linewidth=1, marker='x', markersize=2, zorder=10)\n", + "ax1.plot(psi_n, eq.q(psi_n), color='k', linewidth=1, marker='x', markersize=2, zorder=10)\n", "ax1.set_xlabel(r'$\\hat{\\psi}$')\n", - "ax1.set_ylabel(r\"$fpol(\\hat{\\psi})$\")\n", - "\n" + "ax1.set_ylabel(r\"$q(\\hat{\\psi})$\")\n" ] }, { From 740e978095750b0ca543689e9fc8d9d288af469d Mon Sep 17 00:00:00 2001 From: kpentland Date: Fri, 25 Jul 2025 16:58:17 +0100 Subject: [PATCH 12/13] added more descriptions of profiles to examples --- ...ample01 - static_inverse_solve_MASTU.ipynb | 20 +- ...ample02 - static_forward_solve_MASTU.ipynb | 341 +----------------- 2 files changed, 25 insertions(+), 336 deletions(-) diff --git a/examples/example01 - static_inverse_solve_MASTU.ipynb b/examples/example01 - static_inverse_solve_MASTU.ipynb index afdf7dcb..ef2a2cf5 100644 --- a/examples/example01 - static_inverse_solve_MASTU.ipynb +++ b/examples/example01 - static_inverse_solve_MASTU.ipynb @@ -151,14 +151,18 @@ "\n", "We can now instatiate a profile object that contains the chosen parameterisation of the toroidal plasma current density $J_p$ (i.e. on right hand side of the GS equation). We can then set the paramters for the chosen current density profiles. \n", "\n", - "A number of commonly used profile parameterisations exist in FreeGSNKE, including:\n", - "- `ConstrainPaxisIp`\n", - "- `ConstrainBetapIp`\n", - "- `Fiesta_Topeol`\n", - "- `Lao85`\n", - "- `TensionSpline`\n", - "\n", - "In this notebook, we will make use of the `ConstrainPaxisIp` (and `ConstrainBetapIp`) profiles (see [Jeon (2015)](https://link.springer.com/article/10.3938/jkps.67.843)). Others will be utilised in later notebooks. If there is a profile parameterisation you require that does not exist, please do create an issue. \n", + "The following table indicates which parameterisations are currently available in FreeGSNKE and for which types of equilibrium simulation they have been tested to work:\n", + "\n", + "| Name | Static | Evolutive (linear) | Evolutive (nonlinear) |\n", + "|-------|--------|------------------|---------------------|\n", + "| `ConstrainPaxisIp` | ✅ | ✅ | ✅ |\n", + "| `ConstrainBetapIp` | ✅ | ✅ | ✅ |\n", + "| `FiestaTopeol` | ✅ | ✅ | ✅ |\n", + "| `Lao85` | ✅ | ✅ | ✅ |\n", + "| `TensionSpline` | ✅ | ❌ | ❌ |\n", + "| `GeneralPprimeFFprime` | ✅ | ❌ | ❌ |\n", + "\n", + "In this notebook, we will make use of the `ConstrainPaxisIp` (and `ConstrainBetapIp`) profiles (see [Jeon (2015)](https://link.springer.com/article/10.3938/jkps.67.843)). Others will be utilised in later notebooks. If there is a profile parameterisation you require that does not exist, please do create an issue.\n", "\n", "Both `ConstrainPaxisIp` and `ConstrainBetapIp` are parameterised as follows:\n", " $$J_{p}(\\psi, R, Z) = \\lambda\\big[ \\beta_{0} \\frac{R}{R_{0}} \\left( 1-\\tilde{\\psi}^{\\alpha_m} \\right)^{\\alpha_n} + (1-\\beta_{0}) \\frac{R_0}{R} \\left( 1-\\tilde{\\psi}^{\\alpha_m} \\right)^{\\alpha_n} \\big] \\quad (R,Z) \\in \\Omega_p,$$\n", diff --git a/examples/example02 - static_forward_solve_MASTU.ipynb b/examples/example02 - static_forward_solve_MASTU.ipynb index 9aab4799..856a1ddf 100644 --- a/examples/example02 - static_forward_solve_MASTU.ipynb +++ b/examples/example02 - static_forward_solve_MASTU.ipynb @@ -29,7 +29,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -55,23 +55,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Active coils --> built from pickle file.\n", - "Passive structures --> built from pickle file.\n", - "Limiter --> built from pickle file.\n", - "Wall --> built from pickle file.\n", - "Magnetic probes --> none provided.\n", - "Resistance (R) and inductance (M) matrices --> built using actives (and passives if present).\n", - "Tokamak built.\n" - ] - } - ], + "outputs": [], "source": [ "# build machine\n", "from freegsnke import build_machine\n", @@ -92,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -121,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -150,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -169,169 +155,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'Solenoid': 5000.0,\n", - " 'PX': 4596.742389645389,\n", - " 'D1': 6058.095030349898,\n", - " 'D2': 1893.3329125047176,\n", - " 'D3': 1660.635636548909,\n", - " 'Dp': -396.5350240752278,\n", - " 'D5': 3590.753784703625,\n", - " 'D6': -1082.7038438429436,\n", - " 'D7': -562.2923866580655,\n", - " 'P4': -4567.566109968559,\n", - " 'P5': -4051.737207651754,\n", - " 'P6': 0.0008102610619998001,\n", - " 'vessel_1': 0.0,\n", - " 'vessel_2': 0.0,\n", - " 'vessel_3': 0.0,\n", - " 'vessel_4': 0.0,\n", - " 'vessel_5': 0.0,\n", - " 'vessel_6': 0.0,\n", - " 'vessel_7': 0.0,\n", - " 'vessel_8': 0.0,\n", - " 'vessel_9': 0.0,\n", - " 'vessel_10': 0.0,\n", - " 'vessel_11': 0.0,\n", - " 'vessel_12': 0.0,\n", - " 'vessel_13': 0.0,\n", - " 'vessel_14': 0.0,\n", - " 'vessel_15': 0.0,\n", - " 'vessel_16': 0.0,\n", - " 'vessel_17': 0.0,\n", - " 'vessel_18': 0.0,\n", - " 'vessel_19': 0.0,\n", - " 'vessel_20': 0.0,\n", - " 'vessel_21': 0.0,\n", - " 'vessel_22': 0.0,\n", - " 'centrecolumn_1': 0.0,\n", - " 'centrecolumn_2': 0.0,\n", - " 'centrecolumn_3': 0.0,\n", - " 'centrecolumn_4': 0.0,\n", - " 'centrecolumn_5': 0.0,\n", - " 'centrecolumn_6': 0.0,\n", - " 'centrecolumn_7': 0.0,\n", - " 'centrecolumn_8': 0.0,\n", - " 'centrecolumn_9': 0.0,\n", - " 'centrecolumn_10': 0.0,\n", - " 'colosseum_upper_1': 0.0,\n", - " 'colosseum_upper_2': 0.0,\n", - " 'colosseum_upper_3': 0.0,\n", - " 'colosseum_lower_1': 0.0,\n", - " 'colosseum_lower_2': 0.0,\n", - " 'colosseum_lower_3': 0.0,\n", - " 'colosseum_outer_upper_1': 0.0,\n", - " 'colosseum_outer_upper_2': 0.0,\n", - " 'colosseum_outer_lower_1': 0.0,\n", - " 'colosseum_outer_lower_2': 0.0,\n", - " 'ring_plate_minor_upper_1': 0.0,\n", - " 'ring_plate_minor_upper_2': 0.0,\n", - " 'ring_plate_minor_lower_1': 0.0,\n", - " 'ring_plate_minor_lower_2': 0.0,\n", - " 'ring_plate_major_upper_1': 0.0,\n", - " 'ring_plate_major_lower_1': 0.0,\n", - " 'psp_upper_1': 0.0,\n", - " 'psp_lower_1': 0.0,\n", - " 'gas_baffle_upper_1': 0.0,\n", - " 'gas_baffle_upper_2': 0.0,\n", - " 'gas_baffle_upper_3': 0.0,\n", - " 'gas_baffle_lower_1': 0.0,\n", - " 'gas_baffle_lower_2': 0.0,\n", - " 'gas_baffle_lower_3': 0.0,\n", - " 'd1_case_upper_0': 0.0,\n", - " 'd1_case_upper_1': 0.0,\n", - " 'd1_case_upper_2': 0.0,\n", - " 'd1_case_upper_3': 0.0,\n", - " 'd1_case_lower_0': 0.0,\n", - " 'd1_case_lower_1': 0.0,\n", - " 'd1_case_lower_2': 0.0,\n", - " 'd1_case_lower_3': 0.0,\n", - " 'd2_case_upper_0': 0.0,\n", - " 'd2_case_upper_1': 0.0,\n", - " 'd2_case_upper_2': 0.0,\n", - " 'd2_case_upper_3': 0.0,\n", - " 'd2_case_lower_0': 0.0,\n", - " 'd2_case_lower_1': 0.0,\n", - " 'd2_case_lower_2': 0.0,\n", - " 'd2_case_lower_3': 0.0,\n", - " 'd3_case_upper_0': 0.0,\n", - " 'd3_case_upper_1': 0.0,\n", - " 'd3_case_upper_2': 0.0,\n", - " 'd3_case_upper_3': 0.0,\n", - " 'd3_case_lower_0': 0.0,\n", - " 'd3_case_lower_1': 0.0,\n", - " 'd3_case_lower_2': 0.0,\n", - " 'd3_case_lower_3': 0.0,\n", - " 'd5_case_upper_0': 0.0,\n", - " 'd5_case_upper_1': 0.0,\n", - " 'd5_case_upper_2': 0.0,\n", - " 'd5_case_upper_3': 0.0,\n", - " 'd5_case_lower_0': 0.0,\n", - " 'd5_case_lower_1': 0.0,\n", - " 'd5_case_lower_2': 0.0,\n", - " 'd5_case_lower_3': 0.0,\n", - " 'd6_case_upper_0': 0.0,\n", - " 'd6_case_upper_1': 0.0,\n", - " 'd6_case_upper_2': 0.0,\n", - " 'd6_case_upper_3': 0.0,\n", - " 'd6_case_lower_0': 0.0,\n", - " 'd6_case_lower_1': 0.0,\n", - " 'd6_case_lower_2': 0.0,\n", - " 'd6_case_lower_3': 0.0,\n", - " 'd7_case_upper_0': 0.0,\n", - " 'd7_case_upper_1': 0.0,\n", - " 'd7_case_upper_2': 0.0,\n", - " 'd7_case_upper_3': 0.0,\n", - " 'd7_case_lower_0': 0.0,\n", - " 'd7_case_lower_1': 0.0,\n", - " 'd7_case_lower_2': 0.0,\n", - " 'd7_case_lower_3': 0.0,\n", - " 'dp_case_upper_0': 0.0,\n", - " 'dp_case_upper_1': 0.0,\n", - " 'dp_case_upper_2': 0.0,\n", - " 'dp_case_upper_3': 0.0,\n", - " 'dp_case_lower_0': 0.0,\n", - " 'dp_case_lower_1': 0.0,\n", - " 'dp_case_lower_2': 0.0,\n", - " 'dp_case_lower_3': 0.0,\n", - " 'p4_case_upper_0': 0.0,\n", - " 'p4_case_upper_1': 0.0,\n", - " 'p4_case_upper_2': 0.0,\n", - " 'p4_case_upper_3': 0.0,\n", - " 'p4_case_lower_0': 0.0,\n", - " 'p4_case_lower_1': 0.0,\n", - " 'p4_case_lower_2': 0.0,\n", - " 'p4_case_lower_3': 0.0,\n", - " 'p5_case_upper_0': 0.0,\n", - " 'p5_case_upper_1': 0.0,\n", - " 'p5_case_upper_2': 0.0,\n", - " 'p5_case_upper_3': 0.0,\n", - " 'p5_case_lower_0': 0.0,\n", - " 'p5_case_lower_1': 0.0,\n", - " 'p5_case_lower_2': 0.0,\n", - " 'p5_case_lower_3': 0.0,\n", - " 'p6_case_upper_0': 0.0,\n", - " 'p6_case_upper_1': 0.0,\n", - " 'p6_case_upper_2': 0.0,\n", - " 'p6_case_upper_3': 0.0,\n", - " 'p6_case_upper_4': 0.0,\n", - " 'p6_case_lower_0': 0.0,\n", - " 'p6_case_lower_1': 0.0,\n", - " 'p6_case_lower_2': 0.0,\n", - " 'p6_case_lower_3': 0.0,\n", - " 'p6_case_lower_4': 0.0}" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# load the coil currents\n", "import pickle\n", @@ -370,125 +196,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-----\n", - "Forward static solve starting...\n", - "Initial guess for plasma_psi successful, residual found.\n", - "Initial relative error = 9.65e-01\n", - "-----\n", - "Picard iteration: 0\n", - "Update too large, resized.\n", - "...relative error = 9.46e-01\n", - "-----\n", - "Picard iteration: 1\n", - "Update too large, resized.\n", - "...relative error = 9.23e-01\n", - "-----\n", - "Picard iteration: 2\n", - "Update too large, resized.\n", - "...relative error = 8.97e-01\n", - "-----\n", - "Picard iteration: 3\n", - "Update too large, resized.\n", - "...relative error = 8.67e-01\n", - "-----\n", - "Picard iteration: 4\n", - "Update too large, resized.\n", - "...relative error = 8.31e-01\n", - "-----\n", - "Picard iteration: 5\n", - "Update too large, resized.\n", - "...relative error = 7.90e-01\n", - "-----\n", - "Picard iteration: 6\n", - "Update too large, resized.\n", - "...relative error = 7.43e-01\n", - "-----\n", - "Picard iteration: 7\n", - "Update too large, resized.\n", - "...relative error = 6.92e-01\n", - "-----\n", - "Picard iteration: 8\n", - "Update too large, resized.\n", - "...relative error = 6.32e-01\n", - "-----\n", - "Picard iteration: 9\n", - "Update too large, resized.\n", - "...relative error = 5.59e-01\n", - "-----\n", - "Picard iteration: 10\n", - "Update too large, resized.\n", - "...relative error = 4.75e-01\n", - "-----\n", - "Picard iteration: 11\n", - "Update too large, resized.\n", - "...relative error = 3.77e-01\n", - "-----\n", - "Picard iteration: 12\n", - "Update too large, resized.\n", - "...relative error = 2.65e-01\n", - "-----\n", - "Picard iteration: 13\n", - "Update too large, resized.\n", - "...relative error = 1.40e-01\n", - "-----\n", - "Picard iteration: 14\n", - "...relative error = 2.40e-02\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 15\n", - "...relative error = 4.56e-03\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 16\n", - "...relative error = 7.61e-04\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 17\n", - "...relative error = 2.86e-04\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 18\n", - "...relative error = 6.03e-05\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 19\n", - "...relative error = 8.94e-06\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 20\n", - "...relative error = 2.59e-06\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 21\n", - "...relative error = 4.42e-07\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 22\n", - "...relative error = 1.05e-07\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 23\n", - "...relative error = 9.17e-09\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 24\n", - "...relative error = 3.61e-09\n", - "-----\n", - "-----\n", - "Newton-Krylov iteration: 25\n", - "...relative error = 3.69e-10\n", - "-----\n", - "Forward static solve SUCCESS. Tolerance 3.69e-10 (vs. requested 1.00e-09) reached in 26/100 iterations.\n" - ] - } - ], + "outputs": [], "source": [ "# call the solver\n", "GSStaticSolver.solve(eq=eq, \n", @@ -914,7 +624,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -976,27 +686,9 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Forward static solve SUCCESS. Tolerance 4.52e-10 (vs. requested 1.00e-09) reached in 8/100 iterations.\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# instatiate new equilibrium object\n", "eq_general = deepcopy(eq)\n", @@ -1018,13 +710,6 @@ "plt.tight_layout()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "metadata": {}, From 8c9301ee70af7baf2e78da37cacf8112fc8548ed Mon Sep 17 00:00:00 2001 From: kpentland Date: Fri, 25 Jul 2025 17:11:27 +0100 Subject: [PATCH 13/13] black --- freegsnke/jtor_update.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/freegsnke/jtor_update.py b/freegsnke/jtor_update.py index 7d236126..64afb605 100644 --- a/freegsnke/jtor_update.py +++ b/freegsnke/jtor_update.py @@ -846,6 +846,7 @@ def assign_profile_parameter( ffp_sigma, ] + class GeneralPprimeFFprime(freegs4e.jtor.GeneralPprimeFFprime, Jtor_universal): """FreeGSNKE profile class adapting the FreeGS4E object with the same name, with a few modifications, to: @@ -873,4 +874,4 @@ def assign_profile_parameter( ): """Assigns to the profile object new values for the profile parameters""" - self.profile_parameter = [] \ No newline at end of file + self.profile_parameter = []