diff --git a/process/core/init.py b/process/core/init.py index badd1c714..d5ed1f892 100644 --- a/process/core/init.py +++ b/process/core/init.py @@ -19,7 +19,6 @@ from process.data_structure.impurity_radiation_module import ( init_impurity_radiation_module, ) -from process.data_structure.neoclassics_variables import init_neoclassics_variables from process.data_structure.physics_variables import ( init_physics_module, init_physics_variables, @@ -250,7 +249,6 @@ def init_all_module_vars(): init_tfcoil_variables() constants.init_constants() init_rebco_variables() - init_neoclassics_variables() def check_process(inputs, data): # noqa: ARG001 diff --git a/process/core/model.py b/process/core/model.py index 37ae1e4e9..e2cdb4839 100644 --- a/process/core/model.py +++ b/process/core/model.py @@ -16,6 +16,7 @@ from process.data_structure.fwbs_variables import FWBSData from process.data_structure.heat_transport_variables import HeatTransportData from process.data_structure.ife_variables import IFEData +from process.data_structure.neoclassics_variables import NeoclassicsData from process.data_structure.pf_power_variables import PFPowerData from process.data_structure.pfcoil_variables import PFCoilData from process.data_structure.power_variables import PowerData @@ -61,6 +62,7 @@ class DataStructure: stellarator: StellaratorData = initialise_later stellarator_config: StellaratorConfigData = initialise_later pf_power: PFPowerData = initialise_later + neoclassics: NeoclassicsData = initialise_later def __post_init__(self): for f in fields(self): diff --git a/process/data_structure/neoclassics_variables.py b/process/data_structure/neoclassics_variables.py index 606ed4df9..74380c537 100644 --- a/process/data_structure/neoclassics_variables.py +++ b/process/data_structure/neoclassics_variables.py @@ -4,128 +4,85 @@ Beidler (2013), https://doi.org/10.1088/0029-5515/51/7/076001 """ +from dataclasses import dataclass, field + import numpy as np NO_ROOTS = 30 """Number of Gauss laguerre roots""" -densities: list[float] = None -"""Densities of the species that are considered [/m3]""" -temperatures: list[float] = None -"""Temperature of the species that are considered [J]""" +@dataclass +class NeoclassicsData: + densities: list[float] = field(default_factory=lambda: np.zeros(4)) + """Densities of the species that are considered [/m3]""" -dr_densities: list[float] = None -"""Radial derivative of the density of the species [/m3]""" + temperatures: list[float] = field(default_factory=lambda: np.zeros(4)) + """Temperature of the species that are considered [J]""" -dr_temperatures: list[float] = None -"""Radial derivative of the temperature of the species [J]""" + dr_densities: list[float] = field(default_factory=lambda: np.zeros(4)) + """Radial derivative of the density of the species [/m3]""" -roots: list[float] = None -"""Gauss Laguerre Roots""" + dr_temperatures: list[float] = field(default_factory=lambda: np.zeros(4)) + """Radial derivative of the temperature of the species [J]""" -weights: list[float] = None -"""Gauss Laguerre Weights""" + roots: list[float] = field(default_factory=lambda: np.zeros(NO_ROOTS)) + """Gauss Laguerre Roots""" -nu: list[float] = None -"""90-degree deflection frequency on GL roots""" + weights: list[float] = field(default_factory=lambda: np.zeros(NO_ROOTS)) + """Gauss Laguerre Weights""" -nu_star: list[float] = None -"""Dimensionless deflection frequency""" + nu: list[float] = field(default_factory=lambda: np.zeros((4, NO_ROOTS))) + """90-degree deflection frequency on GL roots""" -nu_star_averaged: list[float] = None -"""Maxwellian averaged dimensionless 90-degree deflection frequency for electrons (index 1) and ions (index 2)""" + nu_star: list[float] = field(default_factory=lambda: np.zeros((4, NO_ROOTS))) + """Dimensionless deflection frequency""" -vd: list[float] = None -"""Drift velocity on GL roots""" + nu_star_averaged: list[float] = field(default_factory=lambda: np.zeros(4)) + """Maxwellian averaged dimensionless 90-degree deflection frequency for electrons (index 1) and ions (index 2)""" -kt: list[float] = None -"""Thermal energy on GL roots""" + vd: list[float] = field(default_factory=lambda: np.zeros((4, NO_ROOTS))) + """Drift velocity on GL roots""" -er: float = None -"""Radial electrical field [V/m]""" + kt: list[float] = field(default_factory=lambda: np.zeros((4, NO_ROOTS))) + """Thermal energy on GL roots""" -iota: float = None -"""Iota (1/safety factor)""" + er: float = 0.0 + """Radial electrical field [V/m]""" -d11_mono: list[float] = None -"""Radial monoenergetic transport coefficient on GL roots (species dependent)""" + iota: float = 1.0 + """Iota (1/safety factor)""" + + d11_mono: list[float] = field(default_factory=lambda: np.zeros((4, NO_ROOTS))) + """Radial monoenergetic transport coefficient on GL roots (species dependent)""" + + d11_plateau: list[float] = field(default_factory=lambda: np.zeros((4, NO_ROOTS))) + """Toroidal monoenergetic transport coefficient as given by the stellarator + input json file as function of nu_star, normalised by the banana value. + """ + + d111: list[float] = field(default_factory=lambda: np.zeros(4)) + """Radial integrated transport coefficient (n=1) (species dependent)""" + + d112: list[float] = field(default_factory=lambda: np.zeros(4)) + """Radial integrated transport coefficient (n=2) (species dependent)""" + + d113: list[float] = field(default_factory=lambda: np.zeros(4)) + """Radial integrated transport coefficient (n=3) (species dependent)""" + + q_flux: list[float] = field(default_factory=lambda: np.zeros(4)) + """energy transport flux (J/m2)""" + + gamma_flux: list[float] = field(default_factory=lambda: np.zeros(4)) + """energy flux from particle transport""" + + d31_mono: list[float] = field(default_factory=lambda: np.zeros(NO_ROOTS)) + """Toroidal monoenergetic transport coefficient""" + + eps_eff: float = 1e-5 + """Epsilon effective (used in neoclassics_calc_D11_mono)""" + + r_eff: float = 0.0 -d11_plateau: list[float] = None -"""Toroidal monoenergetic transport coefficient as given by the stellarator -input json file as function of nu_star, normalised by the banana value. -""" -d111: list[float] = None -"""Radial integrated transport coefficient (n=1) (species dependent)""" - -d112: list[float] = None -"""Radial integrated transport coefficient (n=2) (species dependent)""" - -d113: list[float] = None -"""Radial integrated transport coefficient (n=3) (species dependent)""" - -q_flux: list[float] = None -"""energy transport flux (J/m2)""" - -gamma_flux: list[float] = None -"""energy flux from particle transport""" - -d31_mono: list[float] = None -"""Toroidal monoenergetic transport coefficient""" - -eps_eff: float = None -"""Epsilon effective (used in neoclassics_calc_D11_mono)""" - -r_eff: float = None - - -def init_neoclassics_variables(): - global \ - densities, \ - temperatures, \ - dr_densities, \ - dr_temperatures, \ - roots, \ - weights, \ - nu, \ - nu_star, \ - nu_star_averaged, \ - vd, \ - kt, \ - er, \ - iota, \ - d11_mono, \ - d11_plateau, \ - d111, \ - d112, \ - d113, \ - q_flux, \ - gamma_flux, \ - d31_mono, \ - eps_eff, \ - r_eff - - densities = np.zeros(4) - temperatures = np.zeros(4) - dr_densities = np.zeros(4) - dr_temperatures = np.zeros(4) - roots = np.zeros(NO_ROOTS) - weights = np.zeros(NO_ROOTS) - nu = np.zeros((4, NO_ROOTS)) - nu_star = np.zeros((4, NO_ROOTS)) - nu_star_averaged = np.zeros(4) - vd = np.zeros((4, NO_ROOTS)) - kt = np.zeros((4, NO_ROOTS)) - iota = 1.0 - d11_mono = np.zeros((4, NO_ROOTS)) - d11_plateau = np.zeros((4, NO_ROOTS)) - d111 = np.zeros(4) - d112 = np.zeros(4) - d113 = np.zeros(4) - q_flux = np.zeros(4) - gamma_flux = np.zeros(4) - d31_mono = np.zeros(NO_ROOTS) - eps_eff = 1e-5 - r_eff = 0.0 - er = 0.0 +CREATE_DICTS_FROM_DATACLASS = NeoclassicsData diff --git a/process/models/stellarator/neoclassics.py b/process/models/stellarator/neoclassics.py index 99644fd72..07fc4f642 100644 --- a/process/models/stellarator/neoclassics.py +++ b/process/models/stellarator/neoclassics.py @@ -6,7 +6,6 @@ from process.core.model import Model from process.data_structure import ( impurity_radiation_module, - neoclassics_variables, physics_variables, ) from process.models.stellarator.stellarator import KEV @@ -17,7 +16,7 @@ class Neoclassics(Model): @property def no_roots(self): - return neoclassics_variables.roots.shape[0] + return self.data.neoclassics.roots.shape[0] def output(self): """This model doesn't have any output""" @@ -39,12 +38,12 @@ def init_neoclassics(self, r_effin, eps_effin, iotain): """ ( - neoclassics_variables.densities, - neoclassics_variables.temperatures, - neoclassics_variables.dr_densities, - neoclassics_variables.dr_temperatures, + self.data.neoclassics.densities, + self.data.neoclassics.temperatures, + self.data.neoclassics.dr_densities, + self.data.neoclassics.dr_temperatures, ) = self.init_profile_values_from_PROCESS(r_effin) - neoclassics_variables.roots = np.array([ + self.data.neoclassics.roots = np.array([ 4.740718054080526184e-2, 2.499239167531593919e-1, 6.148334543927683749e-1, @@ -76,7 +75,7 @@ def init_neoclassics(self, r_effin, eps_effin, iotain): 9.155646652253683726e1, 1.041575244310588886e2, ]) - neoclassics_variables.weights = np.array([ + self.data.neoclassics.weights = np.array([ 1.160440860204388913e-1, 2.208511247506771413e-1, 2.413998275878537214e-1, @@ -109,37 +108,37 @@ def init_neoclassics(self, r_effin, eps_effin, iotain): 8.745980440465011553e-45, ]) - neoclassics_variables.kt = self.neoclassics_calc_KT() - neoclassics_variables.nu = self.neoclassics_calc_nu() - neoclassics_variables.nu_star = self.neoclassics_calc_nu_star() - neoclassics_variables.nu_star_averaged = self.neoclassics_calc_nu_star_fromT( + self.data.neoclassics.kt = self.neoclassics_calc_KT() + self.data.neoclassics.nu = self.neoclassics_calc_nu() + self.data.neoclassics.nu_star = self.neoclassics_calc_nu_star() + self.data.neoclassics.nu_star_averaged = self.neoclassics_calc_nu_star_fromT( iotain ) - neoclassics_variables.vd = self.neoclassics_calc_vd() + self.data.neoclassics.vd = self.neoclassics_calc_vd() - neoclassics_variables.d11_plateau = self.neoclassics_calc_D11_plateau() + self.data.neoclassics.d11_plateau = self.neoclassics_calc_D11_plateau() - neoclassics_variables.d11_mono = self.neoclassics_calc_d11_mono( + self.data.neoclassics.d11_mono = self.neoclassics_calc_d11_mono( eps_effin ) # for using epseff - neoclassics_variables.d111 = self.calc_integrated_radial_transport_coeffs( + self.data.neoclassics.d111 = self.calc_integrated_radial_transport_coeffs( index=1 ) - neoclassics_variables.d112 = self.calc_integrated_radial_transport_coeffs( + self.data.neoclassics.d112 = self.calc_integrated_radial_transport_coeffs( index=2 ) - neoclassics_variables.d113 = self.calc_integrated_radial_transport_coeffs( + self.data.neoclassics.d113 = self.calc_integrated_radial_transport_coeffs( index=3 ) - neoclassics_variables.gamma_flux = self.neoclassics_calc_gamma_flux( - neoclassics_variables.densities, - neoclassics_variables.temperatures, - neoclassics_variables.dr_densities, - neoclassics_variables.dr_temperatures, + self.data.neoclassics.gamma_flux = self.neoclassics_calc_gamma_flux( + self.data.neoclassics.densities, + self.data.neoclassics.temperatures, + self.data.neoclassics.dr_densities, + self.data.neoclassics.dr_temperatures, ) - neoclassics_variables.q_flux = self.neoclassics_calc_q_flux() + self.data.neoclassics.q_flux = self.neoclassics_calc_q_flux() def init_profile_values_from_PROCESS(self, rho): """Initialises the profile_values object from PROCESS' parabolic profiles @@ -310,15 +309,15 @@ def calc_neoclassics(self): / physics_variables.a_plasma_surface ) - q_neo = sum(neoclassics_variables.q_flux * 1e-6) + q_neo = sum(self.data.neoclassics.q_flux * 1e-6) gamma_neo = sum( - neoclassics_variables.gamma_flux * neoclassics_variables.temperatures * 1e-6 + self.data.neoclassics.gamma_flux * self.data.neoclassics.temperatures * 1e-6 ) total_q_neo = sum( - neoclassics_variables.q_flux * 1e-6 - + neoclassics_variables.gamma_flux - * neoclassics_variables.temperatures + self.data.neoclassics.q_flux * 1e-6 + + self.data.neoclassics.gamma_flux + * self.data.neoclassics.temperatures * 1e-6 ) @@ -326,43 +325,43 @@ def calc_neoclassics(self): 2 * 2 * ( - neoclassics_variables.q_flux[0] * 1e-6 - + neoclassics_variables.gamma_flux[0] - * neoclassics_variables.temperatures[0] + self.data.neoclassics.q_flux[0] * 1e-6 + + self.data.neoclassics.gamma_flux[0] + * self.data.neoclassics.temperatures[0] * 1e-6 ) ) - q_neo_e = neoclassics_variables.q_flux[0] * 1e-6 - q_neo_D = neoclassics_variables.q_flux[1] * 1e-6 - q_neo_a = neoclassics_variables.q_flux[3] * 1e-6 - q_neo_T = neoclassics_variables.q_flux[2] * 1e-6 + q_neo_e = self.data.neoclassics.q_flux[0] * 1e-6 + q_neo_D = self.data.neoclassics.q_flux[1] * 1e-6 + q_neo_a = self.data.neoclassics.q_flux[3] * 1e-6 + q_neo_T = self.data.neoclassics.q_flux[2] * 1e-6 g_neo_e = ( - neoclassics_variables.gamma_flux[0] + self.data.neoclassics.gamma_flux[0] * 1e-6 - * neoclassics_variables.temperatures[0] + * self.data.neoclassics.temperatures[0] ) g_neo_D = ( - neoclassics_variables.gamma_flux[1] + self.data.neoclassics.gamma_flux[1] * 1e-6 - * neoclassics_variables.temperatures[1] + * self.data.neoclassics.temperatures[1] ) g_neo_a = ( - neoclassics_variables.gamma_flux[3] + self.data.neoclassics.gamma_flux[3] * 1e-6 - * neoclassics_variables.temperatures[3] + * self.data.neoclassics.temperatures[3] ) g_neo_T = ( - neoclassics_variables.gamma_flux[2] + self.data.neoclassics.gamma_flux[2] * 1e-6 - * neoclassics_variables.temperatures[2] + * self.data.neoclassics.temperatures[2] ) - dndt_neo_e = neoclassics_variables.gamma_flux[0] - dndt_neo_D = neoclassics_variables.gamma_flux[1] - dndt_neo_a = neoclassics_variables.gamma_flux[3] - dndt_neo_T = neoclassics_variables.gamma_flux[2] + dndt_neo_e = self.data.neoclassics.gamma_flux[0] + dndt_neo_D = self.data.neoclassics.gamma_flux[1] + dndt_neo_a = self.data.neoclassics.gamma_flux[3] + dndt_neo_T = self.data.neoclassics.gamma_flux[2] dndt_neo_fuel = ( (dndt_neo_D + dndt_neo_T) @@ -383,20 +382,20 @@ def calc_neoclassics(self): ) # kg chi_neo_e = -( - neoclassics_variables.q_flux[0] - + neoclassics_variables.gamma_flux[0] * neoclassics_variables.temperatures[0] + self.data.neoclassics.q_flux[0] + + self.data.neoclassics.gamma_flux[0] * self.data.neoclassics.temperatures[0] ) / ( - neoclassics_variables.densities[0] * neoclassics_variables.dr_temperatures[0] - + neoclassics_variables.temperatures[0] - * neoclassics_variables.dr_densities[0] + self.data.neoclassics.densities[0] * self.data.neoclassics.dr_temperatures[0] + + self.data.neoclassics.temperatures[0] + * self.data.neoclassics.dr_densities[0] ) chi_PROCESS_e = self.st_calc_eff_chi() - nu_star_e = neoclassics_variables.nu_star_averaged[0] - nu_star_d = neoclassics_variables.nu_star_averaged[1] - nu_star_T = neoclassics_variables.nu_star_averaged[2] - nu_star_He = neoclassics_variables.nu_star_averaged[3] + nu_star_e = self.data.neoclassics.nu_star_averaged[0] + nu_star_d = self.data.neoclassics.nu_star_averaged[1] + nu_star_T = self.data.neoclassics.nu_star_averaged[2] + nu_star_He = self.data.neoclassics.nu_star_averaged[3] return ( q_PROCESS, @@ -432,9 +431,9 @@ def neoclassics_calc_KT(self): """Calculates the energy on the given grid which is given by the gauss laguerre roots. """ - k = np.repeat((neoclassics_variables.roots / KEV)[:, np.newaxis], 4, axis=1) + k = np.repeat((self.data.neoclassics.roots / KEV)[:, np.newaxis], 4, axis=1) - return (k * neoclassics_variables.temperatures).T + return (k * self.data.neoclassics.temperatures).T def neoclassics_calc_nu(self): """Calculates the collision frequency""" @@ -450,22 +449,22 @@ def neoclassics_calc_nu(self): # Formula from L. Spitzer.Physics of fully ionized gases. Interscience, New York, 1962 lnlambda = ( 32.2 - - 1.15 * np.log10(neoclassics_variables.densities[0]) + - 1.15 * np.log10(self.data.neoclassics.densities[0]) + 2.3 - * np.log10(neoclassics_variables.temperatures[0] / constants.ELECTRON_CHARGE) + * np.log10(self.data.neoclassics.temperatures[0] / constants.ELECTRON_CHARGE) ) neoclassics_calc_nu = np.zeros((4, self.no_roots), order="F") for j in range(4): for i in range(self.no_roots): - x = neoclassics_variables.roots[i] + x = self.data.neoclassics.roots[i] for k in range(4): xk = ( (mass[k] / mass[j]) * ( - neoclassics_variables.temperatures[j] - / neoclassics_variables.temperatures[k] + self.data.neoclassics.temperatures[j] + / self.data.neoclassics.temperatures[k] ) * x ) @@ -487,10 +486,10 @@ def neoclassics_calc_nu(self): ) phixmgx = (1.0 - 0.5 / xk) * erfn + expxk / np.sqrt(np.pi * xk) v = np.sqrt( - 2.0 * x * neoclassics_variables.temperatures[j] / mass[j] + 2.0 * x * self.data.neoclassics.temperatures[j] / mass[j] ) neoclassics_calc_nu[j, i] += ( - neoclassics_variables.densities[k] + self.data.neoclassics.densities[k] * (z[j] * z[k]) ** 2 * lnlambda * phixmgx @@ -501,8 +500,8 @@ def neoclassics_calc_nu(self): def neoclassics_calc_nu_star(self): """Calculates the normalized collision frequency""" - k = np.repeat(neoclassics_variables.roots[:, np.newaxis], 4, axis=1) - kk = (k * neoclassics_variables.temperatures).T + k = np.repeat(self.data.neoclassics.roots[:, np.newaxis], 4, axis=1) + kk = (k * self.data.neoclassics.temperatures).T mass = np.array([ constants.ELECTRON_MASS, @@ -527,8 +526,8 @@ def neoclassics_calc_nu_star(self): return ( physics_variables.rmajor - * neoclassics_variables.nu - / (neoclassics_variables.iota * v) + * self.data.neoclassics.nu + / (self.data.neoclassics.iota * v) ) def neoclassics_calc_nu_star_fromT(self, iota): @@ -613,8 +612,8 @@ def neoclassics_calc_nu_star_fromT(self, iota): def neoclassics_calc_vd(self): vde = ( - neoclassics_variables.roots - * neoclassics_variables.temperatures[0] + self.data.neoclassics.roots + * self.data.neoclassics.temperatures[0] / ( constants.ELECTRON_CHARGE * physics_variables.rmajor @@ -622,8 +621,8 @@ def neoclassics_calc_vd(self): ) ) vdD = ( - neoclassics_variables.roots - * neoclassics_variables.temperatures[1] + self.data.neoclassics.roots + * self.data.neoclassics.temperatures[1] / ( constants.ELECTRON_CHARGE * physics_variables.rmajor @@ -631,8 +630,8 @@ def neoclassics_calc_vd(self): ) ) vdT = ( - neoclassics_variables.roots - * neoclassics_variables.temperatures[2] + self.data.neoclassics.roots + * self.data.neoclassics.temperatures[2] / ( constants.ELECTRON_CHARGE * physics_variables.rmajor @@ -640,8 +639,8 @@ def neoclassics_calc_vd(self): ) ) vda = ( - neoclassics_variables.roots - * neoclassics_variables.temperatures[3] + self.data.neoclassics.roots + * self.data.neoclassics.temperatures[3] / ( 2.0 * constants.ELECTRON_CHARGE @@ -671,31 +670,31 @@ def neoclassics_calc_D11_plateau(self): v = np.empty((4, self.no_roots)) v[0, :] = constants.SPEED_LIGHT * np.sqrt( 1.0 - - (neoclassics_variables.kt[0, :] / (mass[0] * constants.SPEED_LIGHT**2) + 1) + - (self.data.neoclassics.kt[0, :] / (mass[0] * constants.SPEED_LIGHT**2) + 1) ** (-1) ) v[1, :] = constants.SPEED_LIGHT * np.sqrt( 1.0 - - (neoclassics_variables.kt[1, :] / (mass[1] * constants.SPEED_LIGHT**2) + 1) + - (self.data.neoclassics.kt[1, :] / (mass[1] * constants.SPEED_LIGHT**2) + 1) ** (-1) ) v[2, :] = constants.SPEED_LIGHT * np.sqrt( 1.0 - - (neoclassics_variables.kt[2, :] / (mass[2] * constants.SPEED_LIGHT**2) + 1) + - (self.data.neoclassics.kt[2, :] / (mass[2] * constants.SPEED_LIGHT**2) + 1) ** (-1) ) v[3, :] = constants.SPEED_LIGHT * np.sqrt( 1.0 - - (neoclassics_variables.kt[3, :] / (mass[3] * constants.SPEED_LIGHT**2) + 1) + - (self.data.neoclassics.kt[3, :] / (mass[3] * constants.SPEED_LIGHT**2) + 1) ** (-1) ) return ( np.pi / 4.0 - * neoclassics_variables.vd**2 + * self.data.neoclassics.vd**2 * physics_variables.rmajor - / neoclassics_variables.iota + / self.data.neoclassics.iota / v ) @@ -712,8 +711,8 @@ def neoclassics_calc_d11_mono(self, eps_eff): 4.0 / (9.0 * np.pi) * (2.0 * eps_eff) ** (3.0 / 2.0) - * neoclassics_variables.vd**2 - / neoclassics_variables.nu + * self.data.neoclassics.vd**2 + / self.data.neoclassics.nu ) def calc_integrated_radial_transport_coeffs(self, index: int): @@ -729,9 +728,9 @@ def calc_integrated_radial_transport_coeffs(self, index: int): return np.sum( 2.0 / np.sqrt(np.pi) - * neoclassics_variables.d11_mono - * neoclassics_variables.roots ** (index - 0.5) - * neoclassics_variables.weights, + * self.data.neoclassics.d11_mono + * self.data.neoclassics.roots ** (index - 0.5) + * self.data.neoclassics.weights, axis=1, ) @@ -755,10 +754,10 @@ def neoclassics_calc_gamma_flux( return ( -densities - * neoclassics_variables.d111 + * self.data.neoclassics.d111 * ( - (dr_densities / densities - z * neoclassics_variables.er / temperatures) - + (neoclassics_variables.d112 / neoclassics_variables.d111 - 3.0 / 2.0) + (dr_densities / densities - z * self.data.neoclassics.er / temperatures) + + (self.data.neoclassics.d112 / self.data.neoclassics.d111 - 3.0 / 2.0) * dr_temperatures / temperatures ) @@ -769,17 +768,17 @@ def neoclassics_calc_q_flux(self): z = np.array([-1.0, 1.0, 1.0, 2.0]) return ( - -neoclassics_variables.densities - * neoclassics_variables.temperatures - * neoclassics_variables.d112 + -self.data.neoclassics.densities + * self.data.neoclassics.temperatures + * self.data.neoclassics.d112 * ( ( - neoclassics_variables.dr_densities / neoclassics_variables.densities - - z * neoclassics_variables.er / neoclassics_variables.temperatures + self.data.neoclassics.dr_densities / self.data.neoclassics.densities + - z * self.data.neoclassics.er / self.data.neoclassics.temperatures ) - + (neoclassics_variables.d113 / neoclassics_variables.d112 - 3.0 / 2.0) - * neoclassics_variables.dr_temperatures - / neoclassics_variables.temperatures + + (self.data.neoclassics.d113 / self.data.neoclassics.d112 - 3.0 / 2.0) + * self.data.neoclassics.dr_temperatures + / self.data.neoclassics.temperatures ) ) diff --git a/tests/unit/models/stellarator/test_neoclassics.py b/tests/unit/models/stellarator/test_neoclassics.py index c02217eee..b96e0eefc 100644 --- a/tests/unit/models/stellarator/test_neoclassics.py +++ b/tests/unit/models/stellarator/test_neoclassics.py @@ -3,18 +3,17 @@ import numpy as np import pytest -from process.data_structure import neoclassics_variables, physics_variables -from process.models.stellarator.neoclassics import Neoclassics +from process.data_structure import physics_variables @pytest.fixture -def neoclassics(): +def neoclassics(process_models): """Provides Neoclassics object for testing. :returns: initialised Neoclassics object :rtype: process.stellerator.Neoclassics """ - return Neoclassics() + return process_models.neoclassics class InitNeoclassicsParam(NamedTuple): @@ -1027,29 +1026,45 @@ def test_init_neoclassics(initneoclassicsparam, monkeypatch, neoclassics): initneoclassicsparam.nd_plasma_fuel_ions_vol_avg, ) monkeypatch.setattr( - neoclassics_variables, "densities", initneoclassicsparam.densities + neoclassics.data.neoclassics, "densities", initneoclassicsparam.densities ) monkeypatch.setattr( - neoclassics_variables, "temperatures", initneoclassicsparam.temperatures + neoclassics.data.neoclassics, "temperatures", initneoclassicsparam.temperatures ) monkeypatch.setattr( - neoclassics_variables, "dr_densities", initneoclassicsparam.dr_densities + neoclassics.data.neoclassics, "dr_densities", initneoclassicsparam.dr_densities ) monkeypatch.setattr( - neoclassics_variables, "dr_temperatures", initneoclassicsparam.dr_temperatures + neoclassics.data.neoclassics, + "dr_temperatures", + initneoclassicsparam.dr_temperatures, ) - monkeypatch.setattr(neoclassics_variables, "roots", initneoclassicsparam.roots) - monkeypatch.setattr(neoclassics_variables, "weights", initneoclassicsparam.weights) - monkeypatch.setattr(neoclassics_variables, "nu", initneoclassicsparam.nu) - monkeypatch.setattr(neoclassics_variables, "nu_star", initneoclassicsparam.nu_star) monkeypatch.setattr( - neoclassics_variables, "nu_star_averaged", initneoclassicsparam.nu_star_averaged + neoclassics.data.neoclassics, "roots", initneoclassicsparam.roots + ) + monkeypatch.setattr( + neoclassics.data.neoclassics, "weights", initneoclassicsparam.weights + ) + monkeypatch.setattr(neoclassics.data.neoclassics, "nu", initneoclassicsparam.nu) + monkeypatch.setattr( + neoclassics.data.neoclassics, "nu_star", initneoclassicsparam.nu_star + ) + monkeypatch.setattr( + neoclassics.data.neoclassics, + "nu_star_averaged", + initneoclassicsparam.nu_star_averaged, + ) + monkeypatch.setattr(neoclassics.data.neoclassics, "vd", initneoclassicsparam.vd) + monkeypatch.setattr(neoclassics.data.neoclassics, "iota", initneoclassicsparam.iota) + monkeypatch.setattr( + neoclassics.data.neoclassics, "q_flux", initneoclassicsparam.q_flux + ) + monkeypatch.setattr( + neoclassics.data.neoclassics, "eps_eff", initneoclassicsparam.eps_eff + ) + monkeypatch.setattr( + neoclassics.data.neoclassics, "r_eff", initneoclassicsparam.r_eff ) - monkeypatch.setattr(neoclassics_variables, "vd", initneoclassicsparam.vd) - monkeypatch.setattr(neoclassics_variables, "iota", initneoclassicsparam.iota) - monkeypatch.setattr(neoclassics_variables, "q_flux", initneoclassicsparam.q_flux) - monkeypatch.setattr(neoclassics_variables, "eps_eff", initneoclassicsparam.eps_eff) - monkeypatch.setattr(neoclassics_variables, "r_eff", initneoclassicsparam.r_eff) neoclassics.init_neoclassics( r_effin=initneoclassicsparam.r_effin, @@ -1057,36 +1072,36 @@ def test_init_neoclassics(initneoclassicsparam, monkeypatch, neoclassics): iotain=initneoclassicsparam.iotain, ) - assert neoclassics_variables.densities == pytest.approx( + assert neoclassics.data.neoclassics.densities == pytest.approx( initneoclassicsparam.expected_densities, rel=0.001 ) - assert neoclassics_variables.temperatures == pytest.approx( + assert neoclassics.data.neoclassics.temperatures == pytest.approx( initneoclassicsparam.expected_temperatures, rel=0.001 ) - assert neoclassics_variables.dr_densities == pytest.approx( + assert neoclassics.data.neoclassics.dr_densities == pytest.approx( initneoclassicsparam.expected_dr_densities, rel=0.001 ) - assert neoclassics_variables.dr_temperatures == pytest.approx( + assert neoclassics.data.neoclassics.dr_temperatures == pytest.approx( initneoclassicsparam.expected_dr_temperatures, rel=0.001 ) - assert neoclassics_variables.roots == pytest.approx( + assert neoclassics.data.neoclassics.roots == pytest.approx( initneoclassicsparam.expected_roots, rel=0.001 ) - assert neoclassics_variables.weights == pytest.approx( + assert neoclassics.data.neoclassics.weights == pytest.approx( initneoclassicsparam.expected_weights, rel=0.001 ) - assert neoclassics_variables.nu == pytest.approx( + assert neoclassics.data.neoclassics.nu == pytest.approx( initneoclassicsparam.expected_nu, rel=0.001 ) - assert neoclassics_variables.nu_star == pytest.approx( + assert neoclassics.data.neoclassics.nu_star == pytest.approx( initneoclassicsparam.expected_nu_star, rel=0.001 ) - assert neoclassics_variables.nu_star_averaged == pytest.approx( + assert neoclassics.data.neoclassics.nu_star_averaged == pytest.approx( initneoclassicsparam.expected_nu_star_averaged, rel=0.001 ) - assert neoclassics_variables.vd == pytest.approx( + assert neoclassics.data.neoclassics.vd == pytest.approx( initneoclassicsparam.expected_vd, rel=0.001 ) - assert neoclassics_variables.q_flux == pytest.approx( + assert neoclassics.data.neoclassics.q_flux == pytest.approx( initneoclassicsparam.expected_q_flux, rel=0.001 )