def testCombineCats(self): normkeys = 'FLUX_APER1 FLUXERR_APER1 MAG_APER1 MAGERR_APER1 BLANK1 BLANK2'.split( ) mastercols = [pyfits.Column(name = k, format = 'E', array = numpy.ones(30)) \ for k in normkeys] mastercols[0] = pyfits.Column(name='FLUX_APER1', format='E', array=numpy.random.standard_normal(30)) zerokeys = 'MaxVal BackGr'.split() for key in zerokeys: mastercols.append( pyfits.Column(name=key, format='E', array=numpy.zeros(30))) mastercols.append( pyfits.Column(name='IMAFLAGS_ISO', format='J', array=numpy.ones(30))) cats = [ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(mastercols)))] for i in xrange(5): cols = [pyfits.Column(name = k, format = 'E', array = numpy.random.standard_normal(30)) \ for k in normkeys] cols[0] = pyfits.Column(name='FLUX_APER1', format='E', array=numpy.random.standard_normal(30)) for key in zerokeys: cols.append( pyfits.Column(name=key, format='E', array=numpy.zeros(30))) cols.append( pyfits.Column(name='IMAFLAGS_ISO', format='E', array=numpy.ones(30))) cats.append(ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols)))) keys = normkeys[2:] + zerokeys keys.append('IMAFLAGS_ISO') combinedcat = combineCats(cats, saturation=5) self.assertEqual(type(combinedcat), type(cats[0])) for key in keys: self.assertTrue(key in combinedcat.keys()) self.assertTrue((combinedcat['BLANK1'] == 1).all()) self.assertTrue((combinedcat['BLANK2'] == 1).all()) self.assertTrue((combinedcat['MAG_APER1'] == 1).all()) self.assertTrue((combinedcat['MAGERR_APER1'] == 1).all()) self.assertTrue((combinedcat['FLUX_APER1-1'] != 1).all()) self.assertTrue((combinedcat['FLUXERR_APER1-1'] != 1).all())
def testSaveOffsetsforSLR(self): zplist = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs([pyfits.Column(name = 'filter', format='20A', array = self.filternames), pyfits.Column(name = 'zeropoints', format='E', array = self.orig_zps)]))) saveSlrZP(cluster = 'testcluster', offsetFile = self.offsetFile, zplist = zplist, fluxtype = 'iso', myspec = 'custom', photometry_db = self.db) self.assertEquals(len(self.db.slr), 3) self.assertEquals(sorted([slr.fitFilter for slr in self.db.slr]), sorted(self.slr_zps.keys())) for slr in self.db.slr: match = self.slr_zps[slr.fitFilter] self.assertEquals(slr.cluster, 'testcluster') self.assertEquals(slr.fitFilter, match.filter) self.assertTrue(np.abs(slr.zp - match.zp) < 0.001) self.assertTrue(np.abs(slr.zperr - match.zperr) < 0.001) self.assertEquals(slr.fluxtype, 'iso') self.assertEquals(slr.myspec, 'custom')
def keytoasc(infile, outfile, table, key): header = ldac.LDACCat(infile) data = header[table][key] asc = open(outfile, "w") for i in range(len(data)): asc.write("%d\n" % (data[i])) asc.close()
def calcs_after_fitting(infile, outfile, table, external, replace=False): coeffs = {} header = ldac.LDACCat(infile) data = header[table] coefffile = open(external[0], 'r') for line in coefffile: entries = line.strip().split(" ") coeffs[entries[0]] = float(entries[2]) coeffs[entries[0] + '_Err'] = float(entries[4]) F = np.array(data['IMAGEID'], dtype='float64') F_Err = np.array(data['IMAGEID'], dtype='float64') CHIP = data['IMAGEID'] for i in np.unique(CHIP): np.place(F, F == i, coeffs['F' + str(i)]) np.place(F_Err, F_Err == i, coeffs['F' + str(i) + '_Err']) MagZP = data['MagZP'] A = coeffs['A'] B = coeffs['B'] C = coeffs['C'] D = coeffs['D'] E = coeffs['E'] X = data['Xpos_mod'] Y = data['Ypos_mod'] data[ 'Mag_fitted'] = MagZP - A * X**2 - B * Y**2 - C * X * Y - D * X - E * Y - F Mag_fitted = data['Mag_fitted'] A_Err = coeffs['A_Err'] B_Err = coeffs['B_Err'] C_Err = coeffs['C_Err'] D_Err = coeffs['D_Err'] E_Err = coeffs['E_Err'] MagZPErr = data['MagZPErr'] X_Err = 0.0 # not available yet -> data['Xpos_mod_Err'] Y_Err = 0.0 # not available yet -> data['Ypos_mod_Err'] data['Mag_fitted_Err'] = np.sqrt((MagZPErr)**2 + (-X**2 * A_Err)**2 + (-Y**2 * B_Err)**2 + (-X * Y * C_Err)**2 + (-X * D_Err)**2 + (-Y * E_Err)**2 + (-F_Err)**2 + ((-2.0 * A * X - C * Y - D) * X_Err)**2 + ((-2.0 * B * Y - C * X - E) * Y_Err)**2) Mag_fitted_Err = data['Mag_fitted_Err'] filtername = external[1] reference = data[filtername + 'mag'] reference_err = data[filtername + 'mag_err'] data['Residual_fitted'] = Mag_fitted - reference data['Residual_fitted_Err'] = np.sqrt((Mag_fitted_Err)**2 + (-reference_err)**2) header.add_history( 'Added illumination correction calculations after fiiting.') data.saveas(outfile, clobber=replace)
def parsePDZ(cls, pdzfile, sourcefile): '''parses text output from ZEBRA''' input = open(pdzfile) source = ldac.openObjectFile(sourcefile) minPDZ, maxPDZ, pdzstep = 0.0, 4.005, 0.005 pdzs = [] for line in input.readlines(): if re.match('^#', line): continue tokens = line.split() pdz = map(float, tokens) pdzs.append(pdz) nobjects = len(pdzs) npdzs = len(np.arange(minPDZ, maxPDZ, pdzstep)) ids = source['SeqNr'] cols = [pyfits.Column(name = 'SeqNr', format = 'J', array = ids), pyfits.Column(name = 'pdz', format = '%dE' % npdzs, array = np.array(pdzs))] pdzs = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) pdzs.hdu.header.update('MINPDZ', minPDZ) pdzs.hdu.header.update('MAXPDZ', maxPDZ) pdzs.hdu.header.update('PDZSTEP', pdzstep) return cls(pdzs)
def testConvertAper(self): newhdulist = convertAper(self.hdulist) self.assertTrue(isinstance(newhdulist, pyfits.HDUList)) self.assertEquals(len(newhdulist), 3) seenObjects = False seenFields = False for hdu in newhdulist: if 'EXTNAME' in hdu.header.keys(): tablename = hdu.header['EXTNAME'] if tablename == 'OBJECTS': seenObjects = True self.assertTrue( tablesEqual( hdu, convertAperColumns(ldac.LDACCat( self.objectshdu)).hdu)) elif tablename == 'FIELDS': seenFields = True self.assertTrue(tablesEqual(hdu, self.fieldhdu)) else: self.asssertFail('Unexpected Table') self.assertTrue(seenObjects) self.assertTrue(seenFields)
def testCreateBins(self): cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs([pyfits.Column(name = key, format = 'E', array = vals) \ for key, vals in self.catalog.iteritems()]))) cat.hdu.header.update('EXTNAME', 'OBJECTS') bins = createBins(cat, [[lambda x: x['a'] == 0, lambda x: x['a'] == 1], [lambda x: x['c'] == 1, lambda x: x['c'] == 0]]) self.assertTrue(len(bins), 4) self.assertTrue((0, 0) in bins.keys()) self.assertTrue( np.logical_and(bins[(0, 0)]['a'] == 0, bins[(0, 0)]['c'] == 1).all()) self.assertTrue((1, 0) in bins.keys()) self.assertTrue( np.logical_and(bins[(1, 0)]['a'] == 1, bins[(1, 0)]['c'] == 1).all()) self.assertTrue((0, 1) in bins.keys()) self.assertTrue( np.logical_and(bins[(0, 1)]['a'] == 0, bins[(0, 1)]['c'] == 0).all()) self.assertTrue((1, 1) in bins.keys()) self.assertTrue( np.logical_and(bins[(1, 1)]['a'] == 1, bins[(1, 1)]['c'] == 0).all())
def testCombineCats_instrum(self): normkeys = 'FLUX_APER FLUXERR_APER'.split() zerokeys = 'MaxVal BackGr'.split() cats = [] for i in xrange(6): cols = [pyfits.Column(name = k, format = '5E', array = numpy.random.standard_normal((30,5)))\ for k in normkeys] for key in zerokeys: cols.append( pyfits.Column(name=key, format='E', array=numpy.zeros(30))) cols.append( pyfits.Column(name='IMAFLAGS_ISO', format='J', array=numpy.ones(30))) cats.append(ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols)))) keys = zerokeys combinedcat = combineCats(cats, saturation=5, instrum='SUBARU-10_1') self.assertEqual(type(combinedcat), type(cats[0])) for key in keys: self.assertTrue(key in combinedcat.keys()) self.assertEqual(combinedcat['FLUX_APER-SUBARU-10_1-1'].shape, (30, 5)) self.assertEqual(combinedcat['FLUXERR_APER-SUBARU-10_1-1'].shape, (30, 5))
def tablesEqual(table1, table2): cat1 = ldac.LDACCat(table1) cat2 = ldac.LDACCat(table2) if not len(cat1) == len(cat2): return False if not len(cat1.keys()) == len(cat2.keys()): return False for key in cat1.keys(): if not (cat1[key] == cat2[key]).all(): return False return True
def makeCrossValCats(cat, nsets): if isinstance(cat, ldac.LDACCat): nentries = len(cat) else: nentries = len(cat[cat.keys()[0]]) indices = np.random.permutation(nentries) slicepoints = np.linspace(0, nentries, nsets + 1) cat_sets = [] for cur_set_index in range(nsets): raw_testing_cat = {} raw_training_cat = {} for key in cat.keys(): for i in range(nsets): if i == cur_set_index: raw_testing_cat[key] = cat[key][ indices[slicepoints[i]:slicepoints[i + 1]]] else: if key not in raw_training_cat: raw_training_cat[key] = [] raw_training_cat[key].append( cat[key][indices[slicepoints[i]:slicepoints[i + 1]]]) testing_cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs([pyfits.Column(name = key, format = 'E', array = vals) \ for key, vals in raw_testing_cat.iteritems()]))) testing_cat.hdu.header.update('EXTNAME', 'OBJECTS') training_cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs([pyfits.Column(name = key, format = 'E', array = np.hstack(vals)) \ for key, vals in raw_training_cat.iteritems()]))) training_cat.hdu.header.update('EXTNAME', 'OBJECTS') cat_sets.append((training_cat, testing_cat)) return cat_sets
def testApplyZeropoints_testSLR(self): objectMag = 24.2 target_zp1 = 27.4 target_zp2 = 27.9 target_zperr = 0.1 flux1 = 10**(-0.4 * (objectMag - target_zp1)) * numpy.ones(10) flux2 = 10**(-0.4 * (objectMag - target_zp2)) * numpy.ones(10) cols = [ pyfits.Column(name='FLUX_APER-filter1', format='E', array=flux1), pyfits.Column(name='FLUXERR_APER-filter1', format='E', array=0.001 * flux1), pyfits.Column(name='FLUX_APER-filter2', format='E', array=flux2), pyfits.Column(name='FLUXERR_APER-filter2', format='E', array=0.001 * flux2) ] cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) ########## class fakeSLR(object): def __init__(self, zp, zperr, fitFilter): self.zp = zp self.fitFilter = fitFilter self.zperr = zperr def getZP(cluster, filter, **spec): return fakeSLR(target_zp2, target_zperr, 'filter2') ########## corFlux, corErr, zp, zperr = applyZeropoint( 'testcluster', 'filter1', flux1, 'APER', 0.001 * flux1, type='slr', cat=cat, photometry_db=fakeCalDB(getZP)) self.assertTrue( numpy.abs(zp - target_zp1) < 1e-3, 'Expected: %3.2f Found: %3.2f' % (target_zp1, zp)) corMag = -2.5 * numpy.log10(corFlux) self.assertTrue( (numpy.abs(corMag - objectMag) < 1e-3).all(), 'Expected: %3.2f Found: %3.2f' % (objectMag, corMag[0])) self.assertTrue((numpy.abs(target_zperr - zperr) < 1e-5))
def testCombineCats_multichip(self): zerokeys = 'MaxVal BackGr'.split() cats = [] for i in xrange(6): cols = [ pyfits.Column(name = key, format = 'E', array = numpy.zeros(30)) \ for key in zerokeys ] if i == 1: flags = numpy.ones(30) elif i == 2: flags = 2 * numpy.ones(30) else: flags = numpy.random.random_integers(1, 2, 30) flags[25:] = 3 flux = numpy.ones(30) flux[flags == 2] = 2 flux[flags == 3] = 3 fluxerr = numpy.random.standard_normal(30) cols.append(pyfits.Column(name='FLUX_APER', format='E', array=flux)) cols.append( pyfits.Column(name='FLUXERR_APER', format='E', array=fluxerr)) cols.append( pyfits.Column(name='IMAFLAGS_ISO', format='J', array=flags)) cats.append(ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols)))) keys = zerokeys combinedcat = combineCats(cats, saturation=5) self.assertEqual(type(combinedcat), type(cats[0])) for key in keys: self.assertTrue(key in combinedcat.keys()) self.assertEqual(combinedcat['FLUX_APER-1'].shape, (30, )) self.assertEqual(combinedcat['FLUXERR_APER-1'].shape, (30, )) self.assertTrue((combinedcat['FLUX_APER-1'][:25] == 1).all()) self.assertTrue((combinedcat['FLUX_APER-1'][25:] == -99).all()) self.assertEqual(combinedcat['FLUX_APER-2'].shape, (30, )) self.assertEqual(combinedcat['FLUXERR_APER-2'].shape, (30, )) self.assertTrue((combinedcat['FLUX_APER-2'][:25] == 2).all()) self.assertTrue((combinedcat['FLUX_APER-2'][25:] == -99).all()) self.assertEqual(combinedcat['FLUX_APER-3'].shape, (30, )) self.assertEqual(combinedcat['FLUXERR_APER-3'].shape, (30, )) self.assertTrue((combinedcat['FLUX_APER-3'][25:] == 3).all()) self.assertTrue((combinedcat['FLUX_APER-3'][:25] == -99).all())
def testConvertColumns_KeepOthers(self): newcat = convertAperColumns(ldac.LDACCat(self.objectshdu)) headerkeys = newcat.keys() for key in self.vector_one_cols: self.assertTrue(key in headerkeys) self.assertTrue('SeqNr' in headerkeys) self.assertTrue((newcat['SeqNr'] == numpy.arange(100)).all())
def setUp(self): self.workdir = tempfile.mkdtemp() self.cat1file = '%s/cat1.cat' % self.workdir self.cat2file = '%s/cat2.cat' % self.workdir self.cat1 = ldac.LDACCat( pyfits.new_table( pyfits.ColDefs([ pyfits.Column(name='SeqNr', format='K', array=np.arange(15)) ]))) self.cat1.saveas(self.cat1file) self.cat2 = ldac.LDACCat( pyfits.new_table( pyfits.ColDefs([ pyfits.Column(name='SeqNr', format='K', array=np.arange(15)) ]))) self.cat2.hdu.header.update('EXTNAME', 'STDTAB') self.cat2.saveas(self.cat2file) self.pdzfile = '%s/pdz.cat' % self.workdir pdzcat = ldac.LDACCat( pyfits.new_table( pyfits.ColDefs([ pyfits.Column(name='SeqNr', format='K', array=np.arange(15)), pyfits.Column(name='pdz', format='25E', array=np.ones((15, 25))) ]))) pdzcat.hdu.header.update('MINPDZ', 0) pdzcat.hdu.header.update('MAXPDZ', 25) pdzcat.hdu.header.update('PDZSTEP', 1) pdzcat.saveas(self.pdzfile)
def calcNearestNeighborCut(options, cat, psfsize, ldaclensing): curdir = os.getcwd() os.chdir(ldaclensing) progs = bashreader.parseFile('progs.ini') temp_inputcatfile = utilities.getTempFile(dir=progs.tempdir, suffix='.cat') temp_outputcatfile = utilities.getTempFile(dir=progs.tempdir, suffix='.cat') print cat.sourcefile hdulist = pyfits.open(cat.sourcefile) newhdus = [pyfits.PrimaryHDU()] for hdu in hdulist[1:]: if hdu.header['EXTNAME'] == 'OBJECTS': newhdus.append(cat.hdu) elif hdu.header['EXTNAME'] == 'FIELDS': fieldstable = ldac.LDACCat(hdu) fieldstable['OBJECT_COUNT'][:] = np.array([len(cat)]) newhdus.append(fieldstable.hdu) hdulist = pyfits.HDUList(newhdus) hdulist.writeto(temp_inputcatfile, clobber=True) stringvals = copy.copy(options) stringvals.inputcatfile = temp_inputcatfile stringvals.outputcatfile = temp_outputcatfile #BASH script hardcodes what the comparison catalog is. Bewarned! command = './cut_nearest_neighbours_cc.sh %(cluster)s %(filter)s %(image)s %(inputcatfile)s %(outputcatfile)s %(psfsize)2.4f' % stringvals try: subprocess.check_call(command.split()) outputcat = ldac.openObjectFile(temp_outputcatfile) ids = {} for id in cat['SeqNr']: ids[id] = False for id in outputcat['SeqNr']: ids[id] = True nearest_neighbor_cut = np.array([ids[id] for id in cat['SeqNr']]) finally: # if os.path.exists(temp_inputcatfile): # os.remove(temp_inputcatfile) # if os.path.exists(temp_outputcatfile): # os.remove(temp_outputcatfile) os.chdir(curdir) return nearest_neighbor_cut
def convertTxt2LDAC(file, keys, type): rawfile = readtxtfile(file) cols = [] for i, key, type in zip(xrange(len(keys)), keys, type): cols.append(pyfits.Column(name=key, format=type, array=rawfile[:, i])) hdu = pyfits.new_table(pyfits.ColDefs(cols)) hdu.header.update('EXTNAME', 'OBJECTS') return ldac.LDACCat(hdu)
def testExtractColumn(self): keys = 'FLUX_APER1 FLUXERR_APER1 BLANK1 BLANK2 MAG_APER1 MAGERR_APER1'.split( ) cols = [pyfits.Column(name = k, format = 'E', array = numpy.ones(30)) \ for k in keys] cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) extractedCol = _extractColumn(cat, 'BLANK1') self.assertTrue((extractedCol.array == cols[2].array).all()) self.assertEqual(extractedCol.name, cols[2].name) self.assertEqual(extractedCol.format, cols[2].format)
def testPropogateFlag(self): def getZP(cluster, filter, **spec): return fakeCalibration(self.zps[filter]) cols = [] cols.append( pyfits.Column(name='ALPHA_J2000', format='D', array=numpy.random.standard_normal(self.nObjs))) cols.append( pyfits.Column(name='DELTA_J2000', format='D', array=numpy.random.standard_normal(self.nObjs))) for filter in self.filters: flux = numpy.ones(self.nObjs) flux[-10:self.nObjs] = measure_unstacked_photometry.__bad_flux__ cols.append( pyfits.Column(name='FLUX_ISO-%s' % filter, format='E', array=flux)) cols.append( pyfits.Column(name='FLUXERR_ISO-%s' % filter, format='E', array=flux)) cols.append( pyfits.Column(name='FLUX_ISO-SUBARU-10_1-1', format='E', array=numpy.random.uniform(0, 500, self.nObjs))) cols.append( pyfits.Column(name='FLUXERR_ISO-SUBARU-10_1-1', format='E', array=numpy.random.uniform(0, 500, self.nObjs))) cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) calibrated, zps = photoCalibrateCat(cat, cluster=self.cluster, type='standard', photometry_db=fakeCalDB(getZP), getExtinction=None, getDust=None) for filter in self.filters: self.assertTrue( (calibrated['FLUX_ISO-%s' % filter][-10:self.nObjs] == measure_unstacked_photometry.__bad_flux__).all()) self.assertTrue( (calibrated['FLUXERR_ISO-%s' % filter][-10:self.nObjs] == measure_unstacked_photometry.__bad_flux__).all())
def convertToCat(shear, trueshear, snratio, size, pg, rg): cols = [ pyfits.Column(name='g', format='E', array=shear), pyfits.Column(name='true_g', format='E', array=trueshear), pyfits.Column(name='snratio', format='E', array=snratio), pyfits.Column(name='size', format='E', array=size), pyfits.Column(name='pg', format='E', array=pg), pyfits.Column(name='rg', format='E', array=rg) ] cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) return cat
def makeAllPhotCat(self): cols = [] cols.append( pyfits.Column(name='SeqNr', format='J', array=np.arange(1, 501))) alpha = 152.136393 delta = 56.703567 cols.append( pyfits.Column(name='ALPHA_J2000', format='E', array=alpha * np.ones(500))) cols.append( pyfits.Column(name='DELTA_J2000', format='E', array=delta * np.ones(500))) self.target_mag = 25.5 ebv = utilities.getDust([alpha], [delta]) for filter, zp in self.targetZPs.iteritems(): extinction = utilities.getExtinction(filter) raw_mag = (self.target_mag - zp + ebv * extinction) * np.ones(500) raw_flux = 10**(-0.4 * (raw_mag)) fluxerr = 0.002 * raw_flux flux = raw_flux + fluxerr * np.random.standard_normal(500) mags, magerrs = measure_unstacked_photometry.calcMags( flux, fluxerr) cols.append( pyfits.Column(name='MAG_%s-%s' % (self.fluxtype, filter), format='E', array=mags)) cols.append( pyfits.Column(name='MAGERR_%s-%s' % (self.fluxtype, filter), format='E', array=magerrs)) cols.append( pyfits.Column(name='FLUX_%s-%s' % (self.fluxtype, filter), format='E', array=flux)) cols.append( pyfits.Column(name='FLUXERR_%s-%s' % (self.fluxtype, filter), format='E', array=fluxerr)) hdu = pyfits.new_table(pyfits.ColDefs(cols)) hdu.header.update('EXTNAME', 'OBJECTS') hdu.writeto(self.all_phot_file, clobber=True) self.uncalibrated = ldac.LDACCat(hdu)
def testCreateBins_onebin(self): cat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs([pyfits.Column(name = key, format = 'E', array = vals) \ for key, vals in self.catalog.iteritems()]))) cat.hdu.header.update('EXTNAME', 'OBJECTS') bins = createBins(cat, []) self.assertEquals(bins.keys(), [('')]) bincat = bins[('')] self.assertEquals(len(cat), len(bincat)) self.assertEquals(cat.keys(), bincat.keys())
def writeSimCat(self, outfile): cols = [ pyfits.Column(name='r_mpc', format='E', array=self.meanradii), pyfits.Column(name='ghat', format='E', array=self.meanshear), pyfits.Column(name='ghatdistrosigma', format='E', array=np.sqrt(self.varianceshear)), pyfits.Column(name='ndat', format='E', array=self.ndata), pyfits.Column(name='beta_s', format='E', array=self.meanbeta), pyfits.Column(name='beta_s2', format='E', array=self.meanbeta2) ] catalog = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) catalog.hdu.header.update('ZLENS', self.meanzlens) catalog.saveas(outfile, clobber=True)
def testTransferOffsets(self): transferFilters = 'SUBARU-9-2-W-J-V SUBARU-10_1-1-W-J-V MEGAPRIME-0-1-g'.split() transfer_orig_zps = [23.4, 25.3, 22.4] correspondingFilters = {'SUBARU-9-2-W-J-V' : 'SUBARU-10_2-1-W-J-V', 'SUBARU-10_1-1-W-J-V' : 'SUBARU-10_2-1-W-J-V', 'MEGAPRIME-0-1-g' : None} filternames = self.filternames + transferFilters orig_zps = self.orig_zps.tolist() + transfer_orig_zps zplist = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs([pyfits.Column(name = 'filter', format='20A', array = filternames), pyfits.Column(name = 'zeropoints', format='E', array = orig_zps)]))) saveSlrZP(cluster = 'testcluster', offsetFile = self.offsetFile, zplist = zplist, fluxtype = 'iso', myspec = 'custom', photometry_db = self.db) for filter in filternames: correspondingFilter = filter if filter in correspondingFilters: correspondingFilter = correspondingFilters[filter] if correspondingFilter is not None: slrmatch = None for slr in self.db.slr: if correspondingFilter == slr.fitFilter: slrmatch = slr break self.assertTrue(slrmatch is not None) calibmatch = None for calib in self.db.calibrations: if filter == calib.filter: calibmatch = calib break self.assertTrue(calibmatch is not None) self.assertEquals(calibmatch.cluster, 'testcluster') self.assertEquals(calibmatch.filter, filter) self.assertEquals(calibmatch.fluxtype, 'iso') self.assertEquals(calibmatch.myspec, 'custom') self.assertEquals(calibmatch.calibration, slrmatch)
def bootstrapField(cat, size, snratio, galdensity=150, maxradii=4000, id='ID', pixscale=pixscale, ngals=None): #creates bootstrap realizations with galaxies randomly distributed throughout the field. #galdensity is numbers / square arcmin maxRdist = maxradii / np.sqrt(2.) area = 4 * (maxRdist * pixscale / 60)**2 if ngals is None and galdensity is not None: ngals = galdensity * area else: galdensity = float(ngals) / area xs = np.random.uniform(0, maxRdist, ngals) ys = np.random.uniform(0, maxRdist, ngals) dr_pix = np.sqrt(xs**2 + ys**2) bootstrap = np.random.randint(0, len(cat), ngals) ids = cat[id][bootstrap] sizes = size[bootstrap] snratios = snratio[bootstrap] cols = [ pyfits.Column(name='SeqNr', format='J', array=ids), pyfits.Column(name='r_pix', format='E', array=dr_pix), pyfits.Column(name='size', format='E', array=sizes), pyfits.Column(name='snratio', format='E', array=snratios) ] cols = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols))) cols.hdu.header.update('EXTNAME', 'OBJECTS') cols.hdu.header.update('GDENSITY', galdensity) cols.hdu.header.update('CENTERX', 0.) cols.hdu.header.update('CENTERY', 0.) return cols
def testLDACObject(self): self.objectshdu.header.update('EXTNAME', 'LDAC_OBJECTS') newhdulist = convertAper(self.hdulist) seenObjects = False for hdu in newhdulist: if 'EXTNAME' in hdu.header.keys( ) and hdu.header['EXTNAME'] == 'LDAC_OBJECTS': seenObjects = True self.assertTrue( tablesEqual( hdu, convertAperColumns(ldac.LDACCat(self.objectshdu)).hdu)) self.assertTrue(seenObjects)
def convertAperColumns(cat): cols = [] for key in cat.keys(): if len(cat[key].shape) == 2 and containsAper_regex.search(key): cols.extend(convert2DAperColumn(key, cat[key])) else: cols.append(cat.extractColumn(key)) newcat = ldac.LDACCat(pyfits.BinTableHDU.from_columns( pyfits.ColDefs(cols))) newcat.sourcefile = cat.sourcefile return newcat
def testCombineCats_doubleprecision(self): doublekeys = 'ALPHA_J2000 DELTA_J2000'.split() normkeys = 'FLUX_APER FLUXERR_APER'.split() zerokeys = 'MaxVal BackGr'.split() cats = [] for i in xrange(6): cols = [pyfits.Column(name = k, format = 'E', array = numpy.random.standard_normal(30))\ for k in normkeys] for key in zerokeys: cols.append( pyfits.Column(name=key, format='E', array=numpy.zeros(30))) for key in doublekeys: cols.append( pyfits.Column(name=key, format='D', array=numpy.random.standard_normal(30))) cols.append( pyfits.Column(name='IMAFLAGS_ISO', format='D', array=numpy.ones(30))) cats.append(ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols)))) keys = normkeys + zerokeys + doublekeys keys.append('IMAFLAGS_ISO') combinedcat = combineCats(cats, saturation=5) self.assertEquals(cats[0]['ALPHA_J2000'].dtype, combinedcat['ALPHA_J2000'].dtype) self.assertEquals(cats[0]['DELTA_J2000'].dtype, combinedcat['DELTA_J2000'].dtype) self.assertTrue( (abs(cats[0]['ALPHA_J2000'] - combinedcat['ALPHA_J2000']) < 1e-16).all()) self.assertTrue( (abs(cats[0]['DELTA_J2000'] - combinedcat['DELTA_J2000']) < 1e-16).all())
def convertAper(hdulist): newhdus = [pyfits.PrimaryHDU()] for hdu in hdulist: if 'EXTNAME' in hdu.header: if hdu.header['EXTNAME'] == 'OBJECTS' or hdu.header[ 'EXTNAME'] == 'LDAC_OBJECTS': newhdu = convertAperColumns(ldac.LDACCat(hdu)).hdu newhdu.header.update('EXTNAME', hdu.header['EXTNAME']) newhdus.append(newhdu) else: newhdus.append(hdu) return pyfits.HDUList(newhdus)
def readData(self, manager): options = manager.options manager.open('inputcat', options.inputCatFile, ldac.openObjectFile) manager.concentration = manager.inputcat.hdu.header['CONCEN'] manager.zcluster = manager.inputcat.hdu.header['Z'] manager.store('r500', nfwutils.rdelta, manager.inputcat.hdu.header['R_S'], manager.concentration, 500) bpz = ldac.openObjectFile(options.inputBPZ, 'STDTAB') if bpz is None: bpz = ldac.openObjectFile(options.inputBPZ, 'COS30PHOTZ') manager.matchedBPZ = bpz.matchById(manager.inputcat, 'z_id') bpz = manager.matchedBPZ newcols = [ pyfits.Column(name='z_b', format='E', array=bpz['BPZ_Z_B']), pyfits.Column(name='odds', format='E', array=bpz['BPZ_ODDS']), pyfits.Column(name='z_t', format='E', array=bpz['BPZ_T_B']) ] inputcat = ldac.LDACCat( pyfits.new_table( pyfits.ColDefs(newcols) + manager.inputcat.hdu.columns)) manager.replace('inputcat', inputcat) manager.open('pdzmanager', options.inputPDZ, pdzfile_utils.PDZManager.open) pdzrange, associatedPDZs = manager.pdzmanager.associatePDZ( manager.inputcat['z_id']) pdzrange = pdzrange.astype(np.float64) associatedPDZs = associatedPDZs.astype(np.float64) manager.pdzrange = pdzrange manager.pdz = associatedPDZs manager.replace('pdzmanager', None)
def testConvertColumns_SplitAper(self): newcat = convertAperColumns(ldac.LDACCat(self.objectshdu)) headerkeys = newcat.keys() for col in self.block_one_cols: root, sep, filter = col.partition('-') for i in xrange(self.napers): if filter == '': colname = '%s%d' % (root, i) else: colname = '%s%d-%s' % (root, i, filter) self.assertTrue(colname in headerkeys) self.assertEquals(len(newcat[colname].shape), 1) self.assertTrue((newcat[colname] == i + 1).all())