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