def test_lower_hybrid_frequency():
r"""Test the lower_hybrid_frequency function in parameters.py."""
ion = 'He-4 1+'
omega_ci = gyrofrequency(B, particle=ion)
omega_pi = plasma_frequency(n=n_i, particle=ion)
omega_ce = gyrofrequency(B)
omega_lh = lower_hybrid_frequency(B, n_i=n_i, ion=ion)
assert omega_ci.unit.is_equivalent(u.rad / u.s)
assert omega_pi.unit.is_equivalent(u.rad / u.s)
assert omega_ce.unit.is_equivalent(u.rad / u.s)
assert omega_lh.unit.is_equivalent(u.rad / u.s)
left_hand_side = omega_lh**-2
right_hand_side = 1 / (omega_ci**2 +
omega_pi**2) + omega_ci**-1 * omega_ce**-1
assert np.isclose(left_hand_side.value, right_hand_side.value)
with pytest.raises(ValueError):
lower_hybrid_frequency(0.2 * u.T, n_i=5e19 * u.m**-3, ion='asdfasd')
with pytest.raises(ValueError):
lower_hybrid_frequency(0.2 * u.T, n_i=-5e19 * u.m**-3, ion='asdfasd')
with pytest.raises(ValueError):
lower_hybrid_frequency(np.nan * u.T,
n_i=-5e19 * u.m**-3,
ion='asdfasd')
with pytest.warns(u.UnitsWarning):
assert lower_hybrid_frequency(1.3, 1e19) == lower_hybrid_frequency(
1.3 * u.T, 1e19 * u.m**-3)
assert_can_handle_nparray(lower_hybrid_frequency)
def cold_plasma_LRP(B, species, n, omega ,flag= True ):
"""
@param B: Magnetic field in z direction
@param species: ['e','p'] means electrons and protons
@param n: The density of different species
@param omega: wave_frequency
@param flag: if flag == 1 then omega means to be a number, if flag is not True the omega means a symbol
@return: (l, R, P)
"""
if flag:
wave_frequency = omega
w = wave_frequency.value
else:
wave_frequency = symbols('w')
w = wave_frequency
L, R, P = 1, 1, 1
for s, n_s in zip(species, n):
omega_c = parameters.gyrofrequency(B=B, particle=s, signed=True)
omega_p = parameters.plasma_frequency(n=n_s, particle=s)
L += - omega_p.value ** 2 / (w * (w - omega_c.value))
R += - omega_p.value ** 2 / (w * (w + omega_c.value))
P += - omega_p.value ** 2 / w ** 2
return L, R, P
def test_upper_hybrid_frequency():
r"""Test the upper_hybrid_frequency function in parameters.py."""
omega_uh = upper_hybrid_frequency(B, n_e=n_e)
omega_ce = gyrofrequency(B)
omega_pe = plasma_frequency(n=n_e)
assert omega_ce.unit.is_equivalent(u.rad / u.s)
assert omega_pe.unit.is_equivalent(u.rad / u.s)
assert omega_uh.unit.is_equivalent(u.rad / u.s)
left_hand_side = omega_uh**2
right_hand_side = omega_ce**2 + omega_pe**2
assert np.isclose(left_hand_side.value, right_hand_side.value)
with pytest.raises(ValueError):
upper_hybrid_frequency(5 * u.T, n_e=-1 * u.m**-3)
with pytest.warns(u.UnitsWarning):
assert upper_hybrid_frequency(1.2, 1.3) == upper_hybrid_frequency(
1.2 * u.T, 1.3 * u.m**-3)
with pytest.warns(u.UnitsWarning):
assert upper_hybrid_frequency(1.4 * u.T,
1.3) == upper_hybrid_frequency(
1.4, 1.3 * u.m**-3)
assert_can_handle_nparray(upper_hybrid_frequency)
def __init__(self, name, density, magnetic_field, Tx, Tz):
self.name = name
self.density = density
self.gyro_f = parameters.gyrofrequency(B=magnetic_field,
particle=name,
signed=True)
self.plasma_f = parameters.plasma_frequency(density, particle=name)
self.Tx = Tx
self.Tz = Tz
self.vth_x = parameters.thermal_speed(Tx * u.K, name).value
self.vth_z = parameters.thermal_speed(Tz * u.K, name).value
def anisotropy(name, density, B, T_perp, T_para, waveperOmega, distribution):
if name == 'e':
n = density[0]
else:
n = density[1]
electron = particle.particles(name, n, B, T_perp, T_para)
species = ['e', 'p']
theta_input = 0
theta_deg = theta_input * pi / 180
vx = symbols('vx')
vz = symbols('vz')
vth_x = symbols('vth_x')
vth_z = symbols('vth_z')
G1_term1, G1_term2 = electron.G_1(distribution)
if distribution == 'drift':
f = electron.F_1()
else:
f = electron.F_0()
gyro_frequency = parameters.gyrofrequency(B, name)
wave_frequency = waveperOmega * gyro_frequency
refraction_index_para = disper.solve_dispersion(B, species, density,
wave_frequency,
theta_input)
# result_x = integrate(f, (vz, -oo, oo))
# result = integrate(2 * pi * vx * result_x, (vx, 0, oo))
# set w and Omega and k
Omega = gyro_frequency.value
w = wave_frequency.value
c = const.c.value
k = refraction_index_para * w / c
k_para = k * cos(theta_deg)
k_para_c = k_para * c
vz_res = (w - Omega) / (k_para)
A_bottom = 2 * integrate(f * vx, (vx, 0, oo))
A_top = vz**-1 * integrate(vx**2 * G1_term2, (vx, 0, oo))
A_res = simplify((A_top / A_bottom).subs(vz, vz_res))
A_res_value = A_res.subs([(vth_x, electron.vth_x),
(vth_z, electron.vth_z)])
Eta_res = 2 * pi * (-vz) * integrate(vx * f, (vx, 0, oo))
Eta_res_v = Eta_res.subs(vz, vz_res)
Eta_res_value = Eta_res_v.subs([(vth_x, electron.vth_x),
(vth_z, electron.vth_z)])
A_c = 1 / ((Omega - w) - 1)
wave_growth = pi * Omega * (1 - w / Omega)**2 * Eta_res_value * (
A_res_value - A_c)
return A_res_value, Eta_res_value, wave_growth.evalf()
def test_gyroradius():
r"""Test the gyroradius function in parameters.py."""
assert gyroradius(B, T_i=T_e).unit.is_equivalent(u.m)
assert gyroradius(B, Vperp=25 * u.m / u.s).unit.is_equivalent(u.m)
Vperp = 1e6 * u.m / u.s
Bmag = 1 * u.T
omega_ce = gyrofrequency(Bmag)
analytical_result = (Vperp / omega_ce).to(
u.m, equivalencies=u.dimensionless_angles())
assert gyroradius(Bmag, Vperp=Vperp) == analytical_result
with pytest.raises(TypeError):
gyroradius(u.T)
with pytest.raises(u.UnitConversionError):
gyroradius(5 * u.A, Vperp=8 * u.m / u.s)
with pytest.raises(u.UnitConversionError):
gyroradius(5 * u.T, Vperp=8 * u.m)
with pytest.raises(ValueError):
gyroradius(np.array([5, 6]) * u.T,
Vperp=np.array([5, 6, 7]) * u.m / u.s)
with pytest.raises(ValueError):
gyroradius(np.nan * u.T, Vperp=1 * u.m / u.s)
with pytest.raises(ValueError):
gyroradius(3.14159 * u.T, T_i=-1 * u.K)
with pytest.warns(u.UnitsWarning):
assert gyroradius(1.0, Vperp=1.0) == gyroradius(1.0 * u.T,
Vperp=1.0 * u.m / u.s)
with pytest.warns(u.UnitsWarning):
assert gyroradius(1.1, T_i=1.2) == gyroradius(1.1 * u.T, T_i=1.2 * u.K)
with pytest.raises(ValueError):
gyroradius(1.1 * u.T, Vperp=1 * u.m / u.s, T_i=1.2 * u.K)
with pytest.raises(ValueError):
gyroradius(1.1 * u.T, Vperp=1.1 * u.m, T_i=1.2 * u.K)
assert gyroradius(B, particle="p", T_i=T_i).unit.is_equivalent(u.m)
assert gyroradius(B, particle="p",
Vperp=25 * u.m / u.s).unit.is_equivalent(u.m)
# Case when Z=1 is assumed
assert np.isclose(gyroradius(B, particle='p', T_i=T_i),
gyroradius(B, particle='H+', T_i=T_i),
atol=1e-6 * u.m)
gyroPos = gyroradius(B, particle="p", Vperp=V)
gyroNeg = gyroradius(B, particle="p", Vperp=-V)
assert gyroPos == gyroNeg
Vperp = 1e6 * u.m / u.s
Bmag = 1 * u.T
omega_ci = gyrofrequency(Bmag, particle='p')
analytical_result = (Vperp / omega_ci).to(
u.m, equivalencies=u.dimensionless_angles())
assert gyroradius(Bmag, particle="p", Vperp=Vperp) == analytical_result
T2 = 1.2 * u.MK
B2 = 123 * u.G
particle2 = 'alpha'
Vperp2 = thermal_speed(T2, particle=particle2)
gyro_by_vperp = gyroradius(B2, particle='alpha', Vperp=Vperp2)
assert gyro_by_vperp == gyroradius(B2, particle='alpha', T_i=T2)
explicit_positron_gyro = gyroradius(1 * u.T,
particle='positron',
T_i=1 * u.MK)
assert explicit_positron_gyro == gyroradius(1 * u.T, T_i=1 * u.MK)
with pytest.raises(TypeError):
gyroradius(u.T, particle="p", Vperp=8 * u.m / u.s)
with pytest.raises(ValueError):
gyroradius(B, particle='p', T_i=-1 * u.K)
with pytest.warns(u.UnitsWarning):
gyro_without_units = gyroradius(1.0, particle="p", Vperp=1.0)
gyro_with_units = gyroradius(1.0 * u.T,
particle="p",
Vperp=1.0 * u.m / u.s)
assert gyro_without_units == gyro_with_units
with pytest.warns(u.UnitsWarning):
gyro_t_without_units = gyroradius(1.1, particle="p", T_i=1.2)
gyro_t_with_units = gyroradius(1.1 * u.T, particle="p", T_i=1.2 * u.K)
assert gyro_t_with_units == gyro_t_without_units
with pytest.raises(ValueError):
gyroradius(1.1 * u.T, particle="p", Vperp=1 * u.m / u.s, T_i=1.2 * u.K)
with pytest.raises(ValueError):
gyroradius(1.1 * u.T, particle="p", Vperp=1.1 * u.m, T_i=1.2 * u.K)
with pytest.raises(ValueError):
gyroradius(1.1 * u.T, particle="p", Vperp=1.2 * u.m, T_i=1.1 * u.K)
def test_gyrofrequency():
r"""Test the gyrofrequency function in parameters.py."""
assert gyrofrequency(B).unit.is_equivalent(u.rad / u.s)
assert np.isclose(gyrofrequency(1 * u.T).value, 175882008784.72018)
assert np.isclose(gyrofrequency(2.4 * u.T).value, 422116821083.3284)
assert np.isclose(
gyrofrequency(2.4 * u.T, signed=True).value, -422116821083.3284)
assert np.isclose(gyrofrequency(1 * u.G).cgs.value, 1.76e7, rtol=1e-3)
with pytest.raises(TypeError):
gyrofrequency(u.m)
with pytest.raises(u.UnitConversionError):
gyrofrequency(u.m * 1)
with pytest.raises(ValueError):
gyrofrequency(B_nanarr)
# The following is a test to check that equivalencies from astropy
# are working.
omega_ce = gyrofrequency(2.2 * u.T)
f_ce = (omega_ce / (2 * np.pi)) / u.rad
f_ce_use_equiv = omega_ce.to(u.Hz, equivalencies=[(u.cy / u.s, u.Hz)])
assert np.isclose(f_ce.value, f_ce_use_equiv.value)
with pytest.warns(u.UnitsWarning):
assert gyrofrequency(5.0) == gyrofrequency(5.0 * u.T)
assert gyrofrequency(B, particle=ion).unit.is_equivalent(u.rad / u.s)
assert np.isclose(
gyrofrequency(1 * u.T, particle='p').value, 95788335.834874)
assert np.isclose(
gyrofrequency(2.4 * u.T, particle='p').value, 229892006.00369796)
assert np.isclose(gyrofrequency(1 * u.G, particle='p').cgs.value,
9.58e3,
rtol=2e-3)
assert gyrofrequency(-5 * u.T, 'p') == gyrofrequency(5 * u.T, 'p')
# Case when Z=1 is assumed
# assert gyrofrequency(B, particle='p+') == gyrofrequency(B, particle='H-1')
assert gyrofrequency(B, particle='e+') == gyrofrequency(B)
with pytest.warns(u.UnitsWarning):
gyrofrequency(8, 'p')
with pytest.raises(u.UnitConversionError):
gyrofrequency(5 * u.m, 'p')
with pytest.raises(InvalidParticleError):
gyrofrequency(8 * u.T, particle='asdfasd')
with pytest.warns(u.UnitsWarning):
# TODO this should be WARNS, not RAISES. and it's probably still raised
assert gyrofrequency(5.0, 'p') == gyrofrequency(5.0 * u.T, 'p')
gyrofrequency(1 * u.T, particle='p')
# testing for user input Z
testMeth1 = gyrofrequency(1 * u.T, particle='p', Z=0.8).si.value
testTrue1 = 76630665.79318453
errStr = f"gyrofrequency() gave {testMeth1}, should be {testTrue1}."
assert np.isclose(testMeth1, testTrue1, atol=0.0, rtol=1e-15), errStr
assert_can_handle_nparray(gyrofrequency, kwargs={"signed": True})
assert_can_handle_nparray(gyrofrequency, kwargs={"signed": False})
def time_gyrofrequency(self):
gyrofrequency(0.01*u.T,
particle='T+',
to_hz=True)
def cold_plasma_permittivity_SDP(B, species, n, omega):
r"""
Magnetized Cold Plasma Dielectric Permittivity Tensor Elements.
Elements (S, D, P) are given in the "Stix" frame, ie. with B // z.
The :math:`\exp(-i \omega t)` time-harmonic convention is assumed.
Parameters
----------
B : ~astropy.units.Quantity
Magnetic field magnitude in units convertible to tesla.
species : list of str
List of the plasma particle species
e.g.: ['e', 'D+'] or ['e', 'D+', 'He+'].
n : list of ~astropy.units.Quantity
`list` of species density in units convertible to per cubic meter
The order of the species densities should follow species.
omega : ~astropy.units.Quantity
Electromagnetic wave frequency in rad/s.
Returns
-------
S : ~astropy.units.Quantity
S ("Sum") dielectric tensor element.
D : ~astropy.units.Quantity
D ("Difference") dielectric tensor element.
P : ~astropy.units.Quantity
P ("Plasma") dielectric tensor element.
Notes
-----
The dielectric permittivity tensor is expressed in the Stix frame with
the :math:`\exp(-i \omega t)` time-harmonic convention as
:math:`\varepsilon = \varepsilon_0 A`, with :math:`A` being
.. math::
\varepsilon = \varepsilon_0 \left(\begin{matrix} S & -i D & 0 \\
+i D & S & 0 \\
0 & 0 & P \end{matrix}\right)
where:
.. math::
S = 1 - \sum_s \frac{\omega_{p,s}^2}{\omega^2 - \Omega_{c,s}^2}
D = \sum_s \frac{\Omega_{c,s}}{\omega}
\frac{\omega_{p,s}^2}{\omega^2 - \Omega_{c,s}^2}
P = 1 - \sum_s \frac{\omega_{p,s}^2}{\omega^2}
where :math:`\omega_{p,s}` is the plasma frequency and
:math:`\Omega_{c,s}` is the signed version of the cyclotron frequency
for the species :math:`s`.
References
----------
- T.H. Stix, Waves in Plasma, 1992.
Examples
--------
>>> from astropy import units as u
>>> from plasmapy.constants import pi
>>> B = 2*u.T
>>> species = ['e', 'D+']
>>> n = [1e18*u.m**-3, 1e18*u.m**-3]
>>> omega = 3.7e9*(2*pi)*(u.rad/u.s)
>>> S, D, P = cold_plasma_permittivity_SDP(B, species, n, omega)
>>> S
<Quantity 1.02422902>
>>> D
<Quantity 0.39089352>
>>> P
<Quantity -4.8903104>
"""
S, D, P = 1, 0, 1
for s, n_s in zip(species, n):
omega_c = parameters.gyrofrequency(B=B, particle=s, signed=True)
omega_p = parameters.plasma_frequency(n=n_s, particle=s)
S += -omega_p**2 / (omega**2 - omega_c**2)
D += omega_c / omega * omega_p**2 / (omega**2 - omega_c**2)
P += -omega_p**2 / omega**2
return S, D, P
def cold_plasma_permittivity_LRP(B: u.T, species, n, omega: u.rad / u.s):
r"""
Magnetized Cold Plasma Dielectric Permittivity Tensor Elements.
Elements (L, R, P) are given in the "rotating" basis, ie. in the basis
:math:`(\mathbf{u}_{+}, \mathbf{u}_{-}, \mathbf{u}_z)`,
where the tensor is diagonal and with B // z.
The :math:`\exp(-i \omega t)` time-harmonic convention is assumed.
Parameters
----------
B : ~astropy.units.Quantity
Magnetic field magnitude in units convertible to tesla.
species : list of str
The plasma particle species (e.g.: `['e', 'D+']` or
`['e', 'D+', 'He+']`.
n : list of ~astropy.units.Quantity
`list` of species density in units convertible to per cubic meter.
The order of the species densities should follow species.
omega : ~astropy.units.Quantity
Electromagnetic wave frequency in rad/s.
Returns
-------
L : ~astropy.units.Quantity
L ("Left") Left-handed circularly polarization tensor element.
R : ~astropy.units.Quantity
R ("Right") Right-handed circularly polarization tensor element.
P : ~astropy.units.Quantity
P ("Plasma") dielectric tensor element.
Notes
-----
In the rotating frame defined by
:math:`(\mathbf{u}_{+}, \mathbf{u}_{-}, \mathbf{u}_z)`
with :math:`\mathbf{u}_{\pm}=(\mathbf{u}_x \pm \mathbf{u}_y)/\sqrt{2}`,
the dielectric tensor takes a diagonal form with elements L, R, P with:
.. math::
L = 1 - \sum_s
\frac{\omega_{p,s}^2}{\omega\left(\omega - \Omega_{c,s}\right)}
R = 1 - \sum_s
\frac{\omega_{p,s}^2}{\omega\left(\omega + \Omega_{c,s}\right)}
P = 1 - \sum_s \frac{\omega_{p,s}^2}{\omega^2}
where :math:`\omega_{p,s}` is the plasma frequency and
:math:`\Omega_{c,s}` is the signed version of the cyclotron frequency
for the species :math:`s`.
References
----------
- T.H. Stix, Waves in Plasma, 1992.
Examples
--------
>>> from astropy import units as u
>>> from plasmapy.constants import pi
>>> B = 2*u.T
>>> species = ['e', 'D+']
>>> n = [1e18*u.m**-3, 1e18*u.m**-3]
>>> omega = 3.7e9*(2*pi)*(u.rad/u.s)
>>> L, R, P = cold_plasma_permittivity_LRP(B, species, n, omega)
>>> L
<Quantity 0.63333549>
>>> R
<Quantity 1.41512254>
>>> P
<Quantity -4.8903104>
"""
L, R, P = 1, 1, 1
for s, n_s in zip(species, n):
omega_c = parameters.gyrofrequency(B=B, particle=s, signed=True)
omega_p = parameters.plasma_frequency(n=n_s, particle=s)
L += -omega_p**2 / (omega * (omega - omega_c))
R += -omega_p**2 / (omega * (omega + omega_c))
P += -omega_p**2 / omega**2
return L, R, P
def wave_growth_oblique_m(name, density, B, T_perp, T_para, waveperOmega,
distribution, theta_input, m):
"""
Calculate the m part of growth_rate
Based on Kennel 1966
"""
if name == 'e':
n = density[0]
else:
n = density[1]
electron = particle.particles(name, n, B, T_perp, T_para)
species = ['e', 'p']
theta_deg = theta_input * pi / 180
# Here is positive signed = False
gyro_frequency = parameters.gyrofrequency(B, name)
wave_frequency = waveperOmega * gyro_frequency
# First need to
# Fist solve the refraction_index
refraction_index_para = disper.solve_dispersion(B, species, density,
wave_frequency,
theta_input)
Omega = electron.gyro_f.value
ww = wave_frequency.value
c = const.c.value
kk = refraction_index_para * ww / c
kk_para = kk * cos(theta_deg)
kk_perp = kk * sin(theta_deg)
# set the symbol
vx = symbols('vx')
vz = symbols('vz')
vth_x = symbols('vth_x')
vth_z = symbols('vth_z')
r = symbols('r')
w = symbols('w')
k_para = symbols('k_para')
theta = symbols('theta')
# First integrate the v_parallel
# we need four term
# G1, weight function, Dirac Function, vx**2
# First integrate v_parallel
G1_term1, G1_term2 = electron.G_1(distribution)
G1 = G1_term1 - (kk_para / ww) * G1_term2
v_para_int = integrate(
G1 * electron.delta_function(m).subs([(w, ww), (k_para, kk_para)]),
(vz, -oo, oo))
print(v_para_int)
if electron.name == 'e':
flag = -1
else:
flag = 1
# flag determin the r integrate range -1 means -oo to 0
# 1 means 0 to oo
### The reason here need to change that is because the Jm integration can not with parameters
v_para_int_value = (v_para_int.subs([(vth_x, electron.vth_x),
(vth_z, electron.vth_z)]))
#v_perp_int_value = v_para_int_value * vx**2 * electron.weight_function_p(m)
# # change the vx to (k *v / Omega) and input the vth_z and vth_x
r_vx = r * Omega / kk_perp
v_para_int_value_new = v_para_int_value.subs(vx, r_vx)
v_perp_int = v_para_int_value_new * (
(Omega / kk_perp)**3 * r**2 * electron.weight_function_p(m)).subs(
theta, theta_deg)
# Dothe simplify?
#v_perp_int_test = simplify(v_perp_int)
print("vy success")
#Now do the final integration!
if flag == -1:
v_perp_int_value = integrate(v_perp_int, (r, -oo, 0))
else:
v_perp_int_value = integrate(v_perp_int, (r, 0, oo))
growth_rate_oblique = (-pi**2 * Omega * ww / kk) * v_perp_int_value
return growth_rate_oblique.evalf()
def wave_growth_para(name, density, B, T_perp, T_para, waveperOmega,
distribution):
if name == 'e':
n = density[0]
else:
n = density[1]
electron = particle.particles(name, n, B, T_perp, T_para)
species = ['e', 'p']
theta_input = 0
theta_deg = theta_input * pi / 180
gyro_frequency = parameters.gyrofrequency(B, name)
wave_frequency = waveperOmega * gyro_frequency
refraction_index_para = disper.solve_dispersion(B, species, density,
wave_frequency,
theta_input)
print("nn", refraction_index_para)
vx = symbols('vx')
vz = symbols('vz')
vth_x = symbols('vth_x')
vth_z = symbols('vth_z')
# Tx = symbols('Tx')
# Tz = symbols('Tz')
f = electron.F_0()
# result_x = integrate(f, (vz, -oo, oo))
# result = integrate(2 * pi * vx * result_x, (vx, 0, oo))
# set w and Omega and k
Omega = gyro_frequency.value
w = wave_frequency.value
c = const.c.value
k = refraction_index_para * w / c
k_para = k * cos(theta_deg)
k_para_c = k_para * c
#print(result)
G1_term1, G1_term2 = electron.G_1(distribution)
print(G1_term1, G1_term2, f)
# print(G1_term1, G1_term2)
#print(refraction_index_para)
G1 = G1_term1 - (k_para / w) * G1_term2
G1_para = -(k_para / w) * G1_term2
#
vz_res = (w - Omega) / (k_para)
G1_new = (G1.subs(vz, vz_res))
print("test!!")
print(G1_new)
# G1_res = G1_para.subs(vz, (w - Omega) / (k_para))
#print(G1_res)
# wave_growth_para_coeff= pi**2 * Omega*c/n
wave_para_int = (pi**2 * Omega * w / k) * integrate(
vx**2 * G1_new, (vx, 0, oo))
wave_para_int_new = wave_para_int.subs([(vth_x, electron.vth_x),
(vth_z, electron.vth_z)])
print(wave_para_int_new)
#wave_growth_eva = wave_para_int.subs(vz, vz_res)
#print(wave_para_int)
return wave_para_int_new, vz_res, G1_new
############################################################ # Initialize the fields. We'll take B in the x direction # and E in the y direction, which gets us an E cross B drift # in the z direction. B0 = 4 * u.T plasma.magnetic_field[0, :, :, :] = np.ones((10, 10, 10)) * B0 E0 = 2 * u.V / u.m plasma.electric_field[1, :, :, :] = np.ones((10, 10, 10)) * E0 ############################################################ # Calculate the timestep. We'll take one proton `p`, take its gyrofrequency, invert that # to get to the gyroperiod, and resolve that into 10 steps for higher accuracy. freq = gyrofrequency(B0, 'p').to(u.Hz, equivalencies=u.dimensionless_angles()) gyroperiod = (1/freq).to(u.s) steps_to_gyroperiod = 10 timestep = gyroperiod / steps_to_gyroperiod ############################################################ # Initialize the trajectory calculation. number_steps = steps_to_gyroperiod * int(2 * np.pi) trajectory = ParticleTracker(plasma, 'p', 1, 1, timestep, number_steps) ############################################################ # We still have to initialize the particle's velocity. We'll limit ourselves to # one in the x direction, parallel to the magnetic field B - # that way, it won't turn in the z direction.
import numpy as np
import matplotlib.pyplot as plt
import cold_growth_rate
from sympy import ln
import particle
from scipy.optimize import fsolve
from astropy import constants as const
from sympy import sin, cos, exp
species = ['e', 'p']
B = 1e-6 * u.T
n = [300e6 * u.m**-3, 300e6 * u.m**-3]
theta_input = 0
theta_deg = theta_input * pi / 180
gyro_frequency = parameters.gyrofrequency(B, 'e')
wave_frequency = 0.05 * gyro_frequency
print(wave_frequency)
#%%
# test dispersion solve
refraction_index = disper.solve_dispersion(B, species, n, wave_frequency,
theta_input)
print(refraction_index)
# Draw a picture of n and w/Omega
x = np.arange(0.1, 0.5, 0.005)
refraction_index_array = np.zeros(len(x))
print(refraction_index_array)
refraction_index_array = []
