def run_main(lens_cat, lgal_cat, sagn_cat, sgal_cat):
# lens_cat = {}
# lgal_cat = {}
# sagn_cat = {}
# sgal_cat = {}
bsz = 10.0 # arcsec
nnn = 512
dsx = bsz / nnn #arcsec
dsi = 0.03
zl = lens_cat['zl']
zs = sagn_cat['zs']
xc1 = lens_cat['xc1']
xc2 = lens_cat['xc2']
re = re_sv(lens_cat['SigmaV'], zl, zs)
rc = 0.0
ql = lens_cat['ql']
phl = lens_cat['phl']
esh = lens_cat['ext_shear']
ash = lens_cat['ext_angle']
ekp = lens_cat['ext_kappa']
xi1, xi2 = make_r_coor(nnn, dsx)
ai1, ai2 = deflection_nie(xi1, xi2, xc1, xc2, re, rc, ql, phl, esh, ash,
ekp)
mua = pcs.call_alphas_to_mu(ai1, ai2, nnn, dsx)
yi1 = xi1 - ai1
yi2 = xi2 - ai2
#----------------------------------------------------------------------
# Lensed Point Sources
#
ys1 = sagn_cat['ys1']
ys2 = sagn_cat['ys2']
xroot1, xroot2, nroots = trf.roots_zeros(xi1, xi2, ai1, ai2, ys1, ys2)
muii = pcs.call_inverse_cic_single(mua, xroot1, xroot2, dsx)
#------------------------------------------------------------------------------
# Lensed Galaxies
#
ysc1 = ys1
ysc2 = ys2
sgal_img = loadin_sgal(sgal_cat)
lensed_sgal = lv4.call_ray_tracing(sgal_img, yi1, yi2, ysc1, ysc2, dsi)
#lensed_img = pcs.call_ray_tracing_single(ai1,ai2,nnn,bsz,zl)
#------------------------------------------------------------------------------
# Lens Galaxies
#
lgal_img = loadin_lgal(lgal_cat)
#------------------------------------------------------------------------------
# Stacking All images
#
res = stacking_points_and_galaxies(xroot1, xroot2, lroots[:, 70],
final_img, bsz, nnn)
return res
def single_run_test(ind, ysc1, ysc2, q, vd, pha, zl, zs, lens_tag=1):
# dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 3.0
nnn = 400 # Image dimension
bsz = 9.0 # arcsecs
dsx = bsz / nnn # pixel size of SDSS detector.
nstd = 59 # ^2
xi1, xi2 = make_r_coor(nnn, dsx)
# ----------------------------------------------------------------------
dsi = 0.03
g_source = pyfits.getdata(
"./gals_sources/439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d") * 10.0
g_source[g_source <= 0.0001] = 1e-6
# ----------------------------------------------------------------------
# x coordinate of the center of lens (in units of Einstein radius).
xc1 = 0.0
# y coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0
rc = 0.0 # Core size of lens (in units of Einstein radius).
re = re_sv(vd, zl, zs) # Einstein radius of lens.
print "re = ", re
re_sub = 0.0 * re
a_sub = a_b_bh(re_sub, re)
ext_shears = 0.06
ext_angle = -0.39
ext_kappa = 0.08
# ext_shears = 0.0
# ext_angle = 0.0
# ext_kappa = 0.0
# ----------------------------------------------------------------------
#lpar = np.asarray([xc1, xc2, q, rc, re, pha])
#ai1, ai2, kappa_out, shr1, shr2, mua = lensing_signals_sie(xi1, xi2, lpar)
#ar = np.sqrt(ai1 * ai1 + ai2 * ai2)
# psi_nie = psk.potential_nie(xc1, xc2, pha, q, re, rc, ext_shears, ext_angle,
# ext_kappa, xi1, xi2)
#ai1, ai2 = np.gradient(psi_nie, dsx)
ai1, ai2 = psk.deflection_nie(xc1, xc2, pha, q, re, rc, ext_shears, ext_angle,
ext_kappa, xi1, xi2)
as1, as2 = psk.deflection_sub_pJaffe(0.0, -2.169, re_sub, 0.0, a_sub, xi1, xi2)
yi1 = xi1 - ai1 - as1
yi2 = xi2 - ai2 - as2
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
g_limage[g_limage <= 0.25] = 1e-6
# pl.figure()
# pl.contourf(g_limage)
# pl.colorbar()
g_limage = cosccd2mag(g_limage)
g_limage = mag2sdssccd(g_limage)
# pl.figure()
# pl.contourf(g_limage)
# pl.colorbar()
# -------------------------------------------------------------
dA = Planck13.comoving_distance(zl).value * 1000. / (1.0 + zl)
Re = dA * np.sin(R * np.pi / 180. / 3600.)
counts = Brightness(Re, vd)
vpar = np.asarray([counts, R, xc1, xc2, q, pha])
g_lens = de_vaucouleurs_2d(xi1, xi2, vpar)
g_clean_ccd = g_lens * lens_tag + g_limage
output_filename = "./fits_outputs/clean_lensed_imgs.fits"
pyfits.writeto(output_filename, g_clean_ccd, overwrite=True)
# -------------------------------------------------------------
from scipy.ndimage.filters import gaussian_filter
g_images_psf = gaussian_filter(g_clean_ccd, 2.0)
# -------------------------------------------------------------
g_noise = noise_map(nnn, nnn, np.sqrt(nstd), "Gaussian")
output_filename = "./fits_outputs/noise_map.fits"
pyfits.writeto(output_filename, g_noise, overwrite=True)
g_final = g_images_psf + g_noise
# -------------------------------------------------------------
g_clean_ccd = g_limage
g_images_psf = gaussian_filter(g_clean_ccd, 2.0)
g_final = g_images_psf + g_noise
output_filename = "./fits_outputs/lensed_imgs_only.fits"
pyfits.writeto(output_filename, g_final, overwrite=True)
# -------------------------------------------------------------
output_filename = "./fits_outputs/full_lensed_imgs.fits"
pyfits.writeto(output_filename, g_final + g_lens, overwrite=True)
# pl.figure()
# pl.contourf(g_final)
# pl.colorbar()
return 0
def main():
nnn = 800
boxsize = 24.0
dsx = boxsize / nnn
dsi = dsx * 0.06
xi1 = np.linspace(-boxsize / 2.0, boxsize / 2.0 - dsx, nnn) + 0.5 * dsx
xi2 = np.linspace(-boxsize / 2.0, boxsize / 2.0 - dsx, nnn) + 0.5 * dsx
xi1, xi2 = np.meshgrid(xi1, xi2)
g_snR = pyfits.getdata("/Users/uranus/Desktop/gamer1/galaxy0004R.fits")
g_snG = pyfits.getdata("/Users/uranus/Desktop/gamer1/galaxy0004G.fits")
g_snB = pyfits.getdata("/Users/uranus/Desktop/gamer1/galaxy0004B.fits")
g_snR = np.array(g_snR, dtype="<d")
g_snG = np.array(g_snG, dtype="<d")
g_snB = np.array(g_snB, dtype="<d")
#g_snR = snf.gaussian_filter(np.array(g_snR, dtype="<d"), 16.5)
#g_snG = snf.gaussian_filter(np.array(g_snG, dtype="<d"), 16.5)
#g_snB = snf.gaussian_filter(np.array(g_snB, dtype="<d"), 16.5)
#cc = find_critical_curve(mu)
pygame.init()
FPS = 60
fpsClock = pygame.time.Clock()
screen = pygame.display.set_mode((nnn, nnn), 0, 32)
pygame.display.set_caption("Gravitational Lensing Toy")
mouse_cursor = pygame.Surface((nnn, nnn))
#----------------------------------------------------
base0 = np.zeros((nnn, nnn, 3), 'uint8')
base1 = np.zeros((nnn, nnn, 3), 'uint8')
base2 = np.zeros((nnn, nnn, 3), 'uint8')
#----------------------------------------------------
# lens parameters for main halo
xlc1 = 0.0
xlc2 = 0.0
ql0 = 0.799999999999
rc0 = 0.000000000001
re0 = 4.0
phi0 = 60.0
lpar = np.asarray([xlc1, xlc2, re0, rc0, ql0, phi0])
lpars_list = []
lpars_list.append(lpar)
#----------------------------------------------------
# lens parameters for main halo
xls1 = 0.7
xls2 = 0.8
qls = 0.999999999999
rcs = 0.000000000001
res = 0.0
phis = 0.0
lpars = np.asarray([xls1, xls2, res, rcs, qls, phis])
lpars_list.append(lpars)
scale_factor = 30
ap0 = 1.0
l_sig0 = 0.5
glpar = np.asarray([ap0, l_sig0, xlc1, xlc2, ql0, phi0])
g_lens = lens_galaxies(xi1, xi2, glpar)
base0[:, :, 0] = g_lens * 255
base0[:, :, 1] = g_lens * 180
base0[:, :, 2] = g_lens * 0
#rgb(255, 180, 0)
x = 0
y = 0
step = 1
gr_sig = 0.1
LeftButton = 0
g_xcen = 0.0175
g_ycen = 0.375
#----------------------------------------------------
ic = FPS / 12.0
i = 0
while True:
i = i + 1
for event in pygame.event.get():
if event.type == QUIT:
exit()
if event.type == MOUSEMOTION:
if event.buttons[LeftButton]:
rel = event.rel
x += rel[0]
y += rel[1]
#----------------------------------------------
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 4:
gr_sig -= 0.1
if gr_sig < 0.01:
gr_sig = 0.01
elif event.button == 5:
gr_sig += 0.01
if gr_sig > 0.4:
gr_sig = 0.4
keys = pygame.key.get_pressed() # checking pressed keys
if keys[pygame.K_RIGHT]:
x += step
if x > 500:
x = 500
if keys[pygame.K_LSHIFT] & keys[pygame.K_RIGHT]:
x += 30 * step
if keys[pygame.K_LEFT]:
x -= step
if x < -500:
x = -500
if keys[pygame.K_LSHIFT] & keys[pygame.K_LEFT]:
x -= 30 * step
if keys[pygame.K_UP]:
y -= step
if y < -500:
y = -500
if keys[pygame.K_LSHIFT] & keys[pygame.K_UP]:
y -= 30 * step
if keys[pygame.K_DOWN]:
y += step
if y > 500:
y = 500
if keys[pygame.K_LSHIFT] & keys[pygame.K_DOWN]:
y += 30 * step
#----------------------------------------------
if keys[pygame.K_MINUS]:
gr_sig -= 0.01
if gr_sig < 0.01:
gr_sig = 0.01
if keys[pygame.K_EQUALS]:
gr_sig += 0.01
if gr_sig > 0.1:
gr_sig = 0.1
#gr_sig = 0.005
#----------------------------------------------
# parameters of source galaxies.
#----------------------------------------------
g_amp = 1.0 # peak brightness value
g_sig = gr_sig # Gaussian "sigma" (i.e., size)
#g_xcen = x * 2.0 / nnn # x position of center
#g_ycen = y * 2.0 / nnn # y position of center
g_xcen = 0.0175
g_ycen = 0.375
g_axrat = 1.0 # minor-to-major axis ratio
# major-axis position angle (degrees) c.c.w. from y axis
g_pa = 0.0
gpar = np.asarray([g_amp, g_sig, g_ycen, g_xcen, g_axrat, g_pa])
#----------------------------------------------
#----------------------------------------------
# parameters of SNs.
#----------------------------------------------
g_amp = 1.0 # peak brightness value
g_sig = 0.1 # Gaussian "sigma" (i.e., size)
g_xcen = y * 2.0 / nnn + 0.05 # x position of center
g_ycen = x * 2.0 / nnn + 0.05 # y position of center
g_axrat = 1.0 # minor-to-major axis ratio
# major-axis position angle (degrees) c.c.w. from y axis
g_pa = 0.0
print g_ycen, g_xcen
phi, td, ai1, ai2, kappa, mu, yi1, yi2 = nie_all(
xi1, xi2, xlc1, xlc2, re0, rc0, ql0, phi0, g_ycen, g_xcen)
g_lsB = lv4.call_ray_tracing(g_snB, yi1, yi2, g_xcen, g_ycen, dsi)
g_lsR = lv4.call_ray_tracing(g_snR, yi1, yi2, g_xcen, g_ycen, dsi)
g_lsG = lv4.call_ray_tracing(g_snG, yi1, yi2, g_xcen, g_ycen, dsi)
base2[:, :, 0] = g_lsR / scale_factor * 256
base2[:, :, 1] = g_lsG / scale_factor * 256
base2[:, :, 2] = g_lsB / scale_factor * 256
wf = base1 + base2
idx1 = wf >= base0
idx2 = wf < base0
base = base0 * 0
base[idx1] = wf[idx1]
base[idx2] = base0[idx2]
#base = wf*base0+(base1+base2)
pygame.surfarray.blit_array(mouse_cursor, base)
screen.blit(mouse_cursor, (0, 0))
# font=pygame.font.SysFont(None,30)
#text = font.render("( "+str(x)+", "+str(-y)+" )", True, (255, 255, 255))
#screen.blit(text,(10, 10))
pygame.display.update()
fpsClock.tick(FPS)
def main():
bsz = 9.0
nnn = 900
dsx = bsz / nnn
xi1, xi2 = make_r_coor(nnn, dsx)
xlc1 = 0.0 # x position of the lens, arcseconds
xlc2 = 0.0 # y position of the lens, arcseconds
vd = 320.0
ql = 0.7 # axis ratio b/a
lp = 36.0 # orientation, degree
ext_shears = 0.02
ext_angle = 79.0
zl = 0.5
zs = 2.0 # redshift of the source
rle = ole.re_sv(vd, zl, zs)
#----------------------------------------------------------------------
le = lef.lambda_e_tot(1.0 - ql)
ai1, ai2 = ole.alphas_sie(xlc1, xlc2, lp, ql, rle, le, ext_shears,
ext_angle, 0.0, xi1, xi2)
yi1 = xi1 - ai1 * 1.0
yi2 = xi2 - ai2 * 1.0
al12, al11 = np.gradient(ai1, dsx)
al22, al21 = np.gradient(ai2, dsx)
mua = 1.0 / (1.0 - (al11 + al22) + al11 * al22 - al12 * al21)
#----------------------------------------------------------------------
ysc1 = 0.0 # x position of the source, arcseconds
ysc2 = 0.0 # y position of the source, arcseconds
dsi = 0.03
#----------------------------------------------------------------------
mag_tot_sgal = 23.0 # total magnitude of the source
g_source = pyfits.getdata(
"../gals_sources/439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source.T, dtype="<d")
g_source[g_source <= 0.0001] = 1e-6
g_source = g_source.copy(order='C')
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
mag_lensed_gal = img2_to_mag2(
np.sum(g_source) * dsi * dsi, mag_tot_sgal,
np.sum(g_limage) * dsx * dsx)
#----------------------------------------------------------------------
idac = g_source == g_source.max()
yac1 = (np.indices(np.shape(g_source))[0][idac] -
np.shape(g_source)[0] / 2.0 + 0.5) * dsx
yac2 = (np.indices(np.shape(g_source))[1][idac] -
np.shape(g_source)[1] / 2.0 + 0.5) * dsx
# pl.figure()
# pl.contourf(g_source.T, levels=[0.0,0.015,0.03,0.045,0.06,0.075,0.09,0.105])
# pl.plot(np.indices(np.shape(g_source))[0][idac], np.indices(np.shape(g_source))[1][idac], 'rx')
# pl.colorbar()
mag_tot_sagn = 22.5
a_source = g_source * 0.0
a_source[int((yac1 + bsz / 2.0 - dsx / 2.0) / dsx),
int((yac2 + bsz / 2.0 - dsx / 2.0) / dsx)] = 1.0
# a_source = a_source*mag2_to_img2(np.sum(g_source)*dsi*dsi, mag_tot_sgal, mag_tot_sagn)
agns_rescale = mag2_to_img2(np.sum(g_source)*dsi*dsi, mag_tot_sgal, mag_tot_sagn) \
/(np.sum(a_source)*dsi*dsi)
a_source = a_source * agns_rescale
a_limage = g_limage * 0.0
xroot1, xroot2, nroots = trf.mapping_triangles(yac1, yac2, xi1, xi2, yi1,
yi2)
# if (nroots > len(ximgs[np.nonzero(ximgs)])):
# xroot = np.sqrt(xroot1*xroot1 + xroot2*xroot2)
# idx = xroot == xroot.min()
# xroot1[idx] = 0.0
# xroot2[idx] = 0.0
index2 = ((xroot1 + bsz / 2.0) / dsx).astype('int')
index1 = ((xroot2 + bsz / 2.0) / dsx).astype('int')
a_limage[index1, index2] = a_source.max() * dsi * dsi / (dsx * dsx)
a_limage = a_limage * np.abs(mua)
mag_lensed_agn = img2_to_mag2(
np.sum(a_source) * dsi * dsi, mag_tot_sagn,
np.sum(a_limage) * dsx * dsx)
# print mag_lensed_agn
# pl.figure()
# pl.contourf(xi1, xi2, a_limage)
# pl.plot(xroot1, xroot2, 'rx')
# pl.colorbar()
# print mag_lensed_gal
# pl.figure()
# pl.contourf(xi1, xi2, g_limage)
# pl.plot(xroot1, xroot2, 'rx')
# pl.colorbar()
f_limage = g_limage + a_limage
mag_lensed_tot = img2_to_mag2(
np.sum(g_source) * dsi * dsi, mag_tot_sgal,
np.sum(f_limage) * dsx * dsx)
# print mag_lensed_tot
# pl.figure()
# pl.contourf(np.log10(f_limage))
# pl.colorbar()
#limg_cat = [xlc1, xlc2, mag_tot, Reff_arc, ql, phl, ndex, zl]
lens_cat = [xlc1, xlc2, ql, vd, lp, zl]
limg_cat = gli.lens_img_cat(lens_cat)
limg_hst = sersic.sersic_2d_norm(xi1, xi2, limg_cat[0], limg_cat[1],
limg_cat[3], ql, lp, 4.0)
limg_rescale = mag2_to_img2(np.sum(g_source)*dsi*dsi, mag_tot_sgal, limg_cat[2]) \
/(np.sum(limg_hst)*dsx*dsx)
g_lens = limg_hst * limg_rescale
fimage = g_limage + a_limage + g_lens
mag_tot = img2_to_mag2(
np.sum(g_source) * dsi * dsi, mag_tot_sgal,
np.sum(fimage) * dsx * dsx)
fits_out = "./" + str(mag_tot_sgal) + "_" \
+ str(mag_tot_sagn) + "_" \
+ str(limg_cat[2]) + "_" \
+ str(mag_tot) + "_full.fits"
pyfits.writeto(fits_out, fimage, overwrite=True)
def output_lensed_images(input_fits,yy1,yy2,ys1,ys2,dsi):
g_source = pyfits.getdata(input_fits)
g_source = np.array(g_source,dtype="<d")
#g_source_pin = lv4.call_ray_tracing(g_source,xx1,xx2,g_xcen,g_ycen,dsi)
g_lensimage = lv4.call_ray_tracing(g_source,yy1,yy2,ys1,ys2,dsi)
return g_lensimage
def single_run_test(ind,ysc1,ysc2,q,vd,pha,zl,zs):
dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 3.0000 #
#zl = 0.2 #zl is the redshift of the lens galaxy.
#zs = 1.0
#vd = 520 #Velocity Dispersion.
nnn = 128 #Image dimension
bsz = dsx_sdss*nnn # arcsecs
dsx = bsz/nnn # pixel size of SDSS detector.
nstd = 59 #^2
xx01 = np.linspace(-bsz/2.0,bsz/2.0,nnn)+0.5*dsx
xx02 = np.linspace(-bsz/2.0,bsz/2.0,nnn)+0.5*dsx
xi2,xi1 = np.meshgrid(xx01,xx02)
#----------------------------------------------------------------------
#ysc1 = 0.2
#ysc2 = 0.5
dsi = 0.03
g_source = pyfits.getdata("./439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source,dtype="<d")*10.0
g_source[g_source<=0.0001] = 1e-6
#print np.sum(g_source)
#print np.max(g_source)
#pl.figure()
#pl.contourf(g_source)
#pl.colorbar()
#g_source = p2p.cosccd2mag(g_source)
##g_source = p2p.mag2sdssccd(g_source)
##print np.max(g_source*13*13*52.0)
#pl.figure()
#pl.contourf(g_source)
#pl.colorbar()
#----------------------------------------------------------------------
xc1 = 0.0 #x coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0 #y coordinate of the center of lens (in units of Einstein radius).
#q = 0.7 #Ellipticity of lens.
rc = 0.0 #Core size of lens (in units of Einstein radius).
re = re_sv(vd,zl,zs) #Einstein radius of lens.
#pha = 45.0 #Orintation of lens.
lpar = np.asarray([xc1,xc2,q,rc,re,pha])
#----------------------------------------------------------------------
ai1,ai2,mua = lens_equation_sie(xi1,xi2,lpar)
yi1 = xi1-ai1
yi2 = xi2-ai2
g_limage = lv4.call_ray_tracing(g_source,yi1,yi2,ysc1,ysc2,dsi)
g_limage[g_limage<=0.0001] = 1e-6
g_limage = p2p.cosccd2mag(g_limage)
g_limage = p2p.mag2sdssccd(g_limage)
#pl.figure()
#pl.imshow((g_limage),interpolation='lanczos',cmap=cm.gray)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
dA = Planck13.comoving_distance(zl).value*1000./(1+zl)
Re = dA*np.sin(R*np.pi/180./3600.)
counts =Brightness(Re,vd)
vpar = np.asarray([counts,R,xc1,xc2,q,pha])
#g_lens = deVaucouleurs(xi1,xi2,xc1,xc2,counts,R,1.0-q,pha)
g_lens = de_vaucouleurs_2d(xi1,xi2,vpar)
#pl.figure()
#pl.imshow((g_lens),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
g_clean_ccd = g_lens+g_limage
#pl.figure()
#pl.imshow((g_clean_ccd),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
g_clean_ccd = congrid.congrid(g_clean_ccd,[128,128])
#-------------------------------------------------------------
file_psf = "../PSF_and_noise/sdsspsf.fits"
g_psf = pyfits.getdata(file_psf)-1000.0
g_psf = g_psf/np.sum(g_psf)
#new_shape=[0,0]
#new_shape[0]=np.shape(g_psf)[0]*dsx_sdss/dsx
#new_shape[1]=np.shape(g_psf)[1]*dsx_sdss/dsx
#g_psf = rebin_psf(g_psf,new_shape)
g_images_psf = ss.fftconvolve(g_clean_ccd,g_psf,mode="same")
#g_images_psf = ss.convolve(g_clean_ccd,g_psf,mode="same")
#g_images_psf = g_clean_ccd
#pl.figure()
#pl.imshow((g_psf),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
#g_noise = noise_map(nnn,nnn,np.sqrt(nstd),"Gaussian")
g_noise = noise_map(128,128,np.sqrt(nstd),"Gaussian")
g_final = g_images_psf+g_noise
#pl.figure()
#pl.imshow((g_final.T),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
g_final_rebin = congrid.congrid(g_final,[128,128])
#pl.figure()
#pl.imshow((g_final_rebin.T),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
#-------------------------------------------------------------
output_filename = "../output_fits/"+str(ind)+".fits"
pyfits.writeto(output_filename,g_final_rebin,clobber=True)
pl.show()
return 0
def single_run_test(ind, ysc1, ysc2, q, vd, pha, zl, zs):
dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 3.0000 #
nnn = 300 #Image dimension
bsz = 9.0 # arcsecs
dsx = bsz / nnn # pixel size of SDSS detector.
nstd = 59 #^2
xx01 = np.linspace(-bsz / 2.0, bsz / 2.0, nnn) + 0.5 * dsx
xx02 = np.linspace(-bsz / 2.0, bsz / 2.0, nnn) + 0.5 * dsx
xi2, xi1 = np.meshgrid(xx01, xx02)
#----------------------------------------------------------------------
dsi = 0.03
g_source = pyfits.getdata("./439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d") * 10.0
g_source[g_source <= 0.0001] = 1e-6
#----------------------------------------------------------------------
xc1 = 0.0 #x coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0 #y coordinate of the center of lens (in units of Einstein radius).
#q = 0.7 #Ellipticity of lens.
rc = 0.0 #Core size of lens (in units of Einstein radius).
re = re_sv(vd, zl, zs) #Einstein radius of lens.
#pha = 45.0 #Orintation of lens.
lpar = np.asarray([xc1, xc2, q, rc, re, pha])
#----------------------------------------------------------------------
ai1, ai2, mua = lens_equation_sie(xi1, xi2, lpar)
yi1 = xi1 - ai1
yi2 = xi2 - ai2
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
g_limage[g_limage <= 0.0001] = 1e-6
g_limage = p2p.cosccd2mag(g_limage)
g_limage = p2p.mag2sdssccd(g_limage)
#-------------------------------------------------------------
# Need to be Caliborate the mags
dA = Planck13.comoving_distance(zl).value * 1000. / (1 + zl)
Re = dA * np.sin(R * np.pi / 180. / 3600.)
counts = Brightness(Re, vd)
vpar = np.asarray([counts, R, xc1, xc2, q, pha])
#g_lens = deVaucouleurs(xi1,xi2,xc1,xc2,counts,R,1.0-q,pha)
g_lens = de_vaucouleurs_2d(xi1, xi2, vpar)
#pl.figure()
#pl.contourf(g_lens)
#pl.colorbar()
g_clean_ccd1 = g_lens * 0.0 + g_limage
g_clean_ccd2 = g_lens * 1.0 + g_limage
from scipy.ndimage.filters import gaussian_filter
pl.figure()
pl.contourf(g_clean_ccd1)
pl.colorbar()
pl.savefig("./output_pngs/" + str(i) + "_lensed_imgs_only.png")
#-------------------------------------------------------------
g_images_psf1 = gaussian_filter(g_clean_ccd1, 2.0)
g_images_psf2 = gaussian_filter(g_clean_ccd2, 2.0)
#g_images_psf = ss.convolve(g_clean_ccd,g_psf,mode="same")
#g_images_psf = g_clean_ccd
#-------------------------------------------------------------
# Need to be Caliborate the mags
g_noise = noise_map(nnn, nnn, np.sqrt(nstd), "Gaussian")
#output_filename = "./output_fits/noise_map.fits"
#pyfits.writeto(output_filename,g_noise,clobber=True)
#-------------------------------------------------------------
g_final1 = g_images_psf1 + g_noise
output_filename = "./output_fits/" + str(i) + "_lensed_imgs_only.fits"
pyfits.writeto(output_filename, g_final1, clobber=True)
#-------------------------------------------------------------
g_final2 = g_images_psf2 + g_noise
output_filename = "./output_fits/" + str(i) + "_all_imgs.fits"
pyfits.writeto(output_filename, g_final2, clobber=True)
return 0
def single_run_test(ind, ysc1, ysc2, q, vd, pha, zl, zs):
zeropoint = 18
dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 2.9918 #vd is velocity dispersion.
#zl = 0.2 #zl is the redshift of the lens galaxy.
#zs = 1.0
#vd = 520 #Velocity Dispersion.
nnn = 512 #Image dimension
bsz = 30.0 # arcsecs
dsx = bsz / nnn # pixel size of SDSS detector.
nstd = 59
xx01 = np.linspace(-bsz / 2.0, bsz / 2.0, nnn) + 0.5 * dsx
xx02 = np.linspace(-bsz / 2.0, bsz / 2.0, nnn) + 0.5 * dsx
xi2, xi1 = np.meshgrid(xx01, xx02)
#----------------------------------------------------------------------
#ysc1 = 0.2
#ysc2 = 0.5
dsi = 0.03
g_source = pyfits.getdata("./439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d")
g_source = p2p.pixcos2pixsdss(g_source)
#----------------------------------------------------------------------
xc1 = 0.0 #x coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0 #y coordinate of the center of lens (in units of Einstein radius).
#q = 0.7 #Ellipticity of lens.
rc = 0.0 #Core size of lens (in units of Einstein radius).
re = re_sv(vd, zl, zs) #Einstein radius of lens.
#pha = 45.0 #Orintation of lens.
lpar = np.asarray([xc1, xc2, q, rc, re, pha])
#----------------------------------------------------------------------
ai1, ai2, mua = lens_equation_sie(xi1, xi2, lpar)
yi1 = xi1 - ai1
yi2 = xi2 - ai2
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
g_limage = mag_to_flux(g_limage, zeropoint)
#pl.figure()
#pl.contourf(xi1,xi2,g_limage)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
dA = Planck13.comoving_distance(zl).value * 1000. / (1 + zl)
Re = dA * np.sin(R * np.pi / 180. / 3600.)
counts = Brightness(R, vd)
vpar = np.asarray([counts, Re, xc1, xc2, q, pha])
#g_lens = deVaucouleurs(xi1,xi2,xc1,xc2,counts,R,1.0-q,pha)
g_lens = de_vaucouleurs_2d(xi1, xi2, vpar)
g_lens = ncounts_to_flux(g_lens * 1.5e-4, zeropoint)
#-------------------------------------------------------------
file_psf = "../PSF_and_noise/sdsspsf.fits"
g_psf = pyfits.getdata(file_psf) - 1000.0
g_psf = g_psf / np.sum(g_psf)
new_shape = [0, 0]
new_shape[0] = np.shape(g_psf)[0] * dsx_sdss / dsx
new_shape[1] = np.shape(g_psf)[1] * dsx_sdss / dsx
g_psf = rebin_psf(g_psf, new_shape)
print(np.max(g_psf))
g_limage = ss.fftconvolve(g_limage + g_lens, g_psf, mode="same")
#pl.figure()
#pl.contourf(xi1,xi2,g_limage)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
g_noise = noise_map(nnn, nnn, nstd, "Gaussian")
g_noise = ncounts_to_flux(g_noise * 1e-0 + skycount, zeropoint)
g_limage = g_limage + g_noise
print np.shape(g_limage)
g_limage = congrid.congrid(g_limage, [128, 128])
g_limage = g_limage - np.min(g_limage)
pl.figure()
#pl.contourf(xi1,xi2,g_limage)
pl.contourf(g_limage)
pl.colorbar()
#-------------------------------------------------------------
output_filename = "../output_fits/" + str(ind) + ".fits"
pyfits.writeto(output_filename, g_limage, clobber=True)
pl.show()
return 0
def single_run_test(ind, ysc1, ysc2, q, vd, pha, zl, zs, lens_tag=1):
# dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 3.0
nnn = 400 # Image dimension
bsz = 9.0 # arcsecs
dsx = bsz / nnn # pixel size of SDSS detector.
nstd = 59 # ^2
xi1, xi2 = make_r_coor(nnn, dsx)
# ----------------------------------------------------------------------
dsi = 0.03
g_source = pyfits.getdata(
"./gals_sources/439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d") * 10.0
g_source[g_source <= 0.0001] = 1e-6
# ----------------------------------------------------------------------
# x coordinate of the center of lens (in units of Einstein radius).
xc1 = 0.0
# y coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0
rc = 0.0 # Core size of lens (in units of Einstein radius).
re = re_sv(vd, zl, zs) # Einstein radius of lens.
print "re = ", re
re_sub = 0.0 * re
a_sub = a_b_bh(re_sub, re)
ext_shears = 0.06
ext_angle = -0.39
ext_kappa = 0.08
# ext_shears = 0.0
# ext_angle = 0.0
# ext_kappa = 0.0
# ----------------------------------------------------------------------
#lpar = np.asarray([xc1, xc2, q, rc, re, pha])
#ai1, ai2, kappa_out, shr1, shr2, mua = lensing_signals_sie(xi1, xi2, lpar)
#ar = np.sqrt(ai1 * ai1 + ai2 * ai2)
# psi_nie = psk.potential_nie(xc1, xc2, pha, q, re, rc, ext_shears, ext_angle,
# ext_kappa, xi1, xi2)
#ai1, ai2 = np.gradient(psi_nie, dsx)
ai1, ai2 = psk.deflection_nie(xc1, xc2, pha, q, re, rc, ext_shears,
ext_angle, ext_kappa, xi1, xi2)
as1, as2 = psk.deflection_sub_pJaffe(0.0, -2.169, re_sub, 0.0, a_sub, xi1,
xi2)
yi1 = xi1 - ai1 - as1
yi2 = xi2 - ai2 - as2
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
g_limage[g_limage <= 0.25] = 1e-6
# pl.figure()
# pl.contourf(g_limage)
# pl.colorbar()
g_limage = cosccd2mag(g_limage)
g_limage = mag2sdssccd(g_limage)
# pl.figure()
# pl.contourf(g_limage)
# pl.colorbar()
# -------------------------------------------------------------
dA = Planck13.comoving_distance(zl).value * 1000. / (1.0 + zl)
Re = dA * np.sin(R * np.pi / 180. / 3600.)
counts = Brightness(Re, vd)
vpar = np.asarray([counts, R, xc1, xc2, q, pha])
g_lens = de_vaucouleurs_2d(xi1, xi2, vpar)
g_clean_ccd = g_lens * lens_tag + g_limage
output_filename = "./fits_outputs/clean_lensed_imgs.fits"
pyfits.writeto(output_filename, g_clean_ccd, overwrite=True)
# -------------------------------------------------------------
from scipy.ndimage.filters import gaussian_filter
g_images_psf = gaussian_filter(g_clean_ccd, 2.0)
# -------------------------------------------------------------
g_noise = noise_map(nnn, nnn, np.sqrt(nstd), "Gaussian")
output_filename = "./fits_outputs/noise_map.fits"
pyfits.writeto(output_filename, g_noise, overwrite=True)
g_final = g_images_psf + g_noise
# -------------------------------------------------------------
g_clean_ccd = g_limage
g_images_psf = gaussian_filter(g_clean_ccd, 2.0)
g_final = g_images_psf + g_noise
output_filename = "./fits_outputs/lensed_imgs_only.fits"
pyfits.writeto(output_filename, g_final, overwrite=True)
# -------------------------------------------------------------
output_filename = "./fits_outputs/full_lensed_imgs.fits"
pyfits.writeto(output_filename, g_final + g_lens, overwrite=True)
# pl.figure()
# pl.contourf(g_final)
# pl.colorbar()
return 0
g_xcen = 0.0 # x position of center (also try (0.0,0.14)
g_ycen = 0.0 # y position of center
g_axrat = 1.0 # minor-to-major axis ratio
g_pa = 0.0 # major-axis position angle (degrees) c.c.w. from x axis
#----------------------------------------------------------------------
#g_source = 0.0*xx1
#gpar = np.asarray([g_amp,g_sig,g_xcen,g_ycen,g_axrat,g_pa])
#g_source = gauss_2d(xx1,xx2,gpar)
#g_lensimage = 0.0*yi1
#g_lensimage = gauss_2d(yi1,yi2,gpar)
#g_source = pyfits.getdata("./compound_R_1_0_S_1_1_u.fits")
input_fits = sys.argv[1]
g_source = pyfits.getdata(input_fits)
g_source = np.array(g_source,dtype="<d")
g_source_pin = lv4.call_ray_tracing(g_source,xx1,xx2,g_xcen,g_ycen,dsi)
g_lensimage = lv4.call_ray_tracing(g_source,yi1,yi2,g_xcen,g_ycen,dsi)
filename = "output.fits"
pyfits.writeto(filename,g_lensimage,clobber=True)
##--------------------------lens images contour------------------------
##levels = [0.15,0.30,0.45,0.60,0.75,0.9,1.05]
#figure(num=None,figsize=(10,5),dpi=80, facecolor='w', edgecolor='k')
#a = axes([0.05,0.1,0.4,0.8])
#a.set_xlim(-boxsize/4.0,boxsize/4.0)
#a.set_ylim(-boxsize/4.0,boxsize/4.0)
#a.contourf(xx1,xx2,g_source_pin)
##a.contour(yi1,yi2,mua,0,colors=('g'),linewidths = 2.0)
def run_main():
#----------------------------------------------------------------------
SnapID = 135
HaloID = 50
bsz = 200.0 # kpc/h
zl = 0.5
zs = 2.0
#zs0= 10.0
nnn = 512
dsi = 0.03
dm = il.snapshot.loadHalo(basePath, SnapID, HaloID, 'dm')
#npp = dm['count']
x1 = dm['Coordinates'][:, 0] #/1e3/(1.0+zl) # Mpc/h, comoving
x2 = dm['Coordinates'][:, 1] #/1e3/(1.0+zl) # Mpc/h, comoving
x3 = dm['Coordinates'][:, 2] #/1e3/(1.0+zl) # Mpc/h, comoving
ptnl_p = dm['Potential']
idx_ptnl_p_min = ptnl_p == ptnl_p.min()
xcp1 = x1[idx_ptnl_p_min]
xcp2 = x2[idx_ptnl_p_min]
xcp3 = x3[idx_ptnl_p_min]
sdens = read_sdens_from_illustris(dm, x1 - xcp1, x2 - xcp2, x3 - xcp3, bsz,
nnn)
#kappa = sdens/mm.sigma_crit(zl,zs)
#----------------------------------------------------------------------
bsz = bsz / 1e3 / mm.Da(zl) * mm.apr #arcsec
dsx = bsz / nnn #arcsec
print bsz
print dsx
xi1, xi2 = make_r_coor(nnn, dsx)
ai1, ai2 = pcs.call_cal_alphas0(sdens, nnn, bsz, zl, zs)
yi1 = xi1 - ai1
yi2 = xi2 - ai2
phi = pcs.call_cal_phi(sdens, nnn, bsz, zl, zs)
mua = pcs.call_alphas_to_mu(ai1, ai2, nnn, dsx)
#----------------------------------------------------------------------
ys1 = 0.0
ys2 = 0.0
xroot1, xroot2, nroots = trf.roots_zeros(xi1, xi2, ai1, ai2, ys1, ys2)
#pl.figure()
#pl.plot(ys1,ys2,'ko')
#pl.plot(xroot1,xroot2,'rs')
#pl.contour(xi1,xi2,mua)
#pl.contour(yi1,yi2,mua)
#pl.colorbar()
muii = pcs.call_inverse_cic_single(mua, xroot1, xroot2, dsx)
phii = pcs.call_inverse_cic_single(phi, xroot1, xroot2, dsx)
Kc = (1.0 + zl) / mm.vc * (mm.Da(zl) * mm.Da(zs) / mm.Da2(
zl, zs)) * mm.Mpc / (1e3 * mm.dy) / mm.apr / mm.apr
td = Kc * (0.5 * ((xroot1 - ys1)**2.0 + (xroot2 - ys2)**2.0) - phii)
time_days, mags = np.loadtxt("./SN_opsim.csv",
dtype='string',
delimiter=',',
usecols=(1, 4),
unpack=True)
time_days = time_days.astype("double")
#------------------------------------------------------------------------------
ldays = np.zeros((nroots, len(time_days)))
for i in xrange(nroots):
ldays[i, :] = time_days + td[i]
mags = mags.astype("double")
lmags = np.zeros((nroots, len(time_days)))
for i in xrange(nroots):
lmags[i, :] = mags - 2.5 * np.log10(np.abs(muii[i]))
#cmap = mpl.cm.jet_r
cmap = mpl.cm.gist_earth
pl.figure(figsize=(8, 8))
pl.xlabel("Days")
pl.ylabel("Mags")
pl.ylim(30, 22)
for i in xrange(nroots):
pl.plot(ldays[i, :] - 49500 + 31010 - 50,
lmags[i, :],
linestyle='-',
color=cmap(i / float(nroots)),
markersize=10)
#pl.plot(ldays[0,:]-49500+31010-50,lmags[0,:],linestyle='-',color="k")
#pl.plot(ldays[1,:]-49500+31010-50,lmags[1,:],linestyle='-',color="b")
#pl.plot(ldays[2,:]-49500+31010-50,lmags[2,:],linestyle='-',color="g")
#pl.plot(ldays[3,:]-49500+31010-50,lmags[3,:],linestyle='-',color="m")
#pl.plot(ldays[4,:]-49500+31010-50,lmags[4,:],linestyle='-',color="r")
pl.figure(figsize=(8, 8))
#pl.xlim(-bsz/2.0,bsz/2.0)
#pl.ylim(-bsz/2.0,bsz/2.0)
pl.xlim(-10.0, 10.0)
pl.ylim(-10.0, 10.0)
pl.xlabel("arcsec")
pl.ylabel("arcsec")
for i in xrange(nroots):
pl.plot(xroot1[i],
xroot2[i],
marker='o',
color=cmap(i / float(nroots)),
markersize=10)
#pl.plot(xroot1[0],xroot2[0],marker='o',color="k",markersize=15) #
#pl.plot(xroot1[1],xroot2[1],marker='o',color="b",markersize=15) #
#pl.plot(xroot1[2],xroot2[2],marker='o',color="g",markersize=15) #
#pl.plot(xroot1[3],xroot2[3],marker='o',color="m",markersize=15) #
#pl.plot(xroot1[4],xroot2[4],marker='o',color="r",markersize=15) #
pl.contour(xi1, xi2, mua, colors=('r', ))
pl.contour(yi1, yi2, mua, colors=('g', ))
pl.plot(ys1, ys2, 'cs')
print td
#------------------------------------------------------------------------------
ysc1 = 0.0
ysc2 = 0.0
g_source = pyfits.getdata(
"./dry_run_pipeline/439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d")
pl.figure()
pl.contourf(g_source)
pl.colorbar()
std_srcs = np.std(g_source)
print std_srcs, std_srcs * 4.0
gthhd = 6.0 * std_srcs
g_source = g_source - gthhd
g_source[g_source <= 0.0] = 0.0
lensed_img = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
#lensed_img = pcs.call_ray_tracing_single(ai1,ai2,nnn,bsz,zl)
lenses_img = slf.loadin_fits(HaloID, zl, bsz, nnn)
lroots = 10.0**((lmags - 25.523) / (-2.5))
final_img = lensed_img + lenses_img / 100.0
res = stacking_points_and_galaxies(xroot1, xroot2, lroots[:, 70],
final_img, bsz, nnn)
pl.figure()
pl.contourf(xi1, xi2, res)
pl.colorbar()
pyfits.writeto("all.fits", res, clobber=True)
return res
def single_run_test(ind,ysc1,ysc2,q,vd,pha,zl,zs):
zeropoint = 18
dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 2.9918 #vd is velocity dispersion.
#zl = 0.2 #zl is the redshift of the lens galaxy.
#zs = 1.0
#vd = 520 #Velocity Dispersion.
nnn = 512 #Image dimension
bsz = 30.0 # arcsecs
dsx = bsz/nnn # pixel size of SDSS detector.
nstd = 59
xx01 = np.linspace(-bsz/2.0,bsz/2.0,nnn)+0.5*dsx
xx02 = np.linspace(-bsz/2.0,bsz/2.0,nnn)+0.5*dsx
xi2,xi1 = np.meshgrid(xx01,xx02)
#----------------------------------------------------------------------
#ysc1 = 0.2
#ysc2 = 0.5
dsi = 0.03
g_source = pyfits.getdata("./439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source,dtype="<d")
g_source = p2p.pixcos2pixsdss(g_source)
#----------------------------------------------------------------------
xc1 = 0.0 #x coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0 #y coordinate of the center of lens (in units of Einstein radius).
#q = 0.7 #Ellipticity of lens.
rc = 0.0 #Core size of lens (in units of Einstein radius).
re = re_sv(vd,zl,zs) #Einstein radius of lens.
#pha = 45.0 #Orintation of lens.
lpar = np.asarray([xc1,xc2,q,rc,re,pha])
#----------------------------------------------------------------------
ai1,ai2,mua = lens_equation_sie(xi1,xi2,lpar)
yi1 = xi1-ai1
yi2 = xi2-ai2
g_limage = lv4.call_ray_tracing(g_source,yi1,yi2,ysc1,ysc2,dsi)
g_limage = mag_to_flux(g_limage,zeropoint)
#pl.figure()
#pl.contourf(xi1,xi2,g_limage)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
dA = Planck13.comoving_distance(zl).value*1000./(1+zl)
Re = dA*np.sin(R*np.pi/180./3600.)
counts =Brightness(R,vd)
vpar = np.asarray([counts,Re,xc1,xc2,q,pha])
#g_lens = deVaucouleurs(xi1,xi2,xc1,xc2,counts,R,1.0-q,pha)
g_lens = de_vaucouleurs_2d(xi1,xi2,vpar)
g_lens = ncounts_to_flux(g_lens*1.5e-4,zeropoint)
#-------------------------------------------------------------
file_psf = "../PSF_and_noise/sdsspsf.fits"
g_psf = pyfits.getdata(file_psf)-1000.0
g_psf = g_psf/np.sum(g_psf)
new_shape=[0,0]
new_shape[0]=np.shape(g_psf)[0]*dsx_sdss/dsx
new_shape[1]=np.shape(g_psf)[1]*dsx_sdss/dsx
g_psf = rebin_psf(g_psf,new_shape)
print(np.max(g_psf))
g_limage = ss.fftconvolve(g_limage+g_lens,g_psf,mode="same")
#pl.figure()
#pl.contourf(xi1,xi2,g_limage)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
g_noise = noise_map(nnn,nnn,nstd,"Gaussian")
g_noise = ncounts_to_flux(g_noise*1e-0+skycount,zeropoint)
g_limage = g_limage+g_noise
print np.shape(g_limage)
g_limage = congrid.congrid(g_limage,[128,128])
g_limage = g_limage-np.min(g_limage)
pl.figure()
#pl.contourf(xi1,xi2,g_limage)
pl.contourf(g_limage)
pl.colorbar()
#-------------------------------------------------------------
output_filename = "../output_fits/"+str(ind)+".fits"
pyfits.writeto(output_filename,g_limage,clobber=True)
pl.show()
return 0
def single_run_test(ind, ysc1, ysc2, q, vd, pha, zl, zs, lens_tag=1):
nnn = 400 # Image dimension
bsz = 9.0 # arcsecs
dsx = bsz / nnn # pixel size of SDSS detector.
nstd = 0.001 # ^2
xi1, xi2 = make_r_coor(nnn, dsx)
# ----------------------------------------------------------------------
dsi = 0.03
g_source = pyfits.getdata(
"./gals_sources/439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d")
g_std = np.std(g_source)
print g_std
g_source[g_source <= 6.0*g_std] = 1e-6
# ----------------------------------------------------------------------
# x coordinate of the center of lens (in units of Einstein radius).
xc1 = 0.0
# y coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0
rc = 0.0 # Core size of lens (in units of Einstein radius).
re = re_sv(vd, zl, zs) # Einstein radius of lens.
re_sub = 0.0 * re
a_sub = a_b_bh(re_sub, re)
ext_shears = 0.06
ext_angle = -0.39
ext_kappa = 0.08
# ext_shears = 0.0
# ext_angle = 0.0
# ext_kappa = 0.0
# ----------------------------------------------------------------------
ai1, ai2 = psk.deflection_nie(xc1, xc2, pha, q, re, rc, ext_shears, ext_angle,
ext_kappa, xi1, xi2)
as1, as2 = psk.deflection_sub_pJaffe(0.0, -2.169, re_sub, 0.0, a_sub, xi1, xi2)
yi1 = xi1 - ai1 - as1
yi2 = xi2 - ai2 - as2
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
# g_limage[g_limage <= 0.25] = 1e-6
# -------------------------------------------------------------
afactor = 0.01
Reff = 3.0
ell = q
ori = pha
g_lens = de_vaucouleurs_2d(xi1, xi2, xc1, xc2, afactor, Reff, ell, ori)
g_clean_ccd = g_lens + g_limage
output_filename = "./fits_outputs/clean_lensed_imgs.fits"
pyfits.writeto(output_filename, g_clean_ccd, overwrite=True)
# -------------------------------------------------------------
from scipy.ndimage.filters import gaussian_filter
g_images_psf = gaussian_filter(g_clean_ccd, 2.0)
# -------------------------------------------------------------
g_noise = noise_map(nnn, nnn, np.sqrt(nstd), "Gaussian")
output_filename = "./fits_outputs/noise_map.fits"
pyfits.writeto(output_filename, g_noise, overwrite=True)
g_final = g_images_psf + g_noise
# -------------------------------------------------------------
g_clean_ccd = g_limage
g_images_psf = gaussian_filter(g_clean_ccd, 2.0)
g_final = g_images_psf + g_noise
output_filename = "./fits_outputs/lensed_imgs_only.fits"
pyfits.writeto(output_filename, g_final, overwrite=True)
# -------------------------------------------------------------
output_filename = "./fits_outputs/full_lensed_imgs.fits"
pyfits.writeto(output_filename, g_final + g_lens, overwrite=True)
pl.figure()
pl.contourf(g_final + g_lens)
pl.colorbar()
# -------------------------------------------------------------
# al11,al12 = np.gradient(al1,dsx)
# al21,al22 = np.gradient(al2,dsx)
# mua = 1.0/(1.0-(al11+al22)+al11*al22-al12*al21)
return 0
def main():
nnn = 512
boxsize = 4.0
dsx = boxsize / nnn
dsi = dsx * 2.0
xi1 = np.linspace(-boxsize / 2.0, boxsize / 2.0 - dsx, nnn) + 0.5 * dsx
xi2 = np.linspace(-boxsize / 2.0, boxsize / 2.0 - dsx, nnn) + 0.5 * dsx
xi1, xi2 = np.meshgrid(xi1, xi2)
ysc1 = 0.0
ysc2 = 0.0
g_sn = pyfits.getdata("./compound_R_1_0_S_1_1_u.fits")
g_sn = np.array(g_sn, dtype="<d")
# cc = find_critical_curve(mu)
pygame.init()
FPS = 60
fpsClock = pygame.time.Clock()
screen = pygame.display.set_mode((nnn, nnn), 0, 32)
pygame.display.set_caption("Gravitational Lensing Toy")
mouse_cursor = pygame.Surface((nnn, nnn))
# ----------------------------------------------------
base0 = np.zeros((nnn, nnn, 3), "uint8")
base1 = np.zeros((nnn, nnn, 3), "uint8")
base2 = np.zeros((nnn, nnn, 3), "uint8")
# ----------------------------------------------------
# lens parameters for main halo
xlc1 = 0.0
xlc2 = 0.0
ql0 = 0.699999999999
rc0 = 0.000000000001
re0 = 1.0
phi0 = 30.0
lpar = np.asarray([xlc1, xlc2, re0, rc0, ql0, phi0])
lpars_list = []
lpars_list.append(lpar)
# ----------------------------------------------------
# lens parameters for main halo
xls1 = 0.7
xls2 = 0.8
qls = 0.999999999999
rcs = 0.000000000001
res = 0.0
phis = 0.0
lpars = np.asarray([xls1, xls2, res, rcs, qls, phis])
lpars_list.append(lpars)
ap0 = 1.0
l_sig0 = 0.5
glpar = np.asarray([ap0, l_sig0, xlc1, xlc2, ql0, phi0])
g_lens = lens_galaxies(xi1, xi2, glpar)
# base0[:,:,0] = g_lens*256
# base0[:,:,1] = g_lens*128
# base0[:,:,2] = g_lens*0
base0[:, :, 0] = g_lens * 0
base0[:, :, 1] = g_lens * 0
base0[:, :, 2] = g_lens * 0
x = 0
y = 0
step = 1
gr_sig = 0.1
LeftButton = 0
# ----------------------------------------------------
ic = FPS / 12.0
i = 0
while True:
i = i + 1
for event in pygame.event.get():
if event.type == QUIT:
exit()
if event.type == MOUSEMOTION:
if event.buttons[LeftButton]:
rel = event.rel
x += rel[0]
y += rel[1]
# ----------------------------------------------
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 4:
gr_sig -= 0.1
if gr_sig < 0.01:
gr_sig = 0.01
elif event.button == 5:
gr_sig += 0.01
if gr_sig > 0.4:
gr_sig = 0.4
keys = pygame.key.get_pressed() # checking pressed keys
if keys[pygame.K_RIGHT]:
x += step
if x > 500:
x = 500
if keys[pygame.K_LSHIFT] & keys[pygame.K_RIGHT]:
x += 30 * step
if keys[pygame.K_LEFT]:
x -= step
if x < -500:
x = -500
if keys[pygame.K_LSHIFT] & keys[pygame.K_LEFT]:
x -= 30 * step
if keys[pygame.K_UP]:
y -= step
if y < -500:
y = -500
if keys[pygame.K_LSHIFT] & keys[pygame.K_UP]:
y -= 30 * step
if keys[pygame.K_DOWN]:
y += step
if y > 500:
y = 500
if keys[pygame.K_LSHIFT] & keys[pygame.K_DOWN]:
y += 30 * step
# ----------------------------------------------
if keys[pygame.K_MINUS]:
gr_sig -= 0.01
if gr_sig < 0.01:
gr_sig = 0.01
if keys[pygame.K_EQUALS]:
gr_sig += 0.01
if gr_sig > 0.1:
gr_sig = 0.1
# gr_sig = 0.005
# ----------------------------------------------
# parameters of source galaxies.
# ----------------------------------------------
g_amp = 1.0 # peak brightness value
g_sig = gr_sig # Gaussian "sigma" (i.e., size)
g_xcen = x * 2.0 / nnn # x position of center
g_ycen = y * 2.0 / nnn # y position of center
g_axrat = 1.0 # minor-to-major axis ratio
g_pa = 0.0 # major-axis position angle (degrees) c.c.w. from y axis
gpar = np.asarray([g_amp, g_sig, g_ycen, g_xcen, g_axrat, g_pa])
# ----------------------------------------------
# ----------------------------------------------
# parameters of SNs.
# ----------------------------------------------
g_amp = 1.0 # peak brightness value
g_sig = 0.1 # Gaussian "sigma" (i.e., size)
g_xcen = y * 2.0 / nnn + 0.05 # x position of center
g_ycen = x * 2.0 / nnn + 0.05 # y position of center
g_axrat = 1.0 # minor-to-major axis ratio
g_pa = 0.0 # major-axis position angle (degrees) c.c.w. from y axis
gpsn = np.asarray([g_amp, g_sig, g_ycen, g_xcen, g_axrat, g_pa])
phi, td, ai1, ai2, kappa, mu, yi1, yi2 = nie_all(xi1, xi2, xlc1, xlc2, re0, rc0, ql0, phi0, g_ycen, g_xcen)
g_image, g_lensimage = lensed_images(xi1, xi2, yi1, yi2, gpar)
g_image = g_image * 0.0
g_lensimage = g_lensimage * 0.0
# g_sn,g_lsn = lensed_images_point(xi1,xi2,yi1,yi2,gpsn)
# g_sn = tophat_2d(xi1,xi2,gpsn)
# g_sn_pin = lv4.call_ray_tracing(g_sn,xi1,xi2,ysc1,ysc2,dsi)
# g_lsn = lv4.call_ray_tracing(g_sn,yi1,yi2,ysc1,ysc2,dsi)
g_sn_pin = lv4.call_ray_tracing(g_sn, xi1, xi2, g_xcen, g_ycen, dsi)
g_lsn = lv4.call_ray_tracing(g_sn, yi1, yi2, g_xcen, g_ycen, dsi)
# sktd = td/td.max()*ic
# itmp = (i+30-sktd)%(FPS)
# ratio = (ic-itmp)*itmp/(ic/2.0)**2.0
# sktd0 = 0.0*sktd
# itmp0 = (i+90-sktd0)%(FPS)
# ratio0 = (ic-itmp0)*itmp0/(ic/2.0)**2.0
# ratio[ratio<0]=0.0
# ratio0[ratio0<0]=0.0
# sktd = td/td.max()*ic
# itmp = (i)%(FPS+30)
# ratio = gauss_1d(itmp,2.0*ic+sktd-20,ic,2.0)
# ratio0 = gauss_1d(itmp,2.0*ic,ic,2.0)
sktd = td / td.max() * ic
itmp = (i) % (FPS)
ratio = parabola_1d(itmp, 30 + sktd, ic, 2.0 / ic ** 2.0)
ratio0 = parabola_1d(itmp, 0.0 * sktd, ic, 2.0 / ic ** 2.0)
# base2[:,:,0] = g_lensimage*102*(1+ratio)
# base2[:,:,1] = g_lensimage*178*(1+ratio)
# base2[:,:,2] = g_lensimage*256*(1+ratio)
# base2[:,:,0] = g_lensimage*102*(1.0+ratio)/2
# base2[:,:,1] = g_lensimage*178*(1.0+ratio)/2
# base2[:,:,2] = g_lensimage*256*(1.0+ratio)/2
base1[:, :, 0] = g_sn_pin * 100 * (1.0 + ratio0) / 2 + g_image * 256
base1[:, :, 1] = g_sn_pin * 100 * (1.0 + ratio0) / 2 + g_image * 256
base1[:, :, 2] = g_sn_pin * 100 * (1.0 + ratio0) / 2 + g_image * 256
base2[:, :, 0] = g_lsn * 100 * (1.0 + ratio) / 2 + g_lensimage * 102
base2[:, :, 1] = g_lsn * 100 * (1.0 + ratio) / 2 + g_lensimage * 178
base2[:, :, 2] = g_lsn * 100 * (1.0 + ratio) / 2 + g_lensimage * 256
wf = base1 + base2
idx1 = wf >= base0
idx2 = wf < base0
base = base0 * 0
base[idx1] = wf[idx1]
base[idx2] = base0[idx2]
# base = wf*base0+(base1+base2)
pygame.surfarray.blit_array(mouse_cursor, base)
screen.blit(mouse_cursor, (0, 0))
# font=pygame.font.SysFont(None,30)
# text = font.render("( "+str(x)+", "+str(-y)+" )", True, (255, 255, 255))
# screen.blit(text,(10, 10))
pygame.display.update()
fpsClock.tick(FPS)
def single_run_test(ind, ysc1, ysc2, q, vd, pha, zl, zs):
dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 3.0000 #
#zl = 0.2 #zl is the redshift of the lens galaxy.
#zs = 1.0
#vd = 520 #Velocity Dispersion.
nnn = 128 #Image dimension
bsz = dsx_sdss * nnn # arcsecs
dsx = bsz / nnn # pixel size of SDSS detector.
nstd = 59 #^2
xx01 = np.linspace(-bsz / 2.0, bsz / 2.0, nnn) + 0.5 * dsx
xx02 = np.linspace(-bsz / 2.0, bsz / 2.0, nnn) + 0.5 * dsx
xi2, xi1 = np.meshgrid(xx01, xx02)
#----------------------------------------------------------------------
#ysc1 = 0.2
#ysc2 = 0.5
dsi = 0.03
g_source = pyfits.getdata("./439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source, dtype="<d") * 10.0
g_source[g_source <= 0.0001] = 1e-6
#print np.sum(g_source)
#print np.max(g_source)
#pl.figure()
#pl.contourf(g_source)
#pl.colorbar()
#g_source = p2p.cosccd2mag(g_source)
##g_source = p2p.mag2sdssccd(g_source)
##print np.max(g_source*13*13*52.0)
#pl.figure()
#pl.contourf(g_source)
#pl.colorbar()
#----------------------------------------------------------------------
xc1 = 0.0 #x coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0 #y coordinate of the center of lens (in units of Einstein radius).
#q = 0.7 #Ellipticity of lens.
rc = 0.0 #Core size of lens (in units of Einstein radius).
re = re_sv(vd, zl, zs) #Einstein radius of lens.
#pha = 45.0 #Orintation of lens.
lpar = np.asarray([xc1, xc2, q, rc, re, pha])
#----------------------------------------------------------------------
ai1, ai2, mua = lens_equation_sie(xi1, xi2, lpar)
yi1 = xi1 - ai1
yi2 = xi2 - ai2
g_limage = lv4.call_ray_tracing(g_source, yi1, yi2, ysc1, ysc2, dsi)
g_limage[g_limage <= 0.0001] = 1e-6
g_limage = p2p.cosccd2mag(g_limage)
g_limage = p2p.mag2sdssccd(g_limage)
#pl.figure()
#pl.imshow((g_limage),interpolation='lanczos',cmap=cm.gray)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
dA = Planck13.comoving_distance(zl).value * 1000. / (1 + zl)
Re = dA * np.sin(R * np.pi / 180. / 3600.)
counts = Brightness(Re, vd)
vpar = np.asarray([counts, R, xc1, xc2, q, pha])
#g_lens = deVaucouleurs(xi1,xi2,xc1,xc2,counts,R,1.0-q,pha)
g_lens = de_vaucouleurs_2d(xi1, xi2, vpar)
#pl.figure()
#pl.imshow((g_lens),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
g_clean_ccd = g_lens + g_limage
#pl.figure()
#pl.imshow((g_clean_ccd),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
g_clean_ccd = congrid.congrid(g_clean_ccd, [128, 128])
#-------------------------------------------------------------
file_psf = "../PSF_and_noise/sdsspsf.fits"
g_psf = pyfits.getdata(file_psf) - 1000.0
g_psf = g_psf / np.sum(g_psf)
#new_shape=[0,0]
#new_shape[0]=np.shape(g_psf)[0]*dsx_sdss/dsx
#new_shape[1]=np.shape(g_psf)[1]*dsx_sdss/dsx
#g_psf = rebin_psf(g_psf,new_shape)
g_images_psf = ss.fftconvolve(g_clean_ccd, g_psf, mode="same")
#g_images_psf = ss.convolve(g_clean_ccd,g_psf,mode="same")
#g_images_psf = g_clean_ccd
#pl.figure()
#pl.imshow((g_psf),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
#-------------------------------------------------------------
# Need to be Caliborate the mags
#g_noise = noise_map(nnn,nnn,np.sqrt(nstd),"Gaussian")
g_noise = noise_map(128, 128, np.sqrt(nstd), "Gaussian")
g_final = g_images_psf + g_noise
#pl.figure()
#pl.imshow((g_final.T),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
g_final_rebin = congrid.congrid(g_final, [128, 128])
#pl.figure()
#pl.imshow((g_final_rebin.T),interpolation='nearest',cmap=cm.gray)
#pl.colorbar()
#-------------------------------------------------------------
output_filename = "../output_fits/" + str(ind) + ".fits"
pyfits.writeto(output_filename, g_final_rebin, clobber=True)
pl.show()
return 0
def single_run_test(ind,ysc1,ysc2,q,vd,pha,zl,zs):
dsx_sdss = 0.396 # pixel size of SDSS detector.
R = 3.0000 #
nnn = 300 #Image dimension
bsz = 9.0 # arcsecs
dsx = bsz/nnn # pixel size of SDSS detector.
nstd = 59 #^2
xx01 = np.linspace(-bsz/2.0,bsz/2.0,nnn)+0.5*dsx
xx02 = np.linspace(-bsz/2.0,bsz/2.0,nnn)+0.5*dsx
xi2,xi1 = np.meshgrid(xx01,xx02)
#----------------------------------------------------------------------
dsi = 0.03
g_source = pyfits.getdata("./439.0_149.482739_1.889989_processed.fits")
g_source = np.array(g_source,dtype="<d")*10.0
g_source[g_source<=0.0001] = 1e-6
#----------------------------------------------------------------------
xc1 = 0.0 #x coordinate of the center of lens (in units of Einstein radius).
xc2 = 0.0 #y coordinate of the center of lens (in units of Einstein radius).
#q = 0.7 #Ellipticity of lens.
rc = 0.0 #Core size of lens (in units of Einstein radius).
re = re_sv(vd,zl,zs) #Einstein radius of lens.
#pha = 45.0 #Orintation of lens.
lpar = np.asarray([xc1,xc2,q,rc,re,pha])
#----------------------------------------------------------------------
ai1,ai2,mua = lens_equation_sie(xi1,xi2,lpar)
yi1 = xi1-ai1
yi2 = xi2-ai2
g_limage = lv4.call_ray_tracing(g_source,xi1,xi2,ysc1,ysc2,dsi)
g_limage[g_limage<=0.0001] = 1e-6
g_limage = p2p.cosccd2mag(g_limage)
g_limage = p2p.mag2sdssccd(g_limage)
#-------------------------------------------------------------
# Need to be Caliborate the mags
dA = Planck13.comoving_distance(zl).value*1000./(1+zl)
Re = dA*np.sin(R*np.pi/180./3600.)
counts =Brightness(Re,vd)
vpar = np.asarray([counts,R,xc1,xc2,q,pha])
#g_lens = deVaucouleurs(xi1,xi2,xc1,xc2,counts,R,1.0-q,pha)
g_lens = de_vaucouleurs_2d(xi1,xi2,vpar)
#pl.figure()
#pl.contourf(g_lens)
#pl.colorbar()
g_clean_ccd1 = g_lens*0.0+g_limage
g_clean_ccd2 = g_lens*1.0+g_limage
from scipy.ndimage.filters import gaussian_filter
pl.figure()
pl.contourf(g_clean_ccd1)
pl.colorbar()
pl.savefig("/Users/uranus/GitHub/data_arc_finding_cnn/unlensed_output_pngs/"+str(i)+"_lensed_imgs_only.png")
#-------------------------------------------------------------
g_images_psf1 = gaussian_filter(g_clean_ccd1, 2.0)
g_images_psf2 = gaussian_filter(g_clean_ccd2, 2.0)
#g_images_psf = ss.convolve(g_clean_ccd,g_psf,mode="same")
#g_images_psf = g_clean_ccd
#-------------------------------------------------------------
# Need to be Caliborate the mags
g_noise = noise_map(nnn,nnn,np.sqrt(nstd),"Gaussian")
#output_filename = "./output_fits/noise_map.fits"
#pyfits.writeto(output_filename,g_noise,clobber=True)
#-------------------------------------------------------------
g_final1 = g_images_psf1+g_noise
output_filename = "/Users/uranus/GitHub/data_arc_finding_cnn/unlensed_output_fits/"+str(i)+"_lensed_imgs_only.fits"
pyfits.writeto(output_filename,g_final1,clobber=True)
#-------------------------------------------------------------
g_final2 = g_images_psf2+g_noise
output_filename = "/Users/uranus/GitHub/data_arc_finding_cnn/unlensed_output_fits/"+str(i)+"_all_imgs.fits"
pyfits.writeto(output_filename,g_final2,clobber=True)
return 0
def main():
nnn = 512
dsi = 0.2
dsx = 0.2
boxsize = 0.2*nnn
zzl = 0.5
zs0 = 10.0
xi1 = np.linspace(-boxsize/2.0,boxsize/2.0-dsx,nnn)+0.5*dsx
xi2 = np.linspace(-boxsize/2.0,boxsize/2.0-dsx,nnn)+0.5*dsx
xi1,xi2 = np.meshgrid(xi1,xi2)
limages = np.zeros((nnn,nnn))
#----------------------------------------------------
# lens parameters for main halo
xlc1 = -1.5
xlc2 = 0.0
ql0 = 0.699999999999
rc0 = 0.000000000001
re0 = 6.0
#phi0 = 30.0
band = sys.argv[1]
ai01,ai02 = nie_alphas(xi1,xi2,xlc1,xlc2,re0,rc0,ql0)
gimage = pyfits.getdata("../gals_lens_galsim/test_"+band+".fits")
#----------------------------------------------------
ysc1 = 0.0
ysc2 = 0.0
factor_z = 0;
factor_z0 = mm.Da(zs0)/mm.Da2(zzl,zs0);
s = " "
input_fits_dir = "../catsim_galsim_fits/"
input_fits_sh = s.join(("ls", input_fits_dir,"|grep",band+".fits"))
input_fits = sp.check_output(input_fits_sh,shell=True)
input_fits = input_fits.rstrip()
input_fits_list = input_fits.split("\n")
for i in input_fits_list:
array = i.split("_")
zzsd = np.double(array[1])
zzsu = np.double(array[2])
zzs = (zzsd+zzsu)*0.5
srcs = pyfits.getdata(input_fits_dir+i)
srcs = np.array(srcs,dtype="<d")
if zzs < zzl:
factor_z=0.0
else:
factor_z=mm.Da2(zzl,zzs)/mm.Da(zzs)*factor_z0
#print factor_z
ai1 = ai01*factor_z
ai2 = ai02*factor_z
yi1 = xi1 - ai1
yi2 = xi2 - ai2
#g_sn_pin = lv4.call_ray_tracing(g_sn,xi1,xi2,ysc1,ysc2,dsi)
limages_tmp = lv4.call_ray_tracing(srcs,yi1,yi2,ysc1,ysc2,dsi)
limages = limages + limages_tmp
#limages[128:384,128:384] = limages[128:384,128:384]+gimage
output_file_name = "".join(("../lensed_images/lensed_twinkles_",band,".fits"))
pyfits.writeto(output_file_name,limages,clobber=True)
limages[128:384,128:384] = limages[128:384,128:384]+gimage
output_file_name = "".join(("../final_images/final_twinkles_",band,".fits"))
pyfits.writeto(output_file_name,limages,clobber=True)
return 0