def recover(self):
log.debug("OufileETIFile recover()")
ad = AstroData(self.tmp_name, mode="update")
ad.filename = self.ad_name
ad = gemini_tools.obsmode_del(ad)
log.fullinfo(self.tmp_name + " was loaded into memory")
return ad
def test_method_info_4():
old_stdout = sys.stdout
sys.stdout = mystdout = StringIO()
ad = AstroData(TESTFILE)
ad.info(oid=True, table=True)
sys.stdout = old_stdout
assert isinstance(mystdout.getvalue(), str)
def test_method_info_4():
old_stdout = sys.stdout
sys.stdout = mystdout = StringIO()
ad = AstroData(TESTFILE)
ad.info(oid=True, table=True)
sys.stdout = old_stdout
assert isinstance(mystdout.getvalue(), str)
def _init_as_astrodata(self):
"""
Initialize parameters to be used by as_astrodata.
Creates a WCS object (pywcs) from the SCI header and
form the output AD object with the PHU and MDF from
the input AD. We are adding the TRACEFP extension as well
for later use on the spectral reduction process.
Input:
self.ad: AD object.
Output:
adout: Output AD object with AD phu and MDF
"""
ad = self.ad
# Start output AD with the original phu and the MDF extension.
adout = AstroData(phu=ad.phu)
adout.append(ad['MDF'])
adout.append(ad['TRACEFP'])
# Get wcs information. It is in the PHU
try:
self.wcs = pywcs.WCS(ad.phu.header)
if not hasattr(self.wcs.wcs, 'cd'):
self.wcs = None
except: # Something wrong with WCS, set it to None
self.wcs = None
return adout
def example():
"""
This is just an example. Cut and paste that on the python prompt.
It can also be run as specplot.example().
"""
import numpy as np
import matplotlib.pyplot as plt
from astropy import wcs
from astrodata import AstroData
ad = AstroData('JHK.fits')
x_values = np.arange(ad.get_key_value('NAXIS1'))
wcs_ad = wcs.WCS(ad.header.tostring())
wlen = wcs_ad.wcs_pix2world(zip(x_values), 0)
plt.plot(wlen, ad.data)
plt.xlabel('Wavelength [Angstrom]')
plt.ylabel('Counts')
plt.axis('tight')
plt.ylim(-100, 800)
plt.show()
ad.close()
#plt.axis[[-100,1000,ymin,ymax]]
def atd6():
"""
Verify that a MosaicAD method can create a block from a given extension name.
The test creates a mosaic ndarray from the MosaicAD method mosaic_image_data
with the block parameter value (0,0), indicating to output the lower left block.
NOTE: Having one amp per block, the actual extension data is not the same
as the block since it would be trim by the DATASEC image section.
gmos_file='../data/gS20120420S0033.fits'
gsaoi_file='../data/guS20120413S0048.fits'
"""
from astrodata import AstroData
from gempy.adlibrary.mosaicAD import MosaicAD
# This is the default Mosaic function
from gempy.mosaic.gemMosaicFunction import gemini_mosaic_function
print '\n atd6 REQUIREMENT.......'
print ('***** From a given AstroData object, the system shall create a block from '
'a given extension name')
gmos_file='../data/gS20120420S0033.fits'
gsaoi_file='../data/guS20120413S0048.fits'
for file in [gmos_file,gsaoi_file]:
ad = AstroData(file)
print 'Instrument: ',ad.instrument()
mo = MosaicAD(ad, gemini_mosaic_function)
# Now use the mosaic_image_data method to generate
# an output block by using the parameter block and
# value as a tuple (col,row) (0-based) of the block
# you want returned. For GMOS the block values are
# (0,0), (1,0), (2,0).
block=(1,0)
block_data = mo.mosaic_image_data(block=block,tile=True)
# Get the shape: (height, width) in pixels.
print 'block_data.shape:',block_data.shape
extn = block[0] + block[1]*mo.geometry.mosaic_grid[0] + 1
print 'Input shape for 1-amp per detector:',ad['SCI',extn].data.shape
# Check values of the lower 2x2 pixels
print 'Output block [0:2,0:2] pixels:\n',block_data[:2,:2]
if ad.instrument() == 'GSAOI':
# GSAOI FITS extension 1 correspond to block (1,0)
# and extension 2 to block (0,0). DETSEC image section
# indicates this.
extn = [2,1,3,4][extn-1]
# To get the correct segment we need to look at
# DATASEC, in case the data is trimm -as it appears in data_list.
x1,x2,y1,y2 = ad.data_section().as_dict()['SCI',extn]
print 'Input amp DATASEC[x1:x1+2 pixels:\n',\
ad['SCI',extn].data[x1:x1+2,y1:y1+2]
print '\n'
def test_finding_an_easier_center():
ad = AstroData(get_data_file_name("N20060131S0012.fits"))
selection = get_selection_peak(ad.data, (489.07, 478.99), float(ad.pixel_scale()))
predicted_center = selection.get_center()
assert_tolerance(predicted_center,
(489.11025833697016, 478.68088198208636),
tolerance=0.02)
def test_method_insert_7():
ad = AstroData(TESTFILE)
xname = "TEST"
xver = 99
del header1['EXTNAME']
ad.insert(1, header=header1, data=data1, extname=xname,
extver=xver, auto_number=True)
assert ad[1].header.get("EXTNAME") == xname
assert ad[1].header.get("EXTVER") == xver
def recover(self):
log.debug("OutAtList recover()")
adlist = []
for i, tmpname in enumerate(self.diskoutlist):
ad = AstroData(tmpname, mode="update")
ad.filename = self.ad_name[i]
ad = gemini_tools.obsmode_del(ad)
adlist.append(ad)
log.fullinfo(tmpname + " was loaded into memory")
return adlist
def test_out_of_bound_aperture():
ad = AstroData(get_data_file_name("N20060131S0012.fits"))
selection = get_selection_peak(ad.data, (10.0, 10.0), float(ad.pixel_scale()))
predicted_center = selection.get_center()
# should be rather non-sense that is returned
assert_tolerance(predicted_center,
(50.0, 50.0),
tolerance=50.0)
def test_finding_the_center_of_titan():
ad = AstroData(get_data_file_name("N20060131S0011.fits"))
selection = get_selection_peak(ad.data, (391.0, 539.0), float(ad.pixel_scale()))
predicted_center = selection.get_center()
# the object is titan, doesn't have a very clearly defined center
assert_tolerance(predicted_center,
(384.87060478881705, 542.73266988305159),
tolerance=0.07)
def as_astrodata(self):
"""
With each cut object in the cut_list having the SCI,DQ,VAR set,
form an hdu and append it to adout. Update keywords EXTNAME= 'SCI',
EXTVER=<footprint#>, CCDSEC, DISPAXIS, CUTSECT, CUTORDER in the header
and reset WCS information if there was a WCS in the input AD header.
::
Input:
self.cut_list: List of Cut objects.
self.adout: Output AD object with MDF and
TRACEFP extensions.
Output:
adout: contains the appended HDUs.
"""
adout = self._init_as_astrodata()
ad = self.ad
scihdr = ad['SCI',1].header.copy()
if self.has_dq:
dqheader = ad['DQ', 1].header.copy()
if self.has_var:
varheader = ad['VAR',1].header.copy()
# Update NSCIEXT keyword to represent the current number of cuts.
if new_pyfits_version:
adout.phu.header.update = adout.phu.header.set
adout.phu.header.update('NSCIEXT',len(self.cut_list))
# This is a function renaming when using Pyfits 3.1
if new_pyfits_version:
scihdr.update = scihdr.set
extver = 1
# Generate the cuts using the region's sci_cut,var_cut and
# dq_cut
for region,sci_cut,var_cut,dq_cut in self.cut_list:
rx1,rx2,ry1,ry2 = np.asarray(region) + 1 # To 1-based
csec = '[%d:%d,%d:%d]'%(rx1,rx2,ry1,ry2)
scihdr.update('NSCUTSEC',csec,
comment="Region extracted by 'cut_footprints'")
scihdr.update('NSCUTSPC',extver,comment="Spectral order")
form_extn_wcs(scihdr, self.wcs, region)
new_sci_ext = AstroData(data=sci_cut,header=scihdr)
new_sci_ext.rename_ext(name='SCI',ver=extver)
adout.append(new_sci_ext)
if self.has_dq:
new_dq_ext = AstroData(data=dq_cut, header=dqheader)
new_dq_ext.rename_ext(name='DQ',ver=extver)
adout.append(new_dq_ext)
if self.has_var:
new_var_ext = AstroData(data=var_cut, header=varheader)
new_var_ext.rename_ext(name='VAR',ver=extver)
adout.append(new_var_ext)
extver += 1
return adout
def write_new_table(self, fname):
cols = list(self.get_columns())
cols.extend(self.get_fiber_positions_columns())
# Create the table HDU
tablehdu = pf.new_table(cols)
# Create an AstroData object to contain the table
# and write to disk.
new_ad = AstroData(tablehdu)
new_ad.rename_ext('SCI', 1)
new_ad.write(fname, clobber=True)
def test_method_insert_7():
ad = AstroData(TESTFILE)
xname = "TEST"
xver = 99
del header1['EXTNAME']
ad.insert(1,
header=header1,
data=data1,
extname=xname,
extver=xver,
auto_number=True)
assert ad[1].header.get("EXTNAME") == xname
assert ad[1].header.get("EXTVER") == xver
def check_gmos_image(filepath, calibrations=False):
from astrodata import AstroData
reason = "GMOS image"
try:
ad = AstroData(filepath)
except:
reason = "can't load file"
return False, reason
try:
fp_mask = ad.focal_plane_mask().as_pytype()
except:
fp_mask = None
if "GMOS" not in ad.types:
reason = "not GMOS"
return False, reason
elif "GMOS_DARK" in ad.types:
reason = "GMOS dark"
return False, reason
elif "GMOS_BIAS" in ad.types and not calibrations:
reason = "GMOS bias"
return False, reason
elif "GMOS_IMAGE_FLAT" in ad.types and not calibrations:
reason = "GMOS flat"
return False, reason
elif ("GMOS_IMAGE" in ad.types and
fp_mask!="Imaging"):
reason = "GMOS slit image"
return False, reason
elif (("GMOS_IMAGE" in ad.types and
fp_mask == "Imaging" and
"GMOS_DARK" not in ad.types) or
"GMOS_BIAS" in ad.types or
"GMOS_IMAGE_FLAT" in ad.types):
# Test for 3-amp mode with e2vDD CCDs
# This mode has not been commissioned.
dettype = ad.phu_get_key_value("DETTYPE")
if dettype == "SDSU II e2v DD CCD42-90":
namps = ad.phu_get_key_value("NAMPS")
if namps is not None and int(namps)==1:
reason = "uncommissioned 3-amp mode"
return False, reason
else:
return True, reason
else:
return True, reason
else:
reason = "not GMOS image"
return False, reason
def recover(self):
log.debug("OutAtList recover()")
adlist = []
for i, tmpname in enumerate(self.diskoutlist):
ad = AstroData(tmpname, mode="update")
ad.filename = self.ad_name[i]
ad = gemini_tools.obsmode_del(ad)
# Read the database back in, if it exists
try:
ad = gemini_tools.read_database(
ad, database_name=self.database_name,
input_name=self.tmpin_name[i],
output_name=ad.phu_get_key_value("ORIGNAME"))
except:
pass
adlist.append(ad)
log.fullinfo(tmpname + " was loaded into memory")
return adlist
def check_gmos_longslit(filepath):
from astrodata import AstroData
reason = "GMOS longslit"
try:
ad = AstroData(filepath)
except:
reason = "can't load file"
return False, reason
try:
fp_mask = ad.focal_plane_mask().as_pytype()
except:
fp_mask = None
if "GMOS" not in ad.types:
reason = "not GMOS"
return False, reason
elif "GMOS_DARK" in ad.types:
reason = "GMOS dark"
return False, reason
elif "GMOS_BIAS" in ad.types:
reason = "GMOS bias"
return False, reason
elif "GMOS_NODANDSHUFFLE" in ad.types:
reason = "GMOS nod and shuffle"
return False, reason
elif "GMOS_LS" in ad.types:
# Test for 3-amp mode with e2vDD CCDs
# This mode has not been commissioned.
dettype = ad.phu_get_key_value("DETTYPE")
if dettype == "SDSU II e2v DD CCD42-90":
namps = ad.phu_get_key_value("NAMPS")
if namps is not None and int(namps)==1:
reason = "uncommissioned 3-amp mode"
return False, reason
else:
return True, reason
else:
return True, reason
else:
reason = "not GMOS longslit"
return False, reason
def runinsert(index=None, f1=None, f2=None, auto=False):
ad = AstroData(f1)
md = AstroData(f2)
pstr = "\n\n >>>>>>> AD <<<<<<<<\n"
pstr += str(ad.infostr())
pstr += "\n\n >>>>>>> AD APPEND <<<<<<<<\n"
pstr += str(md.infostr())
ad.insert(index=index, moredata=md, auto_number=auto)
pstr +="\n\n >>>>>>> NEW AD <<<<<<<<\n"
pstr += str(ad.infostr())
print(pstr)
return ad
def test_query_header4(self):
expected_result = { 'band':'JH',
'grism':'JH',
'exptime':30.,
'lnrs': 6,
'rdmode': '6'
}
ad = AstroData(TestBookkeeping.f2arcfile)
result = {}
result['band'] = bookkeeping.query_header(ad, 'band')
result['grism'] = bookkeeping.query_header(ad, 'grism')
result['exptime'] = bookkeeping.query_header(ad, 'exptime')
result['lnrs'] = bookkeeping.query_header(ad, 'lnrs')
result['rdmode'] = bookkeeping.query_header(ad, 'rdmode')
assert_dict_equal(result, expected_result)
def atd1():
"""
With a GMOS AstroData object, the test instantiates a MosaicAD object
containing 'coords' as one of the attributes. The test verify that
coords['amp_mosaic_coord'] and ad['SCI'].detector_array.as_dict() values
match.
"""
print '\n atd1 REQUIREMENT.......'
print ('*****MosaicAD shall instantiate an object from a supported AstroData objec')
gmos_file = '../data/gS20120420S0033.fits'
gsaoi_file = '../data/guS20110324S0146.fits'
nongem_file='../data/kp620765.fits'
from astrodata import AstroData
from gempy.adlibrary.mosaicAD import MosaicAD
# This is the default Mosaic function
from gempy.mosaic.gemMosaicFunction import gemini_mosaic_function
# Success Criteria 1. (GMOS data)
# The tester should provide her/his own GMOS file.
for file in [gmos_file,gsaoi_file,nongem_file]:
ad = AstroData(file)
print '\n ...........CASE for:',file,ad.instrument()
# Create the MosaicAD object
mo = MosaicAD(ad,gemini_mosaic_function)
# print DETECTOR values for all the 'SCI' extensions as
# a dictionary.
print ad['SCI'].detector_section().as_dict()
# print the 'amp_mosaic_coord' key value from the 'coords'
# attribute. This list is in increasing order of extver.
print mo.coords['amp_mosaic_coord']
def test_query_header2(self):
expected_result = { 'band':'dark',
'grism':'Open',
'exptime':8.,
'lnrs': 1,
'rdmode': '1'
}
ad = AstroData(TestBookkeeping.f2darkfile)
result = {}
result['band'] = bookkeeping.query_header(ad, 'band')
result['grism'] = bookkeeping.query_header(ad, 'grism')
result['exptime'] = bookkeeping.query_header(ad, 'exptime')
result['lnrs'] = bookkeeping.query_header(ad, 'lnrs')
result['rdmode'] = bookkeeping.query_header(ad, 'rdmode')
assert_dict_equal(result, expected_result)
def test_query_header1(self):
expected_result = { #'targetname':'SDSSJ022721.25-010445.8',
'band':'JH',
'grism':'JH',
'exptime':90.,
'lnrs': 6,
'rdmode': '6'
}
ad = AstroData(TestBookkeeping.f2sciencefile)
result = {}
#result['targetname'] = bookkeeping.query_header(ad, 'targetname')
result['band'] = bookkeeping.query_header(ad, 'band')
result['grism'] = bookkeeping.query_header(ad, 'grism')
result['exptime'] = bookkeeping.query_header(ad, 'exptime')
result['lnrs'] = bookkeeping.query_header(ad, 'lnrs')
result['rdmode'] = bookkeeping.query_header(ad, 'rdmode')
assert_dict_equal(result, expected_result)
def __init__(self, filename, mosmask=None, mdfdir=None):
self.ad = AstroData(filename)
self.mosmask = mosmask
self.mdfdir = mdfdir
# Determine extension
nsci = len(self.ad)
debug("...nsci = ", nsci)
if nsci > 1:
l_sci_ext = 1
else:
l_sci_ext = 0
debug("...using extension [" + str(l_sci_ext) + "]")
overscan_dv = self.ad[l_sci_ext].overscan_section()
if self.is_mos_mode():
self.box_coords = parse_box_coords(self, self.get_mdf_filename())
self.box_mosaic = BoxMosaic(self, self.box_coords)
self.scidata = self.box_mosaic.get_science_data()
elif self.is_new_gmosn_ccd():
# tile the 2 center parts of the new GMOS image
self.scidata = gmultiamp(self.ad)
elif not overscan_dv.is_none():
# remove the overscan so we don't have to take it into account when guessing the slit location
self.scidata = subtract_overscan(self.ad[l_sci_ext])
# it still affects the center of rotation however
ox1, ox2, oy1, oy2 = overscan_dv.as_list()
correction = np.array([ox2 - ox1, 0])
center = self.get_binned_data_center() - correction
self.fieldcenter = center * self.detector_y_bin()
else:
self.scidata = self.ad[l_sci_ext].data
def test_method_phu_set_key_val_4():
ad = AstroData(TESTFILE2)
test_comment = "This is a TESTKEY"
ad.phu_set_key_value('TESTKEY', 'TESTVALUE', comment=test_comment)
assert ad.phu.header.cards['TESTKEY'].comment.endswith(test_comment)
def test_method_phu_set_key_val_2():
ad = AstroData(TESTFILE2)
ad.phu_set_key_value('BITPIX', 999)
assert isinstance(ad.phu.header['BITPIX'], int)
assert ad.phu.header['BITPIX'] == 999
def test_method_phu_get_key_val_6():
ad = AstroData(TESTFILE2)
with pytest.raises(TypeError):
assert ad.phu_get_key_value()
def test_method_phu_get_key_val_3():
ad = AstroData(TESTFILE2)
assert isinstance(ad.phu_get_key_value('RA'), float)
def test_method_extname_2():
ad = AstroData(TESTFILE2)
assert ad.extname() == 'SCI'
def setup(self):
TestSpectrum.ad = AstroData(TestSpectrum.testfile)
TestSpectrum.adhdu = TestSpectrum.ad['SCI', 1]
TestSpectrum.apf = pf.open(TestSpectrum.testfile)
TestSpectrum.apfhdu = TestSpectrum.apf[0]
def test_method_extver_3():
ad = AstroData(TESTFILE)
with pytest.raises(SingleHDUMemberExcept):
ad.extver()
def test_method_set_key_val_6():
ad = AstroData(TESTFILE2)
with pytest.raises(TypeError):
assert ad.set_key_value('FOO')
def test_constructor_1():
""" Good filename, def mode """
ad = AstroData(dataset=TESTFILE)
assert ad.mode == 'readonly'
def mktable_helper(tablename, auto=True, rawdir="./"):
"""
Create or append to an observation summary table.
This function is interactive and requires input from the users.
:param tablename: Filename for the table. If it exists it will
be extended.
:type tablename: str
:param auto: If True, get some of the information directly from
the FITS headers. [Default: True]
:type auto: boolean
:param rawdir: Path to raw data. Required for auto=True.
[Default: "./"]
:type rawdir: str
"""
from klpyastro.utils import obstable
import os.path
# TODO: change to new astrodata when ready
if auto:
from astrodata import AstroData
# Create an ObsTable. If the file already exists on disk,
# then read it. Otherwise, leave it empty.
# Error handling: If the file exists but there's an read error,
# raise, otherwise assume that you are creating a new file.
table = obstable.ObsTable()
table.filename = tablename
try:
table.read_table()
except IOError:
if os.path.exists(tablename):
print("Error reading table %s\n" % tablename)
raise
else:
print("New table will be created.")
# Start the prompting the user and the data for the information
# that needs to go in the table.
user_not_done = True
while user_not_done:
user_inputs = {}
if auto:
filename_not_known = True
# Get list of prompts for user or data supplied information.
req_input_list = get_req_input_list()
# Loop through record elements
for input_request in req_input_list:
if not input_request['in_hdr'] or not auto:
# if auto and this is a Science entry, get the targetname from
# the header. If not Science, then you need to prompt user.
if auto and input_request['id'] == 'targetname' and \
'datatype' in user_inputs and \
user_inputs['datatype'] == 'Science':
input_value = query_header(ad, input_request['id'])
else:
# prompt the user
try:
input = raw_input
except NameError:
pass
input_value = input(input_request['prompt'])
user_inputs[input_request['id']] = input_value
# Assume that the user has a brain.
# Probe only the first file in 'filerange' since all the
# files in 'filerange' should be similar.
#
# Once we know the name of the first MEF file, open it
# and keep it open until we're done requesting inputs
# (instead of opening and closing it every time).
if auto and filename_not_known:
if 'rootname' in user_inputs and 'filerange' in user_inputs:
# parse filerange, build filename (with rawdir path)
filenumbers = parse_filerange(user_inputs['filerange'])
filename = "%sS%04d.fits" % \
(user_inputs['rootname'], filenumbers[0])
filename = os.path.join(rawdir, filename)
# open ad
ad = AstroData(filename)
filename_not_known = False
else:
# get value from header
input_value = query_header(ad, input_request['id'])
user_inputs[input_request['id']] = input_value
if auto:
ad.close()
# Create record
new_record = create_record(user_inputs)
# Append to table
table.add_records_to_table(new_record)
# Prompt user: add another entry?
try:
input = raw_input
except NameError:
pass
answer = input('Add another entry (y/n): ')
user_not_done = ((answer == 'y') or False)
# All the info is now in the ObsTable.
# Write the ObsTable to disk and close everything, we're done.
table.write_table()
table.pretty_table()
return
def test_method_phu_get_key_val_3():
ad = AstroData(TESTFILE2)
assert isinstance(ad.phu_get_key_value('RA'), float)
def test_method_phu_get_key_val_2():
ad = AstroData(TESTFILE2)
assert isinstance(ad.phu_get_key_value('BITPIX'), int)
def test_constructor_2():
""" filename w mode option """
ad = AstroData(dataset=TESTFILE, mode="update")
assert ad.mode == 'update'
def test_method_phu_get_key_val_1():
ad = AstroData(TESTFILE2)
assert isinstance(ad.phu_get_key_value('SIMPLE'), bool)
def test_method_set_key_val_8():
ad = AstroData(TESTFILE)
with pytest.raises(AstroDataError):
assert ad.set_key_value('BITPIX', 1)
def test_method_set_key_val_4():
ad = AstroData(TESTFILE2)
test_comment = "This is a TESTKEY"
ad.set_key_value('TESTKEY', 'TESTVALUE', comment=test_comment)
assert ad.header.cards['TESTKEY'].comment.endswith(test_comment)
def test_method_get_key_val_7():
ad = AstroData(TESTFILE2)
with pytest.raises(TypeError):
assert ad.get_key_value()
def test_method_extver_2():
ad = AstroData(TESTFILE2)
assert ad.extver() == 1
def test_method_get_key_val_6():
ad = AstroData(TESTFILE2)
assert ad.get_key_value('FOO') is None
def test_method_extver_1():
ad = AstroData(TESTFILE2) # Single 'SCI' ext
assert isinstance(ad.extver(), int)
def test_method_get_key_val_4():
ad = AstroData(TESTFILE2)
assert ad.get_key_value('DATATYP') is None
def test_method_phu_get_key_val_2():
ad = AstroData(TESTFILE2)
assert isinstance(ad.phu_get_key_value('BITPIX'), int)
def test_method_get_key_val_3():
ad = AstroData(TESTFILE2)
assert isinstance(ad.get_key_value('CRVAL1'), float)
def test_method_phu_get_key_val_5():
ad = AstroData(TESTFILE2)
assert ad.phu_get_key_value('FOO') is None
def test_method_get_key_val_1():
ad = AstroData(TESTFILE2)
assert isinstance(ad.get_key_value('EXTNAME'), str)
def test_method_phu_set_key_val_1():
ad = AstroData(TESTFILE2)
test_val = 'TESTVALUE'
ad.phu_set_key_value('TESTKEY', test_val)
assert ad.phu.header['TESTKEY'] == test_val
def mktable_helper(tablename, auto=True, rawdir="./"):
"""
Create or append to an observation summary table.
This function is interactive and requires input from the users.
:param tablename: Filename for the table. If it exists it will
be extended.
:type tablename: str
:param auto: If True, get some of the information directly from
the FITS headers. [Default: True]
:type auto: boolean
:param rawdir: Path to raw data. Required for auto=True.
[Default: "./"]
:type rawdir: str
"""
import obstable
import os.path
if auto:
from astrodata import AstroData
# Create an ObsTable. If the file already exists on disk,
# then read it. Otherwise, leave it empty.
# Error handling: If the file exists but there's an read error,
# raise, otherwise assume that you are creating a new file.
table = obstable.ObsTable()
table.filename = tablename
try:
table.read_table()
except IOError:
if os.path.exists(tablename):
print "Error reading table %s\n" % tablename
raise
else:
print "New table will be created."
# Start the prompting the user and the data for the information
# that needs to go in the table.
user_not_done = True
while user_not_done:
user_inputs = {}
if auto:
filename_not_known = True
# Get list of prompts for user or data supplied information.
req_input_list = get_req_input_list()
# Loop through record elements
for input_request in req_input_list:
if (not input_request['in_hdr'] or not auto):
# if auto and this is a Science entry, get the targetname from
# the header. If not Science, then you need to prompt user.
if auto and input_request['id'] == 'targetname' and \
user_inputs.has_key('datatype') and \
user_inputs['datatype'] == 'Science':
input_value = query_header(ad, input_request['id'])
else:
# prompt the user
input_value = raw_input(input_request['prompt'])
user_inputs[input_request['id']] = input_value
# Assume that the user has a brain.
# Probe only the first file in 'filerange' since all the
# files in 'filerange' should be similar.
#
# Once we know the name of the first MEF file, open it
# and keep it open until we're done requesting inputs
# (instead of opening and closing it every time).
if auto and filename_not_known:
if user_inputs.has_key('rootname') and \
user_inputs.has_key('filerange'):
# parse filerange, build filename (with rawdir path)
filenumbers = parse_filerange(user_inputs['filerange'])
filename = "%sS%04d.fits" % \
(user_inputs['rootname'], filenumbers[0])
filename = os.path.join(rawdir, filename)
# open ad
ad = AstroData(filename)
filename_not_known = False
else:
# get value from header
input_value = query_header(ad, input_request['id'])
user_inputs[input_request['id']] = input_value
if auto:
ad.close()
# Create record
new_record = create_record(user_inputs)
# Append to table
table.add_records_to_table(new_record)
# Prompt user: add another entry?
answer = raw_input('Add another entry (y/n): ')
user_not_done = ((answer=='y') or False)
# All the info is now in the ObsTable.
# Write the ObsTable to disk and close everything, we're done.
table.write_table()
table.pretty_table()
return
def test_method_phu_set_key_val_3():
ad = AstroData(TESTFILE2)
ad.phu_set_key_value('CRVAL1', 1.0)
assert isinstance(ad.phu.header['CRVAL1'], float)
def test_method_extname_1():
ad = AstroData(TESTFILE2) # Single 'SCI' ext
assert isinstance(ad.extname(), str)
def test_method_phu_set_key_val_7():
ad = AstroData(TESTFILE2)
with pytest.raises(AstroDataError):
assert ad.phu_set_key_value('FOO', None)
def test_method_set_key_val_7():
ad = AstroData(TESTFILE2)
with pytest.raises(AstroDataError):
assert ad.set_key_value('FOO', None)
class AcquisitionImage(object):
def __init__(self, filename, mosmask=None, mdfdir=None):
self.ad = AstroData(filename)
self.mosmask = mosmask
self.mdfdir = mdfdir
# Determine extension
nsci = len(self.ad)
debug("...nsci = ", nsci)
if nsci > 1:
l_sci_ext = 1
else:
l_sci_ext = 0
debug("...using extension [" + str(l_sci_ext) + "]")
overscan_dv = self.ad[l_sci_ext].overscan_section()
if self.is_mos_mode():
self.box_coords = parse_box_coords(self, self.get_mdf_filename())
self.box_mosaic = BoxMosaic(self, self.box_coords)
self.scidata = self.box_mosaic.get_science_data()
elif self.is_new_gmosn_ccd():
# tile the 2 center parts of the new GMOS image
self.scidata = gmultiamp(self.ad)
elif not overscan_dv.is_none():
# remove the overscan so we don't have to take it into account when guessing the slit location
self.scidata = subtract_overscan(self.ad[l_sci_ext])
# it still affects the center of rotation however
ox1, ox2, oy1, oy2 = overscan_dv.as_list()
correction = np.array([ox2 - ox1, 0])
center = self.get_binned_data_center() - correction
self.fieldcenter = center * self.detector_y_bin()
else:
self.scidata = self.ad[l_sci_ext].data
@cache
def instrument(self):
return str(self.ad.instrument())
def is_new_gmosn_ccd(self):
header = self.ad.phu.header
if "DETECTOR" not in header:
return False
if header["DETECTOR"] == "GMOS + e2v DD CCD42-90":
return True
return False
def get_science_data(self):
assert self.scidata is not None
return self.scidata
@cache
def unbinned_pixel_scale(self):
return float(self.ad.pixel_scale()) / self.detector_y_bin()
@cache
def binned_pixel_scale(self):
return float(self.ad.pixel_scale())
def _check_binning(self):
if int(self.ad.detector_x_bin()) != int(self.ad.detector_y_bin()):
error("ERROR: incorrect binning!")
error("Sorry about that, better luck next time.")
sys.exit(1)
@cache
def detector_x_bin(self):
self._check_binning()
return int(self.ad.detector_x_bin())
@cache
def detector_y_bin(self):
self._check_binning()
return int(self.ad.detector_y_bin())
@cache
def program_id(self):
return str(self.ad.program_id())
@cache
def observation_id(self):
return str(self.ad.observation_id())
@cache
def saturation_level(self):
dv = self.ad.saturation_level()
return min(dv.as_list())
@cache
def focal_plane_mask(self):
return str(self.ad.focal_plane_mask())
@cache
def grating(self):
return str(self.ad.grating())
def get_detector_size(self):
# mos mode acquisitions don't necessarily have the entire
# field of view in their data sections, so we have to rely on
# other tricks to figure out the center of rotation.
detsize = self.ad.phu_get_key_value("DETSIZE")
xmin, xdim, ymin, ydim = extract_dimensions(detsize)
# adjust for chip gaps
nccds = int(self.ad.phu_get_key_value("NCCDS"))
xdim += ((nccds - 1) * _obtain_unbinned_arraygap(self.ad))
# adjust for un-illuminated pixels
if self.is_gmos():
ydim -= 36 # magic number that should be replaced with a lookup table later
return xdim, ydim
def get_field_center(self):
""" The center of rotation in pixels. """
if hasattr(self, "fieldcenter"):
return self.fieldcenter
if self.is_mos_mode():
xdim, ydim = self.get_detector_size()
return np.array([float(xdim) / 2.0, float(ydim) / 2.0])
return self.get_data_center()
def get_data_center(self):
ydim, xdim = self.get_science_data().shape
return np.array([float(xdim) / 2.0, float(ydim) / 2.0]) * self.detector_y_bin()
def get_binned_data_center(self):
return self.get_data_center() / self.detector_y_bin()
def set_goal_center(self, center):
self.goal_center = np.array(center)
def get_goal_center(self):
default = self.get_data_center()
return getattr(self, "goal_center", default)
def set_binned_custom_center(self, center):
self.set_binned_goal_center(center)
self.custom_center = True
def has_custom_center(self):
return getattr(self, "custom_center", False)
def get_binned_goal_center(self):
return self.get_goal_center() / self.detector_y_bin()
def set_binned_goal_center(self, center):
center = np.array(center) * self.detector_y_bin()
self.set_goal_center(center)
def get_mask_width(self):
debug("...finding slit dimensions...")
slitxbin = self.detector_x_bin()
slitybin = self.detector_y_bin()
debug("...slit image binning = ", slitxbin, " x ", slitybin)
if slitxbin > 1 or slitybin > 1:
warning("! WARNING: Slit image is binned " + slitxbin + " x " + slitybin)
slitmask = self.focal_plane_mask()
return float(slitmask.replace("arcsec", ""))
def get_mask_width_in_pixels(self):
return self.get_mask_width() / self.unbinned_pixel_scale()
def get_slit_size_in_pixels(self):
xsize = self.get_mask_width_in_pixels()
ysize = self.get_science_data().shape[0]
return xsize, ysize
def get_expected_slit_tilt(self):
if self.is_gmos():
return 0.0
error("Instrument is not supported, need to know an expected slit tilt")
sys.exit(1)
@property
def phu(self):
return self.ad.phu
@property
def filename(self):
return self.ad.filename
def get_program_id_parts(self):
gemprgid = str(self.ad.program_id())
parts = gemprgid.split("-")
if len(parts) != 4:
msg = "Cannot parse program id '%s'" % gemprgid
error(msg)
raise ValueError(msg)
observatory, semester, prgtype, queuenum = parts
return observatory, semester, prgtype, int(queuenum)
def get_semester(self):
""" Return something in the form of '2006B' """
observatory, semester, prgtype, queuenum = self.get_program_id_parts()
return semester
def get_observatory_prefix(self):
""" Return something in the form of 'GN' """
observatory, semester, prgtype, queuenum = self.get_program_id_parts()
return observatory
def is_mos_mode(self):
return self.mosmask is not None or self.has_mos_mask()
@cache
def has_mos_mask(self):
if not self.is_gmos() and not self.is_f2():
return False
maskname = self.focal_plane_mask()
if ("Q" in maskname or # Queue program
"C" in maskname or # Classical program
"D" in maskname or # DD program
"V" in maskname): # SV program
xbin = self.detector_x_bin()
ybin = self.detector_y_bin()
if xbin != 1 or ybin != 1:
error ("MOS acquisition image binning must be 1x1, found %ix%i binning." % (xbin, ybin))
clean()
return True
return False
def has_mask_in_beam(self):
maskname = self.focal_plane_mask().lower()
if "imag" in maskname:
return False
slitmask = self.focal_plane_mask()
if self.is_gmos() and "arcsec" in slitmask:
return True
if self.is_gnirs() and "arcsec" in slitmask:
acqmir = slitimage_ad.phu.header["ACQMIR"]
debug("...acqmir = ", acqmir)
if acqmir == "In":
return True
if self.is_niri() and "cam" not in slitmask:
return True
if self.is_f2() and "slit" in slitmask:
return True
if self.is_f2() and "mos" in slitmask:
return True
return self.has_mos_mask()
def get_mdf_filename(self):
if hasattr(self, "mdffile"):
return self.mdffile
self.mdffile = self._get_mdf_filename()
return self.mdffile
def _get_mdf_filename(self):
if self.mosmask is not None:
mdffile = self.mosmask
# Expand the MOS mask number
if is_number(self.mosmask):
observatory, semester, prgtype, queuenum = self.get_program_id_parts()
mdffile = "%s%s%s%03i-%02i" % (observatory, semester, prgtype, queuenum, int(self.mosmask))
debug("...mosmask =", mdffile)
else:
mdffile = self.focal_plane_mask()
mdffile = fits_filename(mdffile)
#-----------------------------------------------------------------------
# Start searching around willy nilly for the MDF file
if os.path.exists(mdffile):
return mdffile
# note, the order in which directories are added to this list gives priority
dirs = []
if self.mdfdir is not None:
dirs.append(self.mdfdir)
dname = os.path.dirname(self.filename)
if dname and dname != ".":
dirs.append(dname)
dirs.append(os.getcwd())
# search through semester directories as well
semester_dir = self.get_observatory_prefix() + self.get_semester()
directories_to_search = []
for dname in dirs:
directories_to_search.append(dname)
dname = os.path.join(dname, semester_dir)
directories_to_search.append(dname)
# now search through the directories
for dname in directories_to_search:
fname = os.path.join(dname, mdffile)
debug("...trying", fname)
if os.path.exists(fname):
return fname
raise ValueError("Unable to find MDF file named '%s'" % mdffile)
def get_num_mos_boxes(self):
return self.box_mosaic.get_num_mos_boxes()
def get_mos_boxes(self):
return self.box_mosaic.get_boxes()
def get_mos_box_borders(self):
for border in self.box_mosaic.get_box_borders():
yield border
@cache
def get_min_slitsize(self):
mdffile_ad = AstroData(self.get_mdf_filename())
xsize = Ellipsis
ysize = Ellipsis
for row in mdffile_ad["MDF"].data:
# select the alignment boxes, designated by priority 0
if row["priority"] not in ["1", "2", "3"]:
continue
xsize = min(xsize, row["slitsize_x"])
ysize = min(ysize, row["slitsize_y"])
return xsize, ysize
def get_extensions(self):
for ext in self.ad:
yield ext
def _get_lazy_detector_section_finder(self):
if not hasattr(self, "detsec_finder"):
self.detsec_finder = DetectorSectionFinder(self)
return self.detsec_finder
def get_box_size(self):
return self._get_lazy_detector_section_finder().get_box_size()
def find_detector_section(self, point):
return self._get_lazy_detector_section_finder().find_detector_section(point)
def get_full_field_of_view(self):
return self._get_lazy_detector_section_finder().get_full_field_of_view()
def is_altair(self):
aofold = self.ad.phu.header["AOFOLD"]
if aofold == "IN":
return True
return False
def is_south_port(self):
inportnum = int(self.ad.phu.header["INPORT"])
if inportnum == 1:
return True
return False
def is_type(self, typename):
return self.ad.is_type(typename)
def is_gmos(self):
return self.is_type("GMOS")
def is_gmosn(self):
return self.is_type("GMOS_N")
def is_gmoss(self):
return self.is_type("GMOS_S")
def is_gnirs(self):
return self.is_type("GNIRS")
def is_f2(self):
return self.is_type("F2")
def is_nifs(self):
return self.is_type("NIFS")
def is_niri(self):
return self.is_type("NIRI")
def test_method_set_key_val_2():
ad = AstroData(TESTFILE2)
ad.set_key_value('BITPIX', 999)
assert isinstance(ad.header['BITPIX'], int)
# it would be useful for the DA/SOSs.
# It can be run on any file with a sextractor style OBJCAT in it, for example
# the _forStack files output by the QAP. If no REFCAT is present, it bails out as no refmags
#
# Paul Hirst 20120321
import math
import sys
from astrodata import AstroData
import numpy as np
import matplotlib.pyplot as plt
from random import random
filename = sys.argv[1]
ad = AstroData(filename)
objcat = ad['OBJCAT']
if (ad['REFCAT'] is None):
print "No Reference Catalog in this file, thus no Zeropoints. Sorry"
sys.exit(0)
mag = objcat.data.field("MAG_AUTO")
magerr = objcat.data.field("MAGERR_AUTO")
refmag = objcat.data.field("REF_MAG")
refmagerr = objcat.data.field("REF_MAG_ERR")
sxflag = objcat.data.field("FLAGS")
dqflag = objcat.data.field("IMAFLAGS_ISO")
# set mag to None where we don't want to use the object
mag = np.where((mag==-999), None, mag)
def test_constructor_0():
""" Good filename """
assert AstroData(dataset=TESTFILE)
def test_method_set_key_val_1():
ad = AstroData(TESTFILE2)
ad.set_key_value('TESTKEY', 'TESTVALUE')
assert ad.header['TESTKEY']
def test_method_set_key_val_3():
ad = AstroData(TESTFILE2)
ad.set_key_value('CRVAL1', 1.0)
assert isinstance(ad.header['CRVAL1'], float)
