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 photoCalibrateCat(cat,
cluster,
type='standard',
specification={},
getExtinction=__get_extinction_default__,
getDust=__get_dust_default__,
photometry_db=__default_photometry_db__):
flux_keys, fluxerr_keys, magonlykeys, other_keys = utilities.sortFluxKeys(
cat.keys())
cols = []
for key in other_keys:
if not (re.match('^MAG_', key) or re.match('^MAGERR_', key)):
cols.append(cat.extractColumn(key))
ebv = None
if 'ebv' in cat:
ebv = cat['ebv']
else:
if getDust:
ebv = getDust(cat['ALPHA_J2000'], cat['DELTA_J2000'])
cols.append(pyfits.Column(name='ebv', format='E', array=ebv))
zp_list = []
zperr_list = []
filters = []
for fluxkey in flux_keys:
filter = extractFilter(fluxkey)
if _is2Darray(cat[fluxkey]) or _isNotValidFilter(filter):
continue
print 'Processing %s' % fluxkey
fluxtype = extractFluxType(fluxkey)
fluxerr_key = 'FLUXERR_%s-%s' % (fluxtype, filter)
mag_key = 'MAG_%s-%s' % (fluxtype, filter)
magerr_key = 'MAGERR_%s-%s' % (fluxtype, filter)
flux = cat[fluxkey]
err = cat[fluxerr_key]
flux, err, zp, zperr = applyZeropoint(cluster,
filter,
flux,
fluxtype,
err,
type,
cat,
photometry_db=photometry_db,
specification=specification)
print 'Found zp = %3.2f +/- %1.4f' % (zp, zperr)
filters.append(fluxkey)
zp_list.append(zp)
zperr_list.append(zperr)
if ebv is not None and getDust is not None:
flux, err = applyDust(filter, flux, err, ebv, getExtinction)
mag, magerr = measure_unstacked_photometry.calcMags(flux, err)
cols.append(pyfits.Column(name=fluxkey, format='E', array=flux))
cols.append(pyfits.Column(name=fluxerr_key, format='E', array=err))
cols.append(pyfits.Column(name=mag_key, format='E', array=mag))
cols.append(pyfits.Column(name=magerr_key, format='E', array=magerr))
for magkey in magonlykeys:
magtype = extractMagType(magkey)
filter = extractMagFilter(magkey)
if _isNotValidFilter(filter):
continue
print 'Processing %s' % magkey
magerr_key = 'MAGERR_%s-%s' % (magtype, filter)
calibration = photometry_db.getZeropoint(cluster,
filter=filter,
**specification)
if calibration is None:
zp = 0
zperr = 0
else:
zp = calibration.zp - _getSourceExtractorZP(cat)
zperr = calibration.zperr
print 'Found zp = %3.2f +/- %1.4f' % (zp, zperr)
dustCorrection = 0.
if getExtinction:
extinction = getExtinction(filter)
dustCorrection = -extinction * ebv
newmag = cat[magkey] + zp + dustCorrection
cols.append(pyfits.Column(name=magkey, format='E', array=newmag))
calibratedCat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols)))
if cat.hdu.header.has_key('EXTNAME'):
calibratedCat.hdu.header.update('EXTNAME', cat.hdu.header['EXTNAME'])
''' now make table with zeropoints used to calibrate catalog '''
zp_cols = [
pyfits.Column(name='filter', format='60A', array=filters),
pyfits.Column(name='zeropoints',
format='E',
array=numpy.array(zp_list)),
pyfits.Column(name='errors', format='E', array=numpy.array(zperr_list))
]
zpCat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(zp_cols)))
zpCat.hdu.header.update('EXTNAME', 'ZPS')
return calibratedCat, zpCat
def applyCorrection(cluster, lensingfilter, activefilter=None):
clusterdir = '%s/%s' % (subarudir, cluster)
photdir = '%s/PHOTOMETRY_%s_aper' % (clusterdir, lensingfilter)
lensingcoadddir = '%s/%s/SCIENCE/coadd_%s_all' % (clusterdir,
lensingfilter, cluster)
coaddfile = '%s/coadd.fits' % lensingcoadddir
photcat = ldac.openObjectFile('%s/%s.slr.cat' % (photdir, cluster))
if activefilter is None:
filters = dcf.dumpFilters(photcat)
masterfilters = uniqueMasterFilters(filters)
else:
masterfilters = [activefilter]
for filter in masterfilters:
catdir = '%s/%s/unstacked' % (photdir, filter)
filtercoadddir = '%s/%s/SCIENCE/coadd_%s_all' % (clusterdir, filter,
cluster)
exposurecats = glob.glob('%s/*.filtered.cat' % (catdir))
localargs = copy.copy(swarpargs)
localargs['RESAMPLE_SUFFIX'] = "%s_all.resamp.fits" % cluster
localargs['RESAMPLE_DIR'] = filtercoadddir
for catfile in exposurecats:
base = os.path.basename(catfile)
exposure = base.split('.')[0]
inputfiles = glob.glob('%s/%s_*.sub.fits' \
% (filtercoadddir, exposure))
print len(inputfiles)
if len(inputfiles) == 0:
print "Skipping %s" % exposure
continue
cat = ldac.openObjectFile(catfile)
posdat = np.column_stack([cat['ALPHA_J2000'], cat['DELTA_J2000']])
fluxscale = cts.calcTransformScaling(coaddfile, inputfiles,
swarpconfig, swarpargs,
posdat)
badfluxes = fluxscale < -9998
flux_keys, fluxerr_keys, magonlykeys, other_keys = utilities.sortFluxKeys(
cat.keys())
cols = [
pyfits.Column(name='fluxscale', format='E', array=fluxscale)
]
for key in other_keys:
if not (re.match('^MAG_', key) or re.match('^MAGERR_', key)):
cols.append(cat.extractColumn(key))
for fluxkey in flux_keys:
fluxtype = utilities.extractFluxType(fluxkey)
fluxerr_key = 'FLUXERR_%s' % fluxtype
mag_key = 'MAG_%s' % fluxtype
magerr_key = 'MAGERR_%s' % fluxtype
if len(cat[fluxkey].shape) == 1:
flux = cat[fluxkey] * fluxscale
fluxerr = cat[fluxerr_key] * fluxscale
flux[badfluxes] = mup.__bad_flux__
fluxerr[badfluxes] = mup.__bad_flux__
arraysize = 'E'
else:
flux = np.zeros_like(cat[fluxkey])
fluxerr = np.zeros_like(cat[fluxerr_key])
for i in range(flux.shape[1]):
flux[:, i] = cat[fluxkey][:, i] * fluxscale
fluxerr[:, i] = cat[fluxerr_key][:, i] * fluxscale
flux[:, i][badfluxes] = mup.__bad_flux__
fluxerr[:, i][badfluxes] = mup.__bad_flux__
arraysize = '%dE' % flux.shape[1]
mag, magerr = mup.calcMags(flux, fluxerr)
cols.append(
pyfits.Column(name=fluxkey, format=arraysize, array=flux))
cols.append(
pyfits.Column(name=fluxerr_key,
format=arraysize,
array=fluxerr))
cols.append(
pyfits.Column(name=mag_key, format=arraysize, array=mag))
cols.append(
pyfits.Column(name=magerr_key,
format=arraysize,
array=magerr))
for magkey in magonlykeys:
magtype = utilities.extractMagType(magkey)
magerr_key = 'MAGERR_%s' % magtype
newmag = cat[magkey] - 2.5 * np.log10(fluxscale)
magerr = cat[magerr_key]
cols.append(
pyfits.Column(name=magkey, format='E', array=newmag))
cols.append(
pyfits.Column(name=magerr_key, format='E', array=magerr))
correctedCat = ldac.LDACCat(pyfits.new_table(pyfits.ColDefs(cols)))
hdus = [pyfits.PrimaryHDU(), correctedCat.hdu]
hdus.extend(pcc._transferOtherHDUs(catfile))
hdulist = pyfits.HDUList(hdus)
print '%s/%s.corrected.cat' % (catdir, base)
hdulist.writeto('%s/%s.corrected.cat' % (catdir, base),
clobber=True)
def makeStarCats(self):
### star catalogs
seqnr = np.arange(501, 601)
pickles = ldac.openObjectFile('Pickles.cat', 'PICKLES')
pickles_sdss = ldac.openObjectFile('Pickles.cat', 'SDSS')
sample = np.random.randint(0, len(pickles), len(seqnr))
filter_cols = {}
for filter, zp in self.targetZPs.iteritems():
if filter == 'SUBARU-COADD-1-W-J-V':
raw_mag = pickles['SUBARU-10_2-1-W-J-V'][sample]
else:
raw_mag = pickles[filter][sample]
raw_flux = 10**(-0.4 * (raw_mag - zp))
fluxerr = 0.002 * raw_flux
flux = raw_flux + fluxerr * np.random.standard_normal(len(sample))
mags, magerrs = measure_unstacked_photometry.calcMags(
flux, fluxerr)
filter_cols[filter] = [mags, magerrs, flux, fluxerr]
### star cat
cols = []
cols.append(pyfits.Column(name='SeqNr', format='J', array=seqnr))
cols.append(
pyfits.Column(name='ALPHA_J2000',
format='E',
array=152.136393 * np.ones_like(seqnr)))
cols.append(
pyfits.Column(name='DELTA_J2000',
format='E',
array=56.703567 * np.ones_like(seqnr)))
for filter, (mags, magerrs, fluxs,
fluxerrs) in filter_cols.iteritems():
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=fluxs))
cols.append(
pyfits.Column(name='FLUXERR_%s-%s' % (self.fluxtype, filter),
format='E',
array=fluxerrs))
hdu = pyfits.new_table(pyfits.ColDefs(cols))
hdu.header.update('EXTNAME', 'OBJECTS')
hdu.writeto(self.star_cat_file, clobber=True)
### matched catalog
cols = []
cols.append(pyfits.Column(name='SeqNr', format='J', array=seqnr))
for filter, (mags, magerrs, fluxs,
fluxerrs) in filter_cols.iteritems():
cols.append(
pyfits.Column(name='SEx_MAG_%s-%s' % (self.fluxtype, filter),
format='E',
array=mags))
cols.append(
pyfits.Column(name='SEx_MAGERR_%s-%s' %
(self.fluxtype, filter),
format='E',
array=magerrs))
cols.append(
pyfits.Column(name='SEx_FLUX_%s-%s' % (self.fluxtype, filter),
format='E',
array=fluxs))
cols.append(
pyfits.Column(name='SEx_FLUXERR_%s-%s' %
(self.fluxtype, filter),
format='E',
array=fluxerrs))
cols.append(
pyfits.Column(name='Clean', format='J',
array=np.zeros_like(seqnr)))
cols.append(
pyfits.Column(name='SEx_BackGr',
format='E',
array=np.ones_like(seqnr)))
cols.append(
pyfits.Column(name='SEx_MaxVal',
format='E',
array=np.ones_like(seqnr)))
cols.append(
pyfits.Column(name='SEx_Flag',
format='J',
array=np.zeros_like(seqnr)))
cols.append(
pyfits.Column(name='SEx_Xpos',
format='E',
array=np.random.uniform(0, 5000, len(seqnr))))
cols.append(
pyfits.Column(name='SEx_Ypos',
format='E',
array=np.random.uniform(0, 5000, len(seqnr))))
for sdss in 'u g r i z'.split():
cols.append(
pyfits.Column(name='%smag' % sdss,
format='E',
array=pickles_sdss['%sp' % sdss][sample]))
cols.append(
pyfits.Column(name='%serr' % sdss,
format='E',
array=0.2 * pickles_sdss['%sp' % sdss][sample]))
for color in 'umg gmr rmi imz'.split():
f1, f2 = color.split('m')
cols.append(
pyfits.Column(name=color,
format='E',
array=pickles_sdss['%sp' % f1][sample] -
pickles_sdss['%sp' % f2][sample]))
cols.append(
pyfits.Column(name='%serr' % color,
format='E',
array=0.2 * np.ones_like(seqnr)))
hdu = pyfits.new_table(pyfits.ColDefs(cols))
hdu.header.update('EXTNAME', 'PSSC')
hdu.writeto(self.matched_catalog_file, clobber=True)