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 _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 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_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_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)