def test_ion_thermal_conductivity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.allclose(ct2.ion_thermal_conductivity(),
expected,
atol=1e-6 * u.W / (u.K * u.m))
errStr = (f"Ion thermal conductivity in {model} model "
f"should be close to {expected} and not "
f"{ct2.ion_thermal_conductivity()}.")
assert testTrue, errStr
class Test_classical_transport:
@classmethod
def setup_class(self):
"""set up some initial values for tests"""
u.set_enabled_equivalencies(u.temperature_energy())
self.T_e = 1000 * u.eV
self.n_e = 2e13 / u.cm**3
self.ion_particle = 'D +1'
self.m_i = particle_mass(self.ion_particle)
self.Z = integer_charge(self.ion_particle)
self.T_i = self.T_e
self.n_i = self.n_e / self.Z
self.B = 0.01 * u.T
self.coulomb_log_val_ei = 17
self.coulomb_log_val_ii = 17
self.hall_e = None
self.hall_i = None
self.V_ei = None
self.V_ii = None
self.mu = m_e / self.m_i
self.theta = self.T_e / self.T_i
self.model = 'Braginskii'
self.field_orientation = 'all'
with pytest.warns(RelativityWarning):
self.ct = ClassicalTransport(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
coulomb_log_ei=self.coulomb_log_val_ei,
coulomb_log_ii=self.coulomb_log_val_ii,
V_ei=self.V_ei,
V_ii=self.V_ii,
hall_e=self.hall_e,
hall_i=self.hall_i,
mu=self.mu,
theta=self.theta,
)
self.ct_wrapper = ClassicalTransport(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
)
self.all_variables = self.ct.all_variables()
def test_spitzer_vs_formulary(self):
"""Spitzer resistivity should agree with approx. in NRL formulary"""
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model='spitzer',
field_orientation='perp')
alpha_spitzer_perp_NRL = (1.03e-4 * ct2.Z * ct2.coulomb_log_ei *
(ct2.T_e.to(u.eV)).value**(-3 / 2) *
u.Ohm * u.m)
testTrue = np.isclose(ct2.resistivity().value,
alpha_spitzer_perp_NRL.value,
rtol=2e-2)
errStr = (f"Resistivity should be close to "
f"{alpha_spitzer_perp_NRL.value} "
f"and not {ct2.resistivity().value}.")
assert testTrue, errStr
def test_resistivity_units(self):
"""output should be a Quantity with units of Ohm m"""
testTrue = self.ct.resistivity().unit == u.Ohm * u.m
errStr = (f"Resistivity units should be {u.Ohm * u.m} and "
f"not {self.ct.resistivity().unit}.")
assert testTrue, errStr
def test_thermoelectric_conductivity_units(self):
"""output should be a Quantity with units of dimensionless"""
testTrue = self.ct.thermoelectric_conductivity().unit == u.m / u.m
errStr = (f"Thermoelectric conductivity units should be dimensionless "
f"and not {self.ct.thermoelectric_conductivity().unit}.")
assert testTrue, errStr
def test_ion_thermal_conductivity_units(self):
"""output should be Quantity with units of W / (m K)"""
testTrue = self.ct.ion_thermal_conductivity().unit == u.W / u.m / u.K
errStr = (f"Ion thermal conductivity units "
f"should be {u.W / u.m / u.K} "
f"and not {self.ct.ion_thermal_conductivity().unit}.")
assert testTrue, errStr
def test_electron_thermal_conductivity_units(self):
"""output should be Quantity with units of W / (m K)"""
testTrue = (self.ct.electron_thermal_conductivity().unit == u.W / u.m /
u.K)
errStr = (f"Electron thermal conductivity units "
f"should be {u.W / u.m / u.K} "
f"and not {self.ct.electron_thermal_conductivity().unit}.")
assert testTrue, errStr
def test_ion_viscosity_units(self):
"""output should be Quantity with units of Pa s """
testTrue = self.ct.ion_viscosity().unit == u.Pa * u.s
errStr = (f"Ion viscosity units should be {u.Pa * u.s} "
f"and not {self.ct.ion_viscosity().unit}.")
assert testTrue, errStr
def test_electron_viscosity_units(self):
"""output should be Quantity with units of Pa s"""
testTrue = self.ct.electron_viscosity().unit == u.Pa * u.s
errStr = (f"Electron viscosity units should be {u.Pa * u.s} "
f"and not {self.ct.electron_viscosity().unit}.")
assert testTrue, errStr
def test_particle_mass(self):
"""should raise ValueError if particle mass not found"""
with pytest.raises(ValueError):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle='empty moment',
Z=1)
def test_particle_charge_state(self):
"""should raise ValueError if particle charge state not found"""
with pytest.raises(InvalidParticleError):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle='empty moment',
m_i=m_p)
def test_Z_checks(self):
"""should raise ValueError if Z is negative"""
with pytest.raises(ValueError):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=-1)
def test_coulomb_log_warnings(self):
"""should warn PhysicsWarning if coulomb log is near 1"""
with pytest.warns(PhysicsWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
coulomb_log_ii=1.3)
with pytest.warns(PhysicsWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
coulomb_log_ei=1.3)
def test_coulomb_log_errors(self):
"""should raise PhysicsError if coulomb log is < 1"""
with pytest.warns(PhysicsWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
coulomb_log_ii=0.3)
with pytest.warns(PhysicsWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
coulomb_log_ei=0.3)
def test_coulomb_log_calc(self):
"""if no coulomb logs are input, they should be calculated"""
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle)
cl_ii = Coulomb_logarithm(self.T_i, self.n_e,
[self.ion_particle, self.ion_particle],
self.V_ii)
cl_ei = Coulomb_logarithm(self.T_e, self.n_e,
['e', self.ion_particle], self.V_ei)
testTrue = cl_ii == ct2.coulomb_log_ii
errStr = (f"Ion-ion coulomb logarithm should be {cl_ii} "
f"and not {ct2.coulomb_log_ii}.")
assert testTrue, errStr
testTrue = cl_ei == ct2.coulomb_log_ei
errStr = (f"Electron-ion coulomb logarithm should be {cl_ei} "
f"and not {ct2.coulomb_log_ei}.")
assert testTrue, errStr
def test_hall_calc(self):
"""if no hall parameters are input, they should be calculated"""
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle)
hall_i = Hall_parameter(ct2.n_i, ct2.T_i, ct2.B, ct2.ion_particle,
ct2.ion_particle, ct2.coulomb_log_ii,
ct2.V_ii)
hall_e = Hall_parameter(ct2.n_e, ct2.T_e, ct2.B, ct2.ion_particle,
ct2.e_particle, ct2.coulomb_log_ei,
ct2.V_ei)
testTrue = hall_i == ct2.hall_i
errStr = (f"Ion hall parameter should be {hall_i} "
f"and not {ct2.hall_i}.")
assert testTrue, errStr
testTrue = hall_e == ct2.hall_e
errStr = (f"Electron hall parameter should be {hall_e} "
f"and not {ct2.hall_e}.")
assert testTrue, errStr
def test_invalid_model(self):
with pytest.raises(ValueError):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model="standard")
def test_invalid_field(self):
with pytest.raises(ValueError):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
field_orientation='to the left')
def test_precalculated_parameters(self):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
hall_i=0,
hall_e=0)
testTrue = np.isclose(ct2.resistivity(),
2.8184954e-8 * u.Ohm * u.m,
atol=1e-6 * u.Ohm * u.m)
errStr = (
f"Resistivity should be close to "
f"{2.8184954e-8 * u.Ohm * u.m} and not {ct2.resistivity()}.")
assert testTrue, errStr
@pytest.mark.parametrize("model, method, field_orientation, expected", [
("ji-held", "resistivity", "all", 3),
("ji-held", "thermoelectric_conductivity", "all", 3),
("ji-held", "electron_thermal_conductivity", "all", 3),
("ji-held", "ion_thermal_conductivity", "all", 3),
("spitzer", "resistivity", "all", 2),
])
def test_number_of_returns(self, model, method, field_orientation,
expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model,
field_orientation=field_orientation)
method_to_call = getattr(ct2, method)
testTrue = np.size(method_to_call()) == expected
errStr = (f"{method} in {model} model returns "
f"{np.size(method_to_call())} objects. "
f"Expected to return {expected} objects.")
assert testTrue, errStr
@pytest.mark.parametrize("model, expected",
[("ji-held", 2.77028546e-8 * u.Ohm * u.m),
("spitzer", 2.78349687e-8 * u.Ohm * u.m),
("braginskii", 2.78349687e-8 * u.Ohm * u.m)])
def test_resistivity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.isclose(ct2.resistivity(),
expected,
atol=1e-6 * u.Ohm * u.m)
errStr = (f"Resistivity in {model} model should be "
f"close to {expected} and not {ct2.resistivity()}.")
assert testTrue, errStr
@pytest.mark.parametrize("model, expected",
[("ji-held", 0.702 * u.s / u.s),
("spitzer", 0.69944979 * u.s / u.s),
("braginskii", 0.711084 * u.s / u.s)])
def test_thermoelectric_conductivity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.isclose(ct2.thermoelectric_conductivity(),
expected,
atol=1e-6 * u.s / u.s)
errStr = (f"Thermoelectric conductivity in {model} model "
f"should be close {expected} and not "
f"{ct2.thermoelectric_conductivity()}.")
assert testTrue, errStr
@pytest.mark.parametrize(
"model, expected",
[("ji-held",
np.array([0.07674402, 0.07674402, 0.07674402, 0, 0]) * u.Pa * u.s),
("braginskii",
np.array([0.07674402, 0.07671874, 0.07671874, 0, 0]) * u.Pa * u.s)])
def test_electron_viscosity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.allclose(ct2.electron_viscosity(),
expected,
atol=1e-6 * u.Pa * u.s)
errStr = (
f"Electron viscosity in {model} model should be close to "
f"{expected} and not {ct2.electron_viscosity()}.")
assert testTrue, errStr
@pytest.mark.parametrize(
"model, expected",
[("ji-held",
np.array([7.96226452, 7.96226452, 7.96226452, 0, 0]) * u.Pa * u.s),
("braginskii",
np.array([7.91936173, 7.89528642, 7.89528642, 0, 0]) * u.Pa * u.s)])
def test_ion_viscosity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.allclose(ct2.ion_viscosity(),
expected,
atol=1e-6 * u.Pa * u.s)
errStr = (
f"Electron viscosity in {model} model should be close to "
f"{expected} and not {ct2.electron_viscosity()}")
assert testTrue, errStr
@pytest.mark.parametrize(
"model, expected",
[("ji-held", 5084253.556001088 * u.W / (u.K * u.m)),
("spitzer", 5082147.824377487 * u.W / (u.K * u.m)),
("braginskii", 5016895.3386957785 * u.W / (u.K * u.m))])
def test_electron_thermal_conductivity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.allclose(ct2.electron_thermal_conductivity(),
expected,
atol=1e-6 * u.W / (u.K * u.m))
errStr = (f"Electron thermal conductivity in {model} model "
f"should be close to {expected} and not "
f"{ct2.electron_thermal_conductivity()}.")
assert testTrue, errStr
@pytest.mark.parametrize(
"model, expected",
[("ji-held", 134547.55528106514 * u.W / (u.K * u.m)),
("braginskii", 133052.21732349042 * u.W / (u.K * u.m))])
def test_ion_thermal_conductivity_by_model(self, model, expected):
with pytest.warns(RelativityWarning):
ct2 = ClassicalTransport(T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
model=model)
testTrue = np.allclose(ct2.ion_thermal_conductivity(),
expected,
atol=1e-6 * u.W / (u.K * u.m))
errStr = (f"Ion thermal conductivity in {model} model "
f"should be close to {expected} and not "
f"{ct2.ion_thermal_conductivity()}.")
assert testTrue, errStr
@pytest.mark.parametrize(
"key, expected", {
'resistivity': [2.84304305e-08, 5.54447070e-08, 1.67853407e-12],
'thermoelectric conductivity':
[7.11083999e-01, 1.61011272e-09, 2.66496639e-05],
'electron thermal conductivity':
[4.91374931e+06, 2.28808496e-03, 6.90324259e+01],
'electron viscosity': [
7.51661800e-02, 5.23617668e-21, 2.09447067e-20, 1.61841341e-11,
3.23682681e-11
],
'ion thermal conductivity':
[1.41709276e+05, 4.20329493e-02, 6.90323924e+01],
'ion viscosity': [
8.43463595e+00, 8.84513731e-13, 3.53805159e-12, 2.54483240e-06,
5.08966116e-06
]
}.items())
def test_dictionary(self, key, expected):
calculated = self.all_variables[key]
testTrue = np.allclose(expected, calculated.si.value)
errStr = (f"Expected values of {key} are {expected} and not"
f"{calculated.si.value}.")
assert testTrue, errStr
def test_resistivity_wrapper(self):
with pytest.warns(RelativityWarning):
assert_quantity_allclose(
resistivity(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
), self.ct_wrapper.resistivity())
def test_thermoelectric_conductivity_wrapper(self):
with pytest.warns(RelativityWarning):
val1 = thermoelectric_conductivity(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
)
val2 = self.ct_wrapper.thermoelectric_conductivity()
assert_quantity_allclose(val1, val2)
def test_ion_thermal_conductivity_wrapper(self):
with pytest.warns(RelativityWarning):
wrapped = ion_thermal_conductivity(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
)
assert_quantity_allclose(
wrapped, self.ct_wrapper.ion_thermal_conductivity())
def test_electron_thermal_conductivity_wrapper(self):
with pytest.warns(RelativityWarning):
wrapped = electron_thermal_conductivity(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
)
assert_quantity_allclose(
wrapped, self.ct_wrapper.electron_thermal_conductivity())
def test_ion_viscosity_wrapper(self):
with pytest.warns(RelativityWarning):
assert_quantity_allclose(
ion_viscosity(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
), self.ct_wrapper.ion_viscosity())
def test_electron_viscosity_wrapper(self):
with pytest.warns(RelativityWarning):
assert_quantity_allclose(
electron_viscosity(
T_e=self.T_e,
n_e=self.n_e,
T_i=self.T_i,
n_i=self.n_i,
ion_particle=self.ion_particle,
Z=self.Z,
B=self.B,
model=self.model,
field_orientation=self.field_orientation,
mu=self.mu,
theta=self.theta,
), self.ct_wrapper.electron_viscosity())
