def MXXLmultibinresidualoverplot(binbase, fig = None):
setMXXL()
if fig is None:
matplotlib.rcParams['figure.figsize'] = [16,8]
fig = pylab.figure()
curplot = 5
for curc in range(4):
pylab.subplot(2,4,curplot)
colori = 0
for curm in range(2):
try:
mass, concen = readtxtfile.readtxtfile('%s_%d_%d.dat' % (binbase, curm, curc))[0]
cat = ldac.openObjectFile('%s_%d_%d.cat' % (binbase, curm, curc))
zlens = cat.hdu.header['ZLENS']
rscale = nfwutils.rscaleConstM(mass/nfwutils.global_cosmology.h, concen, zlens, 200)
gamma = nfwmodeltools.NFWShear(cat['r_mpc'], concen, rscale, zlens)
kappa = nfwmodeltools.NFWKappa(cat['r_mpc'], concen, rscale, zlens)
gpred = cat['beta_s']*gamma / (1 - (cat['beta_s2']*kappa/cat['beta_s']))
pylab.errorbar(cat['r_mpc']*nfwutils.global_cosmology.h, cat['ghat'], cat['ghatdistrosigma']/(np.sqrt(cat['ndat'])),
linestyle='None', marker='o', color=c[colori], label='M=%1.1fx10^14' % (mass/1e14))
pylab.plot(cat['r_mpc']*nfwutils.global_cosmology.h, gpred, 'k-', linewidth=2)
ax = pylab.gca()
ax.set_xscale('log')
pylab.axhline(0.0, c='k', linewidth=2)
pylab.axis([0.05, 10, -0.03, 0.4])
except:
pass
colori+= 1
pylab.title('C=%1.1f' % (concen))
curplot += 1
for i in range(4):
pylab.subplot(2,4,4+i+1)
pylab.xlabel('Radius [Mpc/h]')
pylab.text(0.1, 0.03, 'MXXL')
pylab.minorticks_on()
pylab.subplot(2,4,5)
pylab.ylabel('<g_m/g_p-1>')
pylab.subplot(2,4,8)
pylab.legend(loc='upper right')
pylab.tight_layout()
pylab.savefig('%s_shearstack.png' % binbase)
return fig
def _getSourceExtractorZP(cat):
return ldac.openObjectFile(cat.sourcefile, 'FIELDS')['SEXMGZPT'][0]
def colorCutBias():
fig = pylab.figure()
xmarg = 0.12
ymarg = 0.12
ax = pylab.axes([xmarg, ymarg, 0.95 - xmarg, 0.95 - ymarg])
cosmos = ldac.openObjectFile(
'/u/ki/dapple/nfs12/cosmos/simulations/publication/highsn/APER/bpz.cat',
'STDTAB')
zclusters = np.arange(0.2, 0.8, 0.05)
beta_true = np.array([np.mean(nfwutils.beta_s(cosmos['BPZ_Z_S'], z)) \
for z in zclusters])
beta_measure = np.array([np.mean(nfwutils.beta_s(cosmos['BPZ_Z_B'], z)) \
for z in zclusters])
pylab.plot(zclusters,
beta_measure / beta_true,
'b-',
label='Limited Filters',
linewidth=1.25)
bpz = ldac.openObjectFile(
'/u/ki/dapple/orange/cats_2011-09-08/MACS0018+16.W-J-V.bpz.tab',
'STDTAB')
night1 = ldac.openObjectFile(
'/u/ki/dapple/orange/cats_2011-09-08/MACS0018+16.W-J-V.gabodsid1728.cut_lensing.cat'
)
night2 = ldac.openObjectFile(
'/u/ki/dapple/orange/cats_2011-09-08/MACS0018+16.W-J-V.gabodsid1729.cut_lensing.cat'
)
bpz1 = bpz.matchById(night1)
bpz2 = bpz.matchById(night2)
aveBeta1 = np.array([np.mean(nfwutils.beta_s(bpz1['BPZ_Z_B'], x)) \
for x in zclusters])
aveBeta2 = np.array([np.mean(nfwutils.beta_s(bpz2['BPZ_Z_B'], x)) \
for x in zclusters])
pylab.plot(zclusters,
aveBeta2 / aveBeta1,
'r-',
label='Different Seeing',
linewidth=1.25)
rhcut = night1['rh'] > np.min(night2['rh'])
bpz1a = bpz1.filter(rhcut)
aveBeta1a = np.array([np.mean(nfwutils.beta_s(bpz1a['BPZ_Z_B'], x)) \
for x in zclusters])
pylab.plot(zclusters, aveBeta2 / aveBeta1a, 'r-.', linewidth=1.25)
pylab.axhline(1.0, c='k', linewidth=1.5)
pylab.grid()
pylab.axis([0.15, 0.85, 0.95, 1.24])
pylab.xlabel('Cluster Redshift')
pylab.ylabel(r'$<\beta_{measured}> / <\beta_{true}>$')
pylab.legend(loc='best')
return fig
class ExtractScalarKey():
def __init__(self, key):
self.key = key
def __call__(self, cat, index):
return cat[self.key][index]
class ExtractVectorKey():
def __init__(self, key, pos):
self.key = key
self.pos = pos
def __call__(self, cat, index):
return cat[self.key][index, self.pos]
extractKeys = []
positionArgCheck = re.compile('(.+?):(\d+)')
for key in keys:
match = positionArgCheck.match(key)
if match is None:
extractKeys.append(ExtractScalarKey(key))
else:
actualkey = match.group(1)
pos = int(match.group(2))
extractKeys.append(ExtractVectorKey(actualkey, pos))
cat = ldac.openObjectFile(options.infile, options.table)
for index in xrange(len(cat)):
output = [ '%f' % key(cat, index) for key in extractKeys ]
print ' '.join(output)
#####################
import sys, glob
import pymc, numpy as np
import shapedistro, shapedistro_residuals as sdr, ldac
#####################
trainingfile = sys.argv[1]
testingfile = sys.argv[2]
resfile = sys.argv[3]
modelname = sys.argv[4]
burn = int(sys.argv[5])
outfile = sys.argv[6]
training_cat = ldac.openObjectFile(trainingfile)
testing_cat = ldac.openObjectFile(testingfile)
shapemodel = getattr(shapedistro, modelname)
mcmc = sdr.loadResult(training_cat, resfile, shapemodel)
postpred_dist = mcmc.trace('postpred_g')[burn:]
logp = sdr.calcPostPredLogProb(testing_cat, mcmc.unique_g_true, postpred_dist)
output = open(outfile, 'w')
output.write('%f\n' % logp)
output.close()
def main(flinput, flzps, flnew):
try:
filt_zp_err = getZP(flzps)
catinput = ldac.openObjectFile(flinput)
flproto = flinput.replace(".cat", ".proto-tmp.cat")
mag_aper1_keys = filt_zp_err.keys()
other_keys_del = [] #this will get built up in the loop
ncs = []
zp_tab_cols = []
for mag_key in mag_aper1_keys:
zp, err_zp = filt_zp_err[mag_key]
col_zp = pyfits.Column(name='ZP_' + mag_key,
format='E',
array=numpy.array([zp]))
col_err_zp = pyfits.Column(name='ZPERR_' + mag_key,
format='E',
array=numpy.array([err_zp]))
zp_tab_cols.append(col_zp)
zp_tab_cols.append(col_err_zp)
## add zp,err_zp to image headers and get background/background_rms for this filter
filt = mag_key[mag_key.find('W-'):]
directory = '/'.join([
os.environ['SUBARUDIR'], os.environ['cluster'], filt,
'SCIENCE', 'coadd_*'
])
dirs = glob.glob(directory)
for dir in dirs:
if not os.path.isfile(dir + "/coadd.fits"):
raise Exception("there is no file: " + dir + "/coadd.fits")
header_key_add.add_key_val(dir + "/coadd.fits",
['ZP_BM', 'ZPERR_BM'], [zp, err_zp])
##adam-old get background_rms for this filter
##flcatcoadd='/'.join([os.environ['SUBARUDIR'],os.environ['cluster'],filt,'SCIENCE','coadd_'+os.environ['cluster']+'_all','coadd.stars.cat'])
##catcoadd=ldac.openObjectFile(flcatcoadd,"FIELDS")
##back_level=catcoadd["SEXBKGND"][0]
##back_rms=catcoadd["SEXBKDEV"][0]
## calibrate the catalog and conform to bpz input cat setup
#adam# now that I've determined how to distinguish sextractor non-detections and non-observations, apply that here
#adam# main thing I'd like to do is make MAGERR/FLUXERR, where MAG_APER1-*==-99 acceptable to bpz
#adam# My Hypthesis Confirmed by: ds9e ~/data/MACS1226+21/W-J-V/SCIENCE/coadd_MACS1226+21_all/coadd.fits & #load in ~/bonnpipeline/influx_m99_W-J-V.tsv
## calibrate and fix MAG_APER1- and FLUX_APER1-
flux_key = mag_key.replace("MAG_APER1", "FLUX_APER1")
magerr_key = mag_key.replace("MAG", "MAGERR")
fluxerr_key = flux_key.replace("FLUX", "FLUXERR")
m = catinput[mag_key].copy()
if not m.ndim == 1:
raise Exception(
"this column doesn't seem to need to be split (shape is " +
str(inmag.shape) +
"), but it has APER- in the name. Thats weird and contradictory"
)
f = catinput[flux_key].copy()
em = catinput[magerr_key].copy()
ef = catinput[fluxerr_key].copy()
#mask=f<=0 ## m==-99 ## (mask==nondetected+nonobserved)=True
nondetected = (f <= 0.) * (ef > 0
) #Flux <=0, meaningful phot. error
nonobserved = (ef <= 0.) #Negative errors
frac_zp = 10**(-.4 * zp)
flux_newcol = f * frac_zp #((f==-99)==nonobserved).all()=True
flux_newcol[nonobserved] = -99
eflux_newcol = numpy.where(nonobserved, ef, ef * frac_zp)
# using mag=-2.5*numpy.log10(flux) after calibrating flux even though m+zp gives the same thing, because I should just use fluxes always since magnitudes cannot be trusted!
mag_newcol = -2.5 * numpy.log10(flux_newcol) #=m+zp
mag_newcol[nonobserved + nondetected] = -99
f_bpz = flux_newcol.copy()
ef_bpz = eflux_newcol.copy()
f_bpz[nonobserved + nondetected] = 0
ef_bpz[nonobserved] = 0
#m_bpz=mag_newcol.copy()
#em_bpz=em.copy()
#m_bpz[nonobserved+nondetected]=0
#em_bpz[nonobserved]=0
## Calculate NFILT
detected = numpy.logical_not(nondetected + nonobserved)
if len(ncs) == 0:
NFILT = numpy.zeros(detected.shape, dtype=numpy.float32)
NFILT += numpy.array(detected, dtype=numpy.float32)
## check how the data looks
print '\n%s\n## detected: %i ## nondetected: %i ## nonobserved: %i ## ' % (
filt, detected.sum(), nondetected.sum(), nonobserved.sum())
print mag_key, ' min,mean,max : ', mag_newcol[detected].min(
), mag_newcol[detected].mean(), mag_newcol[detected].max()
print flux_key, ' min,mean,max : ', flux_newcol[detected].min(
), flux_newcol[detected].mean(), flux_newcol[detected].max()
print magerr_key, ' min,mean,max : ', em[detected].min(
), em[detected].mean(), em[detected].max()
print fluxerr_key, ' min,mean,max : ', ef[detected].min(
), ef[detected].mean(), ef[detected].max()
ncs.append(
pyfits.Column(name=mag_key, format='1E', array=mag_newcol))
ncs.append(
pyfits.Column(name=flux_key, format='1E', array=flux_newcol))
ncs.append(
pyfits.Column(name=fluxerr_key,
format='1E',
array=eflux_newcol))
ncs.append(
pyfits.Column(name=flux_key + "_bpz", format='1E',
array=f_bpz))
ncs.append(
pyfits.Column(name=fluxerr_key + "_bpz",
format='1E',
array=ef_bpz))
## no longer needed: fluxerr_newcol magerr_newcol
other_keys_del += [
mag_key.replace("APER1-", "APER-"),
flux_key.replace("APER1-", "APER-"),
magerr_key.replace("APER1-", "APER-"),
fluxerr_key.replace("APER1-", "APER-")
]
print "\nNFILT=", NFILT, "\n"
### adam-old
##inmag=catinput[mag_key].copy()
##influx=catinput[flux_key].copy()
##magerr_newcol=catinput[magerr_key].copy()
##fluxerr_newcol=catinput[fluxerr_key].copy()
##mask=inmag==-99
##mag_newcol=inmag+zp
##non_obs=influx==-99
##non_det=(influx<0)*logical_not(non_obs)
##mag_newcol[non_det]=99
##mag_newcol[non_obs]=-99
##flux_newcol=10.0**(-.4*mag_newcol)# make FLUX_APER1- agree with MAG_APER1-
##flux_newcol[mask]=0 # all(mask==logical_or(non_det,non_obs)) = True
### calibrate and fix FLUXERR_APER1- and MAGERR_APER1-
##fluxerr_newcol[non_det]=back_rms*10**(-.4*zp) #since flux is background subtracted, 1sigma det lim = back_rms
##magerr_newcol[non_det]=-2.5*log10(back_rms)+zp #since flux is background subtracted, 1sigma det mag lim = -2.5*log10(back_rms)
##fluxerr_newcol[non_obs]=0
##magerr_newcol[non_obs]=0
##ncs.append(pyfits.Column(name=magerr_key,format='1E',array=magerr_newcol))
##ncs.append(pyfits.Column(name=fluxerr_key,format='1E',array=fluxerr_newcol))
### print out some of the details here:
##unmasked=logical_not(mask)
##print "\n"+filt+" background RMS=",back_rms," mag of 1sigma det lim =",-2.5*log10(back_rms)+zp
## now add NFILT to ncs and save flproto
ncs.append(
pyfits.Column(name='NFILT',
format='1J',
array=numpy.array(NFILT, dtype=numpy.int32)))
hdu = pyfits.PrimaryHDU()
hduSTDTAB = pyfits.BinTableHDU.from_columns(ncs)
hduZPSTAB = pyfits.BinTableHDU.from_columns(zp_tab_cols)
hdulist = pyfits.HDUList([hdu, hduSTDTAB, hduZPSTAB])
hdulist[1].header['EXTNAME'] = 'OBJECTS'
hdulist[2].header['EXTNAME'] = 'BIGMACS'
print "\n...temporarily saving to flproto=", flproto
hdulist.writeto(flproto, clobber=True)
## make a version of flinput with the keys in flproto deleted so that it doesn't give an error in the ldacjoinkey command
## ALSO remove MAG_APER-/FLUX_APER-/MAGERR_APER-/FLUXERR_APER- so I don't confuse it for MAG_APER1-/... later
keys_del = [
col.name for col in ncs
if not col.name.endswith("_bpz") and not col.name == "NFILT"
] + other_keys_del
flinput2cp = flinput.replace(".cat", ".input-tmp.cat")
ooo = os.system("ldacdelkey -i " + flinput + " -o " + flinput2cp +
" -k " + ' '.join(keys_del))
if ooo != 0:
raise Exception("the line os.system(ldacdelkey...) failed")
flnew2cp = flnew.replace(".cat", ".new-tmp.cat")
keys_add = [col.name for col in ncs]
print "\nnow running: ldacjoinkey -p " + flproto + " -i " + flinput2cp + " -o " + flnew2cp + " -t OBJECTS -k " + ' '.join(
keys_add)
ooo = os.system("ldacjoinkey -p " + flproto + " -i " + flinput2cp +
" -o " + flnew2cp + " -t OBJECTS -k " +
' '.join(keys_add))
if ooo != 0:
raise Exception("the line os.system(" + "ldacjoinkey -p " +
flproto + " -i " + flinput2cp + " -o " + flnew2cp +
" -t OBJECTS -k " + " ".join(keys_add) +
") failed")
## OK, now make the zps table and add it to the cat. example from photocalibrate_cat.py below
#adam-new# new table with ZPs
str_addtab = "ldacaddtab -i " + flnew2cp + " -o " + flnew + " -p " + flproto + " -t BIGMACS"
print "\nnow running: " + str_addtab
ooo = os.system(str_addtab)
if ooo != 0:
raise Exception("the line os.system(" + str_addtab + ") failed")
print "\nsaving to " + flnew
os.system("rm -f " + flproto)
os.system("rm -f " + flinput2cp)
os.system("rm -f " + flnew2cp)
ns.update(locals())
return
except:
ns.update(locals())
raise
import os, cPickle
import pdzfile_utils as pdzutils, nfwutils
#########################
inputCatFile = sys.argv[1]
bpzfile = sys.argv[2]
pdzfile = sys.argv[3]
nBootstraps = int(sys.argv[4])
msigma = float(sys.argv[5])
bpzcut = float(sys.argv[6])
outputFile = sys.argv[7]
##########################
inputcat = ldac.openObjectFile(inputCatFile)
concentration = inputcat.hdu.header['CONCEN']
zcluster = inputcat.hdu.header['Z']
true_scale_radius = inputcat.hdu.header['R_S']
bpz = ldac.openObjectFile(bpzfile, 'STDTAB').matchById(inputcat, 'z_id')
pdzmanager = pdzutils.PDZManager.open(pdzfile)
pdzrange, pdzs = pdzmanager.associatePDZ(inputcat['z_id'])
foregroundprob = pdzs.cumsum(axis=-1).T[pdzrange <= zcluster][-1]
goodObjs = np.logical_and(
bpz['BPZ_ODDS'] > bpzcut,
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)
###################################
parser = OptionParser(usage='dump_cat_filters.py <-a> cat')
parser.add_option('-a', '--apers',
help='Append aperture numbers to filter names',
dest='appendAppers',
action='store_true',
default=False)
options, args = parser.parse_args()
if len(args) != 1:
parser.error('Specify catalog file!')
catfile = args[0]
cat = ldac.openObjectFile(catfile,"PICKLES")
flux_keys, fluxerr_keys, other_keys = utilities.sortFluxKeys(cat.keys())
for fluxkey in flux_keys:
filter = extractFilter(fluxkey)
if _isNotValidFilter(filter):
continue
if options.appendAppers:
nApers = cat[fluxkey].shape[1]
for i in xrange(nApers):
print '%s_A%d' % (filter, i)
else:
#catfile= os.environ['subdir'] + '/' + cluster + '/ACS/merged_photz.cat'
center = map(float, "5000,5000".split(','))
pixscale = float(0.2) # arcsec / pix
command = 'ldacfilter -i ' + catfile + " -c '(e1_acs > 0.0 AND BPZ_ODDS > 0.95);' -t OBJECTS -o " + catfile + '.tmp'
os.system('rm ' + catfile + '.tmp')
print command
os.system(command)
command = 'ldacfilter -i ' + catfile + " -c '(e1_acs > 0.0);' -t OBJECTS -o " + catfile + '.tmp'
#os.system('rm ' + catfile + '.tmp')
print command
#os.system(command)
print catfile
catalog = ldac.openObjectFile(catfile + '.tmp', table='PSSC')
r, E = sp.calcTangentialShear(catalog,
center,
pixscale,
g1col='e1_acs',
g2col='e2_acs')
beta = sp.beta(catalog["BPZ_Z_B"], clusterz)
import scipy
kappacut = scipy.array(
[False] * len(beta),
dtype=bool) #sp.calcWLViolationCut(r, beta, sigma_v = 1300)
for i in range(len(r)):
if 100 < r[i]:
kappacut[i] = True
match = _magsplit.match(magkey)
if match is None:
raise FluxKeyException('Cannot parse magkey: %s' % magkey)
suffix = match.group(1)
return suffix
#########################################
outfile = sys.argv[1]
instrument = sys.argv[2]
coaddcatfile = sys.argv[3]
inputcatfiles = sys.argv[4:]
coaddcat = ldac.openObjectFile(coaddcatfile)
fluxkeys, fluxerrkeys, magonlykeys, otherkeys = _sortFluxKeys(coaddcat.keys())
cols = [_extractColumn(coaddcat, key) for key in otherkeys]
cols = []
for key in otherkeys:
format = filter(lambda x: x.name == key, coaddcat.hdu.columns)[0].format
cols.append(
pyfits.Column(name='%s-%s' % (key, instrument),
format=format,
array=coaddcat[key]))
for flux_key in fluxkeys:
#!/usr/bin/env python
import ldac, dappleutils, sys, os, pyfits
filteredIDs = dappleutils.readtxtfile(sys.argv[1])
filteredIDcat = ldac.LDACCat(
pyfits.new_table(
pyfits.ColDefs(
[pyfits.Column(name='SeqNr', format='J', array=filteredIDs[:,
0])])))
fullCat = ldac.openObjectFile(sys.argv[2])
filteredCat = dappleutils.matchById(filteredIDcat, fullCat)
base, ext = os.path.splitext(sys.argv[2])
outputname = '%s.filtered%s' % (base, ext)
filteredCat.saveas(outputname, clobber=True)
# sys.exit(1)
'python fit_PAT2.py MACS0018+16 0.5 "5000,5000" 0.2'
#cluster = sys.argv[1]
catfile = os.environ[
'subdir'] + '/' + cluster + '/LENSING/' + cluster + '_fbg.cat'
center = map(float, "5000,5000".split(','))
pixscale = float(0.2) # arcsec / pix
command = 'ldacfilter -i ' + catfile + " -c '(rg > 2.0);' -t OBJECTS -o " + catfile + '.tmp'
os.system('rm ' + catfile + '.tmp')
print command
os.system(command)
catalog = ldac.openObjectFile(catfile + '.tmp')
print catfile
r, E = sp.calcTangentialShear(catalog, center, pixscale)
beta = sp.beta(catalog["Z_BEST"], clusterz, calcAverage=False)
import scipy
kappacut = scipy.array(
[False] * len(beta),
dtype=bool) #sp.calcWLViolationCut(r, beta, sigma_v = 1300)
for i in range(len(r)):
if 100 < r[i]: # < 200:
kappacut[i] = 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)
redshift = os.popen("grep %s %s/clusters.redshifts | awk '{print $2}'" %
(cluster, subarudir)).read()
redshift = float(redshift.strip())
sigma_v = os.popen(
"cat %(subaru)s/%(cluster)s/LENSING/%(cluster)s_fbg_sisfit.ml.dat | awk '{print $2}'"
% {
'subaru': subarudir,
'cluster': cluster
}).read()
sigma_v = float(sigma_v.strip())
print sigma_v
X = pi / (3600 * 180) #convert arcseconds to radians
back_cat = ldac.openObjectFile(back_catfile)
minZ = min(back_cat['Z_BEST'])
maxZ = max(back_cat['Z_BEST'])
zstep = float(maxZ - minZ) / back_bins
for curbin in xrange(back_bins):
z_low = minZ + curbin * zstep
z_high = z_low + zstep
inBin = numpy.logical_and(back_cat['Z_BEST'] >= z_low,
back_cat['Z_BEST'] < z_high)
curGals = back_cat.filter(inBin)
#!/usr/bin/env python
#######################
# script to automate making sims from COSMOS photoz
########################
import os, sys, cPickle, glob
import ldac, numpy as np
import pdzfile_utils as pdzfile
import cosmos_sim as cs, shearprofile as sp
import nfwutils
#######################
cosmos = ldac.openObjectFile('/u/ki/dapple/nfs12/cosmos/cosmos.cat')
cosmos30 = ldac.openObjectFile('/u/ki/dapple/nfs12/cosmos/cosmos30.cat')
def prepSourceFiles(
photfilters,
outdirbase='/u/ki/dapple/nfs12/cosmos/simulations/publication',
basedir='/nfs/slac/g/ki/ki05/anja/SUBARU/COSMOS_PHOTOZ'):
# transfer in cosmos photo-z's
# parse PDZ file
# save everything to simulation directory
sourcedir = '%s/PHOTOMETRY_W-C-IC_%s' % (basedir, photfilters)
outputdir = '%s/%s' % (outdirbase, photfilters)
if not os.path.exists(outputdir):
os.mkdir(outputdir)
os.environ['subdir'], cluster, True)
filt = filts[0]
lensext = lensexts[0]
catdir = os.environ[
'subdir'] + '/' + cluster + '/LENSING_' + filt + '_' + filt + '_aper/' + lensext + '/' #+ cluster + '_fbg.cat'
catfile = catdir + 'cut_lensing.cat_step'
photdir = os.environ[
'subdir'] + '/' + cluster + '/PHOTOMETRY_' + filt + '_aper/' #+ cluster + '_fbg.cat'
photcat = photdir + cluster + '.APER1.1.CWWSB_capak.list.all.bpz.tab'
print catfile, photcat
photldac = ldac.openObjectFile(photcat, 'STDTAB')
lens = ldac.openObjectFile(catfile, 'OBJECTS')
phot = photldac.matchById(lens)
print phot['SeqNr'], lens['SeqNr']
#matchedCat.saveas(os.environ['bonn'] + 'test.cat')
#command1 = 'ldacaddtab -i %(inputcat) -o /tmp/tmp1000.cat -p
cluster_z = float(sys.argv[2])
center = map(float, sys.argv[3].split(','))
pixscale = float(sys.argv[4]) # arcsec / pix
#catalog= ldac.openObjectFile(catfile)
def processCluster(brightstarfile, refimage, inputcat, outputfile,
outputregionfile):
wcs = pywcs.WCS(pyfits.open(refimage)[0].header)
outputregions = []
if os.path.exists(brightstarfile):
with open(brightstarfile) as input:
for line in input.readlines():
tokens = line.split()
wcs_x = float(tokens[0])
wcs_y = float(tokens[1])
largest_ring = tokens[-1]
pixCoord = wcs.wcs_sky2pix([wcs_x], [wcs_y], 1)
pix_x = pixCoord[0][0]
pix_y = pixCoord[1][0]
if largest_ring in ringsizes:
radii = ringsizes[largest_ring]
else:
radii = ringsizes['4']
outputregions.append(((pix_x, pix_y), radii))
cat = ldac.openObjectFile(inputcat)
objCat = matching.Catalog(cat['Xpos'], cat['Ypos'], cat['SeqNr'])
toMask = {}
for id in cat['SeqNr']:
toMask[id] = False
trie = matching.buildTrie(objCat)
regions = []
for (x, y), rad in outputregions:
matchedObjs = trie.findNeighbors(np.array([x, y]), rad)
for id in matchedObjs:
toMask[id] = True
regions.append(regionfile.Circle(np.array([x, y]), rad))
flagColumn = np.zeros(len(cat))
masked = np.array([toMask[x] for x in cat['SeqNr']])
flagColumn[masked] = 1.
outcat = ldac.LDACCat(
pyfits.new_table(
pyfits.ColDefs([
pyfits.Column(name='SeqNr', format='K', array=cat['SeqNr']),
pyfits.Column(name='InRings', format='K', array=flagColumn)
])))
outcat.saveas(outputfile, clobber=True)
regionfile.writeRegionFile(outputregionfile,
[x.toPolygon() for x in regions],
overwrite=True)
def oldvsnewMags(filter1,
filter2=None,
data=None,
cluster=None,
lensfilter=None,
image=None):
if data is None:
data = {}
if 'oldcat' not in data:
data['cluster'] = cluster
data['lensfilter'] = lensfilter
data['image'] = image
oldcat = ldac.openObjectFile('/u/ki/dapple/subaru/%s/PHOTOMETRY_%s_aper/%s.unstacked.orig.cat' % \
(cluster, lensfilter, cluster))
newcat = ldac.openObjectFile('/u/ki/dapple/subaru/%s/PHOTOMETRY_%s_aper/%s.unstacked.geocor.cat' % \
(cluster, lensfilter, cluster))
starcat = ldac.openObjectFile('/u/ki/dapple/subaru/%s/LENSING_%s_%s_aper/%s/coadd_stars.cat' % \
(cluster, lensfilter, lensfilter, image))
catfilter, starfilter = matchCats(oldcat['Xpos'],
oldcat['Ypos'],
starcat['Xpos'],
starcat['Ypos'],
bound=3600 * 2)
oldcat = oldcat.filter(catfilter)
newcat = newcat.filter(catfilter)
data['oldcat'] = oldcat
data['newcat'] = newcat
else:
cluster = data['cluster']
lensfilter = data['lensfilter']
image = data['image']
oldcat = data['oldcat']
newcat = data['newcat']
if filter2 is None:
column = 'MAG_APER-%s' % filter1
deltaMag = oldcat[column][:, 1] - newcat[column][:, 1]
goodmatch = np.logical_and(
np.logical_and(np.isfinite(deltaMag), deltaMag < 1.),
np.abs(oldcat[column][:, 1]) < 90)
vmax = min(0.05, np.max(deltaMag[goodmatch]))
vmin = max(-0.05, np.min(deltaMag[goodmatch]))
fig = pylab.figure()
pylab.scatter(oldcat['Xpos'][goodmatch],
oldcat['Ypos'][goodmatch],
c=deltaMag[goodmatch],
vmin=vmin,
vmax=vmax)
pylab.colorbar()
pylab.title('%s %s' % (cluster, filter1))
if vmax != 0.05 or vmin != 0.05:
pylab.xlabel('Warning: Color Axis Range Stretch')
return fig, data, deltaMag[goodmatch]
column1 = 'MAG_APER-%s' % filter1
column2 = 'MAG_APER-%s' % filter2
oldcolor = oldcat[column1] - oldcat[column2]
newcolor = newcat[column1] - newcat[column2]
deltacolor = (oldcolor - newcolor)[:, 1]
goodmatch = np.logical_and(
np.logical_and(np.isfinite(deltacolor), deltacolor < 1),
np.abs(oldcat[column1][:, 1]) < 90)
vmax = min(0.05, np.max(deltacolor[goodmatch]))
vmin = max(-0.05, np.min(deltacolor[goodmatch]))
fig = pylab.figure()
pylab.scatter(oldcat['Xpos'][goodmatch],
oldcat['Ypos'][goodmatch],
c=deltacolor[goodmatch],
vmin=vmin,
vmax=vmax)
pylab.colorbar()
return fig, data, deltacolor[goodmatch]
pylab.ylabel("Number of Galaxies")
pylab.title(cluster)
pylab.savefig(cluster + 'BPZODDS_new.png')
command = 'ldacfilter -i ' + catfile + " -c '(BPZ_ODDS > 0.3);' -t OBJECTS -o " + catfile + '.tmp'
os.system('rm ' + catfile + '.tmp')
print command
os.system(command)
command = 'ldacfilter -i ' + catfile + " -c '(e1_acs > 0.0);' -t OBJECTS -o " + catfile + '.tmp'
#os.system('rm ' + catfile + '.tmp')
print command
#os.system(command)
print catfile
catalog = ldac.openObjectFile(catfile + '.tmp', table='OBJECTS')
r, E, B = sp.calcTangentialShear(
catalog, center, pixscale) #,g1col='e1_acs',g2col='e2_acs')
beta = sp.beta(catalog["Z_BEST"], clusterz)
import scipy
kappacut = scipy.array(
[False] * len(beta),
dtype=bool) #sp.calcWLViolationCut(r, beta, sigma_v = 1300)
for i in range(len(r)):
if 100 < r[i]:
kappacut[i] = True
#print kappacut
def open(cls, pdzfile):
'''opens a pdzfile saved by PDZManager'''
pdz = ldac.openObjectFile(pdzfile)
return cls(pdz)
def zcosmosplot(data=None):
if data is None:
data = {}
if 'bpz' not in data:
data['bpz'] = ldac.openObjectFile(
'/u/ki/dapple/subaru/COSMOS_PHOTOZ/PHOTOMETRY_W-C-IC_BVRIZ/COSMOS_PHOTOZ.APER.1.CWWSB_capak.list.all.bpz.tab',
'STDTAB')
if 'galaxies' not in data:
data['galaxies'] = ldac.openObjectFile(
'/u/ki/dapple/nfs12/cosmos/simulations/publication/highsn/BVRIZ/bpz.cat',
'STDTAB')
if 'zcat' not in data:
data['zcat'] = ldac.openObjectFile(
'/u/ki/dapple/nfs12/cosmos/zcosmos.matched.cat')
if 'refbpz' not in data:
data['refbpz'] = ldac.openObjectFile(
'/u/ki/dapple/subaru/COSMOS_PHOTOZ/PHOTOMETRY_W-C-IC_BVRIZ/bpz.zcosmos.matched.cat',
'STDTAB')
bpz = data['bpz']
galaxies = data['galaxies']
zcat = data['zcat']
refbpz = data['refbpz']
filter = galaxies['BPZ_ODDS'] > 0.5
galaxies = galaxies.filter(filter)
mbpz = bpz.matchById(galaxies)
cat1 = mbpz
cat2 = refbpz
cat1id = 'SeqNr'
cat2id = 'SeqNr'
cat1order = {}
for i, x in enumerate(cat1[cat1id]):
cat1order[x] = i
cat1KeepOrder = []
cat2Keep = []
for x in cat2[cat2id]:
if x in cat1order:
cat1KeepOrder.append(cat1order[x])
cat2Keep.append(True)
else:
cat2Keep.append(False)
cat1keep = np.array(cat1KeepOrder)
cat2keep = np.array(cat2Keep)
cat1matched = cat1.filter(cat1keep)
cat2matched = cat2.filter(cat2keep)
mbpz = mbpz.filter(cat1keep)
mzcat = zcat.filter(cat2keep)
fig = makeHexbin(
mzcat['z'],
mbpz['BPZ_Z_B'],
xlabel=r'Z-COSMOS Spec-$z$',
ylabel=
r'{\it B}$_{\rm J}${\it V}$_{\rm J}${\it r}$^{+}${\it i}$^{+}${\it z}$^{+}$ Photo-$z$',
gridsize=65,
bins='log')
fig.axes[0].text(1.1, 0.05, '\emph{Log Color Scale}')
fig.savefig('publication/zcosmoscomp.pdf')
return fig, data
def createBootstrapCats(cluster, filter, image, outdir, nbootstraps = 100, startnum = 0):
clusterdir = '%s/%s' % (subarudir, cluster)
lensingdir = '%s/LENSING_%s_%s_aper/%s' % (clusterdir, filter, filter, image)
lensingcat = '%s/coadd_photo2.cat' % lensingdir
cutsfile = '%s/cc_cuts3.dat' % lensingdir
outdir = '%s/%s' % (outdir, cluster)
if not os.path.exists(outdir):
os.mkdir(outdir)
cat = ldac.openObjectFile(lensingcat)
zcluster = msf.parseZCluster(cluster)
center = msf.readClusterCenters(cluster)
r_arc, E, B = sp.calcTangentialShear(cat = cat,
center = center,
pixscale = 0.2)
r_mpc = r_arc * (1./3600.) * (np.pi / 180. ) * sp.angulardist(zcluster)
cat = cat.filter(np.logical_and(r_mpc > 0.750, r_mpc < 3.0))
cat.hdu.header.update('EXTNAME','STDTAB')
try:
tmpspace = tempfile.mkdtemp(dir = progs.tempdir)
cat.saveas('%s/base.cat' % tmpspace)
subprocess.check_call("./prefilter_mlcc_bootstrap.sh %s %s %s %s %s %s" \
% (cluster, filter, image,
tmpspace, '%s/base.cat' % tmpspace, '%s/prefiltered.cat' % tmpspace), shell=True)
cat = ldac.openObjectFile('%s/prefiltered.cat' % tmpspace, 'STDTAB')
cat.hdu.header.update('EXTNAME', 'OBJECTS')
for i in range(startnum, startnum + nbootstraps):
bootstrap = np.random.randint(0, len(cat), len(cat))
bootcat = cat.filter(bootstrap)
bootcat.saveas('%s/bootstrap_%d.ml.cat' % (outdir, i), clobber=True)
bootcat.hdu.header['EXTNAME'] = 'STDTAB'
curcat = '%s/filter.cat' % tmpspace
bootcat.saveas(curcat, clobber=True)
with open(cutsfile) as cuts:
for j, cut in enumerate(cuts.readlines()):
cut = cut.strip()
nextcat = '%s/filter_%d.cat' % (tmpspace, j)
print "ldacfilter -i %s -o %s -t STDTAB -c '(%s);'" % (curcat, nextcat, cut)
subprocess.check_call("ldacfilter -i %s -o %s -t STDTAB -c '(%s);'" % (curcat, nextcat, cut), shell=True)
curcat = nextcat
shutil.copyfile(curcat, '%s/bootstrap_%d.cc.cat' % (outdir, i))
for filterfile in glob.glob('%s/filter*' % tmpspace):
os.remove(filterfile)
finally:
shutil.rmtree(tmpspace)
######################
import sys
import numpy as np, pymc
import ldac, shapedistro
######################
inputcatfile = sys.argv[1]
outputcatfile = sys.argv[2]
modelname = sys.argv[3]
nsamples = float(sys.argv[4])
######
cat = ldac.openObjectFile(inputcatfile)
######
model = getattr(shapedistro, modelname)
mcmc = None
for i in range(10):
try:
mcmc = pymc.MCMC(model(cat['size'], cat['snratio'], cat['g'],
cat['true_g']),
db='pickle',
dbname=outputcatfile)
break
except pymc.ZeroProbability:
pass
def main(argv=sys.argv):
###
def parse_spec(option, opt, value, parser):
key, val = value.split('=')
if not hasattr(parser.values, 'specification'):
setattr(parser.values, 'specification', {})
parser.values.specification[key] = val
###
parser = optparse.OptionParser(usage=usage)
parser.add_option('-i',
'--in',
help='Input catalog name',
dest='incatfile')
parser.add_option('-c',
'--cluster',
help='Name of cluster',
dest='cluster')
parser.add_option('-o',
'--out',
help='name of output catalog',
dest='outcatfile')
parser.add_option('-d',
'--nodust',
help='Turn off dust correction',
dest='doDust',
action='store_false',
default=True)
parser.add_option('-t',
'--type',
help='Type of zeropoint -- standard, slr, lephare',
dest='type',
default='standard')
parser.add_option(
'--spec',
dest='specification',
action='callback',
type='string',
help='key=val set determines the uniqueness of this calibration',
default={},
callback=parse_spec)
options, args = parser.parse_args(argv)
if options.incatfile is None:
parser.error('Input catalog required!')
if options.cluster is None:
parser.error('Cluster Name is required!')
if options.outcatfile is None:
parser.error('Output catalog is required!')
if len(args) != 1:
parser.error('One catalog needed!')
cat = ldac.openObjectFile(options.incatfile)
converted = convert_aper.convertAperColumns(cat)
if options.doDust:
calibratedCat, zpCat = photoCalibrateCat(
converted,
options.cluster,
options.type,
specification=options.specification)
else:
calibratedCat, zpCat = photoCalibrateCat(
converted,
options.cluster,
options.type,
getExtinction=None,
getDust=None,
specification=options.specification)
hdus = [pyfits.PrimaryHDU(), calibratedCat.hdu, zpCat.hdu]
hdus.extend(_transferOtherHDUs(options.incatfile))
hdulist = pyfits.HDUList(hdus)
hdulist.writeto(options.outcatfile, clobber=True)
#######################
# Imitate the LDACPASTE program, but hopefully be less of a pain about the FIELDS table
########################
import ldac, pyfits, sys
########################
outcat = sys.argv[1]
inputcats = sys.argv[2:]
finalcat = ldac.openObjectFile(inputcats[0])
for catfile in inputcats[2:]:
cat = ldac.openObjectFile(catfile)
finalcat = finalcat.append(cat)
hdulist = pyfits.open(inputcats[0])
newhdulist = [pyfits.PrimaryHDU(), finalcat.hdu]
for table in hdulist:
if 'EXTNAME' in table.header and table.header['EXTNAME'] != 'OBJECTS' and table.header['EXTNAME'] != 'FIELDS':
def addContamination(sourcebpz,
source_snratio,
source_size,
simcat,
simpdz,
r500,
zcluster,
f500=0.04,
pixscale=pixscale,
refcat='/u/ki/dapple/nfs12/cosmos/cosmos2.cat',
shape_distro=__DEFAULT_SHAPE_DISTRO__,
shape_distro_args=[],
shape_distro_kw={}):
refcat = ldac.openObjectFile(refcat).matchById(sourcebpz, selfid='id')
r_max = max(simcat['r_pix'])
area = np.pi * (r_max * pixscale / 60.)**2
n_back = float(len(simcat)) / area
x, y = nfwsim.stdcontamination((0, 0), pixscale, f500, n_back, r500,
zcluster)
r_pix = np.sqrt(x**2 + y**2)
r_mpc = r_pix * pixscale * (1. / 3600.) * (np.pi /
180.) * sp.angulardist(zcluster)
z = zcluster * np.ones(len(r_pix))
toKeepAvailable = {}
for id in sourcebpz['SeqNr']:
toKeepAvailable[id] = True
for id in simcat['z_id']:
toKeepAvailable[id] = False
zkey = 'zp_best'
if zkey not in sourcebpz:
zkey = 'BPZ_Z_S'
toKeep = np.logical_and(
np.logical_and(
np.array([toKeepAvailable[id] for id in sourcebpz['SeqNr']]),
refcat['mod_gal'] > 8),
np.logical_and(sourcebpz[zkey] > (zcluster - 0.05), sourcebpz[zkey] <
(zcluster + 0.05)))
#toKeep = np.logical_and(np.array([toKeepAvailable[id] for id in sourcebpz['SeqNr']]),
# np.logical_and(sourcebpz[zkey] > (zcluster - 0.05),
# sourcebpz[zkey] < (zcluster + 0.05)))
#
#
availablebpz = sourcebpz.filter(toKeep)
available_snratio = source_snratio[toKeep]
available_size = source_size[toKeep]
selected = np.random.randint(0, len(availablebpz), len(r_pix))
selectedbpz = availablebpz.filter(selected)
selected_snratio = available_snratio[selected]
selected_size = available_size[selected]
col_collection = {
'Seqnr':
-selectedbpz['SeqNr'],
'r_pix':
r_pix,
'r_mpc':
r_mpc,
'z':
z,
'z_id':
selectedbpz['SeqNr'],
'ghats':
shape_distro(np.zeros(len(selectedbpz)),
np.column_stack([selected_size, selected_snratio]),
*shape_distro_args, **shape_distro_kw),
'true_shear':
np.zeros_like(r_pix),
'true_z':
zcluster * np.ones_like(r_pix),
'true_beta':
np.zeros_like(r_pix),
'true_gamma':
np.zeros_like(r_pix),
'true_kappa':
np.zeros_like(r_pix)
}
cols = []
for name, arr in col_collection.iteritems():
if name == 'SeqNr':
col = pyfits.Column(name=name, format='J', array=arr)
else:
col = pyfits.Column(name=name, format='E', array=arr)
cols.append(col)
contamcat = ldac.LDACCat(
pyfits.BinTableHDU.from_columns(pyfits.ColDefs(cols)))
finalcat = simcat.append(contamcat)
return finalcat
def pubSTEPResidual(data = None):
if data is None:
data = {}
if 'cat' not in data:
data['cat'] = ldac.openObjectFile('/u/ki/dapple/ki06/shapedistro/sept2011/anja/sncut.cat')
cat = data['cat']
pivot = 1.97
m_y = -.028
m_slope = 0.20
c = -9.6e-06
if 'resid' not in data:
gcorr = bentvoigtcor(cat['true_g'], cat['size'], pivot, m_slope, m_y, c)
resid = cat['g'] - gcorr
data['resid'] = resid
else:
resid = data['resid']
xdelta = np.arange(-1.5, 1.5, 0.001)
if 'vsigma' not in data:
vdb = pymc.database.pickle.load('/u/ki/dapple/ki06/shapedistro/sept2011/anja/snrestricted.bentvoigt3.out')
gdb = pymc.database.pickle.load('/u/ki/dapple/ki06/shapedistro/sept2011/anja/snrestricted.gauss.out')
vsigma = np.mean(vdb.trace('sigma')[2000:])
vgamma = np.mean(vdb.trace('gamma')[2000:])
gsigma = np.mean(gdb.trace('sigma')[2000:])
data['vsigma'] = vsigma
data['vgamma'] = vgamma
data['gsigma'] = gsigma
else:
vsigma = data['vsigma']
vgamma = data['vgamma']
gsigma = data['gsigma']
fig = pylab.figure()
ax = fig.add_axes([0.12, 0.12, 0.95 - 0.12, 0.95 - 0.12])
hist, edges, patches = ax.hist(resid, bins = 151, log=True, normed=True, label='Fit Residuals', histtype='step', color='k')
ax.plot(xdelta, vtools.voigtProfile(xdelta, vsigma, vgamma), 'r-', label='Voigt Model', linewidth=1.5)
ax.plot(xdelta, gaussprofile(xdelta, gsigma), 'b-.', label='Gaussian Model', linewidth=1.5)
ax.set_ylim(5e-5, 1e1)
ax.set_ylabel(r'$P(\delta g)$')
ax.set_xlabel(r'Shear Residual $\delta g$')
ax.legend(loc='lower center', numpoints=1)
fig.savefig('publication/step_scatter.eps')
return fig, data
import shearprofile as sp
import sys
import os, subprocess
import pylab
if len(sys.argv) != 6:
sys.stderr.write("wrong number of arguments!\n")
sys.exit(1)
catfile = sys.argv[1]
clusterz = float(sys.argv[2])
center = map(float, sys.argv[3].split(','))
pixscale = float(sys.argv[4]) # arcsec / pix
clustername = sys.argv[5]
catalog = ldac.openObjectFile(catfile)
r, E = sp.calcTangentialShear(catalog, center, pixscale)
beta = sp.beta(catalog["Z_BEST"], clusterz, calcAverage=False)
kappacut = sp.calcWLViolationCut(r, beta, sigma_v=1300)
radiuscut = r > 60 #arcseconds
largeradiuscut = r < 500
zcut = logical_and(catalog['Z_BEST'] > 1.2 * clusterz, catalog['Z_BEST'] < 1.2)
cleancut = logical_and(
kappacut, logical_and(radiuscut, logical_and(largeradiuscut, zcut)))
cleancat = catalog.filter(cleancut)
def BK11multibinresidual(dirbase):
setBK11()
matplotlib.rcParams['figure.figsize'] = [16,16]
fig = pylab.figure()
curplot = 1
for curm in range(4):
for curc in range(4):
pylab.subplot(4,4,curplot)
colori = 1
for snap in [124,141]:
try:
mass, concen, redshift = readtxtfile.readtxtfile('%s_%d/bk11stack_%d_%d.dat' % (dirbase, snap,
curm, curc))[0]
cat = ldac.openObjectFile('%s_%d/bk11stack_%d_%d.cat' % (dirbase, snap,
curm, curc))
zlens = cat.hdu.header['ZLENS']
rscale = nfwutils.rscaleConstM(mass/nfwutils.global_cosmology.h, concen, zlens, 200)
gamma = nfwmodeltools.NFWShear(cat['r_mpc'], concen, rscale, zlens)
kappa = nfwmodeltools.NFWKappa(cat['r_mpc'], concen, rscale, zlens)
gpred = cat['beta_s']*gamma / (1 - (cat['beta_s2']*kappa/cat['beta_s']))
pylab.errorbar(cat['r_mpc']*nfwutils.global_cosmology.h, cat['ghat'], cat['ghatdistrosigma']/(np.sqrt(cat['ndat'])),
linestyle='None', marker='o', color=c[colori], label='M=%1.1fx10^14' % (mass/1e14))
pylab.plot(cat['r_mpc']*nfwutils.global_cosmology.h, gpred, 'k-', linewidth=2)
ax = pylab.gca()
ax.set_xscale('log')
pylab.axhline(0.0, c='k', linewidth=2)
pylab.axis([0.05, 10, -0.03, 0.4])
ax = pylab.gca()
ax.set_xscale('log')
pylab.axhline(0.0, c='k', linewidth=2)
# pylab.legend(loc='lower center', fontsize=10)
# pylab.title('M=%1.1fx10^14 C=%1.1f' % ( mass/1e14, concen))
except:
pass
colori+= 1
curplot += 1
for i in range(4):
pylab.subplot(4,4,13+i)
pylab.xlabel('Radius [Mpc/h]')
pylab.subplot(4,4,4*i+1)
pylab.ylabel('<g_m/g_p - 1>')
pylab.tight_layout()
pylab.savefig('%s_multibin_shearprofile.png' % dirbase)
# pylab.savefig('%s_multibin_resid.png' % binbase)
return fig
