def test_fits_mixins_qtable_to_table(tmpdir):
"""Test writing as QTable and reading as Table. Ensure correct classes
come out.
"""
filename = str(tmpdir.join('test_simple.fits'))
names = sorted(mixin_cols)
t = QTable([mixin_cols[name] for name in names], names=names)
t.write(filename, format='fits')
t2 = Table.read(filename, format='fits', astropy_native=True)
assert t.colnames == t2.colnames
for name, col in t.columns.items():
col2 = t2[name]
# Special-case Time, which does not yet support round-tripping
# the format.
if isinstance(col2, Time):
col2.format = col.format
attrs = compare_attrs[name]
compare_class = True
if isinstance(col.info, QuantityInfo):
# Downgrade Quantity to Column + unit
assert type(col2) is Column
# Class-specific attributes like `value` or `wrap_angle` are lost.
attrs = ['unit']
compare_class = False
# Compare data values here (assert_objects_equal doesn't know how in this case)
assert np.all(col.value == col2)
assert_objects_equal(col, col2, attrs, compare_class)
def test_possible_string_format_functions():
"""
The QuantityInfo info class for Quantity implements a
possible_string_format_functions() method that overrides the
standard pprint._possible_string_format_functions() function.
Test this.
"""
t = QTable([[1, 2] * u.m])
t['col0'].info.format = '%.3f'
assert t.pformat() == [' col0',
' m ',
'-----',
'1.000',
'2.000']
t['col0'].info.format = 'hi {:.3f}'
assert t.pformat() == [' col0 ',
' m ',
'--------',
'hi 1.000',
'hi 2.000']
t['col0'].info.format = '.4f'
assert t.pformat() == [' col0 ',
' m ',
'------',
'1.0000',
'2.0000']
def test_ecsv_mixins_qtable_to_table():
"""Test writing as QTable and reading as Table. Ensure correct classes
come out.
"""
names = sorted(mixin_cols)
t = QTable([mixin_cols[name] for name in names], names=names)
out = StringIO()
t.write(out, format="ascii.ecsv")
t2 = Table.read(out.getvalue(), format='ascii.ecsv')
assert t.colnames == t2.colnames
for name, col in t.columns.items():
col2 = t2[name]
attrs = compare_attrs[name]
compare_class = True
if isinstance(col.info, QuantityInfo):
# Downgrade Quantity to Column + unit
assert type(col2) is Column
# Class-specific attributes like `value` or `wrap_angle` are lost.
attrs = ['unit']
compare_class = False
# Compare data values here (assert_objects_equal doesn't know how in this case)
assert np.allclose(col.value, col2, rtol=1e-10)
assert_objects_equal(col, col2, attrs, compare_class)
def generic_export(spectrum, path):
"""
Creates a temporary export format for use in writing out data.
"""
from astropy.table import QTable
import astropy.units as u
data = {
'spectral_axis': spectrum.spectral_axis,
'flux': spectrum.flux,
'mask': spectrum.mask if spectrum.mask is not None
else u.Quantity(np.ones(spectrum.spectral_axis.shape))
}
if spectrum.uncertainty is not None:
data['uncertainty'] = spectrum.uncertainty.array * spectrum.uncertainty.unit
meta = {}
if spectrum.meta is not None and 'header' in spectrum.meta:
meta.update({'header': {k: v for k, v in
spectrum.meta['header'].items()}})
tab = QTable(data, meta=meta)
tab.write(path, format='ascii.ecsv')
def load_HST_WFC3(cls):
""" Load the LLS survey using HST/WFC3
by O'Meara et al. 2013, ApJ, 765, 137
Parameters
----------
Returns
-------
lls_survey : IGMSurvey
"""
# LLS File
lls_fil = pyigm_path+'/data/LLS/HST/lls_wfc3_stat_LLS.fits.gz'
lls = QTable.read(lls_fil)
# Rename some columns?
lls.rename_column('QSO_RA', 'RA')
lls.rename_column('QSO_DEC', 'DEC')
# Read
lls_survey = cls.from_sfits(lls)
lls_survey.ref = 'HST-WFC3'
# QSOs file
qsos_fil = pyigm_path+'/data/LLS/HST/lls_wfc3_qsos_sn1020.fits.gz'
qsos = QTable.read(qsos_fil)
lls_survey.sightlines = qsos
# Return
print('HST-WFC3: Loaded')
return lls_survey
def test_insert_row_bad_unit():
"""
Insert a row into a QTable with the wrong unit
"""
t = QTable([[1] * u.m])
with pytest.raises(ValueError) as exc:
t.insert_row(0, (2 * u.m / u.s,))
assert "'m / s' (speed) and 'm' (length) are not convertible" in str(exc.value)
def test_auto_format_func():
"""Test for #5802 (fix for #5800 where format_func key is not unique)"""
t = Table([[1, 2] * u.m])
t['col0'].format = '%f'
t.pformat() # Force caching of format function
qt = QTable(t)
qt.pformat() # Generates exception prior to #5802
def load_mage_z3(cls, sample='all'):
""" Load the LLS table from the z~3 MagE survey
(Fumagalli et al. 2013, ApJ, 775, 78)
Parameters
----------
sample : str
Survey sample
* all -- All
* non-color -- Restricts to quasars that were *not* color-selected
* color -- Restricts to quasars that were color-selected
Returns
-------
lls_survey : IGMSurvey
Includes all quasars observed in the survey
And all the LLS
"""
# LLS File
survey_fil = pyigm_path+'/data/LLS/HD-LLS/fumagalli13_apj775_78_tab1+2.fits'
tab = Table.read(survey_fil)
# Rename some columns
tab.rename_column('RAJ2000', 'RA')
tab['RA'].unit = u.deg
tab.rename_column('DEJ2000', 'DEC')
tab['DEC'].unit = u.deg
tab.rename_column('zqso', 'Z_QSO')
tab.rename_column('zlls', 'Z_LLS')
tab.rename_column('zend', 'Z_START') # F13 was opposite of POW10
tab.rename_column('zstart', 'Z_END') # F13 was opposite of POW10
# Cut table
if sample == 'all':
pass
elif sample == 'non-color':
NC = np.array([True if row['n_Name'][0] == 'N' else False for row in tab])
tab = tab[NC]
elif sample == 'color':
Clr = [True if row['n_Name'][0] == 'C' else False for row in tab]
tab = tab[Clr]
# Good LLS
lls = tab['Z_LLS'] >= tab['Z_START']
lls_tab = QTable(tab[lls])
nlls = np.sum(lls)
# Set NHI to 17.8 (tau>=2)
lls_tab.add_column(Column([17.8]*nlls, name='NHI'))
lls_tab.add_column(Column([99.9]*nlls, name='SIGNHI'))
# Generate survey
lls_survey = cls.from_sfits(lls_tab)
lls_survey.ref = 'z3_MagE'
lls_survey.sightlines = tab
return lls_survey
def load_SDSS_DR7(cls, sample='stat'):
""" Load the LLS from the SDSS-DR7 survey (Prochaska+10, ApJ, 718, 391)
Parameters
----------
sample : str, optional
LLS sample
stat : Statistical sample
all : All LLS
nonstat : Non-statistical sample
Returns
-------
lls_survey : IGMSurvey
"""
# LLS File
lls_fil = pyigm_path+'/data/LLS/SDSS/lls_dr7_stat_LLS.fits.gz'
print('SDSS-DR7: Loading LLS file {:s}'.format(lls_fil))
lls = QTable.read(lls_fil)
# Rename some columns?
lls.rename_column('QSO_RA', 'RA')
lls.rename_column('QSO_DEC', 'DEC')
# Read
lls_survey = cls.from_sfits(lls)
lls_survey.ref = 'SDSS-DR7'
# QSOs file
qsos_fil = pyigm_path+'/data/LLS/SDSS/lls_dr7_qsos_sn2050.fits.gz'
print('SDSS-DR7: Loading QSOs file {:s}'.format(qsos_fil))
qsos = QTable.read(qsos_fil)
lls_survey.sightlines = qsos
# All?
if sample == 'all':
return lls_survey
# Stat
# z_em cut
zem_min = 3.6
lowz_q = qsos['ZEM'] < zem_min
qsos['ZT2'][lowz_q] = 99.99
# Generate mask
print('SDSS-DR7: Performing stats (~60s)')
mask = lls_stat(lls_survey, qsos)
if sample == 'stat':
lls_survey.mask = mask
else:
lls_survey.mask = ~mask
# Return
print('SDSS-DR7: Loaded')
return lls_survey
def test_quantity_representation():
"""
Test that table representation of quantities does not have unit
"""
t = QTable([[1, 2] * u.m])
assert t.pformat() == ['col0',
' m ',
'----',
' 1.0',
' 2.0']
def test_convert_np_array(mixin_cols):
"""
Test that converting to numpy array creates an object dtype and that
each instance in the array has the expected type.
"""
t = QTable(mixin_cols)
ta = t.as_array()
m = mixin_cols['m']
dtype_kind = m.dtype.kind if hasattr(m, 'dtype') else 'O'
assert ta['m'].dtype.kind == dtype_kind
def __getitem__(self, item):
if self._is_list_or_tuple_of_str(item):
if 'time_bin_start' not in item or 'time_bin_size' not in item:
out = QTable([self[x] for x in item],
meta=deepcopy(self.meta),
copy_indices=self._copy_indices)
out._groups = groups.TableGroups(out, indices=self.groups._indices,
keys=self.groups._keys)
return out
return super().__getitem__(item)
def read_observation_table(pathin):
if pathin[-4:]=='.csv':
table = ascii.read(pathin)
qtable = QTable(table)
for key in qtable.keys():
if key[-3:]=='[s]' or key[-5:]=='[sec]':
qtable[key] = qtable[key] * u.s
if key[-5:]=='[min]':
qtable[key] = qtable[key] * u.min
if key[-3:]=='[h]' or key[-4:]=='[hr]' or key[-6:]=='[hour]':
qtable[key] = qtable[key] * u.s
if key[-3:]=='[d]' or key[-5:]=='[day]':
qtable[key] = qtable[key] * u.d
if key[-5:]=='[mag]':
qtable[key] = qtable[key] * u.Magnitude
if key[-4:]=='[Jy]':
qtable[key] = qtable[key] * u.Jy
if key[-5:]=='[mJy]':
qtable[key] = qtable[key] * u.mJy
if key[-12:]=='[erg/cm^2/s]':
qtable[key] = qtable[key] * u.erg / u.cm / u.cm / u.s
elif pathin[-7:]=='.pickle':
pdata = pickle_utilities.load(pathin)['results']
time = []
time_err_lo = []
time_err_hi = []
eflux = []
eflux_err_lo = []
eflux_err_hi = []
for period in pdata:
time.append(np.sqrt(period['time']['min']*period['time']['max']))
time_err_lo.append(time[-1] - period['time']['min'])
time_err_hi.append(period['time']['max'] - time[-1])
dll_map = period['dloglike']['dloglike']
eflux_map = period['dloglike']['eflux']
args_bestlike = zip(np.where(dll_map==dll_map.min())[0], np.where(dll_map==dll_map.min())[1])[0]
eflux_shown = eflux_map[2.*dll_map<=2.30]
eflux_min = min(eflux_shown.flatten())
eflux_max = max(eflux_shown.flatten())
eflux.append(eflux_map[args_bestlike[0]][args_bestlike[1]])
eflux_err_hi.append(eflux_max-eflux[-1])
eflux_err_lo.append(eflux[-1]-eflux_min)
qtable = QTable()
qtable['time'] = Column(time, unit=u.s)
qtable['time_err_lo'] = Column(time_err_lo, unit=u.s)
qtable['time_err_hi'] = Column(time_err_hi, unit=u.s)
qtable['eflux'] = Column(eflux, unit=u.MeV/u.cm/u.cm/u.s)
qtable['eflux_err_lo'] = Column(eflux_err_lo, unit=u.MeV/u.cm/u.cm/u.s)
qtable['eflux_err_hi'] = Column(eflux_err_hi, unit=u.MeV/u.cm/u.cm/u.s)
return qtable
def get_coord(targ_file, radec=None):
'''
radec: int (None)
None: Read from ASCII file
1: List of [Name, RA, DEC] with RA/DEC as : separated strings
2: List of [Name, RA, DEC] with RA/DEC as decimal degrees
'''
if not isinstance(targ_file,basestring):
raise IOError('Bad input to finder.get_coord!')
from astropy.io import ascii
# Import Tables
if radec == None:
# Read
ra_tab = ascii.read(targ_file) #, names=('Name','RA','DEC','Epoch'))
# Rename the columns
ra_tab.rename_column('col1','Name')
if isinstance(ra_tab['col2'][0],basestring):
ra_tab.rename_column('col2','RAS')
ra_tab.rename_column('col3','DECS')
else:
ra_tab.rename_column('col2','RA')
ra_tab.rename_column('col3','DEC')
elif radec == 1:
# Error check
if len(targ_file) != 3:
return -1
# Manipulate
arr = np.array(targ_file).reshape(1,3)
# Generate the Table
ra_tab = QTable( arr, names=('Name','RAS','DECS') )
elif radec == 2:
# Error check
if len(targ_file) != 3:
return -1
# Manipulate
ras, decs = x_radec.dtos1((targ_file[1], targ_file[2]))
# Generate the Table
ra_tab = QTable( [ [targ_file[0]], [ras], [decs] ], names=('Name','RA','DEC') )
else:
raise ValueError('get_coord: Bad flag')
# Add dummy columns for decimal degrees and EPOCH
nrow = len(ra_tab)
col_RAD = Column(name='RAD', data=np.zeros(nrow), unit=u.degree)
col_DECD = Column(name='DECD', data=np.zeros(nrow), unit=u.degree)
col_EPOCH = Column(name='EPOCH', data=np.zeros(nrow))
ra_tab.add_columns( [col_RAD, col_DECD, col_EPOCH] )
# Assume 2000 for now
ra_tab['EPOCH'] = 2000.
return ra_tab
def test_insert_row(mixin_cols):
"""
Test inserting a row, which only works for BaseColumn and Quantity
"""
t = QTable(mixin_cols)
t['m'].info.description = 'd'
if isinstance(t['m'], (u.Quantity, Column, time.Time)):
t.insert_row(1, t[-1])
assert t[1] == t[-1]
assert t['m'].info.description == 'd'
else:
with pytest.raises(ValueError) as exc:
t.insert_row(1, t[-1])
assert "Unable to insert row" in str(exc.value)
def test_io_ascii_write():
"""
Test that table with mixin column can be written by io.ascii for
every pure Python writer. No validation of the output is done,
this just confirms no exceptions.
"""
from astropy.io.ascii.connect import _get_connectors_table
t = QTable(MIXIN_COLS)
for fmt in _get_connectors_table():
if fmt['Format'] == 'ascii.ecsv' and not HAS_YAML:
continue
if fmt['Write'] and '.fast_' not in fmt['Format']:
out = StringIO()
t.write(out, format=fmt['Format'])
def build_table(self):
"""Generate an astropy QTable out of the component.
Returns
-------
comp_tbl : QTable
"""
if len(self._abslines) == 0:
return
comp_tbl = QTable()
comp_tbl.add_column(Column([iline.wrest.to(u.AA).value for iline in self._abslines]*u.AA, name='wrest'))
for attrib in ['z', 'flag_N', 'logN', 'sig_logN']:
comp_tbl.add_column(Column([iline.attrib[attrib] for iline in self._abslines], name=attrib))
# Return
return comp_tbl
def write_to_ascii(self, outfil, format='ascii.ecsv'):
''' Write to a text file.
Parameters
----------
outfil: str
Filename.
'''
# Convert to astropy Table
table = QTable([self.wavelength, self.flux, self.sig],
names=('WAVE', 'FLUX', 'ERROR'))
# Write
table.write(outfil, format=format)
def test_rename_mixin_columns(mixin_cols):
"""
Rename a mixin column.
"""
t = QTable(mixin_cols)
tc = t.copy()
t.rename_column('m', 'mm')
assert t.colnames == ['i', 'a', 'b', 'mm']
if isinstance(t['mm'], table_helpers.ArrayWrapper):
assert np.all(t['mm'].data == tc['m'].data)
elif isinstance(t['mm'], coordinates.SkyCoord):
assert np.all(t['mm'].ra == tc['m'].ra)
assert np.all(t['mm'].dec == tc['m'].dec)
else:
assert np.all(t['mm'] == tc['m'])
def test_votable_quantity_write(tmpdir):
"""
Test that table with Quantity mixin column can be round-tripped by
io.votable. Note that FITS and HDF5 mixin support are tested (much more
thoroughly) in their respective subpackage tests
(io/fits/tests/test_connect.py and io/misc/tests/test_hdf5.py).
"""
t = QTable()
t['a'] = u.Quantity([1, 2, 4], unit='Angstrom')
filename = str(tmpdir.join('table-tmp'))
t.write(filename, format='votable', overwrite=True)
qt = QTable.read(filename, format='votable')
assert isinstance(qt['a'], u.Quantity)
assert qt['a'].unit == 'Angstrom'
def read_verner94():
""" Read Verner1994 Table
"""
# Read
verner94 = lt_path + '/data/lines/verner94_tab6.fits'
print(
'linetools.lists.parse: Reading linelist --- \n {:s}'.format(
verner94))
tbl_6 = QTable.read(verner94)
# My table
ldict, data = line_data(nrows=len(tbl_6))
# Fill
data['wrest'] = tbl_6['lambda']
data['f'] = tbl_6['Fik']
data['gj'] = tbl_6['Gi']
data['gk'] = tbl_6['Gk']
data['Z'] = tbl_6['Z']
data['ion'] = tbl_6['Z'] - tbl_6['N'] + 1
for ii,row in enumerate(tbl_6):
data[ii]['name'] = (
row['Species'][0:2].strip() + row['Species'][2:].strip() +
' {:d}'.format(int(row['lambda'].value)))
#xdb.set_trace()
# Finish
data['group'] = 1
data['Ref'] = 'Verner1994'
data['mol'] = ''
# Return
return data
def from_sfits(self):
'''Generate the Survey from a summary FITS file
'''
# Read
systems = QTable.read(self.summ_fits)
self.nsys = len(systems)
# Dict
kdict = dict(NHI=['NHI','logNHI'],
sigNHI=['sig(logNHI)'],
name=['Name'],
vlim=['vlim'],
zabs=['Z_LLS'],
zem=['Z_QSO'],
RA=['RA'],
Dec=['DEC','Dec'])
# Parse the Table
inputs = {}
for key in kdict.keys():
vals, tag = lsio.get_table_column(kdict[key],[systems],idx=0)
if vals is not None:
inputs[key] = vals
# Generate
for kk,row in enumerate(systems):
# Generate keywords
kwargs = {}
for key in inputs.keys():
kwargs[key] = inputs[key][kk]
# Instantiate
self._abs_sys.append(set_absclass(self.abs_type)(**kwargs))
def from_sfits(cls, summ_fits, **kwargs):
"""Generate the Survey from a summary FITS file
Handles SPEC_FILES too.
Parameters
----------
summ_fits : str or Table or QTable
Summary FITS file
**kwargs : dict
passed to __init__
"""
# Init
slf = cls(**kwargs)
# Read
if isinstance(summ_fits, Table):
systems = summ_fits
else:
systems = QTable.read(summ_fits)
nsys = len(systems)
# Dict
kdict = dict(NHI=['NHI', 'logNHI'],
sig_NHI=['sig(logNHI)', 'SIGNHI'],
name=['Name'], vlim=['vlim'],
zabs=['Z_LLS', 'ZABS', 'zabs'],
zem=['Z_QSO', 'QSO_ZEM'],
RA=['RA'], Dec=['DEC', 'Dec'])
# Parse the Table
inputs = {}
for key in kdict.keys():
vals, tag = lsio.get_table_column(kdict[key], [systems],idx=0)
if vals is not None:
inputs[key] = vals
# vlim
if 'vlim' not in inputs.keys():
default_vlim = [-1000, 1000.]* u.km / u.s
inputs['vlim'] = [default_vlim]*nsys
# Generate
for kk in range(nsys):
# Generate keywords
kwargs = {}
args = {}
for key in inputs.keys():
if key in ['vlim', 'zabs', 'RA', 'Dec']:
args[key] = inputs[key][kk]
else:
kwargs[key] = inputs[key][kk]
# Instantiate
abssys = class_by_type(slf.abs_type)((args['RA'], args['Dec']), args['zabs'], args['vlim'], **kwargs)
# spec_files
try:
abssys.spec_files += systems[kk]['SPEC_FILES'].tolist()
except (KeyError, AttributeError):
pass
slf._abs_sys.append(abssys)
# Mask
slf.init_mask()
# Return
return slf
def test_votable_mixin_write_fail(mixin_cols):
"""
Test that table with mixin columns (excluding Quantity) cannot be written by
io.votable.
"""
t = QTable(mixin_cols)
# Only do this test if there are unsupported column types (i.e. anything besides
# BaseColumn and Quantity class instances).
unsupported_cols = t.columns.not_isinstance((BaseColumn, u.Quantity))
if not unsupported_cols:
pytest.skip("no unsupported column types")
out = StringIO()
with pytest.raises(ValueError) as err:
t.write(out, format='votable')
assert 'cannot write table with mixin column(s)' in str(err.value)
def test_group_mixins():
"""
Test grouping a table with mixin columns
"""
# Setup mixins
idx = np.arange(4)
x = np.array([3., 1., 2., 1.])
q = x * u.m
lon = coordinates.Longitude(x * u.deg)
lat = coordinates.Latitude(x * u.deg)
# For Time do J2000.0 + few * 0.1 ns (this requires > 64 bit precision)
tm = time.Time(2000, format='jyear') + time.TimeDelta(x * 1e-10, format='sec')
sc = coordinates.SkyCoord(ra=lon, dec=lat)
aw = table_helpers.ArrayWrapper(x)
nd = np.array([(3, 'c'), (1, 'a'), (2, 'b'), (1, 'a')],
dtype='<i4,|S1').view(NdarrayMixin)
qt = QTable([idx, x, q, lon, lat, tm, sc, aw, nd],
names=['idx', 'x', 'q', 'lon', 'lat', 'tm', 'sc', 'aw', 'nd'])
# Test group_by with each supported mixin type
mixin_keys = ['x', 'q', 'lon', 'lat', 'tm', 'sc', 'aw', 'nd']
for key in mixin_keys:
qtg = qt.group_by(key)
# Test that it got the sort order correct
assert np.all(qtg['idx'] == [1, 3, 2, 0])
# Test that the groups are right
# Note: skip testing SkyCoord column because that doesn't have equality
for name in ['x', 'q', 'lon', 'lat', 'tm', 'aw', 'nd']:
assert np.all(qt[name][[1, 3]] == qtg.groups[0][name])
assert np.all(qt[name][[2]] == qtg.groups[1][name])
assert np.all(qt[name][[0]] == qtg.groups[2][name])
# Test that unique also works with mixins since most of the work is
# done with group_by(). This is using *every* mixin as key.
uqt = unique(qt, keys=mixin_keys)
assert len(uqt) == 3
assert np.all(uqt['idx'] == [1, 2, 0])
assert np.all(uqt['x'] == [1., 2., 3.])
# Column group_by() with mixins
idxg = qt['idx'].group_by(qt[mixin_keys])
assert np.all(idxg == [1, 3, 2, 0])
def write_to_ascii(self, outfil, format='ascii.ecsv'):
''' Write spectrum to an ASCII file
Parameters
----------
outfil: str
Name of the FITS file
Returns:
--------
Outputs an ASCII file
'''
# Convert to astropy Table
table = QTable([self.dispersion, self.flux, self.sig],
names=('WAVE','FLUX','ERROR'))
# Write
table.write(outfil,format=format)
def test_ecsv_mixins_ascii_read_class():
"""Ensure that ascii.read(ecsv_file) returns the correct class
(QTable if any Quantity subclasses, Table otherwise).
"""
# Make a table with every mixin type except Quantities
t = QTable({name: col for name, col in mixin_cols.items()
if not isinstance(col.info, QuantityInfo)})
out = StringIO()
t.write(out, format="ascii.ecsv")
t2 = ascii.read(out.getvalue(), format='ecsv')
assert type(t2) is Table
# Add a single quantity column
t['lon'] = mixin_cols['lon']
out = StringIO()
t.write(out, format="ascii.ecsv")
t2 = ascii.read(out.getvalue(), format='ecsv')
assert type(t2) is QTable
def test_assignment_and_copy():
"""
Test that assignment of an int, slice, and fancy index works.
Along the way test that copying table works.
"""
for name in ('quantity', 'arraywrap'):
m = MIXIN_COLS[name]
t0 = QTable([m], names=['m'])
for i0, i1 in ((1, 2),
(slice(0, 2), slice(1, 3)),
(np.array([1, 2]), np.array([2, 3]))):
t = t0.copy()
t['m'][i0] = m[i1]
if name == 'arraywrap':
assert np.all(t['m'].data[i0] == m.data[i1])
assert np.all(t0['m'].data[i0] == m.data[i0])
assert np.all(t0['m'].data[i0] != t['m'].data[i0])
else:
assert np.all(t['m'][i0] == m[i1])
assert np.all(t0['m'][i0] == m[i0])
assert np.all(t0['m'][i0] != t['m'][i0])
def test_write_with_mixins():
"""Writing a table with mixins just drops them via to_pandas()
This also tests passing a kwarg to pandas read and write.
"""
sc = SkyCoord([1, 2], [3, 4], unit='deg')
q = [5, 6] * u.m
qt = QTable([[1, 2], q, sc], names=['i', 'q', 'sc'])
buf = StringIO()
qt.write(buf, format='pandas.csv', sep=' ')
exp = ['i q sc.ra sc.dec',
'1 5.0 1.0 3.0',
'2 6.0 2.0 4.0']
assert buf.getvalue().splitlines() == exp
# Read it back
buf.seek(0)
qt2 = Table.read(buf, format='pandas.csv', sep=' ')
exp_t = ascii.read(exp)
assert qt2.colnames == exp_t.colnames
assert np.all(qt2 == exp_t)
def read_elvis_z0(fn):
tab = QTable.read(fn, format='ascii.commented_header', data_start=0, header_start=1)
col_name_re = re.compile(r'(.*?)(\(.*\))?$')
for col in tab.columns.values():
match = col_name_re.match(col.name)
if match:
nm, unit = match.groups()
if nm != col.name:
col.name = nm
if unit is not None:
col.unit = u.Unit(unit[1:-1]) # 1:-1 to get rid of the parenthesis
return tab
def test_masked_column_with_unit_in_qtable():
"""Test that adding a MaskedColumn with a unit to QTable issues warning"""
t = QTable()
with catch_warnings() as w:
t['a'] = MaskedColumn([1, 2])
assert len(w) == 0
assert isinstance(t['a'], MaskedColumn)
with catch_warnings() as w:
t['b'] = MaskedColumn([1, 2], unit=u.m)
assert len(w) == 0
assert isinstance(t['b'], u.Quantity)
with catch_warnings() as w:
t['c'] = MaskedColumn([1, 2], unit=u.m, mask=[True, False])
assert len(w) == 1
assert "dropping mask in Quantity column 'c'"
assert isinstance(t['b'], u.Quantity)
def test_create_grism_objects():
source_catalog = get_file_path('step_SourceCatalogStep_cat.ecsv')
# create from test ascii file
grism_objects = read_catalog(source_catalog)
assert isinstance(grism_objects,
list), "return grism objects were not a list"
required_fields = list(SkyObject()._fields)
go_fields = grism_objects[0]._fields
assert all([a == b for a, b in zip(required_fields, go_fields)
]), "Required fields mismatch for SkyObject and GrismObject"
# create from QTable object
tempcat = QTable.read(source_catalog, format='ascii.ecsv')
grism_object_from_table = read_catalog(tempcat)
assert isinstance(grism_object_from_table,
list), "return grism objects were not a list"
def test_get_items(mixin_cols):
"""
Test that slicing / indexing table gives right values and col attrs inherit
"""
attrs = ('name', 'unit', 'dtype', 'format', 'description', 'meta')
m = mixin_cols['m']
m.info.name = 'm'
m.info.format = '{0}'
m.info.description = 'd'
m.info.meta = {'a': 1}
t = QTable([m])
for item in ([1, 3], np.array([0, 2]), slice(1, 3)):
t2 = t[item]
m2 = m[item]
assert_table_name_col_equal(t2, 'm', m[item])
for attr in attrs:
assert getattr(t2['m'].info, attr) == getattr(m.info, attr)
assert getattr(m2.info, attr) == getattr(m.info, attr)
def catalog(self):
"""
The final source catalog.
"""
self.convert_to_jy()
self.set_segment_properties()
self.set_aperture_properties()
self.set_ci_properties()
catalog = QTable()
for column in self.colnames:
catalog[column] = getattr(self, column)
catalog[column].info.description = self.column_desc[column]
catalog = self.format_columns(catalog)
catalog.meta.update(self.catalog_metadata)
return catalog
def __init__(self, filename='$GAMMA_CAT/docs/data/gammacat.fits.gz'):
filename = make_path(filename)
if 'GAMMA_CAT' not in os.environ:
msg = 'The gamma-cat repo is not available. '
msg += 'You have to set the GAMMA_CAT environment variable '
msg += 'to point to the location for it to be found.'
raise GammaCatNotFoundError(msg)
self.filename = str(filename)
table = QTable.read(self.filename)
source_name_key = 'common_name'
source_name_alias = ('other_names', 'gamma_names')
super(SourceCatalogGammaCat, self).__init__(
table=table,
source_name_key=source_name_key,
source_name_alias=source_name_alias,
)
def test_units():
""" test units on multi-row tables """
ground_truth = QTable(
[[1, 2, 3] * u.Unit('m'), [4, 5, 6] * u.m / u.s, ['a', 'b', 'c']],
names=('aa', 'bb', 'cc'))
assert ((ground_truth['aa']**2).unit == 'm2')
test_dict = DataClass.from_dict(
OrderedDict((('aa', [1, 2, 3] * u.m), ('bb', [4, 5, 6] * u.m / u.s),
('cc', ['a', 'b', 'c']))))
assert all(test_dict.table == ground_truth)
test_array = DataClass.from_columns(
[[1, 2, 3] * u.m, [4, 5, 6] * u.m / u.s, ['a', 'b', 'c']],
names=('aa', 'bb', 'cc'))
assert all(test_array.table == ground_truth)
def load_specific_scope_settings(path):
"""One scope settings file will be loaded into a table
example usage:
PATH = 'Scope_Settings/FAKEDATA_observation_2458180_7314443593_scope_settings.csv'
scope_settings = load_specific_scope_settings(PATH)"""
names = ['obs_JD', 'east_alt', 'east_az', 'west_alt', 'west_az']
table = QTable(ascii.read(path), names = names)
table['east_alt'].unit = u.deg
table['east_az' ].unit = u.deg
table['west_alt'].unit = u.deg
table['west_az' ].unit = u.deg
return table
def read_elvis_z0(fn):
tab = QTable.read(fn,
format='ascii.commented_header',
data_start=0,
header_start=1)
col_name_re = re.compile(r'(.*?)(\(.*\))?$')
for col in tab.columns.values():
match = col_name_re.match(col.name)
if match:
nm, unit = match.groups()
if nm != col.name:
col.name = nm
if unit is not None:
col.unit = u.Unit(
unit[1:-1]) # 1:-1 to get rid of the parenthesis
return tab
def _properties_table(obj, columns=None, exclude_columns=None):
if isinstance(obj, SourceCatalog) and len(obj) == 0:
raise ValueError('SourceCatalog contains no sources.')
# all scalar-valued properties
columns_all = [
'id', 'xcentroid', 'ycentroid', 'sky_centroid', 'sky_centroid_icrs',
'source_sum', 'source_sum_err', 'background_sum', 'background_mean',
'background_at_centroid', 'xmin', 'xmax', 'ymin', 'ymax', 'min_value',
'max_value', 'minval_xpos', 'minval_ypos', 'maxval_xpos',
'maxval_ypos', 'area', 'equivalent_radius', 'perimeter',
'semimajor_axis_sigma', 'semiminor_axis_sigma', 'eccentricity',
'orientation', 'ellipticity', 'elongation', 'covar_sigx2',
'covar_sigxy', 'covar_sigy2', 'cxx', 'cxy', 'cyy'
]
table_columns = None
if exclude_columns is not None:
table_columns = [s for s in columns_all if s not in exclude_columns]
if columns is not None:
table_columns = np.atleast_1d(columns)
if table_columns is None:
table_columns = columns_all
tbl = QTable()
for column in table_columns:
values = getattr(obj, column)
if isinstance(obj, SourceProperties):
values = np.atleast_1d(values)
if isinstance(values[0], u.Quantity):
# turn list of Quantities into a Quantity array
values = u.Quantity(values)
if isinstance(values[0], SkyCoord): # pragma: no cover
# turn list of SkyCoord into a SkyCoord array
values = SkyCoord(values)
if isinstance(obj, SourceCatalog) and values is None:
values = [None] * len(obj)
tbl[column] = values
return tbl
def cenA_model():
cwd = os.getenv('LUVOIR_SIMTOOLS_DIR')
#### Grab Cen A information from SIMBAD eventually the galaxy will be a user choice
cenA = Simbad.query_object('ngc5128')
cenAdistance = 3.8 * u.Mpc # Harris et al. (2010)
cenACoords = SkyCoord(cenA['RA'][0], cenA['DEC'][0], unit=(u.hourangle, u.deg))
imCenA = plt.imread(cwd+'/data/cenA-Fermi-noLabel.jpg')
imCenA = imCenA[:,0:556,:]
# Work out angle for FoV on the sky. The "scale" is based on a measurement with
# a different image, so need to get that scale right (all the bits at the end).
scale = 300.*u.kpc / (595*786./1007) # kpc/pixel
FoV = np.array(np.shape(imCenA)[0:-1])
FoV = FoV[[1,0]]
FoV_kpc = FoV * scale
angle = np.rad2deg(np.arctan(FoV_kpc / cenAdistance.to('kpc')) )
area = angle[0]*angle[1] # x * y
dr7qso = QTable.read(cwd+'/data/dr7_qso_galex.fits')
zem = dr7qso['Z'][0]
fuv = dr7qso['FUV_MAG'][0]
nuv = dr7qso['NUV_MAG'][0]
# these limiting mags correspond to the apertures Howk used
limitingmags = [18.0,19.2,20.1,21.0,21.8]
numQSOs = np.zeros_like(limitingmags)
for j in np.arange(np.size(limitingmags)):
num = ((fuv > 10) & (fuv < limitingmags[j]))
num = num.sum()
numQSOs[j] += num
numQSOs = np.array(numQSOs)/np.max(numQSOs) # Make this a relative number:
qso_density_ref = 5./u.deg**2 # Rough QSO density = 5 for 15-m
num_qsos = qso_density_ref * numQSOs[j] * area
xqso=np.random.randint(0,FoV[0],size=num_qsos)
yqso=np.random.randint(0,FoV[1],size=num_qsos)
print 'numQSOs', numQSOs
# need to randomly generate mags too. . . .
mags = 3.8 * np.random.rand(num_qsos) + 18.
return xqso, yqso, mags
def as_fits_table(self, line: QTable) -> QTable:
"""
Writes out the results for an emission line within a multiple line fit
for which there is no spectral coverage
Input:
self: emission line fit parameters
line: lab properties of the fitted emission line
Return:
Fits table with all the lab and measured properties of a particular
emission line
"""
t = QTable()
# Vacuum/laboratory properties of the line
t = hstack([t, line])
t["z"] = Column([self.z],
dtype="f",
description="Source redshift, from specpro")
# Line fits
# Continuum around line
t["cont"] = Column(
[self.continuum.value.value],
dtype="f",
unit=self.continuum.value.unit,
description="Continuum around line, Gaussian fit",
)
t["cont_err"] = Column(
[self.continuum.error.value],
dtype="f",
unit=self.continuum.error.unit,
description="Error on continuum around line, Gaussian fit",
)
# Detection flag
t["detected"] = Column([False],
dtype="bool",
description="Detected or nondetected line")
# Coverage flag
t["covered"] = Column([False],
dtype="bool",
description="Does the spectrum cover the line?")
return t
def make_catalog_table(self):
spatial_pixel_scale = self.get_spatial_pixel_scale(self.img_path)
catalog = []
with open(self.target_file_path) as f:
for line in f:
if '#' in line:
continue
line = line.replace("\n", "")
row = line.split(" ")
if len(row) != 3 and len(row) != 4:
raise Exception("Incorrect target catalog file format.")
for i, r in enumerate(row[1:]):
i += 1
row[i] = float(r)
row.append(spatial_pixel_scale)
row.append(self.cutout_x_size) #cutout_x_size
row.append(self.cutout_y_size) #cutout_y_size
catalog.append(row)
if len(catalog[0]) == 7:
colNames = [
"id", "ra", "dec", "slit_pa", "spatial_pixel_scale",
"cutout_x_size", "cutout_y_size"
]
elif len(catalog[0]) == 6:
colNames = [
"id", "ra", "dec", "spatial_pixel_scale", "cutout_x_size",
"cutout_y_size"
]
else:
raise Exception("Catalog generation unsuccessful.")
t = QTable(rows=catalog, names=colNames)
t["ra"].unit = u.deg
t["dec"].unit = u.deg
t["spatial_pixel_scale"].unit = (u.arcsec / u.pix)
t["cutout_x_size"].unit = u.arcsec
t["cutout_y_size"].unit = u.arcsec
if len(row[0]) == 7:
t["slit_pa"].unit = u.deg
return t
def _parse_result(self, response, verbose=False):
"""
internal wrapper to parse queries
"""
if self._get_raw_response:
return response.text
# intercept error messages
response_txt = response.text.split('\n')[2:-1]
if len(response_txt) < 3 and len(response_txt[-1].split('|')) < 21:
raise RuntimeError(response_txt[-1])
names = response_txt[0].replace('# ', '').strip().split(' | ')
results = ascii.read(response_txt[1:],
delimiter='|',
names=names,
fast_reader=False)
results = QTable(results)
# convert coordinates to degrees
coo = SkyCoord(ra=results['RA(h)'],
dec=results['DE(deg)'],
unit=(u.hourangle, u.deg),
frame='icrs')
results['RA(h)'] = coo.ra.deg
results['DE(deg)'] = coo.dec.deg
colnames = results.columns[:]
for fieldname in colnames:
# apply field name change
results.rename_column(fieldname, conf.field_names[fieldname])
# apply unit, if available
if conf.field_names[fieldname] in conf.field_units:
results[conf.field_names[fieldname]].unit = conf.field_units[
conf.field_names[fieldname]]
# convert object numbers to int
# unnumbered asteroids return as non numeric values ('-')
# this is treated as defaulting to 0, and masking the entry
unnumbered_mask = [not str(x).isdigit() for x in results['Number']]
numbers = [
int(x) if str(x).isdigit() else 0 for x in results['Number']
]
asteroid_number_col = MaskedColumn(numbers,
name='Number',
mask=unnumbered_mask)
results.replace_column('Number', asteroid_number_col)
return results
def build_table(filename):
data_array = np.genfromtxt(filename)
## Read from columns of data arrays
Lx = data_array[:,0]
Ly = data_array[:,1]
Lz = data_array[:,2]
r = data_array[:,3]
## Get more quantities
L = np.sqrt(Lx*Lx + Ly*Ly + Lz*Lz)
lx = Lx/L
ly = Ly/L
lz = Lz/L
rho = L*r**(-1./2.)
tilt = np.arcsin(np.sqrt(lx*lx + ly*ly))*180.0/np.pi
prec = np.arctan2(ly,lx)*180.0/np.pi
## Derivative quantitiess need to know how grid is spaced (linear or log)
if ((r[1] - r[0]) - (r[2] - r[1]) < 1e-14):
dr = r[2:] - r[:-2]
print "Assuming linearly spaced grid..."
elif (((np.log10(r)[1] - np.log10(r)[0]) - (np.log10(r)[2] - np.log10(r)[1])) < 1e-14):
dr = r[1:-1]*np.log(10)*(np.log10(r)[2:] - np.log10(r)[:-2])
print "Assuming log10 spaced grid..."
else:
print "Error: Something is wrong with the log check! Exiting!"
return
## Need to fill guard cells for derivative quantities
# Build warp amplitude Psi
psi = np.zeros(len(L))
psi_x = (0.5*r[1:-1]/dr)*(lx[2:]-lx[:-2])
psi_y = (0.5*r[1:-1]/dr)*(ly[2:]-ly[:-2])
psi_z = (0.5*r[1:-1]/dr)*(lz[2:]-lz[:-2])
psi[1:-1] = np.sqrt(psi_x**2.0 + psi_y**2.0 + psi_z**2.0)
psi[0] = psi[1]
psi[-1] = psi[-2]
## Compile tables
table_list = [Lx,Ly,Lz,r,L,lx,ly,lz,rho,tilt,prec,psi]
table_titles = ["Lx","Ly","Lz","r","L","lx","ly","lz","rho","tilt","prec","psi"]
return QTable(data=table_list,names=table_titles)
def loadScenarios(filename=None):
'''
Load various observing scenarios
'''
if filename is None:
fname = path + '/Inputs/ETC/Scenarios.csv'
else:
fname = filename
scens = pd.read_csv(fname, skip_blank_lines=True)
scenarios = QTable.from_pandas(scens)
# two indexes
scenarios.add_index('Scenario')
scenarios.add_index('Coronagraph')
scenarios['Center lam'].unit = u.nm
scenarios['t integ, hrs'].unit = u.h
scenarios['Years at L2'].unit = u.year
scenarios['Ref Dmag'].unit = u.mag
return scenarios
def build_table(self):
"""Generate an astropy QTable out of the abs lines
Returns
-------
comp_tbl : QTable
"""
if len(self._abslines) == 0:
return
comp_tbl = QTable()
comp_tbl.add_column(
Column([iline.wrest.to(u.AA).value
for iline in self._abslines] * u.AA,
name='wrest'))
comp_tbl.add_column(
Column([iline.z for iline in self._abslines], name='z'))
for attrib in ['flag_N', 'logN', 'sig_logN']:
comp_tbl.add_column(
Column([iline.attrib[attrib] for iline in self._abslines],
name=attrib))
# Return
return comp_tbl
def __init__(self, version=None, verbose=True):
# Set version
if version is None:
self._version = 'DR7'
else:
self._version = version
self.verbose = verbose
# Paths
if os.getenv('SDSSPATH') is None:
print('SDSS_QUASAR: This code requires an SDSS database. Discuss with JXP')
return
self._path = os.getenv('SDSSPATH')+'/'+self._version+'_QSO/'
self._datdir = self._path+'spectro/1d_26/'
# Grab Summary FITS file
self._summf = self._path+self._version.lower()+'_qso.fits.gz'
if self.verbose:
print('SDSS_QUASAR: Using summary file {:s}'.format(self._summf))
self._data = QTable.read(self._summf)
def prepare_catalog(cat,
size,
band,
ra='ra',
dec='dec',
name=None,
unit='arcsec',
prefix=None,
output='./'):
"""Get the input catalog ready."""
# RA, Dec: convert to standard column names
ra_arr, dec_arr = cat[ra], cat[dec]
# Name of the output file
if prefix is None:
prefix = DATA_ROOT.split('/')[-1]
prefix = prefix.lower()
if name is None:
name_arr = ra_dec_prefix(ra_arr, dec_arr, band, prefix, output=output)
else:
name_arr = [
os.path.join(
output, "{:s}_{:s}_{:s}".format(prefix,
str(name).strip(),
band.lower()))
for name in cat[name]
]
# Radius of the cutout
if is_number(size):
# Using the same size for all objects
size_arr = np.full(len(cat), float(size))
else:
size_arr = cat[size]
# Add size unit if necessary
if unit != 'pixel':
size_arr = [s * u.Unit(unit) for s in size_arr]
return QTable([name_arr, list(ra_arr),
list(dec_arr), size_arr],
names=('prefix', 'ra', 'dec', 'radius'))
def __init__(self,
n_levels=None,
energy_unit=None,
level_name='j',
*args,
**kwargs):
"""
Constructor
"""
super(EnergyLevelsOnDegreeOfFreedom, self).__init__(*args, **kwargs)
table_type = {
level_name: numpy.zeros(n_levels, 'i4'),
'g': numpy.zeros(n_levels, 'i4'),
'label': numpy.zeros(n_levels, 'i4'),
'E': numpy.zeros(n_levels, 'f8') * energy_unit
}
self.data = QTable(dict(**table_type))
"""the astropy table that holds the levels data"""
def test_easplomparser(tmpdir):
f = tmpdir.mkdir('ion_sources').join('be_2.easplom')
f.write(
""" 4 2 1 3 1 7.551e-01 8.649e+00 1.700e+00 9.785e-02 1.007e-01 1.147e-01 1.415e-01 1.749e-01
-1
%file: be_2.easplom
%excitation autoionization cross section parameter file
derived from fits to experimental and theoretical data
Dere, K. P., 2007, A&A, 466, 771
ADS ref: http://adsabs.harvard.edu/abs/2007A%26A...466..771D
created for CHIANTI database for astrophysical spectroscopy
created by Ken Dere (GMU) Fri Jan 26 12:40:26 2007
-1""")
table = QTable(
data=[[1], [3], [1], [0.7551], [8.649], [1.7],
[np.array([0.09785, 0.1007, 0.1147, 0.1415, 0.1749])]],
names=EasplomParser.headings,
meta={
'element':
'be',
'ion':
'be_2',
'filename':
'be_2.easplom',
'footer':
"file: be_2.easplom\nexcitation autoionization cross section parameter file\nderived from fits to experimental and theoretical data\nDere, K. P., 2007, A&A, 466, 771\nADS ref: http://adsabs.harvard.edu/abs/2007A%26A...466..771D\ncreated for CHIANTI database for astrophysical spectroscopy\ncreated by Ken Dere (GMU) Fri Jan 26 12:40:26 2007"
})
for h, unit in zip(EasplomParser.headings, EasplomParser.units):
table[h].unit = unit
p = EasplomParser('be_2.easplom',
full_path=os.path.join(f.dirname, f.basename))
table_parsed = p.parse()
for c in table.colnames:
for row, row_parsed in zip(table[c], table_parsed[c]):
test = row == row_parsed
if isinstance(test, np.ndarray):
assert np.all(test)
else:
assert test
for k in ('footer', 'filename', 'element', 'ion'):
assert table_parsed.meta[k] == table.meta[k]
assert 'chianti_version' in table_parsed.meta
assert 'descriptions' in table_parsed.meta
def test_creation_multi():
""" test the creation of DataClass objects from dicts or arrays;
multiple rows"""
ground_truth = QTable([[1, 2, 3], [4, 5, 6], ['a', 'b', 'c']],
names=('a', 'b', 'c'))
test_dict = DataClass.from_dict(
[OrderedDict((('a', 1), ('b', 4), ('c', 'a'))),
OrderedDict((('a', 2), ('b', 5), ('c', 'b)'))),
OrderedDict((('a', 3), ('b', 6), ('c', 'c')))])
assert all(test_dict.table == ground_truth)
test_array = DataClass.from_array([[1, 2, 3], [4, 5, 6],
['a', 'b', 'c']],
names=('a', 'b', 'c'))
assert all(test_array.table == ground_truth)
test_table = DataClass.from_table(ground_truth)
assert all(test_table.table == ground_truth)
# test reading data from file
ra = [10.223423, 10.233453, 10.243452]
dec = [-12.42123, -12.41562, -12.40435]
epoch = 2451523.5 + array([0.1234, 0.2345, 0.3525])
file_ground_truth = DataClass.from_array(
[ra, dec, epoch], names=['ra', 'dec', 't'])
test_file = DataClass.from_file(data_path('test.txt'),
format='ascii')
assert all(file_ground_truth.table == test_file.table)
# test failing if columns have different lengths
with pytest.raises(ValueError):
test_dict = DataClass.from_dict(
OrderedDict([(('a', 1), ('b', 4), ('c', 'a')),
(('a', 2), ('b', 5), ('c', 'b)')),
(('a', 3), ('b', 6), ('c', 7))]))
with pytest.raises(ValueError):
test_array = DataClass.from_array([[1, 2, 3], [4, 5, 6], ['a', 'b']],
names=('a', 'b', 'c'))
def write_angular_resolutions(outfile, e_bins, res, overwrite=False, append=True):
"""
Parameters
----------
outfile: str
e_bins: `numpy.ndarray` or `astropy.Quantity`
res: `np.ndarray`
overwrite
append
"""
e_bins_t = QTable(data=e_bins[..., np.newaxis], names=['energy_bins'])
data = res
names = ['angular_res', 'angular_res_err_lo', 'angular_res_err_hi']
res_t = Table(data=data, names=names)
write_table_hdf5(e_bins_t, outfile, path='bins', overwrite=overwrite, append=append, serialize_meta=True)
write_table_hdf5(res_t, outfile, path='res', append=True)
def test_insert_row(mixin_cols):
"""
Test inserting a row, which only works for BaseColumn and Quantity
"""
t = QTable(mixin_cols)
t['m'].info.description = 'd'
if isinstance(t['m'], (u.Quantity, Column, time.Time)):
t.insert_row(1, t[-1])
assert t[1] == t[-1]
assert t['m'].info.description == 'd'
else:
with pytest.raises(ValueError) as exc:
t.insert_row(1, t[-1])
assert "Unable to insert row" in str(exc.value)
def read_summary_table(file: str) -> QTable:
"""Read summary table to be in Astropy format.
Parameters
----------
file: str
file to read with QTable
Returns
-------
df : QTable
"""
# read table, in Table format for better editing access
df = Table.read(file, format="ascii.commented_header")
df.add_index("Name") # index by name
# units dictionary
units = {
"ra": u.deg,
"dec": u.deg,
"dist": u.kpc,
"vlos": u.km / u.s,
"vloserr": u.km / u.s,
"sigma": u.km / u.s,
"rmax": u.arcmin,
"pmra": u.mas / u.yr,
"pmdec": u.mas / u.yr,
"pmra_e": u.mas / u.yr,
"pmdec_e": u.mas / u.yr,
"rscale": u.arcmin,
"pmdisp": u.mas / u.yr,
"pmscale": u.mas / u.yr,
"pmscale_e": u.mas / u.yr,
}
# assign units
for name, unit in units.items():
if name in df.columns: # needed b/c creating columns
df[name].unit = unit
return QTable(df)
def convert_qe_curve(filename):
"""Convert a single QE curve from its native FITS format to an
an `astropy.table.QTable` representation.
Parameters
----------
filename : `str`
Full path, including filename for the file to be converted.
Returns
-------
table : `astropy.table.QTable`
A QTable object containing the columns that describe this
QE curve.
Notes
-----
This function is specific to how the ts8 data are formatted
with a curve per amp. If ther are other formats, a different
converter will be necessary.
"""
with fits.open(filename) as hdu_list:
# qe data is in first extension
data = hdu_list[1].data
wlength = []
eff = dict()
for row in data:
wlength.append(row['WAVELENGTH'])
for i in range(16): # There are 16 amps
col_name = f'AMP{i+1:02d}'
eff.setdefault(amp_name_map[col_name], []).append(row[col_name])
out_data = {'amp_name': [], 'wavelength': [], 'efficiency': []}
for k in eff:
amp_names = [k] * len(wlength)
out_data['amp_name'] += amp_names
out_data['wavelength'] += wlength
out_data['efficiency'] += eff[k]
out_data['amp_name'] = numpy.array(out_data['amp_name'])
out_data['wavelength'] = numpy.array(out_data['wavelength']) * u.nanometer
out_data['efficiency'] = numpy.array(out_data['efficiency']) * u.percent
return QTable(out_data)
def test_create_histogram_table():
'''Test create histogram table'''
from pyirf.binning import create_histogram_table
events = QTable({
'reco_energy': [1, 1, 10, 100, 100, 100] * u.TeV,
})
bins = [0.5, 5, 50, 500] * u.TeV
# test without weights
hist = create_histogram_table(events, bins, key='reco_energy')
assert np.all(hist['n'] == [2, 1, 3])
assert np.all(hist['n_weighted'] == [2, 1, 3])
# test with weights
events['weight'] = [0.5, 2, 2.5, 0.5, 0.2, 0.3]
hist = create_histogram_table(events, bins, key='reco_energy')
assert np.all(hist['n'] == [2, 1, 3])
assert np.all(hist['n_weighted'] == [2.5, 2.5, 1.0])
# test with particle_types
types = np.array(['gamma', 'electron', 'gamma', 'electron', 'gamma', 'proton'])
events['particle_type'] = types
hist = create_histogram_table(events, bins, key='reco_energy')
assert np.all(hist['n'] == [2, 1, 3])
assert np.all(hist['n_weighted'] == [2.5, 2.5, 1.0])
assert np.all(hist['n_gamma'] == [1, 1, 1])
assert np.all(hist['n_electron'] == [1, 0, 1])
assert np.all(hist['n_proton'] == [0, 0, 1])
assert np.allclose(hist['n_gamma_weighted'], [0.5, 2.5, 0.2])
assert np.allclose(hist['n_electron_weighted'], [2, 0, 0.5])
assert np.allclose(hist['n_proton_weighted'], [0, 0, 0.3])
# test with empty table
empty = events[:0]
hist = create_histogram_table(empty, bins, key='reco_energy')
zeros = np.zeros(3)
assert np.all(hist['n'] == zeros)
assert np.all(hist['n_weighted'] == zeros)
def T1(request):
T = QTable.read([
' a b c d',
' 2 c 7.0 0',
' 2 b 5.0 1',
' 2 b 6.0 2',
' 2 a 4.0 3',
' 0 a 0.0 4',
' 1 b 3.0 5',
' 1 a 2.0 6',
' 1 a 1.0 7',
],
format='ascii')
T['q'] = np.arange(len(T)) * u.m
T.meta.update({'ta': 1})
T['c'].meta.update({'a': 1})
T['c'].description = 'column c'
if request.param:
T.add_index('a')
return T
def _load_nbody() -> TableType:
"""Get Palomar 5 at pericenter Nbody Data.
TODO move to ZENODO and download to cache instead.
Returns
-------
data : `~astropy.table.QTable`
File in "data/00590_peri.dat"
"""
fname: str = get_pkg_data_filename(
os.path.join("data", "00590_peri.dat"),
package="trackstream",
)
data: TableType = QTable.read(fname, format="ascii.ecsv")
return data
def test_table_write(self, serialize_method, tmpdir):
name = str(tmpdir.join("test.ecsv"))
self.t.write(name, serialize_method=serialize_method)
with open(name) as fh:
lines = fh.readlines()
t2 = QTable.read(name)
assert isinstance(t2['ma'], self.ma.__class__)
if serialize_method == 'data_mask':
# Will data_mask, we have data and mask columns and should
# exactly round-trip.
assert len(lines[-1].split()) == 2
assert_masked_equal(t2['ma'], self.ma)
else:
# With null_value we have just a data column with null values
# marked, so we lost information on the data below the mask.
assert len(lines[-1].split()) == 1
assert np.all(t2['ma'] == self.ma)
assert np.all(t2['ma'].mask == self.mask_a)
def get_mcmc_samples(filename):
smp = Table.read(filename,
format='ascii',
names=[
'd1', 'd2', 'lb_blue', 'c0_blue', 'sc_blue', 'lb_red',
'c0_red', 'sc_red', 'kappa_blue', 'kappa_red',
'lb_PN', 'kappa_PN', 'M/L', 'logL'
])
smp['rho_s'] = 10.**smp['d2'] * u.Msun / u.pc**3
smp['r_s'] = 10.**((smp['d1'] - 2. * smp['d2']) / 3.) * u.pc
smp['M/L'] *= u.Msun / u.Lsun
for col in ['red', 'blue']:
smp['c0_{0}'.format(col)] *= u.mag
smp['sc_{0}'.format(col)] *= u.mag
for col in ['red', 'blue', 'PN']:
smp['beta_z_{0}'.format(col)] = 1. - np.exp(-smp['lb_{0}'.format(col)])
smp = QTable(smp) # use Qtables instead of table
return smp
