def test_consistency_with_rotatedsunframe():
old_observer = frames.HeliographicStonyhurst(10 * u.deg,
20 * u.deg,
1 * u.AU,
obstime='2001-01-01')
new_observer = frames.HeliographicStonyhurst(30 * u.deg,
40 * u.deg,
2 * u.AU,
obstime='2001-01-08')
hpc_coord = SkyCoord(100 * u.arcsec,
200 * u.arcsec,
frame='helioprojective',
observer=old_observer,
obstime=old_observer.obstime)
# Perform the differential rotation using solar_rotate_coordinate()
result1 = solar_rotate_coordinate(hpc_coord, observer=new_observer)
# Perform the differential rotation using RotatedSunFrame, with translational motion of the Sun
# ignored using transform_with_sun_center()
rsf_coord = RotatedSunFrame(base=hpc_coord,
rotated_time=new_observer.obstime)
with transform_with_sun_center():
result2 = rsf_coord.transform_to(result1.replicate_without_data())
assert_quantity_allclose(result1.Tx, result2.Tx)
assert_quantity_allclose(result1.Ty, result2.Ty)
assert_quantity_allclose(result1.distance, result2.distance)
def test_great_arc_calculable(start, end):
c = SkyCoord(start[0]*u.degree, start[1]*u.degree, frame=frames.HeliographicStonyhurst,
observer=frames.HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
d = SkyCoord(end[0]*u.degree, end[1]*u.degree, frame=frames.HeliographicStonyhurst,
observer=frames.HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
gc = GreatArc(c, d)
c_trans = c.transform_to(frames.Heliocentric)
assert gc.start.x == c_trans.x
assert gc.start.y == c_trans.y
assert gc.start.z == c_trans.z
assert gc.start.observer.lat == 0*u.deg
assert gc.start.observer.lon == 0*u.deg
assert gc.start.observer.radius == 1 * u.AU
d_trans = d.transform_to(frames.Heliocentric(observer=c.observer))
assert gc.end.x == d_trans.x
assert gc.end.y == d_trans.y
assert gc.end.z == d_trans.z
assert gc.end.observer.lat == 0*u.deg
assert gc.end.observer.lon == 0*u.deg
assert gc.end.observer.radius == 1 * u.AU
np.testing.assert_almost_equal(gc.inner_angle.to('deg').value, 45.0)
np.testing.assert_almost_equal(gc.radius.to('km').value, sun.constants.radius.to('km').value)
np.testing.assert_almost_equal(gc.distance.to(
'km').value, sun.constants.radius.to('km').value * 2 * np.pi/8, decimal=1)
def test_rotated_time_to_duration():
r1 = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-02'),
rotated_time='2001-01-03')
assert_quantity_allclose(r1.duration, 1 * u.day)
r2 = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-02'),
rotated_time='2001-01-01')
assert_quantity_allclose(r2.duration, -1 * u.day)
def test_rotated_time_property():
r1 = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-02'),
duration=1 * u.day)
assert r1.rotated_time == Time('2001-01-03')
r2 = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-02'),
duration=-1 * u.day)
assert r2.rotated_time == Time('2001-01-01')
def test_great_arc_calculable(start, end):
c = SkyCoord(start[0]*u.degree, start[1]*u.degree, frame=frames.HeliographicStonyhurst,
observer=frames.HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
d = SkyCoord(end[0]*u.degree, end[1]*u.degree, frame=frames.HeliographicStonyhurst,
observer=frames.HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU))
gc = GreatArc(c, d)
assert gc.start == c
assert gc.end == d
np.testing.assert_almost_equal(gc.inner_angle.to('deg').value, 45.0)
np.testing.assert_almost_equal(gc.radius.to('km').value, sun.constants.radius.to('km').value)
np.testing.assert_almost_equal(gc.distance.to('km').value, sun.constants.radius.to('km').value * 2 * np.pi/8, decimal=1)
def get_observer_meta(observer, rsun: (u.Mm, None) = None):
"""
Function to get observer meta from coordinate frame.
Parameters
----------
coordinate : `~astropy.coordinates.BaseCoordinateFrame`
The coordinate of the observer, must be transformable to Heliographic
Stonyhurst.
rsun : `astropy.units.Quantity`, optional
The radius of the Sun. If ``None``, the RSUN_OBS and RSUN_REF keys are
not set.
Returns
-------
coord_meta : `dict`
WCS metadata, with the keys ``['hgln_obs', 'hglt_obs', 'dsun_obs']``,
and additionally if ``rsun`` is given ``['rsun_obs', 'rsun_ref']``.
"""
observer = observer.transform_to(
frames.HeliographicStonyhurst(obstime=observer.obstime))
coord_meta = {}
coord_meta['hgln_obs'] = observer.lon.to_value(u.deg)
coord_meta['hglt_obs'] = observer.lat.to_value(u.deg)
coord_meta['dsun_obs'] = observer.radius.to_value(u.m)
if rsun is not None:
coord_meta['rsun_ref'] = rsun.to_value(u.m)
coord_meta['rsun_obs'] = sun._angular_radius(
rsun, observer.radius).to_value(u.arcsec)
return coord_meta
def test_default_observer_transform_hpc():
center = frames.HeliographicStonyhurst(0 * u.deg,
0 * u.deg,
obstime="2017-07-11 15:00")
hpc = center.transform_to(frames.Helioprojective)
assert_quantity_allclose(hpc.Ty, -66.04425197 * u.arcsec)
def test_default_observer_transform_hcc():
center = frames.HeliographicStonyhurst(0 * u.deg,
0 * u.deg,
obstime="2017-07-11 15:00")
hpc = center.transform_to(frames.Heliocentric(obstime="2017-07-11 15:00"))
assert_quantity_allclose(hpc.y, -48471.1283979 * u.km)
def get_observer_meta(observer, rsun: (u.Mm, None)):
"""
Function to get observer meta from coordinate frame.
Parameters
----------
coordinate : ~`astropy.coordinates.BaseFrame`
The coordinate of the observer, must be transformable to Heliographic
Stonyhurst.
rsun : `astropy.units.Quantity`
The radius of the Sun.
Returns
-------
`dict`
Containing the WCS meta information
* hgln_obs, hglt_obs
* dsun_obs
* rsun_obs
* rsun_ref
"""
observer = observer.transform_to(
frames.HeliographicStonyhurst(obstime=observer.obstime))
coord_meta = {}
coord_meta['hgln_obs'] = observer.lon.to_value(u.deg)
coord_meta['hglt_obs'] = observer.lat.to_value(u.deg)
coord_meta['dsun_obs'] = observer.radius.to_value(u.m)
if rsun:
coord_meta['rsun_ref'] = rsun.to_value(u.m)
coord_meta['rsun_obs'] = np.arctan(rsun / observer.radius).to_value(
u.arcsec)
return coord_meta
def test_tranformation_to_nonobserver_frame(indirect_fixture):
base_class, rot_frame = indirect_fixture
hgs_frame = f.HeliographicStonyhurst(obstime='2020-01-01')
hgs_coord = rot_frame.transform_to(hgs_frame)
assert hgs_coord.obstime == hgs_frame.obstime
def rot_hgs():
return (f.HeliographicStonyhurst,
RotatedSunFrame(
lon=1 * u.deg,
lat=2 * u.deg,
radius=3 * u.AU,
base=f.HeliographicStonyhurst(obstime='2001-01-01'),
duration=4 * u.day))
def test_scalar_base_and_array_duration():
scalar_base = f.HeliographicStonyhurst(1*u.deg, 2*u.deg, obstime='2001-01-02')
array_duration = [1, -1]*u.day
r = RotatedSunFrame(base=scalar_base, duration=array_duration)
assert not r.data.isscalar
assert r.data.shape == array_duration.shape
assert_quantity_allclose(r.cartesian[0].xyz, scalar_base.cartesian.xyz)
assert_quantity_allclose(r.cartesian[1].xyz, scalar_base.cartesian.xyz)
def test_hcc_observer_version(tmpdir):
"""
This test verifies that the heliocentric frame has an upto date list of
the HGS schema versions by ensuring that a HPC frame with a instantiated
HGS frame as the observer round trips correctly.
"""
time = "2021-10-13T11:08"
obs = frames.HeliographicStonyhurst(0*u.deg, 0*u.deg, 1*u.AU, obstime=time)
coord = frames.Heliocentric(1*u.Mm, 1*u.Mm, 1*u.Mm, obstime=time, observer=obs)
assert_round_trip_frame(coord)
def test_transform():
# Check that field lines can be transformed into different coordinates
obstime = Time('1992-12-21')
stonyhurst = sunframes.HeliographicStonyhurst(
12 * u.deg, 0 * u.deg, obstime=obstime)
fline = FieldLine([1, 2.5], [0, 0], [0, 0], None, None)
# Check field line transform
fline.coords.transform_to(stonyhurst)
# Check footpoint transform
fline.solar_footpoint.transform_to(stonyhurst)
def semi_circular_loop(length: u.cm, latitude: u.deg = 0 * u.deg):
"""
Return HGS coordinates for a semi-circular loop
"""
angles = np.linspace(0, 1, 1000) * np.pi * u.rad
z = length / np.pi * np.sin(angles)
x = length / np.pi * np.cos(angles)
hcc_frame = frames.Heliocentric(observer=frames.HeliographicStonyhurst(
lon=0 * u.deg, lat=latitude, radius=constants.au))
return SkyCoord(x=x,
y=np.zeros_like(x),
z=z + constants.radius,
frame=hcc_frame)
def test_hpc_observer_version(tmpdir):
"""
This test verifies that the helioprojective frame has an upto date list of
the HGS schema versions by ensuring that a HPC frame with a instantiated
HGS frame as the observer round trips correctly.
"""
time = "2021-10-13T11:08"
obs = frames.HeliographicStonyhurst(0 * u.deg,
0 * u.deg,
1 * u.AU,
obstime=time)
coord = frames.Helioprojective(10 * u.arcsec,
10 * u.arcsec,
obstime=time,
observer=obs)
tree = {'coord': coord}
assert_roundtrip_tree(tree, tmpdir)
def set_observer_coord(m, observer_coord):
"""
Set observer coordinate.
Parameters
----------
m : `~sunpy.map.GenericMap`
Input map.
observer_coord : astropy.coordiantes.SkyCoord
Observer coordinate.
"""
from sunpy.coordinates import frames
new_obs_frame = frames.HeliographicStonyhurst(obstime=m.date)
observer_coord = observer_coord.transform_to(new_obs_frame)
new_meta = remove_obs_keywords(m.meta)
new_meta['hglt_obs'] = observer_coord.lat.to_value(u.deg)
new_meta['hgln_obs'] = observer_coord.lon.to_value(u.deg)
new_meta['dsun_obs'] = observer_coord.radius.to_value(u.m)
return sunpy.map.Map(m.data, new_meta)
def make_map_ipa(file):
"""
Function to make a sunpy.map.GenericMap from a NoRH fits file.
This function fixes the header keywords so that it works within
map.
Parameters
----------
file : `str`
path of NoRH fits file to read into a map
Returns
-------
`sunpy.map.GenericMap
"""
hdu = fits.open(file)[0]
header = hdu.header
data = hdu.data
header['CUNIT1'], header['CUNIT2'] = 'arcsec', 'arcsec'
header['CTYPE1'], header['CTYPE2'] = 'HPLN-TAN', 'HPLT-TAN'
header['date-obs'] = header['date-obs'] + 'T' + header['time-obs']
# get observer location
observer = get_earth(header['date-obs'])
observer = observer.transform_to(
frames.HeliographicStonyhurst(obstime=observer.obstime))
header['hgln_obs'] = observer.lon.to_value(u.deg)
header['hglt_obs'] = observer.lat.to_value(u.deg)
header['dsun_obs'] = observer.radius.to_value(u.m)
header['rsun_obs'] = sun.angular_radius(
header['date-obs']).to('arcsec').value
norh_map = sunpy.map.Map(data, header)
norh_map.plot_settings['cmap'] = 'BuPu'
#norh_map.plot_settings['norm'] = LogNorm()
return norh_map
def semi_circular_loop(length: u.m, latitude: u.deg = 0 * u.deg):
"""
Return a Heliographic Stonyhurst coordinate object with points of a semi circular loop in it.
"""
r_sun = constants.radius
def r_2_func(x):
return np.arccos(0.5 * x / r_sun.to(u.cm).value) - np.pi + length.to(
u.cm).value / 2. / x
# Find the loop radius corresponding to the loop length
r_2 = scipy.optimize.bisect(r_2_func,
length.to(u.cm).value / (2 * np.pi),
length.to(u.cm).value / np.pi) * u.cm
alpha = np.arccos(0.5 * (r_2 / r_sun))
phi = np.linspace(-np.pi * u.rad + alpha, np.pi * u.rad - alpha, 2000)
hcc_frame = frames.Heliocentric(observer=frames.HeliographicStonyhurst(
lon=0 * u.deg, lat=latitude, radius=1 * u.AU))
return SkyCoord(x=r_2 * np.sin(phi),
y=0 * u.cm,
z=r_2 * np.cos(phi) + r_sun,
frame=hcc_frame).transform_to('heliographic_stonyhurst')
def test_no_obstime():
with pytest.raises(ValueError):
RotatedSunFrame(base=f.HeliographicStonyhurst(obstime=None))
def test_alternate_rotation_model():
r = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-01'),
rotation_model="allen")
assert r.rotation_model == "allen"
def test_default_rotation_model():
r = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-01'))
assert r.rotation_model == "howard"
def test_default_duration():
r = RotatedSunFrame(base=f.HeliographicStonyhurst(obstime='2001-01-01'))
assert_quantity_allclose(r.duration, 0 * u.day)
