def test_filter_thru(self):
fname = get_pkg_data_filename('t/spPlate-4055-55359-0020.fits')
with fits.open(fname) as hdulist:
flux = hdulist[0].data
npix = hdulist[0].header['NAXIS1']
ntrace = hdulist[0].header['NAXIS2']
crval1 = hdulist[0].header['COEFF0']
cd1_1 = hdulist[0].header['COEFF1']
assert flux.shape == (ntrace, npix)
loglam0 = crval1 + cd1_1*np.arange(npix, dtype=flux.dtype)
waveimg = 10**(np.tile(loglam0, 20).reshape(flux.shape))
assert waveimg.shape == flux.shape
f = filter_thru(flux, waveimg=waveimg)
idl_data_file = get_pkg_data_filename('t/filter_thru_idl_data.txt')
idl_data = np.loadtxt(idl_data_file, dtype='f', delimiter=',').T
assert f.shape == (20, 5)
assert np.allclose(f, idl_data, atol=1.0e-6)
#
# Test bad input.
#
with raises(ValueError):
f = filter_thru(flux)
with raises(ValueError):
f = filter_thru(flux, waveimg=waveimg, filter_prefix='sdss')
return
def test_coeff(basename):
nmax = 6
lmax = 10 # HACK: these are hard-set in Fortran
pos_path = os.path.abspath(get_pkg_data_filename('data/{}-samples.dat.gz'.format(basename)))
coeff_path = os.path.abspath(get_pkg_data_filename('data/computed-{0}.coeff'.format(basename)))
coeff = np.atleast_2d(np.loadtxt(coeff_path))
xyz = np.ascontiguousarray(np.loadtxt(pos_path, skiprows=1))
S,T = compute_coeffs_discrete(xyz, mass=np.zeros(xyz.shape[0])+1./xyz.shape[0],
nmax=nmax, lmax=lmax, r_s=1.)
S_f77 = np.zeros((nmax+1,lmax+1,lmax+1))
T_f77 = np.zeros((nmax+1,lmax+1,lmax+1))
for row in coeff:
n,l,m,cc,sc = row
# transform from H&O 1992 coefficients to Lowing 2011 coefficients
if l != 0:
fac = np.sqrt(4*np.pi) * np.sqrt((2*l+1) / (4*np.pi) * factorial(l-m) / factorial(l+m))
cc /= fac
sc /= fac
S_f77[int(n),int(l),int(m)] = -cc
T_f77[int(n),int(l),int(m)] = -sc
assert np.allclose(S_f77, S)
def list_votable_fields(self):
"""
Lists all the fields that can be fetched for a VOTable.
Examples
--------
>>> from astroquery.simbad import Simbad
>>> Simbad.list_votable_fields()
--NOTES--...
"""
# display additional notes:
notes_file = get_pkg_data_filename(os.path.join('data', 'votable_fields_notes.json'))
with open(notes_file, "r") as f:
notes = json.load(f)
print ("--NOTES--\n")
for i, line in list(enumerate(notes)):
print ("{lineno}. {msg}\n".format(lineno=i+1, msg=line))
# load the table
votable_fields_table = Table.read(get_pkg_data_filename
(os.path.join('data',
'votable_fields_table.txt')),
format='ascii')
print (votable_fields_table)
print("\nFor more information on a field :\nSimbad.get_field_description "
"('field_name')")
def list_votable_fields(self):
"""
Lists all the fields that can be fetched for a VOTable.
Examples
--------
>>> from astroquery.simbad import Simbad
>>> Simbad.list_votable_fields()
--NOTES--...
"""
# display additional notes:
notes_file = get_pkg_data_filename(
os.path.join('data', 'votable_fields_notes.json'))
with open(notes_file, "r") as f:
notes = json.load(f)
print("--NOTES--\n")
for i, line in list(enumerate(notes)):
print("{lineno}. {msg}\n".format(lineno=i + 1, msg=line))
dict_file = get_pkg_data_filename(
os.path.join('data', 'votable_fields_dict.json'))
with open(dict_file, "r") as f:
fields_dict = json.load(f)
print("Available VOTABLE fields:\n")
for field in list(sorted(fields_dict.keys())):
print("{}".format(field))
print("For more information on a field:\n"
"Simbad.get_field_description ('field_name') \n"
"Currently active VOTABLE fields:\n {0}"
.format(self._VOTABLE_FIELDS))
def test_file(filename):
filename = get_pkg_data_filename(filename)
regs = read_ds9(filename, errors='warn')
coordsys = os.path.basename(filename).split(".")[1]
actual = ds9_objects_to_string(regs, coordsys=str(coordsys), fmt='.2f',
radunit=None if coordsys=='physical' else 'arcsec').strip()
reffile = get_pkg_data_filename('data/{coordsys}{strip}_reference.reg'
.format(coordsys=coordsys,
strip=("_strip"
if "strip" in filename
else "")))
with open(reffile, 'r') as fh:
desired = fh.read().strip()
# since metadata is not required to preserve order, we have to do a more
# complex comparison
desired_lines = [set(line.split(" ")) for line in desired.split("\n")]
actual_lines = [set(line.split(" ")) for line in actual.split("\n")]
for split_line in actual_lines:
assert split_line in desired_lines
for split_line in desired_lines:
assert split_line in actual_lines
def list_votable_fields(self):
"""
Lists all the fields that can be fetched for a VOTable.
Examples
--------
>>> from astroquery.simbad import Simbad
>>> Simbad.list_votable_fields()
--NOTES--...
"""
# display additional notes:
notes_file = get_pkg_data_filename(
os.path.join('data', 'votable_fields_notes.json'))
with open(notes_file, "r") as f:
notes = json.load(f)
print("--NOTES--\n")
for i, line in list(enumerate(notes)):
print("{lineno}. {msg}\n".format(lineno=i + 1, msg=line))
if not hasattr(self,'_votable_fields_table'):
# load the table
votable_fields_table = Table.read(
get_pkg_data_filename(os.path.join('data',
'votable_fields_table.txt')),
format='ascii')
self._votable_fields_table = votable_fields_table
else:
votable_fields_table = self._votable_fields_table
print("Available VOTABLE fields:\n")
votable_fields_table.pprint(max_lines=100)
print("For more information on a field :\n"
"Simbad.get_field_description ('field_name') \n"
"Currently active VOTABLE fields:\n {0}"
.format(self._VOTABLE_FIELDS))
def setup(self):
# extracted from spFrame-b1-00057618.fits
self.sdss = fits.open(get_pkg_data_filename('t/sdss_traceset.fits'))
# extracted from spFrame-r1-00180406.fits
self.boss = fits.open(get_pkg_data_filename('t/boss_traceset.fits'))
return
def test_gradient(basename):
pos_path = os.path.abspath(get_pkg_data_filename('data/positions.dat.gz'))
coeff_path = os.path.abspath(get_pkg_data_filename('data/{0}.coeff'.format(basename)))
accp_path = os.path.abspath(get_pkg_data_filename('data/{0}-accp.dat.gz'.format(basename)))
xyz = np.loadtxt(pos_path, skiprows=1)
coeff = np.atleast_2d(np.loadtxt(coeff_path, skiprows=1))
accp = np.loadtxt(accp_path)
nmax = coeff[:,0].astype(int).max()
lmax = coeff[:,1].astype(int).max()
cos_coeff = np.zeros((nmax+1, lmax+1, lmax+1))
sin_coeff = np.zeros((nmax+1, lmax+1, lmax+1))
for row in coeff:
n, l, m, cc, sc = row
# transform from H&O 1992 coefficients to Lowing 2011 coefficients
if l != 0:
fac = np.sqrt(4*np.pi) * np.sqrt((2*l+1) / (4*np.pi) * factorial(l-m) / factorial(l+m))
cc /= fac
sc /= fac
cos_coeff[int(n), int(l), int(m)] = cc
sin_coeff[int(n), int(l), int(m)] = sc
grad = gradient(xyz, G=1., M=1., r_s=1.,
Snlm=cos_coeff, Tnlm=sin_coeff)
# I output the acceleration from SCF when I make the files
# so I have no idea why I don't need a minus sign here...
scf_grad = accp[:, :3]
np.testing.assert_allclose(grad, scf_grad, rtol=1E-6)
def test_potential(basename):
coeff_path = os.path.abspath(get_pkg_data_filename('data/{0}.coeff'.format(basename)))
accp_path = os.path.abspath(get_pkg_data_filename('data/{0}-accp.dat.gz'.format(basename)))
coeff = np.atleast_2d(np.loadtxt(coeff_path, skiprows=1))
accp = np.loadtxt(accp_path)
pos_path = os.path.abspath(get_pkg_data_filename('data/positions.dat.gz'))
xyz = np.loadtxt(pos_path, skiprows=1)
nmax = coeff[:, 0].astype(int).max()
lmax = coeff[:, 1].astype(int).max()
cos_coeff = np.zeros((nmax+1, lmax+1, lmax+1))
sin_coeff = np.zeros((nmax+1, lmax+1, lmax+1))
for row in coeff:
n, l, m, cc, sc = row
# transform from H&O 1992 coefficients to Lowing 2011 coefficients
if l != 0:
fac = np.sqrt(4*np.pi) * np.sqrt((2*l+1) / (4*np.pi) * factorial(l-m) / factorial(l+m))
cc /= fac
sc /= fac
cos_coeff[int(n), int(l), int(m)] = cc
sin_coeff[int(n), int(l), int(m)] = sc
potv = potential(xyz, G=1., M=1., r_s=1.,
Snlm=cos_coeff, Tnlm=sin_coeff)
# for some reason, SCF potential is -potential
scf_potv = -accp[:, -1]
np.testing.assert_allclose(potv, scf_potv, rtol=1E-6)
def test_density(basename):
pos_path = os.path.abspath(get_pkg_data_filename('data/positions.dat.gz'))
coeff_path = os.path.abspath(get_pkg_data_filename('data/{0}.coeff'.format(basename)))
accp_path = os.path.abspath(get_pkg_data_filename('data/{0}-accp.dat.gz'.format(basename)))
xyz = np.ascontiguousarray(np.loadtxt(pos_path, skiprows=1).T)
coeff = np.atleast_2d(np.loadtxt(coeff_path, skiprows=1))
nmax = coeff[:,0].astype(int).max()
lmax = coeff[:,1].astype(int).max()
cos_coeff = np.zeros((nmax+1, lmax+1, lmax+1))
sin_coeff = np.zeros((nmax+1, lmax+1, lmax+1))
for row in coeff:
n, l, m, cc, sc = row
# transform from H&O 1992 coefficients to Lowing 2011 coefficients
if l != 0:
fac = np.sqrt(4*np.pi) * np.sqrt((2*l+1) / (4*np.pi) * factorial(l-m) / factorial(l+m))
cc /= fac
sc /= fac
cos_coeff[int(n), int(l), int(m)] = cc
sin_coeff[int(n), int(l), int(m)] = sc
dens = density(xyz, M=1., r_s=1.,
Snlm=cos_coeff, Tnlm=sin_coeff)
def test_no_resource_check():
output = io.StringIO()
with catch_warnings():
# We can't test xmllint, because we can't rely on it being on the
# user's machine.
result = validate(get_pkg_data_filename('data/no_resource.xml'),
output, xmllint=False)
assert result is False
output.seek(0)
output = output.readlines()
# Uncomment to generate new groundtruth
# with open('no_resource.txt', 'wt', encoding='utf-8') as fd:
# fd.write(u''.join(output))
with open(
get_pkg_data_filename('data/no_resource.txt'),
'rt', encoding='utf-8') as fd:
truth = fd.readlines()
truth = truth[1:]
output = output[1:-1]
sys.stdout.writelines(
difflib.unified_diff(truth, output, fromfile='truth', tofile='output'))
assert truth == output
def test_file_lines(self):
#
# Find the test files
#
line_numbers = (1, 42, 137)
plainfiles = [get_pkg_data_filename('t/this-file-contains-{0:d}-lines.txt'.format(l)) for l in line_numbers]
gzfiles = [get_pkg_data_filename('t/this-file-contains-{0:d}-lines.txt.gz'.format(l)) for l in line_numbers]
for i, p in enumerate(plainfiles):
n = file_lines(p)
assert n == line_numbers[i]
for i, p in enumerate(gzfiles):
n = file_lines(p, compress=True)
assert n == line_numbers[i]
#
# Test list passing
#
n = file_lines(plainfiles)
assert tuple(n) == line_numbers
n = file_lines(gzfiles, compress=True)
assert tuple(n) == line_numbers
#
# Make sure empty files work
#
n = file_lines(get_pkg_data_filename('t/this-file-is-empty.txt'))
assert n == 0
def filenames():
"""Dictionary of available file names."""
result = dict()
result['psf'] = get_pkg_data_filename('data/fermi/psf.fits')
result['counts'] = get_pkg_data_filename('data/fermi/fermi_counts.fits.gz')
result['diffuse_model'] = get_pkg_data_filename('data/fermi/gll_iem_v02_cutout.fits')
return result
def ebv(coordinate, order=1):
"""
Return SFD E(B-V) at the input coordinate(s).
Parameters
----------
coordinate : :class:`~astropy.coordinates.SkyCoord`, :class:`~astropy.coordinates.BaseCoordinateFrame`
The coordinate(s) to compute extinction at.
order : int (optional)
Passed to :func:`~scipy.ndimage.map_coordinates`.
Returns
-------
EBV : :class:`~numpy.ndarray`
Extinction at each input coordinate.
Example
-------
TODO
h, w = 1000, 4000
b, l = numpy.mgrid[0:h,0:w]
l = 180.-(l+0.5) / float(w) * 360.
b = 90. - (b+0.5) / float(h) * 180.
ebv = dust.getval(l, b)
imshow(ebv, aspect='auto', norm=matplotlib.colors.LogNorm())
"""
ngp_filename = get_pkg_data_filename("data/SFD_dust_4096_ngp.fits")
sgp_filename = get_pkg_data_filename("data/SFD_dust_4096_sgp.fits")
# convert input coordinate to Galactic frame
gal = coordinate.transform_to(coord.Galactic)
l = gal.l.wrap_at(180*u.degree).degree
b = gal.b.degree
# output extinctions
EBV = np.zeros_like(l, dtype='f4') + np.nan
b_gtr_zero = b >= 0.
b_les_zero = np.logical_not(b_gtr_zero)
if np.any(b_gtr_zero): # north
hdulist = fits.open(ngp_filename)
w = wcs.WCS(hdulist[0].header)
x, y = w.wcs_world2pix(l[b_gtr_zero], b[b_gtr_zero], 0)
EBV[b_gtr_zero] = map_coordinates(hdulist[0].data, [y, x], order=order, mode='nearest')
hdulist.close()
if np.any(b_les_zero): # south
hdulist = fits.open(sgp_filename)
w = wcs.WCS(hdulist[0].header)
x, y = w.wcs_world2pix(l[b_les_zero], b[b_les_zero], 0)
EBV[b_les_zero] = map_coordinates(hdulist[0].data, [y, x], order=order, mode='nearest')
hdulist.close()
return EBV
def test_multiple_targettables(self):
with pytest.warns(W12):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/multiple_targettables.xml"))
with pytest.raises(W12):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/multiple_targettables.xml"),
pedantic=True)
def test_no_schemas(self):
with pytest.warns(W14):
vosi.parse_tables(
get_pkg_data_filename("data/tables/no_schemas.xml"))
with pytest.raises(W14):
vosi.parse_tables(
get_pkg_data_filename("data/tables/no_schemas.xml"),
pedantic=True)
def setup_function(fn):
ra, dec, pmra, pmdec = np.load(get_pkg_data_filename('c_pm.npy'))
c = coord.SkyCoord(ra=ra*u.deg, dec=dec*u.deg,
pm_ra_cosdec=pmra*u.mas/u.yr,
pm_dec=pmdec*u.mas/u.yr)
cov = np.load(get_pkg_data_filename('pm_cov.npy'))
fn.c = c
fn.cov = cov
def test_tap_size(self):
with pytest.warns(W03):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/sizenegative.xml"))
with pytest.raises(W03):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/sizenegative.xml"),
pedantic=True)
def test_wrong_flag(self):
with pytest.warns(W04):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/wrong_flag.xml"))
with pytest.raises(W04):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/wrong_flag.xml"),
pedantic=True)
def test_multiple_schema_descriptions(self):
with pytest.warns(W06):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/multiple_schema_descriptions.xml"))
with pytest.raises(W06):
vosi.parse_tables(
get_pkg_data_filename(
"data/tables/multiple_schema_descriptions.xml"),
pedantic=True)
def test_multiple_foreignkey_utypes(self):
with pytest.warns(W09):
vosi.parse_tables(get_pkg_data_filename(
"data/tables/multiple_foreignkey_utypes.xml"))
with pytest.raises(W09):
vosi.parse_tables(
get_pkg_data_filename(
"data/tables/multiple_foreignkey_utypes.xml"),
pedantic=True)
def test_reproject_celestial_slices_2d():
header_in = fits.Header.fromtextfile(get_pkg_data_filename('../../tests/data/gc_ga.hdr'))
header_out = fits.Header.fromtextfile(get_pkg_data_filename('../../tests/data/gc_eq.hdr'))
array_in = np.ones((700, 690))
wcs_in = WCS(header_in)
wcs_out = WCS(header_out)
array_out = reproject_celestial(array_in, wcs_in, wcs_out, (660, 680))
def test_read():
potential = load(get_pkg_data_filename("Plummer.yml"))
assert np.allclose(potential.parameters["m"], 100000000000.0)
assert np.allclose(potential.parameters["b"], 0.26)
potential = load(get_pkg_data_filename("HarmonicOscillator1D.yml"))
assert potential.units is None
potential = load(get_pkg_data_filename("Composite.yml"))
assert "disk" in potential.keys()
assert "halo" in potential.keys()
assert str(potential) == "CompositePotential"
def test_reproject():
hdr1 = fits.Header.fromfile(get_pkg_data_filename('data/simple_wcs.hdr'))
hdr2 = fits.Header.fromfile(get_pkg_data_filename('data/simple_wcs2.hdr'))
w1 = fitswcs.WCS(hdr1)
w2 = fitswcs.WCS(hdr2)
gw2 = wcs.WCS(output_frame='icrs',
forward_transform=gwutil.make_fitswcs_transform(hdr2))
func1 = reproject(w1, w2)
func2 = reproject(w1, gw2)
x1, y1 = func1(1, 2)
x2, y2 = func2(1, 2)
utils.assert_allclose(x1, x2, atol=10**-7)
utils.assert_allclose(y1, y2, atol=10**-7)
def setup_class(self):
self.header_in = fits.Header.fromtextfile(get_pkg_data_filename('../../tests/data/gc_ga.hdr'))
self.header_out = fits.Header.fromtextfile(get_pkg_data_filename('../../tests/data/gc_eq.hdr'))
self.header_out['NAXIS'] = 2
self.header_out['NAXIS1'] = 600
self.header_out['NAXIS2'] = 550
self.array_in = np.ones((100, 100))
self.wcs_in = WCS(self.header_in)
self.wcs_out = WCS(self.header_out)
def fermi_galactic_center():
"""Fermi high-energy counts image of the Galactic center region.
TODO: document energy band, region, content of the files.
Returns
-------
filenames : dict
Dictionary with filenames for keys 'psf', 'counts'
"""
filenames = dict()
filenames['psf'] = get_pkg_data_filename('fermi/psf.fits')
filenames['counts'] = get_pkg_data_filename('fermi/fermi_counts.fits.gz')
return filenames
def test_galactic(filename):
filename = get_pkg_data_filename(filename)
regs = read_ds9(filename)
actual = ds9_objects_to_string(regs, coordsys='galactic', fmt='.2f', radunit='arcsec')
# Use this to produce reference file for now
# print(actual)
# 1 / 0
reference_file = get_pkg_data_filename('data/galactic_reference.reg')
with open(reference_file, 'r') as fh:
desired = fh.read()
assert actual == desired
def test_physical(filename):
filename = get_pkg_data_filename(filename)
regs = read_ds9(filename)
actual = ds9_objects_to_string(regs, coordsys='physical', fmt='.2f')
# Use this to produce reference file for now
# print(actual)
# 1 / 0
reference_file = get_pkg_data_filename('data/physical_reference.reg')
with open(reference_file, 'r') as fh:
desired = fh.read()
assert actual == desired
def _load_dqparser(self, instrument):
"""Create new DQParser for given instrument."""
dqdict = self.settings.get('dqdict', self._def_dqdict)
if instrument not in dqdict:
self.logger.warn(
'{0} is not supported, using default'.format(instrument))
return self._def_parser
try:
dqfile = get_pkg_data_filename(dqdict[instrument],
package='stginga')
except Exception as e:
dqfile = dqdict[instrument]
if os.path.isfile(dqfile):
self.logger.info('Using external data {0}'.format(dqfile))
else:
self.logger.warn('{0} not found for {1}, using default'.format(
dqfile, instrument))
dqfile = None
else:
self.logger.info('Using package data {0}'.format(dqfile))
if dqfile is None:
return self._def_parser
try:
dqp = utils.DQParser(dqfile)
except Exception as e:
self.logger.warn('Cannot extract DQ info from {0}, using '
'default'.format(dqfile))
dqp = self._def_parser
return dqp
def setUp(self):
resultfile = get_pkg_data_filename(ssaresultfile)
self.tbl = votableparse(resultfile)
self.result = ssa.SSAResults(self.tbl)
self.rec = self.result.getrecord(0)
self.outdir = tempfile.mkdtemp()
def test_pedantic_true(self):
with pytest.raises(AstropyDeprecationWarning):
with pytest.raises(VOWarning):
parse(get_pkg_data_filename('data/gemini.xml'), pedantic=True)
from astropy import units as u from astropy.wcs import WCS import pylab as pl from astropy.io import fits from astropy.utils.data import get_pkg_data_filename import numpy as np from matplotlib_scalebar.scalebar import ScaleBar #Establishing file names & paths nh3_11 = "/Users/Josh/W51/data/nh3_11_m0.fits" par_maps = "/Users/Josh/W51/data/par_maps.fits" ################################################ base = get_pkg_data_filename(nh3_11) base_hdu = fits.open(base)[0] base_wcs = WCS(base_hdu.header) cube = get_pkg_data_filename(par_maps) cube_hdu = fits.open(cube)[0] cube_wcs = WCS(cube_hdu.header) ax = pl.subplot(projection=base_wcs.celestial) ax.set(xlim=(30,265), ylim=(50,250)) ax.coords[0].set_ticks_visible(False) ax.coords[1].set_ticks_visible(False) ax.coords[0].set_ticklabel_visible(False) ax.coords[1].set_ticklabel_visible(False) pl.imshow(base_hdu.data, origin='lower') ax.contour(cube_hdu.data[2,:,:], levels=[15.5,16,16.5,17,17.5,18], colors='white', alpha=0.8) pl.show()
def test_conf_verify_warn(self):
with conf.set_temp('verify', 'warn'):
with pytest.warns(VOWarning) as w:
parse(get_pkg_data_filename('data/gemini.xml'))
assert len(w) == 24
def test_validate_with_2_wcses():
# From Issue #2053
results = wcs.validate(get_pkg_data_filename("data/2wcses.hdr"))
assert "WCS key 'A':" in str(results)
def setup(self):
fname = get_pkg_data_filename('data/header_with_time.fits')
self.header = fits.Header.fromfile(fname)
self.w = wcs.WCS(self.header, key='A')
import numpy as np
from astropy.cosmology import Planck15
from astropy.units import allclose
from astropy import units as u
from astropy.utils.data import get_pkg_data_filename
import pytest
# load the external class result to test against
class_result_filename = get_pkg_data_filename('data/class_result.txt')
test_pzk = np.loadtxt(class_result_filename)
# try to import the requirement, if it doesn't exist, skip test
try:
__import__('classy')
except ImportError:
CLASS_NOT_FOUND = True
else:
CLASS_NOT_FOUND = False
@pytest.mark.skipif(CLASS_NOT_FOUND, reason='classy not found')
def test_classy():
'''
Test a default astropy cosmology
'''
from skypy.power_spectrum import classy
Pl15massless = Planck15.clone(name='Planck 15 massless neutrino', m_nu=[0., 0., 0.]*u.eV)
redshift = [0.0, 1.0]
wavenumber = np.logspace(-4.0, np.log10(2.0), 200)
def test_info(self, psf):
info_str = open(get_pkg_data_filename("data/psf_info.txt")).read()
print(psf.info())
assert psf.info() == info_str
import numpy as np
from astropy.utils.data import get_pkg_data_filename
import pytest
from ..targetpixelfile import KeplerTargetPixelFile, KeplerQualityFlags
filename_tpf_all_zeros = get_pkg_data_filename("data/test-tpf-all-zeros.fits")
filename_tpf_one_center = get_pkg_data_filename("data/test-tpf-non-zero-center.fits")
def test_tpf_shapes():
"""Are the data array shapes of the TargetPixelFile object consistent?"""
tpf = KeplerTargetPixelFile(filename_tpf_all_zeros)
assert tpf.quality_mask.shape == tpf.hdu[1].data['TIME'].shape
assert tpf.flux.shape == tpf.flux_err.shape
def test_tpf_zeros():
"""Does the LightCurve of a zero-flux TPF make sense?"""
tpf = KeplerTargetPixelFile(filename_tpf_all_zeros, quality_bitmask=None)
lc = tpf.to_lightcurve()
# If you don't mask out bad data, time contains NaNs
assert np.any(lc.time != tpf.time) # Using the property that NaN does not equal NaN
#When you do mask out bad data everything should work.
tpf = KeplerTargetPixelFile(filename_tpf_all_zeros, quality_bitmask='hard')
lc = tpf.to_lightcurve()
assert len(lc.time) == len(lc.flux)
assert np.all(lc.time == tpf.time)
assert np.all(lc.flux == 0)
# The default QUALITY bitmask should have removed all NaNs in the TIME
assert ~np.any(np.isnan(tpf.time))
def test_sff_corrector():
"""Does our code agree with the example presented in Vanderburg
and Johnson (2014)?"""
# The following csv file, provided by Vanderburg and Johnson
# at https://www.cfa.harvard.edu/~avanderb/k2/ep60021426.html,
# contains the results of applying SFF to EPIC 60021426.
fn = get_pkg_data_filename('../../tests/data/ep60021426alldiagnostics.csv')
data = np.genfromtxt(fn, delimiter=',', skip_header=1)
mask = data[:, -2] == 0 # indicates whether the thrusters were on or off
time = data[:, 0]
raw_flux = data[:, 1]
corrected_flux = data[:, 2]
centroid_col = data[:, 3]
centroid_row = data[:, 4]
# NOTE: we need a small number of windows below because this test data set
# is unusually short, i.e. has an unusually small number of cadences.
lc = LightCurve(time=time, flux=raw_flux, flux_err=np.ones(len(raw_flux)) * 0.0001)
sff = SFFCorrector(lc)
corrected_lc = sff.correct(centroid_col=centroid_col,
centroid_row=centroid_row,
restore_trend=True,
windows=1)
assert (np.isclose(corrected_flux, corrected_lc.flux, atol=0.001).all())
assert len(sff.window_points) == 0 # expect 0 break points for 1 window
# masking
corrected_lc = sff.correct(centroid_col=centroid_col,
centroid_row=centroid_row,
windows=3,
restore_trend=True,
cadence_mask=mask)
assert (np.isclose(corrected_flux, corrected_lc.flux, atol=0.001).all())
assert len(sff.window_points) == 2 # expect 2 break points for 3 windows
# masking and breakindex
corrected_lc = sff.correct(centroid_col=centroid_col,
centroid_row=centroid_row,
windows=3,
restore_trend=True,
cadence_mask=mask)
assert (np.isclose(corrected_flux, corrected_lc.flux, atol=0.001).all())
# masking and breakindex and iters
corrected_lc = sff.correct(centroid_col=centroid_col,
centroid_row=centroid_row, windows=3, restore_trend=True,
cadence_mask=mask, niters=3)
assert (np.isclose(corrected_flux, corrected_lc.flux, atol=0.001).all())
# masking and breakindex and bins
corrected_lc = sff.correct(centroid_col=centroid_col,
centroid_row=centroid_row, windows=3, restore_trend=True,
cadence_mask=mask, bins=5)
assert (np.isclose(corrected_flux, corrected_lc.flux, atol=0.001).all())
assert np.all((sff.lc.flux_err/sff.corrected_lc.flux_err) == 1)
# masking and breakindex and bins and propagate_errors
corrected_lc = sff.correct(centroid_col=centroid_col,
centroid_row=centroid_row, windows=3, restore_trend=True,
cadence_mask=mask, bins=5, propagate_errors=True)
assert (np.isclose(corrected_flux, corrected_lc.flux, atol=0.001).all())
assert np.all((sff.lc.flux_err/sff.corrected_lc.flux_err) < 1)
# test using KeplerLightCurve interface
klc = KeplerLightCurve(time=time,
flux=raw_flux,
flux_err=np.ones(len(raw_flux)) * 0.0001,
centroid_col=centroid_col,
centroid_row=centroid_row)
sff = klc.to_corrector("sff")
klc = sff.correct(windows=3, restore_trend=True)
assert (np.isclose(corrected_flux, klc.flux, atol=0.001).all())
# Can plot
sff.diagnose()
def setup_class(self):
self.region_file = get_pkg_data_filename(
'data/ds9.fits.reg', package='regions.io.ds9.tests')
self.arr = np.ones((1024, 1024))
self.raw_regions = Regions.read(self.region_file, format='ds9')
__all__ = [
'Conf', 'conf', 'earth_orientation_table', 'IERS', 'IERS_B', 'IERS_A',
'IERS_Auto', 'FROM_IERS_B', 'FROM_IERS_A', 'FROM_IERS_A_PREDICTION',
'TIME_BEFORE_IERS_RANGE', 'TIME_BEYOND_IERS_RANGE', 'IERS_A_FILE',
'IERS_A_URL', 'IERS_A_URL_MIRROR', 'IERS_A_README', 'IERS_B_FILE',
'IERS_B_URL', 'IERS_B_README', 'IERSRangeError', 'IERSStaleWarning',
'LeapSeconds', 'IERS_LEAP_SECOND_FILE', 'IERS_LEAP_SECOND_URL',
'IETF_LEAP_SECOND_URL'
]
# IERS-A default file name, URL, and ReadMe with content description
IERS_A_FILE = 'finals2000A.all'
IERS_A_URL = 'ftp://*****:*****@gdc.cddis.eosdis.nasa.gov/pub/products/iers/finals2000A.all'
IERS_A_URL_MIRROR = 'https://datacenter.iers.org/data/9/finals2000A.all'
IERS_A_README = get_pkg_data_filename('data/ReadMe.finals2000A')
# IERS-B default file name, URL, and ReadMe with content description
IERS_B_FILE = get_pkg_data_filename('data/eopc04_IAU2000.62-now')
IERS_B_URL = 'http://hpiers.obspm.fr/iers/eop/eopc04/eopc04_IAU2000.62-now'
IERS_B_README = get_pkg_data_filename('data/ReadMe.eopc04_IAU2000')
# LEAP SECONDS default file name, URL, and alternative format/URL
IERS_LEAP_SECOND_FILE = get_pkg_data_filename('data/Leap_Second.dat')
IERS_LEAP_SECOND_URL = 'https://hpiers.obspm.fr/iers/bul/bulc/Leap_Second.dat'
IETF_LEAP_SECOND_URL = 'https://www.ietf.org/timezones/data/leap-seconds.list'
# Status/source values returned by IERS.ut1_utc
FROM_IERS_B = 0
FROM_IERS_A = 1
FROM_IERS_A_PREDICTION = 2
def test_all(self):
capabilities = vosi.parse_capabilities(
get_pkg_data_filename("data/capabilities.xml"))
assert equals(capabilities[0].standardid,
"ivo://ivoa.net/std/VOSI#availability")
assert type(capabilities[0].interfaces[0]) == vs.ParamHTTP
assert capabilities[0].interfaces[0].accessurls[0].use == "full"
assert equals(capabilities[0].interfaces[0].accessurls[0].content,
"http://example.org/tap/availability")
assert equals(capabilities[1].standardid,
"ivo://ivoa.net/std/VOSI#capabilities")
assert type(capabilities[1].interfaces[0]) == vs.ParamHTTP
assert capabilities[1].interfaces[0].accessurls[0].use == "full"
assert equals(capabilities[1].interfaces[0].accessurls[0].content,
"http://example.org/tap/capabilities")
assert capabilities[2].standardid == "ivo://ivoa.net/std/VOSI#tables"
assert type(capabilities[2].interfaces[0]) == vs.ParamHTTP
assert capabilities[2].interfaces[0].accessurls[0].use == "full"
assert equals(capabilities[2].interfaces[0].accessurls[0].content,
"http://example.org/tap/tables")
assert type(capabilities[3]) == tr.TableAccess
assert capabilities[3].standardid == "ivo://ivoa.net/std/TAP"
assert capabilities[3].interfaces[0].accessurls[0].use == "base"
assert equals(capabilities[3].interfaces[0].accessurls[0].content,
"http://example.org/tap")
assert equals(capabilities[3].datamodels[0].ivo_id,
"ivo://ivoa.net/std/ObsCore#table-1.1")
assert capabilities[3].datamodels[0].content == "Obscore-1.1"
assert equals(capabilities[3].datamodels[1].ivo_id,
"ivo://ivoa.net/std/RegTAP#1.0")
assert capabilities[3].datamodels[1].content == "Registry 1.0"
assert capabilities[3].languages[0].name == "ADQL"
assert equals(capabilities[3].languages[0].versions[0].ivo_id,
"ivo://ivoa.net/std/ADQL#v2.0")
assert capabilities[3].languages[0].versions[0].content == "2.0"
assert capabilities[3].languages[0].description == "ADQL 2.0"
assert equals(
capabilities[3].languages[0].languagefeaturelists[0].type,
"ivo://ivoa.net/std/TAPRegExt#features-udf")
assert equals(
capabilities[3].languages[0].languagefeaturelists[0][0].form,
"form 1")
assert equals(
capabilities[3].languages[0].languagefeaturelists[0]
[0].description, "description 1")
assert equals(
capabilities[3].languages[0].languagefeaturelists[0][1].form,
"form 2")
assert equals(
capabilities[3].languages[0].languagefeaturelists[0].features[1].
description, "description 2")
assert equals(
capabilities[3].languages[0].languagefeaturelists[1].type,
"ivo://ivoa.net/std/TAPRegExt#features-adqlgeo")
assert equals(
capabilities[3].languages[0].languagefeaturelists[1].features[0].
form, "BOX")
assert equals(
capabilities[3].languages[0].languagefeaturelists[1].features[1].
form, "POINT")
assert equals(capabilities[3].outputformats[0].ivo_id,
"ivo://ivoa.net/std/TAPRegExt#output-votable-binary")
assert capabilities[3].outputformats[0].mime == "text/xml"
assert capabilities[3].outputformats[1].ivo_id is None
assert capabilities[3].outputformats[1].mime == "text/html"
assert equals(capabilities[3].uploadmethods[0].ivo_id,
"ivo://ivoa.net/std/TAPRegExt#upload-https")
assert equals(capabilities[3].uploadmethods[1].ivo_id,
"ivo://ivoa.net/std/TAPRegExt#upload-inline")
assert capabilities[3].retentionperiod.default == 172800
assert capabilities[3].executionduration.default == 3600
assert capabilities[3].outputlimit.default.unit == "row"
assert capabilities[3].outputlimit.default.content == 2000
assert capabilities[3].outputlimit.hard.unit == "row"
assert capabilities[3].outputlimit.hard.content == 10000000
assert capabilities[3].uploadlimit.hard.unit == "byte"
assert capabilities[3].uploadlimit.hard.content == 100000000
p0 = 1.013250e5 * u.Pa
rho0 = 1.2250 * u.K
T0 = 288.15 * u.K
g0 = 9.80665 * u.m / u.s ** 2
S = 110.4 * u.K
Ti = 273.15 * u.K
beta = 1.458e-6 * u.kg / u.s / u.m / u.K ** (0.5)
_gamma = 1.4
sigma = 3.65e-10 * u.m
N = 6.02257e26 * (u.kg * u.mol) ** -1
R = 8314.32 * u.J / u.kg / u.K
R_air = 287.053 * u.J / u.kg / u.K
alpha = 34.1632 * u.K / u.km
# Reading layer parameters file
coesa_file = get_pkg_data_filename("data/coesa62.dat")
coesa62_data = ascii.read(coesa_file)
b_levels = coesa62_data["b"].data
zb_levels = coesa62_data["Zb [km]"].data * u.km
hb_levels = coesa62_data["Hb [km]"].data * u.km
Tb_levels = coesa62_data["Tb [K]"].data * u.K
Lb_levels = coesa62_data["Lb [K/km]"].data * u.K / u.km
pb_levels = coesa62_data["pb [mbar]"].data * u.mbar
class COESA62(COESA):
""" Holds the model for U.S Standard Atmosphere 1962. """
def __init__(self):
""" Constructor for the class. """
super().__init__(
from astropy.io import fits
from astropy import wcs
from astropy.io.fits.card import UNDEFINED
import astropy.units as u
from astropy.utils.exceptions import AstropyWarning
from ..targetpixelfile import KeplerTargetPixelFile, TargetPixelFileFactory
from ..targetpixelfile import TessTargetPixelFile, TargetPixelFile
from ..lightcurve import TessLightCurve
from ..utils import LightkurveWarning, LightkurveDeprecationWarning
from ..io import read
from ..search import search_tesscut
from .test_synthetic_data import filename_synthetic_flat
filename_tpf_all_zeros = get_pkg_data_filename("data/test-tpf-all-zeros.fits")
filename_tpf_one_center = get_pkg_data_filename("data/test-tpf-non-zero-center.fits")
filename_tess = get_pkg_data_filename("data/tess25155310-s01-first-cadences.fits.gz")
TABBY_Q8 = ("https://archive.stsci.edu/missions/kepler/lightcurves"
"/0084/008462852/kplr008462852-2011073133259_llc.fits")
TABBY_TPF = ("https://archive.stsci.edu/missions/kepler/target_pixel_files"
"/0084/008462852/kplr008462852-2011073133259_lpd-targ.fits.gz")
TESS_SIM = ("https://archive.stsci.edu/missions/tess/ete-6/tid/00/000"
"/004/176/tess2019128220341-0000000417699452-0016-s_tp.fits")
asteroid_TPF = get_pkg_data_filename("data/asteroid_test.fits")
@pytest.mark.remote_data
def test_load_bad_file():
'''Test if a light curve can be opened without exception.'''
def map2alm(
maps,
lmax=None,
mmax=None,
iter=3,
pol=True,
use_weights=False,
datapath=None,
gal_cut=0,
use_pixel_weights=False,
verbose=True,
):
"""Computes the alm of a Healpix map. The input maps must all be
in ring ordering.
For recommendations about how to set `lmax`, `iter`, and weights, see the
`Anafast documentation <https://healpix.sourceforge.io/html/fac_anafast.htm>`
Pixel values are weighted before applying the transform:
* when you don't specify any weights, the uniform weight value 4*pi/n_pix is used
* with ring weights enabled (use_weights=True), pixels in every ring
are weighted with a uniform value similar to the one above, ring weights are
included in healpy
* with pixel weights (use_pixel_weights=True), every pixel gets an individual weight
Pixel weights provide the most accurate transform, so you should always use them if
possible. However they are not included in healpy and will be automatically downloaded
and cached in ~/.astropy the first time you compute a trasform at a specific nside.
If datapath is specified, healpy will first check that local folder before downloading
the weights.
The easiest way to setup the folder is to clone the healpy-data repository:
git clone --depth 1 https://github.com/healpy/healpy-data
cd healpy-data
bash download_weights_8192.sh
and set datapath to the root of the repository.
Parameters
----------
maps : array-like, shape (Npix,) or (n, Npix)
The input map or a list of n input maps. Must be in ring ordering.
lmax : int, scalar, optional
Maximum l of the power spectrum. Default: 3*nside-1
mmax : int, scalar, optional
Maximum m of the alm. Default: lmax
iter : int, scalar, optional
Number of iteration (default: 3)
pol : bool, optional
If True, assumes input maps are TQU. Output will be TEB alm's.
(input must be 1 or 3 maps)
If False, apply spin 0 harmonic transform to each map.
(input can be any number of maps)
If there is only one input map, it has no effect. Default: True.
use_weights: bool, scalar, optional
If True, use the ring weighting. Default: False.
datapath : None or str, optional
If given, the directory where to find the pixel weights.
See in the docstring above details on how to set it up.
gal_cut : float [degrees]
pixels at latitude in [-gal_cut;+gal_cut] are not taken into account
use_pixel_weights: bool, optional
If True, use pixel by pixel weighting, healpy will automatically download the weights, if needed
verbose : bool, optional
Deprecated, has not effect.
Returns
-------
alms : array or tuple of array
alm or a tuple of 3 alm (almT, almE, almB) if polarized input.
Notes
-----
The pixels which have the special `UNSEEN` value are replaced by zeros
before spherical harmonic transform. They are converted back to `UNSEEN`
value, so that the input maps are not modified. Each map have its own,
independent mask.
"""
maps = ma_to_array(maps)
info = maptype(maps)
nside = pixelfunc.get_nside(maps)
check_max_nside(nside)
pixel_weights_filename = None
if use_pixel_weights:
if use_weights:
raise RuntimeError("Either use pixel or ring weights")
filename = "full_weights/healpix_full_weights_nside_%04d.fits" % nside
if datapath is not None:
pixel_weights_filename = os.path.join(datapath, filename)
if os.path.exists(pixel_weights_filename):
log.info("Accessing pixel weights from %s", pixel_weights_filename)
else:
raise RuntimeError(
"You specified datapath but pixel weights file"
"is missing at {}".format(pixel_weights_filename)
)
if pixel_weights_filename is None:
with data.conf.set_temp("dataurl", DATAURL), data.conf.set_temp(
"dataurl_mirror", DATAURL_MIRROR
), data.conf.set_temp("remote_timeout", 30):
pixel_weights_filename = data.get_pkg_data_filename(
filename, package="healpy"
)
if pol or info in (0, 1):
alms = _sphtools.map2alm(
maps,
niter=iter,
datapath=datapath,
use_weights=use_weights,
lmax=lmax,
mmax=mmax,
gal_cut=gal_cut,
pixel_weights_filename=pixel_weights_filename,
)
else:
# info >= 2 and pol is False : spin 0 spht for each map
alms = [
_sphtools.map2alm(
mm,
niter=iter,
datapath=datapath,
use_weights=use_weights,
lmax=lmax,
mmax=mmax,
gal_cut=gal_cut,
pixel_weights_filename=pixel_weights_filename,
)
for mm in maps
]
return np.array(alms)
def test_str(self, ref):
actual = str(self.cat[ref["idx"]])
expected = open(get_pkg_data_filename(ref["str_ref_file"])).read()
assert actual == expected
def test_all_world2pix(fname=None,
ext=0,
tolerance=1.0e-4,
origin=0,
random_npts=25000,
adaptive=False,
maxiter=20,
detect_divergence=True):
"""Test all_world2pix, iterative inverse of all_pix2world"""
# Open test FITS file:
if fname is None:
fname = get_pkg_data_filename('data/j94f05bgq_flt.fits')
ext = ('SCI', 1)
if not os.path.isfile(fname):
raise OSError(
"Input file '{:s}' to 'test_all_world2pix' not found.".format(
fname))
h = fits.open(fname)
w = wcs.WCS(h[ext].header, h)
h.close()
del h
crpix = w.wcs.crpix
ncoord = crpix.shape[0]
# Assume that CRPIX is at the center of the image and that the image has
# a power-of-2 number of pixels along each axis. Only use the central
# 1/64 for this testing purpose:
naxesi_l = list((7. / 16 * crpix).astype(int))
naxesi_u = list((9. / 16 * crpix).astype(int))
# Generate integer indices of pixels (image grid):
img_pix = np.dstack(
[i.flatten() for i in np.meshgrid(*map(range, naxesi_l, naxesi_u))])[0]
# Generage random data (in image coordinates):
with NumpyRNGContext(123456789):
rnd_pix = np.random.rand(random_npts, ncoord)
# Scale random data to cover the central part of the image
mwidth = 2 * (crpix * 1. / 8)
rnd_pix = crpix - 0.5 * mwidth + (mwidth - 1) * rnd_pix
# Reference pixel coordinates in image coordinate system (CS):
test_pix = np.append(img_pix, rnd_pix, axis=0)
# Reference pixel coordinates in sky CS using forward transformation:
all_world = w.all_pix2world(test_pix, origin)
try:
runtime_begin = datetime.now()
# Apply the inverse iterative process to pixels in world coordinates
# to recover the pixel coordinates in image space.
all_pix = w.all_world2pix(all_world,
origin,
tolerance=tolerance,
adaptive=adaptive,
maxiter=maxiter,
detect_divergence=detect_divergence)
runtime_end = datetime.now()
except wcs.wcs.NoConvergence as e:
runtime_end = datetime.now()
ndiv = 0
if e.divergent is not None:
ndiv = e.divergent.shape[0]
print(f"There are {ndiv} diverging solutions.")
print("Indices of diverging solutions:\n{}".format(e.divergent))
print("Diverging solutions:\n{}\n".format(
e.best_solution[e.divergent]))
print("Mean radius of the diverging solutions: {}".format(
np.mean(np.linalg.norm(e.best_solution[e.divergent], axis=1))))
print("Mean accuracy of the diverging solutions: {}\n".format(
np.mean(np.linalg.norm(e.accuracy[e.divergent], axis=1))))
else:
print("There are no diverging solutions.")
nslow = 0
if e.slow_conv is not None:
nslow = e.slow_conv.shape[0]
print("There are {} slowly converging solutions.".format(nslow))
print("Indices of slowly converging solutions:\n{}".format(
e.slow_conv))
print("Slowly converging solutions:\n{}\n".format(
e.best_solution[e.slow_conv]))
else:
print("There are no slowly converging solutions.\n")
print("There are {} converged solutions.".format(
e.best_solution.shape[0] - ndiv - nslow))
print("Best solutions (all points):\n{}".format(e.best_solution))
print(f"Accuracy:\n{e.accuracy}\n")
print("\nFinished running 'test_all_world2pix' with errors.\n"
"ERROR: {}\nRun time: {}\n".format(e.args[0],
runtime_end - runtime_begin))
raise e
# Compute differences between reference pixel coordinates and
# pixel coordinates (in image space) recovered from reference
# pixels in world coordinates:
errors = np.sqrt(np.sum(np.power(all_pix - test_pix, 2), axis=1))
meanerr = np.mean(errors)
maxerr = np.amax(errors)
print("\nFinished running 'test_all_world2pix'.\n"
"Mean error = {:e} (Max error = {:e})\n"
"Run time: {}\n".format(meanerr, maxerr,
runtime_end - runtime_begin))
assert (maxerr < 2.0 * tolerance)
def wcs():
filename = get_pkg_data_filename('data/example_header.fits')
header = fits.getheader(filename)
return WCS(header)
def test_load_fits_path():
fits_name = get_pkg_data_filename('data/sip.fits')
w = wcs.WCS(fits_name)
def test_xz(filename):
t_comp = read(get_pkg_data_filename(filename))
t_uncomp = read(get_pkg_data_filename(filename.replace('.xz', '')))
assert t_comp.dtype.names == t_uncomp.dtype.names
assert np.all(t_comp.as_array() == t_uncomp.as_array())
def test_str(self):
actual = str(self.cat["3FHL J2301.9+5855e"]) # an extended source
expected = open(get_pkg_data_filename("data/3fhl_j2301.9+5855e.txt")).read()
assert actual == expected
#
# Plot DS9 regions in a Ginga viewer
#
# NOTE: You need the Astropy "regions" package for this to work.
#
from ginga import toolkit
toolkit.use('qt5')
from astropy.utils.data import get_pkg_data_filename
import regions
from ginga.gw import sv
from ginga.util import ap_region
vf = sv.ViewerFactory()
v = vf.make_viewer(name="Ginga regions example", width=1000, height=1000)
image_file = get_pkg_data_filename('tutorials/FITS-images/HorseHead.fits')
v.load(image_file)
ds9_file = get_pkg_data_filename('data/plot_image.reg',
package='regions.io.ds9.tests')
regs = regions.read_ds9(ds9_file)
canvas = v.add_canvas()
for i, reg in enumerate(regs):
ap_region.add_region(canvas, reg)
vf.mainloop()
def test_conf_verify_exception(self):
with conf.set_temp('verify', 'exception'):
with pytest.raises(VOWarning):
parse(get_pkg_data_filename('data/gemini.xml'))
def setup_class(self):
bandfile = get_pkg_data_filename(
os.path.join('data', 'hst_acs_hrc_f555w.fits'))
self.bp = SpectralElement.from_file(bandfile)
def test_conf_verify_ignore(self):
with conf.set_temp('verify', 'ignore'):
parse(get_pkg_data_filename('data/gemini.xml'))
def setup_class(self):
specfile = get_pkg_data_filename(
os.path.join('data', 'hst_acs_hrc_f555w_x_grw70d5824.fits'))
self.sp = SourceSpectrum.from_file(specfile)
def test_pedantic_false(self):
with pytest.warns(VOWarning) as w:
parse(get_pkg_data_filename('data/gemini.xml'), pedantic=False)
assert len(w) == 25
import numpy as np
from astropy.cosmology import Planck15
from astropy.units import allclose
from astropy.utils.data import get_pkg_data_filename
import pytest
# load the external camb result to test against
camb_result_filename = get_pkg_data_filename('data/camb_result.txt')
test_pkz = np.loadtxt(camb_result_filename, delimiter=',')
# try to import the requirement, if it doesn't exist, skip test
try:
__import__('camb')
except ImportError:
CAMB_NOT_FOUND = True
else:
CAMB_NOT_FOUND = False
@pytest.mark.skipif(CAMB_NOT_FOUND, reason='CAMB not found')
def test_camb():
'''
Test a default astropy cosmology
'''
from skypy.power_spectrum import camb
# test shape and compare with the mocked power spectrum
redshift = [0.0, 1.0]
wavenumber = np.logspace(-4.0, np.log10(2.0), 200)
pkz = camb(wavenumber, redshift, Planck15, 2.e-9, 0.965)
assert pkz.shape == (len(redshift), len(wavenumber))
def test_info(self, psf):
filename = get_pkg_data_filename("data/psf_info.txt")
info_str = open(filename, "r").read()
assert psf.info() == info_str
def test_flattened_hernquist():
"""
This test compares the coefficients against some computed in the mathematica
notebook 'flattened-hernquist.nb'. nmax and lmax here must match nmax and lmax
in that notebook.
"""
coeff_path = os.path.abspath(get_pkg_data_filename('data/Snlm-mathematica.csv'))
G = 1.
M = 1
a = 1.
q = 0.9
# Note: this must be the same as in the mathematica notebook
nmax = 8
lmax = 8
(Snlm,Serr),(Tnlm,Terr) = compute_coeffs(flattened_hernquist_density,
nmax=nmax, lmax=lmax, skip_odd=True, skip_m=True,
M=M, r_s=a, args=(M,a,q))
for l in range(1, lmax+1, 2):
for m in range(lmax+1):
assert Snlm[0,l,m] == 0.
m_Snl0 = np.loadtxt(coeff_path, delimiter=',')
m_Snl0 = m_Snl0[:,::2] # every other l
assert np.allclose(Snlm[0,::2,0], m_Snl0[0])
# check that random points match in gradient and density
np.random.seed(42)
n_test = 1024
r = 10.*np.cbrt(np.random.uniform(0.1**3,1,size=n_test)) # 1 to 10
t = np.arccos(2*np.random.uniform(size=n_test) - 1)
ph = np.random.uniform(0, 2*np.pi, size=n_test)
x = r*np.cos(ph)*np.sin(t)
y = r*np.sin(ph)*np.sin(t)
z = r*np.cos(t)
xyz = np.vstack((x, y, z))
# confirmed by testing...
tru_dens = flattened_hernquist_density(xyz[0], xyz[1], xyz[2], M, a, q)
bfe_dens = density(np.ascontiguousarray(xyz.T), Snlm, Tnlm, M, a)
assert np.all((np.abs(bfe_dens - tru_dens) / tru_dens) < 0.05) # <5%
tru_grad = np.array([flattened_hernquist_gradient(xyz[0,i], xyz[1,i], xyz[2,i], G, M, a, q)
for i in range(xyz.shape[1])]).T
bfe_grad = gradient(np.ascontiguousarray(xyz.T), Snlm, Tnlm, G, M, a).T
# check what typical errors are
# for j in range(3):
# pl.hist(np.abs((bfe_grad[j]-tru_grad[j])/tru_grad[j]))
for j in range(3):
assert np.all(np.abs((bfe_grad[j]-tru_grad[j])/tru_grad[j]) < 0.005) # 0.5%
return
# ------------------------------------------------------------------------
# plots:
# coefficients
fig,ax = pl.subplots(1,1,figsize=(10,8))
n,l = np.mgrid[:nmax+1, :lmax+1]
c = ax.scatter(n.ravel(), l.ravel(), c=Snlm[:,:,0].ravel(), s=64,
norm=mpl.colors.SymLogNorm(1E-5), cmap='RdBu_r',
vmin=-100, vmax=100, linewidths=1., edgecolors='#666666')
ax.xaxis.set_ticks(np.arange(0,nmax+1,1))
ax.yaxis.set_ticks(np.arange(0,lmax+1,1))
ax.set_xlim(-0.5, nmax+0.5)
ax.set_ylim(-0.5, lmax+0.5)
ax.set_xlabel('$n$')
ax.set_ylabel('$l$')
tickloc = np.concatenate((-10.**np.arange(2,-5-1,-1),
10.**np.arange(-5,2+1,1)))
fig.colorbar(c, ticks=tickloc, format='%.0e')
fig.tight_layout()
# contour plot in r,t at ph=0
rgrid = np.logspace(-1, 1., 128)
tgrid = np.linspace(0, np.pi, 128)
r,t = np.meshgrid(rgrid,tgrid)
x = r*np.sin(t)
z = r*np.cos(t)
_xyz = np.vstack((x.ravel(),np.zeros_like(x.ravel()),z.ravel()))
bfe_dens = density(np.ascontiguousarray(_xyz.T), Snlm, Tnlm, M, a)
true_dens = flattened_hernquist_density(_xyz[0], _xyz[1], _xyz[2], M, a, q)
fig,ax = pl.subplots(1, 1, figsize=(8,8))
levels = 10**np.linspace(-4.5, 1, 16)
ax.contour(np.log10(r), t, true_dens.reshape(x.shape),
levels=levels, colors='k',
locator=mpl.ticker.LogLocator(), label='True')
ax.contour(np.log10(r), t, bfe_dens.reshape(x.shape),
levels=levels, colors='r',
locator=mpl.ticker.LogLocator(), label='BFE')
ax.legend()
fig.tight_layout()
pl.show()
