def readData(manager):
options = manager.options
manager.zcluster = options.zcluster
manager.r500 = options.r500
manager.psfsize = options.psfsize
manager.pixscale = options.pixscale
if 'lensingcat' not in manager:
manager.open('lensingcat', options.lensingcat, ldac.openObjectFile)
r_arc, E, B = sp.calcTangentialShear(cat=manager.lensingcat,
center=(options.centerx, options.centery),
pixscale=options.pixscale,
xcol=options.xcol,
ycol=options.ycol,
g1col=options.g1col,
g2col=options.g2col)
r_pix = r_arc / options.pixscale
r_mpc = r_arc * (1. / 3600.) * (np.pi / 180. ) * sp.angulardist(options.zcluster)
size = manager.lensingcat[options.sizecol] / options.psfsize
snratio = manager.lensingcat[options.snratio]
manager.open('bpzcat', options.bpzfile, ldac.openObjectFile, 'STDTAB')
manager.store('matched_bpzcat', manager.bpzcat.matchById, manager.lensingcat)
z_b = manager.matched_bpzcat['BPZ_Z_B']
odds = manager.matched_bpzcat['BPZ_ODDS']
nfilt = manager.matched_bpzcat['NFILT']
galtype = manager.matched_bpzcat['BPZ_T_B']
cols = [pyfits.Column(name='SeqNr', format='J', array=manager.lensingcat['SeqNr']),
pyfits.Column(name='r_mpc', format='E', array=r_mpc),
pyfits.Column(name='size', format='E', array=size),
pyfits.Column(name='snratio', format='E', array=snratio),
pyfits.Column(name='z_b', format='E', array=z_b),
pyfits.Column(name='z_t', format='E', array=galtype),
pyfits.Column(name='odds', format='E', array=odds),
pyfits.Column(name='nfilt', format='I', array=nfilt),
pyfits.Column(name='ghats', format='E', array=E),
pyfits.Column(name='B', format='E', array=B)]
manager.store('inputcat', ldac.LDACCat(pyfits.BinTableHDU.from_columns(pyfits.ColDefs(cols))))
manager.open('pdzmanager', options.inputPDZ, pdzfile_utils.PDZManager.open)
manager.store('pdzrange pdz'.split(),
manager.pdzmanager.associatePDZ(manager.lensingcat['SeqNr']))
manager.replace('pdzmanager', None)
manager.replace('matched_bpz', None)
manager.replace('bpzcat', None)
def beta_contamination(x,
y,
g1,
g2,
mag,
useInContam,
areamap,
zdist,
zcluster,
norm_radii,
concentration_prior=4.,
density_prior=[0, 30],
contam_prior=[0, 10],
fitrange=(0.4, 4.),
bins=15,
logbin=False,
pixscale=__DEFAULT_PIXSCALE__,
center=__DEFAULT_CENTER__):
#######
# save config setting
#######
momento = {
'x': x,
'y,': y,
'g1': g1,
'g2': g2,
'mag': mag,
'useInContam': useInContam,
'areamap': areamap,
'zdist': zdist,
'zcluster': zcluster,
'norm_radii': norm_radii,
'concentration_prior': concentration_prior,
'density_prior': density_prior,
'contam_prior': contam_prior,
'fitrange': fitrange,
'bins': bins,
'logbin': logbin,
'pixscale': pixscale,
'center': center
}
#######
# Data Prep
#######
D_lens = sp.angulardist(zcluster)
cat = {'Xpos': x, 'Ypos': y, 'gs1': g1, 'gs2': g2}
r_arcsec, E, B = sp.calcTangentialShear(cat, center, pixscale)
r_mpc = r_arcsec * (1. / 3600.) * (np.pi / 180.) * D_lens
if logbin:
dr = log(dr)
rmin = log(rmin)
rmax = log(rmax)
leftedges, binwidth = linspace(rmin,
rmax,
bins + 1,
endpoint=True,
retstep=True)
rbin = exp(leftedges)
rbin = (rbin[1:] + rbin[:-1]) / 2.
else:
leftedges, binwidth = linspace(rmin,
rmax,
bins,
endpoint=False,
retstep=True)
rbin = leftedges + binwidth / 2.
# Set up binning grid:
Ebin = zeros(bins, dtype=float64)
Ebinerr = zeros(bins, dtype=float64)
Bbin = zeros(bins)
Bbinerr = zeros(bins)
nbin = zeros(bins)
index = ((dr - rmin) / binwidth).astype(int)
goodentry = logical_and(index >= 0, index < bins)
#######
# Model
#######
## r_scale is log-uniform
log_r_scale = pymc.Uniform('log_r_scale', np.log(.01), np.log(1.))
normgal_density = pymc.Uniform('n_normgals', density_prior[0],
density_prior[1])
contam_amp = pymc.Uniform('A_contam', contam_prior[0], contam_prior[1])
@pymc.stochastic(observed=True)
def shear(value=ghats,
log_r_scale=log_r_scale,
normgal_density=normgal_density,
contam_amp=contam_amp):
return tools.likelihood(log_r_scale, r_mpc, ghat_matrix, beta_matrix,
pdz, concentration, zcluster, D_lens,
shape_sigma)
@pymc.stochastic(observed=True)
def numcounts(value=ngals,
normgal_density=normgal_density,
contam_amp=contam_amp):
pass
########
return locals()
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)
samples = sp.simpleBootstrap(cleancat, clusterz, pixscale, center,
beta[cleancut])
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(lens,
center,
pixscale,
g1col='gs1corr',
g2col='gs2corr')
beta = sp.beta(phot["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
#print kappacut
kappacut = (phot['BPZ_Z_B_MAX'] - phot['BPZ_Z_B_MIN'] < 2.0) * (
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)
def readData(manager):
options = manager.options
manager.zcluster = options.zcluster
manager.r500 = options.r500
manager.psfsize = options.psfsize
manager.pixscale = options.pixscale
if 'lensingcat' not in manager:
manager.open('lensingcat', options.lensingcat, ldac.openObjectFile)
r_arc, E, B = sp.calcTangentialShear(cat=manager.lensingcat,
center=(options.centerx,
options.centery),
pixscale=options.pixscale,
xcol=options.xcol,
ycol=options.ycol,
g1col=options.g1col,
g2col=options.g2col)
r_pix = r_arc / options.pixscale
r_mpc = r_arc * (1. / 3600.) * (np.pi / 180.) * sp.angulardist(
options.zcluster)
size = manager.lensingcat[options.sizecol] / options.psfsize
snratio = manager.lensingcat[options.snratio]
manager.open('bpzcat', options.bpzfile, ldac.openObjectFile, 'STDTAB')
manager.store('matched_bpzcat', manager.bpzcat.matchById,
manager.lensingcat)
z_b = manager.matched_bpzcat['BPZ_Z_B']
odds = manager.matched_bpzcat['BPZ_ODDS']
nfilt = manager.matched_bpzcat['NFILT']
galtype = manager.matched_bpzcat['BPZ_T_B']
cols = [
pyfits.Column(name='SeqNr',
format='J',
array=manager.lensingcat['SeqNr']),
pyfits.Column(name='r_mpc', format='E', array=r_mpc),
pyfits.Column(name='size', format='E', array=size),
pyfits.Column(name='snratio', format='E', array=snratio),
pyfits.Column(name='z_b', format='E', array=z_b),
pyfits.Column(name='z_t', format='E', array=galtype),
pyfits.Column(name='odds', format='E', array=odds),
pyfits.Column(name='nfilt', format='I', array=nfilt),
pyfits.Column(name='ghats', format='E', array=E),
pyfits.Column(name='B', format='E', array=B)
]
manager.store(
'inputcat',
ldac.LDACCat(pyfits.BinTableHDU.from_columns(
pyfits.ColDefs(cols))))
manager.open('pdzmanager', options.inputPDZ,
pdzfile_utils.PDZManager.open)
manager.store(
'pdzrange pdz'.split(),
manager.pdzmanager.associatePDZ(manager.lensingcat['SeqNr']))
manager.replace('pdzmanager', None)
manager.replace('matched_bpz', None)
manager.replace('bpzcat', None)
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)
r, E, B = sp.calcTangentialShear(lens, center, pixscale)
beta = sp.beta(phot["BPZ_Z_B"], cluster_z) #, 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 0 < r[i] < 1000:
kappacut[i] = True
print kappacut
#kappacut = sp.calcWLViolationCut(r, beta, sigma_v = 1300)
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)
r, E = sp.calcTangentialShear(curGals, (5000, 5000), .2)
beta = sp.beta(curGals["Z_BEST"], redshift, calcAverage=False)
kappacut = sp.calcWLViolationCut(r, beta, sigma_v=1300)
curGals = curGals.filter(kappacut)
aprofile = sp.easyprofile(curGals, (1, 3000),
bins=8,
center=(5000, 5000),
logbin=False)
pylab.subplot(back_bins, 1, curbin + 1)
if emode:
spp.plotprofile((0, 3000), aprofile.r, aprofile.E, aprofile.Eerr)
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
kappacut = sp.calcWLViolationCut(r, beta, sigma_v=1300)
r = r[kappacut]
