def test_differential_rotate(aia171_test_map, all_off_disk_map, all_on_disk_map, straddles_limb_map): # Test a map that is entirely off the disk of the Sun # Should report an error with pytest.raises(ValueError): dmap = differential_rotate(all_off_disk_map) # Test a full disk map new_observer = get_earth(aia171_test_map.date + 6 * u.hr) dmap = differential_rotate(aia171_test_map, observer=new_observer) assert dmap.data.shape == aia171_test_map.data.shape # Test a map that is entirely on disk - triggers sub full disk branches # Rotated map should have a smaller extent in the x - direction new_observer = get_earth(all_on_disk_map.date - 48 * u.hr) dmap = differential_rotate(all_on_disk_map, observer=new_observer) assert dmap.data.shape[1] < all_on_disk_map.data.shape[1] # This rotated map should have a larger extent in the x direction new_observer = get_earth(all_on_disk_map.date + 48 * u.hr) dmap = differential_rotate(all_on_disk_map, observer=new_observer) assert dmap.data.shape[1] > all_on_disk_map.data.shape[1] # Test a map that straddles the limb - triggers sub full disk branches # Rotated map should have a smaller extent in the x - direction new_observer = get_earth(straddles_limb_map.date + 48 * u.hr) dmap = differential_rotate(straddles_limb_map, observer=new_observer) assert dmap.data.shape[1] < straddles_limb_map.data.shape[1] # The output map should have the positional properties of the observer assert dmap.date == new_observer.obstime assert dmap.heliographic_latitude == new_observer.lat assert dmap.heliographic_longitude == new_observer.lon
def test_differential_rotate(aia171_test_map, all_off_disk_map, all_on_disk_map, straddles_limb_map): # Test a map that is entirely off the disk of the Sun # Should report an error with pytest.raises(ValueError): dmap = differential_rotate(all_off_disk_map) # Test a full disk map new_observer = get_earth(aia171_test_map.date + 6*u.hr) dmap = differential_rotate(aia171_test_map, observer=new_observer) assert dmap.data.shape == aia171_test_map.data.shape # Test a map that is entirely on disk - triggers sub full disk branches # Rotated map should have a smaller extent in the x - direction new_observer = get_earth(all_on_disk_map.date - 48*u.hr) dmap = differential_rotate(all_on_disk_map, observer=new_observer) assert dmap.data.shape[1] < all_on_disk_map.data.shape[1] # This rotated map should have a larger extent in the x direction new_observer = get_earth(all_on_disk_map.date + 48*u.hr) dmap = differential_rotate(all_on_disk_map, observer=new_observer) assert dmap.data.shape[1] > all_on_disk_map.data.shape[1] # Test a map that straddles the limb - triggers sub full disk branches # Rotated map should have a smaller extent in the x - direction new_observer = get_earth(straddles_limb_map.date + 48*u.hr) dmap = differential_rotate(straddles_limb_map, observer=new_observer) assert dmap.data.shape[1] < straddles_limb_map.data.shape[1] # The output map should have the positional properties of the observer assert dmap.date == new_observer.obstime assert dmap.heliographic_latitude == new_observer.lat assert dmap.heliographic_longitude == new_observer.lon
def test_solar_rotate_coordinate(): # Testing along the Sun-Earth line, observer is on the Earth obs_time = '2010-09-10 12:34:56' observer = get_earth(obs_time) c = SkyCoord(-570 * u.arcsec, 120 * u.arcsec, obstime=obs_time, observer=observer, frame=frames.Helioprojective) new_time = '2010-09-11 12:34:56' new_observer = get_earth(new_time) # Test that when both the observer and the time are specified, an error is raised. with pytest.raises(ValueError): d = solar_rotate_coordinate(c, observer=observer, time=new_time) # Test that the code properly filters the observer keyword with pytest.raises(ValueError): d = solar_rotate_coordinate(c, observer='earth') # Test that the code properly filters the time keyword with pytest.raises(ValueError): with pytest.warns( UserWarning, match="Using 'time' assumes an Earth-based observer"): d = solar_rotate_coordinate(c, time='noon') # Test that the code gives the same output for multiple different inputs # that define the same observer location and time. for i, definition in enumerate( (1 * u.day, TimeDelta(1 * u.day), new_time, new_observer)): if i in (0, 1, 2): with pytest.warns( UserWarning, match="Using 'time' assumes an Earth-based observer"): d = solar_rotate_coordinate(c, time=definition) else: d = solar_rotate_coordinate(c, observer=definition) # Test that a SkyCoordinate is created assert isinstance(d, SkyCoord) # Test the coordinate np.testing.assert_almost_equal(d.Tx.to(u.arcsec).value, -371.8885208634674, decimal=1) np.testing.assert_almost_equal(d.Ty.to(u.arcsec).value, 105.35006656251727, decimal=1) np.testing.assert_allclose(d.distance.to(u.km).value, 1.499642e+08, rtol=1e-5) # Test that the SkyCoordinate is Helioprojective assert isinstance(d.frame, frames.Helioprojective)
def test_get_earth(): # Validate against published values from the Astronomical Almanac (2013) e1 = get_earth('2013-Jan-01') assert e1.lon == 0 * u.deg assert_quantity_allclose(e1.lat, -3.03 * u.deg, atol=5e-3 * u.deg) assert_quantity_allclose(e1.radius, 0.9832947 * u.AU, atol=5e-7 * u.AU) e2 = get_earth('2013-Sep-01') assert e2.lon == 0 * u.deg assert_quantity_allclose(e2.lat, 7.19 * u.deg, atol=5e-3 * u.deg) assert_quantity_allclose(e2.radius, 1.0092561 * u.AU, atol=5e-7 * u.AU)
def test_differential_rotate_observer_all_on_disk(all_on_disk_map): # Test a map that is entirely on disk - triggers sub full disk branches # Rotated map should have a smaller extent in the x - direction new_observer = get_earth(all_on_disk_map.date - 48 * u.hr) dmap = differential_rotate(all_on_disk_map, observer=new_observer) assert dmap.data.shape[1] < all_on_disk_map.data.shape[1] # This rotated map should have a larger extent in the x direction new_observer = get_earth(all_on_disk_map.date + 48 * u.hr) dmap = differential_rotate(all_on_disk_map, observer=new_observer) assert dmap.data.shape[1] > all_on_disk_map.data.shape[1] assert dmap.date.isot == new_observer.obstime.isot assert dmap.heliographic_latitude == new_observer.lat assert dmap.heliographic_longitude == new_observer.lon
def test_solar_rotate_coordinate(): # Testing along the Sun-Earth line, observer is on the Earth obstime = '2010-09-10 12:34:56' newtime = '2010-09-10 13:34:56' c = SkyCoord(-570*u.arcsec, 120*u.arcsec, obstime=obstime, observer=get_earth(obstime), frame=frames.Helioprojective) d = solar_rotate_coordinate(c, newtime) # Test that a SkyCoordinate is created assert isinstance(d, SkyCoord) # Test the coordinate np.testing.assert_almost_equal(d.Tx.to(u.arcsec).value, -562.3768, decimal=1) np.testing.assert_almost_equal(d.Ty.to(u.arcsec).value, 119.2684, decimal=1) np.testing.assert_almost_equal(d.distance.to(u.km).value, 150083151.97246578, decimal=1) # Test that the SkyCoordinate is Helioprojective assert isinstance(d.frame, frames.Helioprojective) # Test the observer assert d.observer.obstime == Time(parse_time(newtime), scale='utc') np.testing.assert_almost_equal(d.observer.lon.to(u.deg).value, 0.0, decimal=5) np.testing.assert_almost_equal(d.observer.lat.to(u.deg).value, 7.248, decimal=3) np.testing.assert_almost_equal(d.observer.radius.to(u.AU).value, 1.006954, decimal=6) assert isinstance(d.observer, frames.HeliographicStonyhurst)
def test_solar_rotate_coordinate(): # Testing along the Sun-Earth line, observer is on the Earth obstime = '2010-09-10 12:34:56' newtime = '2010-09-10 13:34:56' c = SkyCoord(-570*u.arcsec, 120*u.arcsec, obstime=obstime, observer=get_earth(obstime), frame=frames.Helioprojective) d = solar_rotate_coordinate(c, newtime) # Test that a SkyCoordinate is created assert isinstance(d, SkyCoord) # Test the coordinate np.testing.assert_almost_equal(d.Tx.to(u.arcsec).value, -562.3768, decimal=1) np.testing.assert_almost_equal(d.Ty.to(u.arcsec).value, 119.2684, decimal=1) np.testing.assert_almost_equal(d.distance.to(u.km).value, 150083151.97246578, decimal=1) # Test that the SkyCoordinate is Helioprojective assert isinstance(d.frame, frames.Helioprojective) # Test the observer assert d.observer.obstime == Time(parse_time(newtime), scale='utc') np.testing.assert_almost_equal(d.observer.lon.to(u.deg).value, 0.0, decimal=5) np.testing.assert_almost_equal(d.observer.lat.to(u.deg).value, 7.248, decimal=3) np.testing.assert_almost_equal(d.observer.radius.to(u.AU).value, 1.006954, decimal=6) assert isinstance(d.observer, frames.HeliographicStonyhurst)
def test_rotate_submap_edge(aia171_test_map, all_off_disk_map, all_on_disk_map, straddles_limb_map): observer = get_earth(aia171_test_map.date + 2*u.day) # For a map that has all the edges off disk, the function should # return just the edges of the map - no solar rotation applied. for this_map in (aia171_test_map, all_off_disk_map): edges = map_edges(this_map) for this_edge in range(0, 4): pixels = edges[this_edge] res = _rotate_submap_edge(this_map, pixels, observer) assert all(res.Tx == (this_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty == (this_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) # For an on disk map, all the edges should change edges = map_edges(all_on_disk_map) for this_edge in range(0, 4): pixels = edges[this_edge] res = _rotate_submap_edge(all_on_disk_map, pixels, observer) assert all(res.Tx != (all_on_disk_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty != (all_on_disk_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) # For the limb map, two of the edges move and two do not edges = map_edges(straddles_limb_map) for this_edge in (0, 3): # Top and right edges do not move pixels = edges[this_edge] res = _rotate_submap_edge(straddles_limb_map, pixels, observer) assert all(res.Tx == (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty == (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) for this_edge in (1, 2): # Bottom and left edges do move pixels = edges[this_edge] res = _rotate_submap_edge(straddles_limb_map, pixels, observer) assert all(res.Tx != (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty != (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty)
def test_rotate_submap_edge(aia171_test_map, all_off_disk_map, all_on_disk_map, straddles_limb_map): observer = get_earth(aia171_test_map.date + 2*u.day) # For a map that has all the edges off disk, the function should # return just the edges of the map - no solar rotation applied. for this_map in (aia171_test_map, all_off_disk_map): edges = map_edges(this_map) for this_edge in range(0, 4): pixels = edges[this_edge] res = _rotate_submap_edge(this_map, pixels, observer) assert all(res.Tx == (this_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty == (this_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) # For an on disk map, all the edges should change edges = map_edges(all_on_disk_map) for this_edge in range(0, 4): pixels = edges[this_edge] res = _rotate_submap_edge(all_on_disk_map, pixels, observer) assert all(res.Tx != (all_on_disk_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty != (all_on_disk_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) # For the limb map, two of the edges move and two do not edges = map_edges(straddles_limb_map) for this_edge in (0, 3): # Top and right edges do not move pixels = edges[this_edge] res = _rotate_submap_edge(straddles_limb_map, pixels, observer) assert all(res.Tx == (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty == (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) for this_edge in (1, 2): # Bottom and left edges do move pixels = edges[this_edge] res = _rotate_submap_edge(straddles_limb_map, pixels, observer) assert all(res.Tx != (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty != (straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty)
def calc_ci(MAPCUBE, xdim, ydim, LOCS, id): c1 = SkyCoord(LOCS[id].Tx - xdim/2.0, LOCS[id].Ty - ydim/2.0, frame = MAPCUBE[id].coordinate_frame) c2 = SkyCoord(LOCS[id].Tx + xdim/2.0, LOCS[id].Ty + ydim/2.0, frame = MAPCUBE[id].coordinate_frame) CUTOUT = MAPCUBE[id].submap(c1, c2) DATA = CUTOUT.data THRESHOLD = np.amax(DATA) - 500 for i in range(len(DATA)): for j in range(len(DATA[0])): if DATA[i][j] < THRESHOLD: DATA[i][j] = 0 ci = list(ndimage.measurements.center_of_mass(DATA)) ci = [int(ci[1] + 0.5) * u.pixel, int(ci[0] + 0.5) * u.pixel] COORD = CUTOUT.pixel_to_world(ci[0], ci[1]) return SkyCoord(COORD.Tx, COORD.Ty, obstime = str(MAPCUBE[id].date), observer = get_earth(MAPCUBE[id].date), frame = frames.Helioprojective)
def map_rot_correct(mmap,refx,refy,reftime): """ Correct the solar rotation. Parameters ---------- mmap : sunpy.map.GenericMap Single map class. refx : astropy.units.Quantity Horizontal wcs information of reference frame. refy : astropy.units.Quantity Vertical wcs information of reference frame. reftime : astropy.time.Time Time for the reference frame. Returns ------- smap : sunpy.map.GenericMap Solar rotation corrected map class. """ refc = SkyCoord(refx, refy, obstime= reftime, observer= get_earth(reftime), frame= frames.Helioprojective) date = mmap.date res = solar_rotate_coordinate(refc, date ,frame_time= 'synodic') x = res.Tx.value y = res.Ty.value sx = x - refx.value sy = y - refy.value smap = mmap.shift(-sx,-sy) return smap
def test_get_body_heliographic_stonyhurst_light_travel_time(): # Tests whether the apparent position of the Sun accounts for light travel time t = Time('2012-06-05 22:34:48.350') # An arbitrary test time # Use the implemented correction for light travel time implementation = get_body_heliographic_stonyhurst('sun', t, observer=get_earth(t)) implementation_icrs = SkyCoord(implementation).icrs.cartesian # Use a manual correction for light travel time light_travel_time = get_earth(t).radius / speed_of_light manual = get_body_heliographic_stonyhurst('sun', t - light_travel_time) manual_icrs = SkyCoord(manual).icrs.cartesian difference = (implementation_icrs - manual_icrs).norm() assert_quantity_allclose(difference, 0 * u.m, atol=1 * u.m)
def test_differential_rotate_observer_full_disk(aia171_test_map): # Test a full disk map new_observer = get_earth(aia171_test_map.date + 6 * u.hr) dmap = differential_rotate(aia171_test_map, observer=new_observer) assert dmap.data.shape == aia171_test_map.data.shape assert dmap.date.isot == new_observer.obstime.isot assert dmap.heliographic_latitude == new_observer.lat assert dmap.heliographic_longitude == new_observer.lon
def test_get_body_heliographic_stonyhurst_light_travel_time_array(): # Tests whether requesting an array of locations returns the same answers as individually t1 = Time('2001-02-03 04:05:06') t2 = Time('2011-12-13 14:15:16') venus1 = get_body_heliographic_stonyhurst('venus', t1, observer=get_earth(t1)) venus2 = get_body_heliographic_stonyhurst('venus', t2, observer=get_earth(t2)) both = get_body_heliographic_stonyhurst('venus', [t1, t2], observer=get_earth([t1, t2])) assert_quantity_allclose(venus1.lon, both[0].lon) assert_quantity_allclose(venus1.lat, both[0].lat) assert_quantity_allclose(venus1.radius, both[0].radius) assert_quantity_allclose(venus2.lon, both[1].lon) assert_quantity_allclose(venus2.lat, both[1].lat) assert_quantity_allclose(venus2.radius, both[1].radius)
def test_get_bounding_coordinates(): coords = SkyCoord([-1, 0, 1] * u.arcsec, [-2, 0, 2] * u.arcsec, frame=frames.Helioprojective, observer=get_earth("1999-09-13 00:00:00")) bl, tr = _get_bounding_coordinates(coords) assert bl.Tx == -1*u.arcsec assert bl.Ty == -2*u.arcsec assert bl.observer == coords[0].observer assert tr.Tx == 1*u.arcsec assert tr.Ty == 2*u.arcsec assert tr.observer == coords[0].observer
def test_get_bounding_coordinates(): coords = SkyCoord([-1, 0, 1] * u.arcsec, [-2, 0, 2] * u.arcsec, frame=frames.Helioprojective, observer=get_earth("1999-09-13 00:00:00")) bl, tr = _get_bounding_coordinates(coords) assert bl.Tx == -1*u.arcsec assert bl.Ty == -2*u.arcsec assert bl.observer == coords[0].observer assert tr.Tx == 1*u.arcsec assert tr.Ty == 2*u.arcsec assert tr.observer == coords[0].observer
def test_rotate_submap_edge(aia171_test_map, all_off_disk_map, all_on_disk_map, straddles_limb_map): observer = get_earth(aia171_test_map.date + 2 * u.day) # For a map that has all the edges off disk, the function should # return just the edges of the map - no solar rotation applied. for this_map in (aia171_test_map, all_off_disk_map): edges = map_edges(this_map) for this_edge in range(0, 4): pixels = edges[this_edge] res = _rotate_submap_edge(this_map, pixels, observer) assert all( res.Tx == (this_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all( res.Ty == (this_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) # For an on disk map, all the edges should change edges = map_edges(all_on_disk_map) for this_edge in range(0, 4): pixels = edges[this_edge] res = _rotate_submap_edge(all_on_disk_map, pixels, observer) assert all(res.Tx != ( all_on_disk_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty != ( all_on_disk_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) # For the limb map, two of the edges move and two do not edges = map_edges(straddles_limb_map) for this_edge in (0, 3): # Top and right edges do not move pixels = edges[this_edge] res = _rotate_submap_edge(straddles_limb_map, pixels, observer) assert all(res.Tx == ( straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty == ( straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty) for this_edge in (1, 2): # Bottom and left edges do move pixels = edges[this_edge] res = _rotate_submap_edge(straddles_limb_map, pixels, observer) # Ignore some invalid NaN comparisions within astropy # (fixed in astropy 4.0.1 https://github.com/astropy/astropy/pull/9843) with np.errstate(invalid='ignore'): assert all(res.Tx != ( straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Tx) assert all(res.Ty != ( straddles_limb_map.pixel_to_world(pixels[:, 0], pixels[:, 1])).Ty)
def test_consistency_with_horizons(astropy_ephemeris_de432s, obstime): # get_horizons_coord() depends on astroquery pytest.importorskip("astroquery") # Check whether the location of Earth is the same between Astropy and JPL HORIZONS e1 = get_earth(obstime) e2 = get_horizons_coord('Geocenter', obstime) assert_quantity_allclose(e2.separation_3d(e1), 0 * u.km, atol=50 * u.m) # Check whether the location of Mars is the same between Astropy and JPL HORIZONS e1 = get_body_heliographic_stonyhurst('mars', obstime) e2 = get_horizons_coord('Mars barycenter', obstime) assert_quantity_allclose(e2.separation_3d(e1), 0 * u.km, atol=500 * u.m)
def test_differential_rotate_observer_straddles_limb(straddles_limb_map): # Test a map that straddles the limb - triggers sub full disk branches # Rotated map should have a smaller extent in the x - direction new_observer = get_earth(straddles_limb_map.date + 48 * u.hr) # Ignore some invalid NaN comparisons within astropy # (fixed in astropy 4.0.1 https://github.com/astropy/astropy/pull/9843) with np.errstate(invalid='ignore'): dmap = differential_rotate(straddles_limb_map, observer=new_observer) assert dmap.data.shape[1] < straddles_limb_map.data.shape[1] # The output map should have the positional properties of the observer assert dmap.date.isot == new_observer.obstime.isot assert dmap.heliographic_latitude == new_observer.lat assert dmap.heliographic_longitude == new_observer.lon
def test_consistency_with_horizons(use_DE440s, obstime): # Check that the high-accuracy Astropy ephemeris has been set assert solar_system_ephemeris.get() == 'de440s' # Check whether the location of Earth is the same between Astropy and JPL HORIZONS e1 = get_earth(obstime) e2 = get_horizons_coord('Geocenter', obstime) assert_quantity_allclose(e2.separation_3d(e1), 0 * u.km, atol=50 * u.m) # Check whether the location of Mars is the same between Astropy and JPL HORIZONS e1 = get_body_heliographic_stonyhurst('mars', obstime) e2 = get_horizons_coord('Mars barycenter', obstime) assert_quantity_allclose(e2.separation_3d(e1), 0 * u.km, atol=500 * u.m)
def test_solar_rotate_coordinate(): # Testing along the Sun-Earth line, observer is on the Earth obs_time = '2010-09-10 12:34:56' observer = get_earth(obs_time) c = SkyCoord(-570*u.arcsec, 120*u.arcsec, obstime=obs_time, observer=observer, frame=frames.Helioprojective) new_time = '2010-09-11 12:34:56' new_observer = get_earth(new_time) # Test that when both the observer and the time are specified, an error is raised. with pytest.raises(ValueError): d = solar_rotate_coordinate(c, observer=observer, time=new_time) # Test that the code properly filters the observer keyword with pytest.raises(ValueError): d = solar_rotate_coordinate(c, observer='earth') # Test that the code properly filters the time keyword with pytest.raises(ValueError): d = solar_rotate_coordinate(c, time='noon') # Test that the code gives the same output for multiple different inputs # that define the same observer location and time. for i, definition in enumerate((1 * u.day, TimeDelta(1*u.day), new_time, new_observer)): if i in (0, 1, 2): d = solar_rotate_coordinate(c, time=definition) else: d = solar_rotate_coordinate(c, observer=definition) # Test that a SkyCoordinate is created assert isinstance(d, SkyCoord) # Test the coordinate np.testing.assert_almost_equal(d.Tx.to(u.arcsec).value, -371.8885208634674, decimal=1) np.testing.assert_almost_equal(d.Ty.to(u.arcsec).value, 105.35006656251727, decimal=1) np.testing.assert_allclose(d.distance.to(u.km).value, 1.499642e+08, rtol=1e-5) # Test that the SkyCoordinate is Helioprojective assert isinstance(d.frame, frames.Helioprojective)
def test_velocity_hgs_hci(): # HGS and HCI share the same origin and Z axis, so the induced velocity is entirely angular obstime = Time(['2021-01-01', '2021-04-01', '2021-07-01', '2021-10-01']) venus_hgs = get_body_heliographic_stonyhurst('venus', obstime, include_velocity=True) venus_hci = venus_hgs.transform_to(HeliocentricInertial(obstime=obstime)) # The induced velocity is the longitude component of Earth's velocity, ~360 deg/yr induced_dlon = get_earth(obstime, include_velocity=True).heliocentricinertial.d_lon assert_quantity_allclose(induced_dlon, 360*u.deg/u.yr, rtol=0.05) # The HCI velocity should be the same as the HGS velocity except for the induced velocity assert_quantity_allclose(venus_hci.d_distance, venus_hgs.d_radius, rtol=1e-5) assert_quantity_allclose(venus_hci.d_lon, venus_hgs.d_lon + induced_dlon, rtol=1e-6) assert_quantity_allclose(venus_hci.d_lat, venus_hgs.d_lat)
def test_warp_sun_coordinates(all_on_disk_map): # Define an observer new_observer = get_earth(all_on_disk_map.date + 6 * u.hr) dummy_array = np.zeros((500, 2)) # Call the warp xy2 = _warp_sun_coordinates(dummy_array, all_on_disk_map, new_observer) # Test the properties of the output assert xy2.shape == dummy_array.shape assert isinstance(xy2, np.ndarray) # Test the values - values are not independently found # We are passing in 500 pairs of (0,0) so all the output pixels should be the same np.testing.assert_almost_equal(xy2[:, 0], -2.08384686, decimal=2) np.testing.assert_almost_equal(xy2[:, 1], -0.23927568, decimal=2)
def test_get_new_observer(aia171_test_map): initial_obstime = aia171_test_map.date rotation_interval = 2 * u.day new_time = initial_obstime + rotation_interval time_delta = new_time - initial_obstime observer = get_earth(initial_obstime + rotation_interval) # The observer time is set along with other definitions of time for time in (rotation_interval, new_time, time_delta): with pytest.raises(ValueError): new_observer = _get_new_observer(initial_obstime, observer, time) # Obstime property is present but the value is None observer_obstime_is_none = SkyCoord(12*u.deg, 46*u.deg, frame=frames.HeliographicStonyhurst) with pytest.raises(ValueError): new_observer = _get_new_observer(None, observer_obstime_is_none, None) # When the observer is set, it gets passed back out new_observer = _get_new_observer(initial_obstime, observer, None) assert isinstance(new_observer, SkyCoord) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, decimal=3) # When the time is set, a coordinate for Earth comes back out for time in (rotation_interval, new_time, time_delta): with pytest.warns(UserWarning, match="Using 'time' assumes an Earth-based observer"): new_observer = _get_new_observer(initial_obstime, None, time) assert isinstance(new_observer, SkyCoord) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, decimal=3) # The observer and the time cannot both be None with pytest.raises(ValueError): new_observer = _get_new_observer(initial_obstime, None, None)
def test_get_new_observer(aia171_test_map): initial_obstime = aia171_test_map.date rotation_interval = 2 * u.day new_time = initial_obstime + rotation_interval time_delta = new_time - initial_obstime observer = get_earth(initial_obstime + rotation_interval) # The observer time is set along with other definitions of time for time in (rotation_interval, new_time, time_delta): with pytest.raises(ValueError): new_observer = _get_new_observer(initial_obstime, observer, time) # Obstime property is present but the value is None observer_obstime_is_none = SkyCoord(12*u.deg, 46*u.deg, frame=frames.HeliographicStonyhurst) with pytest.raises(ValueError): new_observer = _get_new_observer(None, observer_obstime_is_none, None) # When the observer is set, it gets passed back out new_observer = _get_new_observer(initial_obstime, observer, None) assert isinstance(new_observer, SkyCoord) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, decimal=3) # When the time is set, a coordinate for Earth comes back out for time in (rotation_interval, new_time, time_delta): new_observer = _get_new_observer(initial_obstime, None, time) assert isinstance(new_observer, SkyCoord) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lon.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, observer.transform_to(frames.HeliographicStonyhurst).lat.to(u.deg).value, decimal=3) np.testing.assert_almost_equal(new_observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, observer.transform_to(frames.HeliographicStonyhurst).radius.to(u.au).value, decimal=3) # The observer and the time cannot both be None with pytest.raises(ValueError): new_observer = _get_new_observer(initial_obstime, None, None)
def test_warp_sun_coordinates(all_on_disk_map): # Define an observer new_observer = get_earth(all_on_disk_map.date + 6*u.hr) # This array is not used in the function but is part of the signature dummy_array = np.zeros(10) # Call the warp xy2 = _warp_sun_coordinates(dummy_array, all_on_disk_map, new_observer) # Test the properties of the output shape = all_on_disk_map.data.shape assert xy2.shape == (shape[0]*shape[1], 2) assert isinstance(xy2, np.ma.core.MaskedArray) # Test the values - values are not independently found np.testing.assert_almost_equal(xy2[0, 0], -2.063284482734346, decimal=2) np.testing.assert_almost_equal(xy2[0, 1], -0.23511899658107005, decimal=2) np.testing.assert_almost_equal(xy2[499, 0], 16.396007639829428, decimal=2) np.testing.assert_almost_equal(xy2[499, 1], 23.87553530074777, decimal=2)
def test_warp_sun_coordinates(all_on_disk_map): # Define an observer new_observer = get_earth(all_on_disk_map.date + 6 * u.hr) # This array is not used in the function but is part of the signature dummy_array = np.zeros(10) # Call the warp xy2 = _warp_sun_coordinates(dummy_array, all_on_disk_map, new_observer) # Test the properties of the output shape = all_on_disk_map.data.shape assert xy2.shape == (shape[0] * shape[1], 2) assert isinstance(xy2, np.ma.core.MaskedArray) # Test the values - values are not independently found np.testing.assert_almost_equal(xy2[0, 0], -2.063284482734346, decimal=2) np.testing.assert_almost_equal(xy2[0, 1], -0.23511899658107005, decimal=2) np.testing.assert_almost_equal(xy2[499, 0], 16.396007639829428, decimal=2) np.testing.assert_almost_equal(xy2[499, 1], 23.87553530074777, decimal=2)
def update_fiss_header(file,alignfile,**kwargs): """ Create the new FISS data with update header. Parameters ---------- file : list FISS fts file list alignfile : str Aligned information binary (.npz) file. sil : (optional) bool If False, it print the ongoing time index. * Default is True. sol_rot : (optional) bool If True, correct the solar rotation when update the file header. * Default is False. Returns ------- mfts : file List of files which updated the header. Notes ----- Name of saved fits data file is added 'm' to the first character of original data name. """ sil=kwargs.pop('sil',False) sol_rot=kwargs.pop('sol_rot',False) if not sil: print('Add the align information to the haeder.') level=alignfile[-8:-4] inform=np.load(alignfile) fissht=[getheader(i) for i in file] fissh=[fits.getheader(i) for i in file] tlist=[i['date'] for i in fissht] time=Time(tlist,format='isot',scale='ut1') angle=inform['angle'] ny=fissht[0]['naxis2'] nx=fissht[0]['naxis3'] x=np.array((0,nx-1,nx-1,0)) y=np.array((0,0,ny-1,ny-1)) xc=inform['xc'].item() yc=inform['yc'].item() dx=inform['dx'] dy=inform['dy'] xt1,yt1=rot_trans(x,y,xc,yc,angle.max()) xt2,yt2=rot_trans(x,y,xc,yc,angle.min()) tmpx=np.concatenate((xt1,xt2)) tmpy=np.concatenate((yt1,yt2)) xmargin=int(np.abs(np.round(tmpx.min()+dx.min())))+1 ymargin=int(np.abs(np.around(tmpy.min()+dy.min())))+1 if level=='lev0': for i,h in enumerate(fissh): h['alignl']=(0,'Alignment level') h['reflect']=(False,'Mirror reverse') h['reffr']=(inform['reffr'].item(),'Reference frame in alignment') h['reffi']=(inform['reffi'].item(),'Reference file name in alignment') h['cdelt2']=(0.16,'arcsec per pixel') h['cdelt3']=(0.16,'arcsec per pixel') h['crota2']=(angle[i], 'Roation angle about reference pixel') h['crpix3']=(inform['xc'].item(),'Reference pixel in data axis 3') h['shift3']=(inform['dx'][i], 'Shifting pixel value along data axis 2') h['crpix2']=(inform['yc'].item(),'Reference pixel in data axis 2') h['shift2']=(inform['dy'][i], 'Shifting pixel value along data axis 3') h['margin2']=(ymargin,'Rotation margin in axis 2') h['margin3']=(xmargin,'Rotation margin in axis 3') h['history']='FISS aligned (lev0)' elif level=='lev1': wcsx=inform['wcsx'] wcsy=inform['wcsy'] xref=wcsx*u.arcsec yref=wcsy*u.arcsec reffr=inform['reffr'] for i,h in enumerate(fissh): if sol_rot: refc = SkyCoord(xref, yref, obstime = time[reffr], observer= get_earth(time[reffr]), frame= frames.Helioprojective) res = solar_rotate_coordinate(refc, time[i], frame_time= 'synodic') wcsx = res.Tx.value wcsy = res.Ty.value h['crval3']=(wcsx.value, 'Location of ref pixel x (arcsec)') h['crval2']=(wcsy.value, 'Location of ref pixel y (arcsec)') else: h['crval3']=(wcsx.item(), 'Location of ref pixel for ref frame x (arcsec)') h['crval2']=(wcsy.item(), 'Location of ref pixel for ref frame y (arcsec)') h['alignl']=(1,'Alignment level') h['reflect']=(inform['reflect'].item(),'Mirror reverse') h['reffr']=(inform['reffr'].item(),'Reference frame in alignment') h['reffi']=(inform['reffi'].item(),'Reference file name in alignment') h['cdelt2']=(0.16,'arcsec per pixel') h['cdelt3']=(0.16,'arcsec per pixel') h['crota1']=(inform['sdo_angle'].item(), 'Rotation angle of reference frame (radian)') h['crota2']=(inform['angle'][i], 'Rotation angle about reference pixel (radian)') h['crpix3']=(inform['xc'].item(),'Reference pixel in data axis 3') h['shift3']=(inform['dx'][i], 'Shifting pixel value along data axis 3') h['crpix2']=(inform['yc'].item(),'Reference pixel in data axis 2') h['shift2']=(inform['dy'][i], 'Shifting pixel value along data axis 2') h['margin2']=(ymargin,'Rotation margin in axis 2') h['margin3']=(xmargin,'Rotation margin in axis 3') h['srot']=(True,'Solar Rotation correction') h['history']='FISS aligned and matched wcs (lev1)' else: raise ValueError('The level of alignfile is neither lev0 or lev1.') data=[fits.getdata(i) for i in file] odirname=os.path.dirname(file[0]) if not odirname: odirname=os.getcwd() dirname = os.path.join(odirname, 'match') try: os.mkdir(dirname) except: pass for i,oname in enumerate(file): name='m'+os.path.basename(oname) fits.writeto(os.path.join(dirname, name),data[i],fissh[i]) try: pfilelist=[i['pfile'] for i in fissh] pfileset=set(pfilelist) for i in pfileset: copy2(os.path.join(odirname, i),os.path.join(dirname,i)) except: pass if not sil: print("The align information is updated to the header, " "and new fts file is locate %s the file name is 'mFISS*.fts'"%dirname)
else: INIT_COORD = cutout_selection(MAPCUBE) auto_sel = False ######################### PRINTER.line() INIT_TIME = str(MAPCUBE[0].date) PRINTER.display_item("Initial time", INIT_TIME) ######################### INIT_LOC = SkyCoord(INIT_COORD.Tx, INIT_COORD.Ty, obstime = INIT_TIME, observer = get_earth(INIT_TIME), frame = frames.Helioprojective) PRINTER.display_item("Initial location", "(%s arcsec, %s arcsec)" % (INIT_LOC.Tx, INIT_LOC.Ty)) ######################### PRINTER.info_text("Calculating future coordinates") LOCS = [solar_rotate_coordinate(INIT_LOC, MAPCUBE[i].date) for i in range(len(MAPCUBE))] ######################### if ask_to_change_default_settings: if(PRINTER.input_text("Use default settings (low scale 0, high scale 40000)? [y/n]") == "n"): default_low_scale = int(PRINTER.input_text("Enter low scale"))