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