def load_tyc_hd() -> Table:
"""Load the Tycho-HD cross index."""
print('Loading TYC-HD cross index')
with tarfile.open(os.path.join('vizier', 'tyc2hd.tar.gz'), 'r:gz') as tf:
with tf.extractfile('./ReadMe') as readme:
col_names = ['TYC1', 'TYC2', 'TYC3', 'HD']
reader = io_ascii.get_reader(io_ascii.Cds,
readme=readme,
include_names=col_names)
reader.data.table_name = 'tyc2_hd.dat'
with tf.extractfile('./tyc2_hd.dat.gz') as gzf, gzip.open(gzf, 'rb') as f:
data = reader.read(f)
parse_tyc_cols(data)
err_del = np.array(TYC_HD_ERRATA['delete'] + [a[1] for a in TYC_HD_ERRATA['add']])
data = data[np.logical_not(np.isin(data['HD'], err_del))]
err_add = Table(np.array(TYC_HD_ERRATA['add']),
names=['TYC', 'HD'],
dtype=[np.int64, np.int64])
data = vstack([data, err_add], join_type='exact')
data = unique(data.group_by('HD'), keys='TYC')
data = unique(data.group_by('TYC'), keys='HD')
return data
def test_col_dtype_in_custom_class():
"""Test code in BaseOutputter._convert_vals to handle Column.dtype
attribute. See discussion in #11895."""
dtypes = [np.float32, np.int8, np.int16]
class TestDtypeHeader(ascii.BasicHeader):
def get_cols(self, lines):
super().get_cols(lines)
for col, dtype in zip(self.cols, dtypes):
col.dtype = dtype
class TestDtype(ascii.Basic):
"""
Basic table Data Reader with data type alternating float32, int8
"""
header_class = TestDtypeHeader
txt = """
a b c
1 2 3
"""
reader = ascii.get_reader(TestDtype)
t = reader.read(txt)
for col, dtype in zip(t.itercols(), dtypes):
assert col.dtype.type is dtype
def parse_ssois_return(ssois_return,
camera_filter='r.MP9601',
telescope_instrument='CFHT/MegaCam'):
assert camera_filter in ['r.MP9601', 'u.MP9301']
ret_table = []
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = _skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(ssois_return)
for row in table:
# check if a dbimages object exists
ccd = int(row['Ext']) - 1
expnum = row['Image'].rstrip('p')
X = row['X']
Y = row['Y']
mjd = row['MJD']
# Excludes the OSSOS wallpaper.
# note: 'Telescope_Insturment' is a typo in SSOIS's return format
if (row['Telescope_Insturment'] == telescope_instrument) and (row['Filter'] == camera_filter) \
and not row['Image_target'].startswith('WP'):
ret_table.append(row)
return ret_table
def extract(self, ra, dec, width, height, keep=0):
if not self.valid:
return
if keep == 0:
self.data = Table()
polygon = SkyCoord( [ra-width/2., ra+width/2., ra+width/2., ra-width/2.],\
[dec-height/2., dec-height/2., dec+height/2., dec+height/2.],\
unit = 'deg' ).cartesian.get_xyz().T
pix = hp.query_polygon(self.NSIDE, polygon, inclusive=True, nest=True)
rangelist = self._get_tgasptyc_zone_file(pix)
f = open(self.datafile, "r")
lines = []
for r in rangelist:
f.seek(r[0] * self.linelength)
lines.append(f.read((r[1] - r[0]) * self.linelength))
f.close()
content = ''.join(lines)
reader = ascii.get_reader(Reader=ascii.Cds,
fill_values=[('', 0)],
readme=self.readmefile)
reader.data.table_name = "tgasptyc.dat"
catalog = reader.read(content)
p = catalog[ np.where( ( catalog['RAdeg'] > ra - width/2. )\
& ( catalog['RAdeg'] < ra + width/2. )\
& ( catalog['DEdeg'] > dec - height/2. )\
& ( catalog['DEdeg'] < dec + height/2. ) ) ]
self.data = astropy.table.vstack([self.data, p])
return (len(self.data))
def parse_ssois_return(ssois_return, object_name, imagetype, camera_filter='r.MP9601',
telescope_instrument='CFHT/MegaCam'):
"""
Parse through objects in ssois query and filter out images of desired filter, type, exposure time, and instrument
"""
assert camera_filter in ['r.MP9601', 'u.MP9301']
ret_table = []
good_table = 0
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = _skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(ssois_return)
for row in table:
# Excludes the OSSOS wallpaper.
# note: 'Telescope_Insturment' is a typo in SSOIS's return format
if not 'MegaCam' in row['Telescope_Insturment']:
continue
# Check if image of object exists in OSSOS observations
if not storage.exists(storage.get_uri(row['Image'][:-1])):
continue
if not str(row['Image_target']).startswith('WP'):
good_table += 1
ret_table.append(row)
if good_table > 0:
print((" %d images found" % good_table))
return ret_table
def test_write_table(fast_writer):
table = ascii.get_reader(Reader=ascii.Daophot)
data = table.read('t/daophot.dat')
for test_def in test_defs:
check_write_table(test_def, data, fast_writer)
check_write_table_via_table(test_def, data, fast_writer)
def test_write_table(fast_writer):
table = ascii.get_reader(Reader=ascii.Daophot)
data = table.read('data/daophot.dat')
for test_def in test_defs:
check_write_table(test_def, data, fast_writer)
check_write_table_via_table(test_def, data, fast_writer)
def parse_ssois_return(ssois_return, object_name, imagetype, camera_filter='r.MP9601',
telescope_instrument='CFHT/MegaCam'):
"""
Parse through objects in ssois query and filter out images of desired filter, type, exposure time, and instrument
"""
assert camera_filter in ['r.MP9601', 'u.MP9301']
ret_table = []
good_table = 0
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = _skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(ssois_return)
for row in table:
# Excludes the OSSOS wallpaper.
# note: 'Telescope_Insturment' is a typo in SSOIS's return format
if not 'MegaCam' in row['Telescope_Insturment']:
continue
if not storage.exists(storage.get_uri(row['Image'][:-1])): #Check if image of object exists in OSSOS observations
continue
if not str(row['Image_target']).startswith('WP'):
good_table += 1
ret_table.append(row)
if good_table > 0:
print " %d images found" % good_table
return ret_table
def test_write_valid_meta_ipac():
"""Write an IPAC table that contains no data and has *correctly* specified
metadata. No warnings should be issued"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('data/no_data_ipac.dat')
data.meta['keywords']['blah'] = {'value': 'invalid'}
out = StringIO()
data.write(out, format='ascii.ipac')
def _create_reader(cls, readme: IO, table: str, names: List[str],
**kwargs) -> io_ascii.Cds:
reader = io_ascii.get_reader(io_ascii.Cds,
readme=readme,
include_names=names,
**kwargs)
reader.data.table_name = table
return reader
def test_write_no_data_ipac(fast_writer):
"""Write an IPAC table that contains no data."""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('t/no_data_ipac.dat')
for test_def in test_defs_no_data:
check_write_table(test_def, data, fast_writer)
check_write_table_via_table(test_def, data, fast_writer)
def test_cds_units():
from astropy import units
data_and_readme = 'data/cds.dat'
reader = ascii.get_reader(ascii.Cds)
table = reader.read(data_and_readme)
# column unit is GMsun (giga solar masses)
# make sure this is parsed correctly, not as a "string" unit
assert table['Fit'].to(units.solMass).unit == units.solMass
def test_cds_units():
from astropy import units
data_and_readme = 'data/cds.dat'
reader = ascii.get_reader(ascii.Cds)
table = reader.read(data_and_readme)
# column unit is GMsun (giga solar masses)
# make sure this is parsed correctly, not as a "string" unit
assert table['Fit'].to(units.solMass).unit == units.solMass
def test_write_no_data_ipac(fast_writer):
"""Write an IPAC table that contains no data."""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('data/no_data_ipac.dat')
for test_def in test_defs_no_data:
check_write_table(test_def, data, fast_writer)
check_write_table_via_table(test_def, data, fast_writer)
def test_cds_function_units(reader_cls):
data_and_readme = 'data/cdsFunctional.dat'
reader = ascii.get_reader(reader_cls)
table = reader.read(data_and_readme)
assert table['logg'].unit == u.dex(u.cm / u.s**2)
assert table['logTe'].unit == u.dex(u.K)
assert table['Mass'].unit == u.Msun
assert table['e_Mass'].unit == u.Msun
assert table['Age'].unit == u.Myr
assert table['e_Age'].unit == u.Myr
def test_cds_function_units():
from astropy.units import dex
data_and_readme = 'data/cdsFunctional.dat'
reader = ascii.get_reader(ascii.Cds)
table = reader.read(data_and_readme)
assert table['logg'].unit == u.dex(u.cm / u.s**2)
assert table['logTe'].unit == u.dex(u.K)
assert table['Mass'].unit == u.Msun
assert table['e_Mass'].unit == u.Msun
assert table['Age'].unit == u.Myr
assert table['e_Age'].unit == u.Myr
def test_write_valid_meta_ipac():
"""Write an IPAC table that contains no data and has *correctly* specified
metadata. No warnings should be issued"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('t/no_data_ipac.dat')
data.meta['keywords']['blah'] = {'value': 'invalid'}
with catch_warnings(AstropyWarning) as ASwarn:
out = StringIO()
data.write(out, format='ascii.ipac')
assert len(ASwarn) == 0
def convert_to_fits(msss_cat):
#if .txt file do this, but need to remove comments at start of file, not sure why...
rdr = ascii.get_reader(Reader=ascii.Basic)
rdr.header.splitter.delimiter = ' '
rdr.data.splitter.delimiter = ' '
rdr.header.start_line = 0
rdr.data.start_line = 1
rdr.data.end_line = None
rdr.header.comment = r'\s*#'
rdr.data.comment = r'\s*#'
data = rdr.read(msss_cat + '.txt')
data.write(msss_cat + '.fits', format='fits')
def test_write_invalid_toplevel_meta_ipac():
"""Write an IPAC table that contains no data but has invalid (incorrectly
specified) metadata stored in the top-level metadata and therefore should
raise a warning, and check that the warning has been raised"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('data/no_data_ipac.dat')
data.meta['blah'] = 'extra'
out = StringIO()
with pytest.warns(AstropyWarning, match=r'.*were not written.*') as warn:
data.write(out, format='ascii.ipac')
assert len(warn) == 1
def parse(self, ssos_result_filename_or_lines):
"""
given the result table create 'source' objects.
:param ssos_result_filename_or_lines:
:rtype Table
"""
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = self._skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
return table_reader.read(ssos_result_filename_or_lines)
def test_cds_function_units2(reader_cls):
# This one includes some dimensionless dex.
data_and_readme = 'data/cdsFunctional2.dat'
reader = ascii.get_reader(reader_cls)
table = reader.read(data_and_readme)
assert table['Teff'].unit == u.K
assert table['logg'].unit == u.dex(u.cm / u.s**2)
assert table['vturb'].unit == u.km / u.s
assert table['[Fe/H]'].unit == u.dex(u.one)
assert table['e_[Fe/H]'].unit == u.dex(u.one)
assert_almost_equal(table['[Fe/H]'].to(u.one),
10.**(np.array([-2.07, -1.50, -2.11, -1.64])))
def test_read_normal_names():
"""Nice, typical fixed format table with col names provided"""
table = """
# comment (with blank line above)
| Col1 | Col2 |
| 1.2 | "hello" |
| 2.4 |'s worlds|
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth,
names=('name1', 'name2'))
dat = reader.read(table)
assert_equal(dat.colnames, ['name1', 'name2'])
assert_almost_equal(dat[1][0], 2.4)
def test_read_normal_names():
"""Nice, typical fixed format table with col names provided"""
table = """
# comment (with blank line above)
| Col1 | Col2 |
| 1.2 | "hello" |
| 2.4 |'s worlds|
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth,
names=('name1', 'name2'))
dat = reader.read(table)
assert_equal(dat.colnames, ['name1', 'name2'])
assert_almost_equal(dat[1][0], 2.4)
def test_read_weird():
"""Weird input table with data values chopped by col extent """
table = """
Col1 | Col2 |
1.2 "hello"
2.4 sdf's worlds
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth)
dat = reader.read(table)
assert_equal(dat.colnames, ['Col1', 'Col2'])
assert_almost_equal(dat[1][0], 2.4)
assert_equal(dat[0][1], '"hel')
assert_equal(dat[1][1], "df's wo")
def test_read_normal_exclude():
"""Nice, typical fixed format table with col name excluded"""
table = """
# comment (with blank line above)
| Col1 | Col2 |
| 1.2 | "hello" |
| 2.4 |'s worlds|
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth,
exclude_names=('Col1', ))
dat = reader.read(table)
assert_equal(dat.colnames, ['Col2'])
assert_equal(dat[1][0], "'s worlds")
def test_write_invalid_toplevel_meta_ipac():
"""Write an IPAC table that contains no data but has invalid (incorrectly
specified) metadata stored in the top-level metadata and therefore should
raise a warning, and check that the warning has been raised"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('t/no_data_ipac.dat')
data.meta['blah'] = 'extra'
with catch_warnings(AstropyWarning) as ASwarn:
out = StringIO()
data.write(out, format='ascii.ipac')
assert len(ASwarn) == 1
assert "were not written" in str(ASwarn[0].message)
def test_read_normal_exclude():
"""Nice, typical fixed format table with col name excluded"""
table = """
# comment (with blank line above)
| Col1 | Col2 |
| 1.2 | "hello" |
| 2.4 |'s worlds|
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth,
exclude_names=('Col1',))
dat = reader.read(table)
assert_equal(dat.colnames, ['Col2'])
assert_equal(dat[1][0], "'s worlds")
def test_read_weird():
"""Weird input table with data values chopped by col extent """
table = """
Col1 | Col2 |
1.2 "hello"
2.4 sdf's worlds
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth)
dat = reader.read(table)
assert_equal(dat.colnames, ['Col1', 'Col2'])
assert_almost_equal(dat[1][0], 2.4)
assert_equal(dat[0][1], '"hel')
assert_equal(dat[1][1], "df's wo")
def parse(self, ssos_result_filename_or_lines):
"""
given the result table create 'source' objects.
:param ssos_result_filename_or_lines:
:rtype Table
"""
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = self._skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
return table_reader.read(ssos_result_filename_or_lines)
def test_write_invalid_toplevel_meta_ipac():
"""Write an IPAC table that contains no data but has invalid (incorrectly
specified) metadata stored in the top-level metadata and therefore should
raise a warning, and check that the warning has been raised"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('t/no_data_ipac.dat')
data.meta['blah'] = 'extra'
with catch_warnings(AstropyWarning) as ASwarn:
out = StringIO()
data.write(out, format='ascii.ipac')
assert len(ASwarn) == 1
assert "were not written" in str(ASwarn[0].message)
def test_write_invalid_keyword_meta_ipac():
"""Write an IPAC table that contains no data but has invalid (incorrectly
specified) metadata stored appropriately in the ``keywords`` section
of the metadata but with invalid format and therefore should raise a
warning, and check that the warning has been raised"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('data/no_data_ipac.dat')
data.meta['keywords']['blah'] = 'invalid'
out = StringIO()
with pytest.warns(AstropyWarning, match=r'.*has been skipped.*') as warn:
data.write(out, format='ascii.ipac')
assert len(warn) == 1
def test_read_unbounded_right_column_header():
"""The right hand column should be allowed to overflow"""
table = """
# comment (with blank line above)
===== ===== ====
Col1 Col2 Col3Long
===== ===== ====
1.2 2 Hello
2.4 4 Worlds
===== ===== ====
"""
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat.colnames[-1], "Col3Long")
def cone_search(ra,
dec,
dra=0.01,
ddec=0.01,
mjdate=None,
calibration_level=2):
"""Do a QUERY on the TAP service for all observations that are part of OSSOS (*P05/*P016)
where taken after mjd and have calibration 'observable'.
:param ra: float degrees
:param dec: float degrees
:param dra: float degrees
:param ddec: float degrees
"""
data = dict(QUERY=(
" SELECT Observation.observationID as collectionID, "
" Plane.time_bounds_cval1 AS mjdate "
" FROM caom2.Observation AS Observation "
" JOIN caom2.Plane AS Plane "
" ON Observation.obsID = Plane.obsID "
" WHERE ( Observation.collection = 'CFHT' ) "
" AND Plane.calibrationLevel={} "
" AND ( Observation.proposal_id LIKE '%P05' or Observation.proposal_id LIKE '%P06' )"
),
REQUEST="doQuery",
LANG="ADQL",
FORMAT="tsv")
data["QUERY"] = data["QUERY"].format(calibration_level)
data["QUERY"] += (" AND "
" INTERSECTS( BOX('ICRS', {}, {}, {}, {}), "
" Plane.position_bounds ) = 1 ").format(
ra, dec, dra, ddec)
if mjdate is not None:
data[
"QUERY"] += " AND Plane.time_bounds_cval1 < {} AND Plane.time_bounds_cval2 > {} ".format(
mjdate + 1.0 / 24.0, mjdate - 1 / 24.0)
result = requests.get(TAP_WEB_SERVICE, params=data, verify=False)
assert isinstance(result, requests.Response)
logger.debug("Doing TAP Query using url: %s" % (str(result.url)))
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(result.text)
logger.debug(str(table))
return table
def test_read_unbounded_right_column_header():
"""The right hand column should be allowed to overflow"""
table = """
# comment (with blank line above)
===== ===== ====
Col1 Col2 Col3Long
===== ===== ====
1.2 2 Hello
2.4 4 Worlds
===== ===== ====
"""
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat.colnames[-1], "Col3Long")
def test_read_normal():
"""Nice, typical fixed format table"""
table = """
# comment (with blank line above)
| Col1 | Col2 |
| 1.2 | "hello" |
| 2.4 |'s worlds|
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth)
dat = reader.read(table)
assert_equal(dat.colnames, ['Col1', 'Col2'])
assert_almost_equal(dat[1][0], 2.4)
assert_equal(dat[0][1], '"hello"')
assert_equal(dat[1][1], "'s worlds")
def test_read_normal():
"""Nice, typical fixed format table"""
table = """
# comment (with blank line above)
| Col1 | Col2 |
| 1.2 | "hello" |
| 2.4 |'s worlds|
"""
reader = ascii.get_reader(Reader=ascii.FixedWidth)
dat = reader.read(table)
assert_equal(dat.colnames, ['Col1', 'Col2'])
assert_almost_equal(dat[1][0], 2.4)
assert_equal(dat[0][1], '"hello"')
assert_equal(dat[1][1], "'s worlds")
def test_read_normal_exclude():
"""Nice, typical SimpleRST table with col name excluded"""
table = """
======= ==========
Col1 Col2
======= ==========
1.2 "hello"
2.4 's worlds
======= ==========
"""
reader = ascii.get_reader(Reader=ascii.RST, exclude_names=('Col1', ))
dat = reader.read(table)
assert_equal(dat.colnames, ['Col2'])
assert_equal(dat[1][0], "'s worlds")
def test_write_invalid_keyword_meta_ipac():
"""Write an IPAC table that contains no data but has invalid (incorrectly
specified) metadata stored appropriately in the ``keywords`` section
of the metadata but with invalid format and therefore should raise a
warning, and check that the warning has been raised"""
table = ascii.get_reader(Reader=ascii.Ipac)
data = table.read('t/no_data_ipac.dat')
data.meta['keywords']['blah'] = 'invalid'
with catch_warnings(AstropyWarning) as ASwarn:
out = StringIO()
data.write(out, format='ascii.ipac')
assert len(ASwarn) == 1
assert "has been skipped" in str(ASwarn[0].message)
def cone_search(ra, dec, dra=0.01, ddec=0.01, runids=('13AP05','13AP06','13BP05', '14AP05')):
"""Do a QUERY on the TAP service for all observations that are part of runid,
where taken after mjd and have calibration 'observable'.
:param runids:
:param ra:
:param dec:
:param dra: degrees
:param ddec: degrees
mjd : float
observable: str ( CAL or RAW)
runid: tuple eg. ('13AP05', '13AP06')
ra: float right ascension
dec: float declination
"""
data= {
"QUERY": ( " SELECT Observation.collectionID as dataset_name "
" FROM caom.Observation AS Observation "
" JOIN caom.Plane AS Plane "
" ON Observation.obsID = Plane.obsID "
" WHERE ( Observation.collection = 'CFHT' ) "
" AND Plane.observable_ctype='CAL' "
" AND Observation.proposal_id IN %s " ) % ( str(runids)),
"REQUEST": "doQuery",
"LANG": "ADQL",
"FORMAT": "tsv" }
data["QUERY"] += ( " AND "
" CONTAINS( BOX('ICRS', {}, {}, {}, {}), "
" Plane.position_bounds ) = 1 " ).format(ra,dec, dra, ddec)
result = requests.get(TAP_WEB_SERVICE, params=data)
assert isinstance(result,requests.Response)
logger.debug("Doing TAP Query using url: %s" % ( str(result.url)))
#data = StringIO(result.text)
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(result.text)
#vot = votable.parse_single_table(data)
#vot.array.sort(order='dataset_name')
#t = vot.array
logger.debug(type(table))
logger.debug(str(table))
return table
def test_read_normal_names():
"""Normal SimpleRST Table with provided column names"""
table = """
# comment (with blank line above)
======= =========
Col1 Col2
======= =========
1.2 "hello"
2.4 's worlds
======= =========
"""
reader = ascii.get_reader(Reader=ascii.RST, names=('name1', 'name2'))
dat = reader.read(table)
assert_equal(dat.colnames, ['name1', 'name2'])
assert_almost_equal(dat[1][0], 2.4)
def test_read_normal_exclude():
"""Nice, typical SimpleRST table with col name excluded"""
table = """
======= ==========
Col1 Col2
======= ==========
1.2 "hello"
2.4 's worlds
======= ==========
"""
reader = ascii.get_reader(Reader=ascii.RST,
exclude_names=('Col1',))
dat = reader.read(table)
assert_equal(dat.colnames, ['Col2'])
assert_equal(dat[1][0], "'s worlds")
def test_read_unbounded_right_column():
"""The right hand column should be allowed to overflow"""
table = """
# comment (with blank line above)
===== ===== ====
Col1 Col2 Col3
===== ===== ====
1.2 2 Hello
2.4 4 Worlds
===== ===== ====
"""
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat[0][2], "Hello")
assert_equal(dat[1][2], "Worlds")
def test_read_unbounded_right_column():
"""The right hand column should be allowed to overflow"""
table = """
# comment (with blank line above)
===== ===== ====
Col1 Col2 Col3
===== ===== ====
1.2 2 Hello
2.4 4 Worlds
===== ===== ====
"""
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat[0][2], "Hello")
assert_equal(dat[1][2], "Worlds")
def load_tyc2specnew() -> Table:
"""Load revised spectral types."""
print("Loading revised TYC2 spectral types")
with tarfile.open(os.path.join('vizier', 'tyc2specnew.tar.gz')) as tf:
with tf.extractfile('./ReadMe') as readme:
reader = io_ascii.get_reader(io_ascii.Cds,
readme=readme,
include_names=['HIP', 'SpType1'])
reader.data.table_name = 'table2.dat'
with tf.extractfile('./table2.dat') as f:
# Suppress a warning because reader does not handle logarithmic units
with warnings.catch_warnings():
warnings.simplefilter("ignore", UnitsWarning)
data = reader.read(f)
return data[data['SpType1'] != '']
def load_ubvri() -> Table:
"""Load UBVRI Teff calibration from VizieR archive."""
print('Loading UBVRI calibration')
with tarfile.open(os.path.join('vizier', 'ubvriteff.tar.gz'), 'r:gz') as tf:
with tf.extractfile('./ReadMe') as readme:
col_names = ['V-K', 'B-V', 'V-I', 'J-K', 'H-K', 'Teff']
reader = io_ascii.get_reader(io_ascii.Cds,
readme=readme,
include_names=col_names)
reader.data.table_name = 'table3.dat'
with tf.extractfile('./table3.dat.gz') as gzf, gzip.open(gzf, 'rb') as f:
# Suppress a warning generated because the reader does not handle logarithmic units
with warnings.catch_warnings():
warnings.simplefilter('ignore', UnitsWarning)
return reader.read(f)
def test_read_right_indented_table():
"""We should be able to read right indented tables correctly"""
table = """
# comment (with blank line above)
==== ==== ====
Col1 Col2 Col3
==== ==== ====
3 3.4 foo
1 4.5 bar
==== ==== ====
"""
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat.colnames, ["Col1", "Col2", "Col3"])
assert_equal(dat[0][2], "foo")
assert_equal(dat[1][0], 1)
def test_read_normal_names():
"""Normal SimpleRST Table with provided column names"""
table = """
# comment (with blank line above)
======= =========
Col1 Col2
======= =========
1.2 "hello"
2.4 's worlds
======= =========
"""
reader = ascii.get_reader(Reader=ascii.RST,
names=('name1', 'name2'))
dat = reader.read(table)
assert_equal(dat.colnames, ['name1', 'name2'])
assert_almost_equal(dat[1][0], 2.4)
def test_ipac_read_types():
table = r"""\
| ra | dec | sai |-----v2---| sptype |
| real | float | l | real | char |
| unit | unit | unit | unit | ergs |
| null | null | null | null | -999 |
2.09708 2956 73765 2.06000 B8IVpMnHg
"""
reader = ascii.get_reader(Reader=ascii.Ipac)
dat = reader.read(table)
types = [
ascii.FloatType, ascii.FloatType, ascii.IntType, ascii.FloatType,
ascii.StrType
]
for (col, expected_type) in zip(reader.cols, types):
assert_equal(col.type, expected_type)
def test_ipac_read_types():
table = r"""\
| ra | dec | sai |-----v2---| sptype |
| real | float | l | real | char |
| unit | unit | unit | unit | ergs |
| null | null | null | null | -999 |
2.09708 2956 73765 2.06000 B8IVpMnHg
"""
reader = ascii.get_reader(Reader=ascii.Ipac)
dat = reader.read(table)
types = [ascii.FloatType,
ascii.FloatType,
ascii.IntType,
ascii.FloatType,
ascii.StrType]
for (col, expected_type) in zip(reader.cols, types):
assert_equal(col.type, expected_type)
def test_read_normal():
"""Normal SimpleRST Table"""
table = """
# comment (with blank line above)
======= =========
Col1 Col2
======= =========
1.2 "hello"
2.4 's worlds
======= =========
"""
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat.colnames, ['Col1', 'Col2'])
assert_almost_equal(dat[1][0], 2.4)
assert_equal(dat[0][1], '"hello"')
assert_equal(dat[1][1], "'s worlds")
def csv_to_table(handle,
delimiter='|',
comments=r'\s*(#|//|--)',
header_search=r'(?P<keyword>\w+)\s*=\s*(?P<value>\w+.*?)(/(?P<comment>.*))?$'):
'''Produce an astropy table, and related keyword/value pairs from a CSV file.
Parameters
----------
handle: File handle
The file object being read from.
delimiter: str
The single character delimiter that distinguish columns.
comments: string
A regular expression for determining whether a line
is a comment or not.
header_search: string
A regular expression the finds and parses
keyword/value pairs from comment lines.
The regex must contain two named groups:
'keyword' for the keyword match and 'value'
for the value. An optional 'comment'
group may also be present to put a comment with
the keyword/value pair, as in standard FITS fashion.
Returns
-------
astropy.Table:
An astropy Table is returned.
Of note is one extra parameter on the table, 'meta',
which is the dict of header keywords found.
'''
# Setup the astropy reader.
reader = ascii.get_reader(Reader=CSVKeywords)
reader.header.start_line = 0
reader.header.splitter.delimiter = delimiter
reader.data.splitter.delimiter = reader.header.splitter.delimiter
reader.header.comment = comments
reader.data.comment = reader.header.comment
reader.header.keywords = header_search
# All setup, return the table
return reader.read(handle)
def test_trailing_spaces_in_row_definition():
""" Trailing spaces in the row definition column shouldn't matter"""
table = (
"\n"
"# comment (with blank line above)\n"
" ==== ==== ==== \n"
" Col1 Col2 Col3\n"
" ==== ==== ==== \n"
" 3 3.4 foo\n"
" 1 4.5 bar\n"
" ==== ==== ==== \n"
)
# make sure no one accidentally deletes the trailing whitespaces in the
# table.
assert len(table) == 151
reader = ascii.get_reader(Reader=ascii.RST)
dat = reader.read(table)
assert_equal(dat.colnames, ["Col1", "Col2", "Col3"])
assert_equal(dat[0][2], "foo")
assert_equal(dat[1][0], 1)
def parse(self, ssos_result_filename_or_lines, mpc_observations=None):
"""
given the result table create 'source' objects.
:param ssos_result_filename_or_lines:
:param mpc_observations: a list of mpc.Observation objects used to retrieve the SSOS observations
"""
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = self._skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
ssos_table = table_reader.read(ssos_result_filename_or_lines)
dbimage_list = storage.list_dbimages(dbimages=storage.DBIMAGES)
logger.debug("Comparing to {} observations in dbimages: {}".format(len(dbimage_list), storage.DBIMAGES))
sources = []
observations = []
source_readings = []
if mpc_observations is not None and isinstance(mpc_observations[0], mpc.Observation):
orbit = Orbfit(mpc_observations)
else:
from mp_ephem import horizons
start_time = Time(min(ssos_table['MJD']), format='mjd')
stop_time = Time(max(ssos_table['MJD']), format='mjd')
step_size = 5.0 * units.hour
orbit = horizons.Body(self.provisional_name, start_time, stop_time, step_size)
warnings.filterwarnings('ignore')
logger.info("Loading {} observations\n".format(len(ssos_table)))
expnums_examined = []
for row in ssos_table:
# Trim down to OSSOS-specific images
logger.debug("Checking row: {}".format(row))
if (row['Filter'] not in parameters.OSSOS_FILTERS) or row['Image_target'].startswith('WP'):
logger.debug("Failed filter / target name check")
continue
# check if a dbimages object exists
# For CFHT/MegaCam strip off the trailing character to get the exposure number.
ftype = row['Image'][-1]
expnum = row['Image'][:-1]
if str(expnum) not in dbimage_list:
logger.debug("Expnum: {} Failed dbimage list check".format(expnum))
continue
logger.debug("Expnum: {} Passed dbimage list check".format(expnum))
# The file extension is the ccd number + 1 , or the first extension.
ccd = int(row['Ext'])-1
if 39 < ccd < 0 or ccd < 0:
ccd = None
x = row['X'] * units.pix
y = row['Y'] * units.pix
ra = row['Object_RA'] * units.degree
dec = row['Object_Dec'] * units.degree
ssois_coordinate = SkyCoord(ra, dec)
mjd = row['MJD'] * units.day
# if not 0 < x.value < 2060 or not 0 < y.value < 4700:
# continue
obs_date = Time(mjd, format='mjd', scale='utc')
logger.info("Calling predict")
orbit.predict(obs_date)
logger.info("Done calling predict")
if orbit.dra > 4 * units.arcminute or orbit.ddec > 4.0 * units.arcminute:
print "Skipping entry as orbit uncertainty at date {} is large.".format(obs_date)
continue
if expnum in expnums_examined:
logger.debug("Already checked this exposure.")
continue
expnums_examined.append(expnum)
logger.debug(("SSOIS Prediction: exposure:{} ext:{} "
"ra:{} dec:{} x:{} y:{}").format(expnum, ccd, ra, dec, x, y))
logger.debug(("Orbfit Prediction: "
"ra:{} dec:{} ").format(orbit.coordinate.ra.to(units.degree),
orbit.coordinate.dec.to(units.degree)))
logger.info("Building Observation")
observation = SSOSParser.build_source_reading(expnum, ccd, ftype=ftype)
observation.mjd = mjd
from_input_file = observation.rawname in self.input_rawnames
# compare to input observation list.
previous = False
mpc_observation = None
if from_input_file:
for mpc_observation in mpc_observations:
try:
if mpc_observation.comment.frame.strip() == observation.rawname:
# only skip previous obseravtions if not discovery.
previous = not mpc_observation.discovery
break
except Exception as e:
logger.debug(str(e))
pass
mpc_observation = None
# skip previously measured observations if requested.
if self.skip_previous and ( previous or observation.rawname in self.null_observations):
continue
logger.info('built observation {}'.format(observation))
observations.append(observation)
null_observation = observation.rawname in self.null_observations
ddec = orbit.ddec + abs(orbit.coordinate.dec - ssois_coordinate.dec)
dra = orbit.dra + abs(orbit.coordinate.ra - ssois_coordinate.ra)
logger.info(" Building SourceReading .... \n")
source_reading = astrom.SourceReading(x=x, y=y, x0=x, y0=y,
ra=orbit.coordinate.ra.to(units.degree).value,
dec=orbit.coordinate.dec.to(units.degree).value,
xref=x, yref=y, obs=observation,
ssos=True, from_input_file=from_input_file,
dx=dra, dy=ddec, pa=orbit.pa,
null_observation=null_observation)
source_reading.mpc_observation = mpc_observation
source_readings.append(source_reading)
logger.info("Source Reading Built")
# build our array of SourceReading objects
sources.append(source_readings)
warnings.filterwarnings('once')
return SSOSData(observations, sources, self.provisional_name)
def compare_heiles_2003(magmo_gas):
print("## Comparing with Heiles & Troland 2003 ##")
# Read in ht03 data
rdr = ascii.get_reader(Reader=ascii.Csv)
ht03_table = rdr.read('../Millennium_data.csv')
# filter for just the CNM data |b| < 10
cnm = np.array(ht03_table['CNM'])
sample = ht03_table[cnm >= '0']
abs_lat = np.absolute(np.array(sample['GLAT']))
ht03_low_cnm = sample[abs_lat <= 10]
spin_temp = np.array(ht03_low_cnm['Ts'])
print("Sample had {} values, mean {:0.3f}, median {:0.3f}, sd {:0.3f}".format(len(spin_temp),
np.mean(spin_temp),
np.median(spin_temp),
np.std(spin_temp)))
votable = from_table(ht03_low_cnm)
writeto(votable, 'millenium_spin.vot')
# comparative histogram of the two CNM spin temp sets
fig = plt.figure(figsize=(7.5, 3))
gs = matplotlib.gridspec.GridSpec(1, 2)
gas_array = magmo_gas
# Spin Temperature
ax1 = fig.add_subplot(gs[0, 0])
sample = np.ma.array(gas_array['temp_spin']).compressed()
bins = np.linspace(0,450,19)
hist, edges = build_hist_fraction(sample, bins, 450)
ax1.step(edges, hist)
ht03_sample = np.array(ht03_low_cnm['Ts'])
hist, edges = build_hist_fraction(ht03_sample, bins, 450)
ax1.step(edges, hist, color='black', ls='--')
ax1.set_xlabel('Spin Temperature (K)')
ax1.set_ylabel('Fraction of components')
statistic, p_value = stats.ks_2samp(np.ma.filled(sample), np.ma.filled(ht03_sample))
print ('Spin temp population similarity p_value={}'.format(p_value))
# Column Density
ax2 = fig.add_subplot(gs[0, 1])
sample = np.ma.array(gas_array['column_density']).compressed()
sample = np.log10(sample)
bins = np.linspace(19, 24, 21)
hist, edges = build_hist_fraction(sample, bins, 24)
sample = np.array(ht03_low_cnm['NHI']) * 1E20
sample = np.log10(sample[sample > 0])
ht03_hist, edges = build_hist_fraction(sample, bins, 24)
ax2.step(edges, hist) #, width=edges[1]-edges[0])
ax2.step(edges, ht03_hist, color='black', ls=':') # , width=edges[1]-edges[0]
label = 'Column Density $\\log_{10}(N_{H}$) (cm$^{-2}$)'
ax2.set_xlabel(label)
ax2.set_ylabel('Fraction of components')
statistic, p_value = stats.ks_2samp(np.ma.filled(gas_array['column_density']), np.ma.filled(np.array(ht03_low_cnm['NHI']) * 1E20))
print ('Column density population similarity p_value={}'.format(p_value))
gs.update(wspace=0.5, hspace=0.5)
filename = 'magmo-heiles_2003_comp.pdf'
plt.savefig(filename, bbox_inches="tight")
plt.close()
return
def dat2hdf5(table_dir):
"""
Convert the Marshall et al. (2006) map from \*.dat.gz to \*.hdf5.
"""
import astropy.io.ascii as ascii
import gzip
from contextlib import closing
readme_fname = os.path.join(table_dir, 'ReadMe')
table_fname = os.path.join(table_dir, 'table1.dat.gz')
h5_fname = os.path.join(table_dir, 'marshall.h5')
# Extract the gzipped table
with gzip.open(table_fname, 'rb') as f:
# Read in the table using astropy's CDS table reader
r = ascii.get_reader(ascii.Cds, readme=readme_fname)
r.data.table_name = 'table1.dat' # Hack to deal with bug in CDS reader.
table = r.read(f)
print(table)
# Reorder table entries according to Galactic (l, b)
l = coordinates.Longitude(
table['GLON'][:],
wrap_angle=180.*units.deg)
b = table['GLAT'][:]
sort_idx = np.lexsort((b, l))
l = l[sort_idx].astype('f4')
b = b[sort_idx].astype('f4')
l.shape = (801, 81)
b.shape = (801, 81)
# Extract arrays from the table
chi2_all = np.reshape((table['x2all'][sort_idx]).astype('f4'), (801,81))
chi2_giants = np.reshape((table['x2gts'][sort_idx]).astype('f4'), (801,81))
A = np.empty((801*81,33), dtype='f4')
sigma_A = np.empty((801*81,33), dtype='f4')
dist = np.empty((801*81,33), dtype='f4')
sigma_dist = np.empty((801*81,33), dtype='f4')
for k in range(33):
A[:,k] = table['ext{:d}'.format(k+1)][sort_idx]
sigma_A[:,k] = table['e_ext{:d}'.format(k+1)][sort_idx]
dist[:,k] = table['r{:d}'.format(k+1)][sort_idx]
sigma_dist[:,k] = table['e_r{:d}'.format(k+1)][sort_idx]
A.shape = (801,81,33)
sigma_A.shape = (801,81,33)
dist.shape = (801,81,33)
sigma_dist.shape = (801,81,33)
# Construct the HDF5 file
h5_fname = os.path.join(table_dir, 'marshall.h5')
filter_kwargs = dict(
chunks=True,
compression='gzip',
compression_opts=3,
# scaleoffset=4
)
with h5py.File(h5_fname, 'w') as f:
dset = f.create_dataset('A', data=A, **filter_kwargs)
dset.attrs['description'] = 'Extinction of each bin'
dset.attrs['band'] = 'Ks (2MASS)'
dset.attrs['units'] = 'mag'
dset = f.create_dataset('sigma_A', data=sigma_A, **filter_kwargs)
dset.attrs['description'] = 'Extinction uncertainty of each bin'
dset.attrs['band'] = 'Ks (2MASS)'
dset.attrs['units'] = 'mag'
dset = f.create_dataset('dist', data=dist, **filter_kwargs)
dset.attrs['description'] = 'Distance of each bin'
dset.attrs['units'] = 'kpc'
dset = f.create_dataset('sigma_dist', data=sigma_dist, **filter_kwargs)
dset.attrs['description'] = 'Distance uncertainty of each bin'
dset.attrs['units'] = 'kpc'
dset = f.create_dataset('chi2_all', data=chi2_all, **filter_kwargs)
dset.attrs['description'] = 'Chi^2, based on all the stars'
dset.attrs['units'] = 'unitless'
dset = f.create_dataset('chi2_giants', data=chi2_giants, **filter_kwargs)
dset.attrs['description'] = 'Chi^2, based on giants only'
dset.attrs['units'] = 'unitless'
# filter_kwargs.pop('scaleoffset')
dset = f.create_dataset('l', data=l, **filter_kwargs)
dset.attrs['description'] = 'Galactic longitude'
dset.attrs['units'] = 'deg'
dset = f.create_dataset('b', data=b, **filter_kwargs)
dset.attrs['description'] = 'Galactic latitude'
dset.attrs['units'] = 'deg'
def read_table2(readme, data):
reader = ascii.get_reader(Reader=ascii.Cds, readme=readme)
reader.outputter = ascii.TableOutputter()
return reader.read(data)
def parse(self, ssos_result_filename_or_lines):
"""
given the result table create 'source' objects.
:param ssos_result_filename_or_lines:
"""
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = self._skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(ssos_result_filename_or_lines)
sources = []
observations = []
source_readings = []
warnings.filterwarnings('ignore')
ref_x = None
ref_y = None
ref_mjd = None
ref_expnum = None
ref_ccd = None
for row in table:
# check if a dbimages object exists
ccd = int(row['Ext']) - 1
expnum = row['Image'].rstrip('p')
X = row['X']
Y = row['Y']
# ADDING THIS TEMPORARILY TO GET THE NON-OSSOS DATA OUT OF THE WAY WHILE DEBUGGING
if (row['Telescope_Insturment'] != 'CFHT/MegaCam') or (row['Filter'] != 'r.MP9601'):
continue
# Build astrom.SourceReading
observation = self.build_source_reading(expnum, ccd, X, Y)
if observation is None:
continue
observations.append(observation)
from_input_file = observation.rawname in self.input_rawnames
null_observation = observation.rawname in self.null_observations
mjd = Time(observation.header['MJD_OBS_CENTER'],
format='mpc',
scale='utc').jd
if ref_x is None or mjd - ref_mjd > 0.5:
ref_x = X
ref_y = Y
ref_expnum = expnum
ref_ccd = ccd
ref_mjd = mjd
x0 = X
y0 = Y
else:
(x0, y0) = self.get_coord_offset(expnum,
ccd,
X,
Y,
ref_expnum,
ref_ccd)
# Also reset the reference point if the x/y shift is large.
if x0 - X > 250 or y0 - Y > 250 :
ref_x = X
ref_y = Y
ref_expnum = expnum
ref_ccd = ccd
ref_mjd = mjd
x0 = X
y0 = Y
source_reading = astrom.SourceReading(
x=row['X'], y=row['Y'],
xref=ref_x, yref=ref_y,
x0=x0, y0=y0,
ra=row['Object_RA'], dec=row['Object_Dec'],
obs=observation,
ssos=True,
from_input_file=from_input_file,
null_observation=null_observation)
source_readings.append(source_reading)
# build our array of SourceReading objects
sources.append(source_readings)
warnings.filterwarnings('once')
return SSOSData(observations, sources, self.provisional_name)
def parse(self, ssos_result_filename_or_lines):
"""
given the result table create 'source' objects.
:type ssos_result_table: Table
:param ssos_result_table:
"""
table_reader = ascii.get_reader(Reader=ascii.Basic)
table_reader.inconsistent_handler = self._skip_missing_data
table_reader.header.splitter.delimiter = '\t'
table_reader.data.splitter.delimiter = '\t'
table = table_reader.read(ssos_result_filename_or_lines)
sources = []
observations = []
source_readings = []
ref_pvwcs = None
downloader = Downloader()
warnings.filterwarnings('ignore')
for row in table:
# check if a dbimages object exists
ccd = int(row['Ext']) - 1
expnum = row['Image'].rstrip('p')
# ADDING THIS TEMPORARILY TO GET THE NON-OSSOS DATA OUT OF THE WAY WHILE DEBUGGING
if (row['Telescope_Insturment'] != 'CFHT/MegaCam') or (row['Filter'] != 'r.MP9601'):
continue
# it's fine for OSSOS, go get the image
image_uri = storage.dbimages_uri(expnum=expnum,
ccd=None,
version='p',
ext='.fits',
subdir=None)
logger.info('Trying to access %s\n%s' % (row.data, image_uri))
if not storage.exists(image_uri, force=False):
logger.warning('Image not in dbimages? Trying subdir.')
image_uri = storage.dbimages_uri(expnum=expnum,
ccd=ccd,
version='p')
if not storage.exists(image_uri, force=False):
logger.warning("Image doesn't exist in ccd subdir. %s" % image_uri)
continue
if row['X'] == -9999 or row['Y'] == -9999 :
logger.warning("Skipping %s as x/y not resolved." % ( row['Image']))
continue
mopheader_uri = storage.dbimages_uri(expnum=expnum,
ccd=ccd,
version='p',
ext='.mopheader')
if not mopheader_uri in mopheaders:
if not storage.exists(mopheader_uri, force=False):
logger.warning('mopheader missing, but images exists')
continue
# raise flag if no MOPHEADER
mopheader_fpt = cStringIO.StringIO(storage.open_vos_or_local(mopheader_uri).read())
mopheader = fits.open(mopheader_fpt)
mopheaders[mopheader_uri] = mopheader
mopheader = mopheaders[mopheader_uri]
# Build astrom.Observation
observation = astrom.Observation(expnum=str(expnum),
ftype='p',
ccdnum=str(ccd),
fk="")
observation.rawname = os.path.splitext(os.path.basename(image_uri))[0]+str(ccd).zfill(2)
observation.header = mopheader[0].header
MJD_OBS_CENTER = mpc.Time(observation.header['MJD-OBSC'],
format='mjd',
scale='utc', precision=5 ).replicate(format='mpc')
observation.header['MJD_OBS_CENTER'] = str(MJD_OBS_CENTER)
observation.header['MAXCOUNT'] = MAXCOUNT
observation.header['SCALE'] = observation.header['PIXSCALE']
#observation.header['CHIP'] = str(observation.header['CHIPNUM']).zfill(2)
observation.header['NAX1'] = observation.header['NAXIS1']
observation.header['NAX2'] = observation.header['NAXIS2']
observation.header['MOPversion'] = observation.header['MOP_VER']
observation.header['FWHM'] = 4
# a download pixel 1,1 of this data to due offsets with.
x_cen = int(min(max(1,row['X']),observation.header['NAX1']))
y_cen = int(min(max(1,row['Y']),observation.header['NAX2']))
if image_uri not in astheaders:
hdulist = downloader.download_hdulist(
uri=image_uri,
view='cutout',
cutout='[{}][{}:{},{}:{}]'.format(ccd+1, x_cen, x_cen, y_cen, y_cen))
astheaders[image_uri] = hdulist
hdulist = astheaders[image_uri]
pvwcs = wcs.WCS(hdulist[0].header)
(ra,dec) = pvwcs.xy2sky(x_cen, y_cen)
if ref_pvwcs is None:
ref_pvwcs = pvwcs
xref = row['X']
yref = row['Y']
(x0, y0) = ref_pvwcs.sky2xy(ra,dec)
x0 += row['X'] - x_cen
y0 += row['Y'] - y_cen
# Build astrom.SourceReading
observations.append(observation)
from_input_file = observation.rawname in self.input_rawnames
null_observation = observation.rawname in self.null_observations
print observation.rawname, observation.header['MJD_OBS_CENTER'], null_observation, from_input_file
source_reading = astrom.SourceReading(x=row['X'], y=row['Y'],
xref=xref, yref=yref,
x0=x0, y0=y0,
ra=row['Object_RA'], dec=row['Object_Dec'],
obs=observation,
ssos=True,
from_input_file=from_input_file,
null_observation=null_observation)
#if observation.rawname in self.input_rawnames:
# source_readings.insert(0, source_reading)
#else:
source_readings.append(source_reading)
# build our array of SourceReading objects
sources.append(source_readings)
warnings.filterwarnings('once')
return SSOSData(observations, sources, self.provisional_name)