def test_channel(show=False, verbose=False):
"""Test eigenvalue solver using ChebyshevRationalGrid"""
import numpy as np
from psecas import Solver, ChebyshevRationalGrid, System
grid = ChebyshevRationalGrid(N=199, z='z')
class Channel(System):
def make_background(self):
import numpy as np
zg = self.grid.zg
self.h = np.exp(-zg**2 / 2)
# Create the Channel system
system = Channel(grid, variables='G', eigenvalue='K2')
# Add the first (and only) equation
system.add_equation("-h*K2*G = dz(dz(G)) +z*dz(G)", boundary=True)
solver = Solver(grid, system, do_gen_evp=True)
# Number of modes to test
modes = 3
results = np.zeros(modes, dtype=np.complex128)
checks = np.array([85.08037778, 69.4741069099, 55.4410282999])
def sorting_strategy(E):
"""Sorting strategy for channel modes"""
E[E.real > 100.0] = 0
E[E.real < -10.0] = 0
index = np.argsort(np.real(E))[::-1]
return (E, index)
solver.sorting_strategy = sorting_strategy
if show:
import matplotlib.pyplot as plt
plt.figure(3)
plt.clf()
fig, axes = plt.subplots(num=3, ncols=modes, sharey=True)
for mode in range(modes):
Ns = np.arange(1, 6) * 32
omega, vec, err = solver.iterate_solver(Ns, mode=mode, verbose=True)
results[mode] = omega
if show:
phi = np.arctan(vec[2].imag / vec[2].real)
solver.keep_result(omega, vec * np.exp(-1j * phi), mode)
axes[mode].set_title(r"$\sigma = ${:1.4f}".format(omega.real),
fontsize=10)
axes[mode].plot(grid.zg, system.result['G'].real)
axes[mode].plot(grid.zg, system.result['G'].imag)
axes[mode].set_xlim(-4, 4)
if show:
plt.show()
np.testing.assert_allclose(results, checks, rtol=1e-6)
def test_mti_solution(show=False, verbose=False):
"""Test eigenvalue solver using ChebyshevExtremaGrid"""
import numpy as np
from psecas import Solver, ChebyshevExtremaGrid
from psecas.systems.mti import MagnetoThermalInstability
grid = ChebyshevExtremaGrid(N=64, zmin=0, zmax=1)
system = MagnetoThermalInstability(grid, beta=1e5, Kn0=200, kx=4 * np.pi)
system.beta = 1e5
system.Kn0 = 200
assert system.Kn0 == 200
assert system.beta == 1e5
solver = Solver(grid, system)
Ns = np.hstack(np.arange(1, 10) * 16)
mode = 0
omega, vec, err = solver.iterate_solver(Ns,
mode=mode,
tol=1e-8,
verbose=verbose)
system.get_bx_and_by()
if show:
from psecas import plot_solution
phi = np.arctan(vec[2].imag / vec[2].real)
solver.keep_result(omega, vec * np.exp(-1j * phi), mode=mode)
plot_solution(system, smooth=True, num=1)
np.testing.assert_allclose(1.7814514515967603, omega, atol=1e-8)
return err
modes = 11
fig, axes = plt.subplots(num=1,
nrows=2,
ncols=modes,
sharex=True,
sharey='row')
for mode in range(modes):
Ns = np.hstack((np.arange(3, 6) * 32, np.arange(4, 12) * 64))
K2, vec, err = ch.iterate_solver(Ns,
mode=mode,
tol=1e-4,
verbose=True,
guess_tol=5e-3)
K = np.sqrt(K2.real)
phi = np.arctan(vec[2].imag / vec[2].real)
A = np.max(np.abs(vec))
ch.keep_result(K2, vec * np.exp(-1j * phi) / A, mode=mode)
axes[0, mode].set_title(r"$\sigma = ${:1.4f}".format(K), fontsize=10)
axes[0, mode].plot(grid.zg, system.result["F"].real)
axes[0, mode].plot(grid.zg, system.result["F"].imag)
axes[0, mode].set_xlim(-4, 4)
axes[1, mode].set_xlabel(r'$z$')
G = grid.der(system.result['F']) / K
axes[1, mode].plot(grid.zg, G.real)
axes[1, mode].plot(grid.zg, G.imag)
axes[0, 0].set_ylabel(r'$F(z)$')
axes[1, 0].set_ylabel(r'$G(z)$')
plt.show()
from psecas.systems.kh_uniform import KelvinHelmholtzUniform
from psecas import save_system
from psecas import plot_solution
import matplotlib.pyplot as plt
kxmax = 4.54704305
# omega = 1.7087545
grid = FourierGrid(N=64, zmin=0, zmax=2)
system = KelvinHelmholtzUniform(grid, beta=1e3, nu=1e-2, kx=kxmax)
# Set up a solver
solver = Solver(grid, system)
# Iteratively solve
Ns = np.hstack((np.arange(1, 5) * 16, np.arange(3, 24) * 32))
omega, vec, err = solver.iterate_solver(Ns, verbose=True, tol=1e-8)
phi = np.arctan(vec[2].imag / vec[2].real)
solver.keep_result(omega, vec * np.exp(-1j * phi), mode=0)
# Normalize eigenmodes
y = np.vstack([
system.result["dvx"].real,
system.result["dvx"].imag,
system.result["dvz"].real,
system.result["dvz"].imag,
])
val = np.max(np.abs(y))
for key in system.variables:
system.result[key] /= val
# Save system pickle object
save_system(system, "./khi_nu.p")
def test_mri_solution(show=False, verbose=False):
"""Test eigenvalue solver using ChebyshevExtremaGrid"""
import numpy as np
from psecas import Solver, ChebyshevExtremaGrid, System
class HallMRI(System):
def __init__(self, grid, kz, variables, eigenvalue):
# Set parameters
self.q = 1.5
self.eta = 0.003
self.lh = 1
self.h = 0.25
self.va = 0.002
self.kz = kz
super().__init__(grid, variables, eigenvalue)
# Create a grid
grid = ChebyshevExtremaGrid(N=128, zmin=1, zmax=2, z='r')
variables = ['rho', 'vr', 'vphi', 'vz', 'Aphi', 'bphi']
kz = 2 * np.pi
# Create the system
system = HallMRI(grid, kz, variables=variables, eigenvalue='sigma')
# The linearized equations
system.add_equation("-r*sigma*rho = r*dr(vr) + vr + 1j*kz*r*vz")
system.add_equation(
"-r*r*sigma*vr = - 2*r**(2-q)*vphi + h**2*r*r*dr(rho) + va**2*(DrAphi)"
)
system.add_equation("-sigma*vphi = + (2-q)*r**(-q)*vr - va**2*1j*kz*bphi")
system.add_equation("-sigma*vz = h**2*1j*kz*rho")
system.add_equation(
"-r*r*sigma*Aphi = + r*r*vr - eta*(DrAphi) + lh*va*1j*kz*r*r*bphi")
system.add_equation(
"-r*r*sigma*bphi = - 1j*kz*r*r*vphi - 1j*kz*q*r**(2-q)*Aphi - eta*(Drbphi) - lh*va*1j*kz*(DrAphi)"
)
# The boundary conditions
Aphi_bound = 'r**2*dr(dr(Aphi)) + r*dr(Aphi) - Aphi = 0'
system.add_boundary('vr', 'Dirichlet', 'Dirichlet')
system.add_boundary('vphi', 'Dirichlet', 'Dirichlet')
system.add_boundary('vz', 'Neumann', 'Neumann')
system.add_boundary('Aphi', Aphi_bound, Aphi_bound)
system.add_boundary('bphi', 'Dirichlet', 'Dirichlet')
# Short hands for long expressions for derivatives
system.add_substitution(
'DrAphi = r*r*dr(dr(Aphi)) + r*dr(Aphi) - Aphi - kz**2*r*r*Aphi')
system.add_substitution(
'Drbphi = r*r*dr(dr(bphi)) + r*dr(bphi) - bphi - kz**2*r*r*bphi')
solver = Solver(grid, system)
mode = 0
Ns = np.hstack(np.arange(1, 10) * 32)
omega, vec, err = solver.iterate_solver(Ns,
mode=mode,
tol=1e-8,
verbose=verbose)
if show:
from psecas import plot_solution
phi = np.arctan(vec[2].imag / vec[2].real)
solver.keep_result(omega, vec * np.exp(-1j * phi), mode=mode)
plot_solution(system, smooth=True, num=1)
np.testing.assert_allclose(0.09892641, omega, atol=1e-8)
return err
