def test_footpoints(dipole_result):
input, out = dipole_result
out_frame = out.coordinate_frame
tracer = tracing.PythonTracer(atol=1e-8, rtol=1e-8)
def check_radius(coord, r):
coord.representation_type = 'spherical'
assert quantity_allclose(coord.radius, r)
def check_open_fline(fline):
check_radius(fline.solar_footpoint, const.R_sun)
check_radius(fline.source_surface_footpoint, 2.5 * const.R_sun)
seed = coord.SkyCoord(0 * u.deg, 90 * u.deg, 1.01 * R_sun, frame=out_frame)
field_line = tracer.trace(seed, out)[0]
check_open_fline(field_line)
seed = coord.SkyCoord(0 * u.deg,
-90 * u.deg,
1.01 * R_sun,
frame=out_frame)
field_line = tracer.trace(seed, out)[0]
check_open_fline(field_line)
seed = coord.SkyCoord(0 * u.deg, 0 * u.deg, 1.01 * R_sun, frame=out_frame)
field_line = tracer.trace(seed, out)[0]
check_radius(field_line.solar_footpoint, const.R_sun)
check_radius(field_line.source_surface_footpoint, const.R_sun)
def __init__(self, nrho, rss, gong_map=sunpy.map.Map(get_gong_map())):
self._nrho = nrho
self._rss = rss
self.gong_map = gong_map
self.input = pfsspy.Input(self.gong_map, self.nrho, self.rss)
self._output = pfsspy.pfss(self.input)
self.tracer = tracing.PythonTracer()
def test_field_lines(dipole_map, seeds):
input, out = dipole_map
tracer = tracing.PythonTracer()
field_lines = tracer.trace(seeds, out)
assert isinstance(field_lines.solar_feet, coord.SkyCoord)
assert isinstance(field_lines.source_surface_feet, coord.SkyCoord)
assert isinstance(field_lines.polarities, np.ndarray)
def test_field_line_polarity(dipole_map):
input, out = dipole_map
tracer = tracing.PythonTracer()
field_line = tracer.trace(np.array([0, 0, 1.01]), out)
assert field_line[0].polarity == 1
field_line = tracer.trace(np.array([0, 0, -1.01]), out)
assert field_line[0].polarity == -1
# This is a closed field line
eq_field_line = tracer.trace(np.array([0, 1, 0.1]), out)[0]
assert eq_field_line.polarity == 0
def test_field_line_polarity(dipole_result):
input, out = dipole_result
out_frame = out.coordinate_frame
tracer = tracing.PythonTracer()
seed = coord.SkyCoord(0 * u.deg, 90*u.deg, 1.01 * R_sun, frame=out_frame)
field_line = tracer.trace(seed, out)
assert field_line[0].polarity == 1
seed = coord.SkyCoord(0 * u.deg, -90*u.deg, 1.01 * R_sun, frame=out_frame)
field_line = tracer.trace(seed, out)
assert field_line[0].polarity == -1
# This is a closed field line
seed = coord.SkyCoord(0 * u.deg, 0 * u.deg, 1.01 * R_sun, frame=out_frame)
eq_field_line = tracer.trace(seed, out)[0]
assert eq_field_line.polarity == 0
def test_expansion_factor(dipole_map):
inp, out = dipole_map
tracer = tracing.PythonTracer()
field_line = tracer.trace(np.array(pfsspy.coords.strum2cart(0.01, 0.9, 0)),
out)[0]
assert field_line.expansion_factor > 1
field_line = tracer.trace(
np.array(pfsspy.coords.strum2cart(0.01, -0.9, 0)), out)[0]
assert field_line.expansion_factor > 1
# This is a closed field line
eq_field_line = tracer.trace(np.array([0, 1, 0.1]), out)[0]
assert np.isnan(eq_field_line.expansion_factor)
# Check that a field line near the equator has a bigger expansion
# factor than one near the pole
pil_field_line = tracer.trace(
np.array(pfsspy.coords.strum2cart(np.log(2.5 - 0.01), 0.1, 0)), out)[0]
assert pil_field_line.expansion_factor > field_line.expansion_factor
def test_footpoints(dipole_map):
input, out = dipole_map
tracer = tracing.PythonTracer(atol=1e-8, rtol=1e-8)
def check_radius(coord, r):
coord.representation_type = 'spherical'
assert quantity_allclose(coord.radius, r)
def check_open_fline(fline):
check_radius(fline.solar_footpoint, const.R_sun)
check_radius(fline.source_surface_footpoint, 2.5 * const.R_sun)
field_line = tracer.trace(np.array([0, 0, 1.01]), out)[0]
check_open_fline(field_line)
field_line = tracer.trace(np.array([0, 0, -1.01]), out)[0]
check_open_fline(field_line)
field_line = tracer.trace(np.array([0, 1, 0.1]), out)[0]
check_radius(field_line.solar_footpoint, const.R_sun)
check_radius(field_line.source_surface_footpoint, const.R_sun)
def test_expansion_factor(dipole_result):
inp, out = dipole_result
out_frame = out.coordinate_frame
tracer = tracing.PythonTracer()
seed = coord.SkyCoord(0 * u.deg, 80 * u.deg, 1.1 * R_sun, frame=out_frame)
field_line = tracer.trace(seed, out)[0]
assert field_line.expansion_factor > 1
seed = coord.SkyCoord(0 * u.deg, -80 * u.deg, 1.1 * R_sun, frame=out_frame)
field_line = tracer.trace(seed, out)[0]
assert field_line.expansion_factor > 1
# This is a closed field line
seed = coord.SkyCoord(0 * u.deg, 0 * u.deg, 1.1 * R_sun, frame=out_frame)
eq_field_line = tracer.trace(seed, out)[0]
assert np.isnan(eq_field_line.expansion_factor)
# Check that a field line near the equator has a bigger expansion
# factor than one near the pole
seed = coord.SkyCoord(0 * u.deg, 10 * u.deg, 2.49 * R_sun, frame=out_frame)
pil_field_line = tracer.trace(seed, out)[0]
assert pil_field_line.expansion_factor > field_line.expansion_factor
import astropy.coordinates as coord
import astropy.constants as const
import astropy.units as u
import numpy as np
import pytest
import pfsspy
from pfsspy import tracing
from .example_maps import dipole_map, dipole_result
@pytest.mark.parametrize(
'tracer',
[tracing.PythonTracer(), tracing.FortranTracer()],
ids=('python', 'fortran'))
def test_field_lines(dipole_result, tracer):
input, out = dipole_result
out_frame = out.coordinate_frame
seed = coord.SkyCoord(0 * u.deg,
-45 * u.deg,
1.01 * const.R_sun,
frame=out_frame)
field_lines = tracer.trace(seed, out)
assert isinstance(field_lines[0], pfsspy.fieldline.FieldLine)
assert isinstance(field_lines.open_field_lines.solar_feet, coord.SkyCoord)
assert isinstance(field_lines.open_field_lines.source_surface_feet,
coord.SkyCoord)
assert isinstance(field_lines.polarities, np.ndarray)
# Plot the source surface map
br.plot(cmap='RdBu')
# Plot formatting
plt.colorbar()
ax.set_title('$B_{r}$ ' + f'at r={r:.2f}' + '$r_{\\odot}$')
set_axes_lims(ax)
###############################################################################
# Finally, using the 3D magnetic field solution we can trace some field lines.
# In this case 64 points equally gridded in theta and phi are chosen and
# traced from the source surface outwards.
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
tracer = tracing.PythonTracer()
r = 1.2 * const.R_sun
lat = np.linspace(-np.pi / 2, np.pi / 2, 8, endpoint=False)
lon = np.linspace(0, 2 * np.pi, 8, endpoint=False)
lat, lon = np.meshgrid(lat, lon, indexing='ij')
lat, lon = lat.ravel() * u.rad, lon.ravel() * u.rad
seeds = SkyCoord(lon, lat, r, frame=output.coordinate_frame)
field_lines = tracer.trace(seeds, output)
for field_line in field_lines:
color = {0: 'black', -1: 'tab:blue', 1: 'tab:red'}.get(field_line.polarity)
coords = field_line.coords
coords.representation_type = 'cartesian'
ax.plot(coords.x / const.R_sun,
fig.colorbar(mesh)
ax.scatter(np.rad2deg(phi), s, color='k', s=1)
ax.set_xlim(50, 70)
ax.set_ylim(0, 0.35)
ax.set_title('Field line footpoints')
###############################################################################
# Compute the PFSS solution from the GONG magnetic field input
output = pfsspy.pfss(input)
###############################################################################
# Trace field lines from the footpoints defined above. :mod:`pfsspy.coords`
# is used to convert the s, phi cooridnates into the cartesian coordinates that
# are needed by the tracer.
tracer = tracing.PythonTracer(atol=1e-8)
flines = []
for s, phi in zip(s.ravel(), phi.ravel()):
x0 = np.array(pfsspy.coords.strum2cart(0.01, s, phi))
flines += tracer.trace(x0, output)
###############################################################################
# Plot the input GONG magnetic field map, along with the traced mangetic field
# lines.
fig, ax = plt.subplots()
mesh = input.plot_input(ax)
for fline in flines:
fline.coords.representation_type = 'spherical'
ax.plot(fline.coords.lon / u.deg,
np.sin(fline.coords.lat),
color='black',
