def get_profile(self, params): if 'flux_b' in params and 'flux_d' in params: flux_b = params['flux_b'] flux_d = params['flux_d'] elif 'flux_b' and 'flux_b/flux_total' in params: raise NotImplementedError('Need to implement flux_b/flux_total') else: raise ValueError('Flux was not specified.') if 'hlr_b' in params and 'hlr_d' in params: hlr_d = params['hlr_d'] hlr_b = params['hlr_b'] elif 'hlr_d' and 'R_r' in params: hlr_d = params['hlr_d'] hlr_b = params['R_r'] * hlr_d else: raise ValueError('Size was not specified.') bulge = galsim.Sersic(n=params['n_b'], half_light_radius=hlr_b, flux=flux_b) disk = galsim.Sersic(n=params['n_d'], half_light_radius=hlr_d, flux=flux_d) if 'delta_e' in params or 'delta_theta' in params: raise NotImplementedError('Need to implement delta_e or ' 'delta_theta.') return bulge + disk
def get_gal_cg(Args): """ Return surface brightness profile (SBP) of cocentric bulge + disk galaxy. Bulge and disk have co-centric Sersic profiles. @param Args Class with the following attributes: Args.bulge_n Sersic index of bulge. Args.bulge_HLR Half-light-radius of the bulge. Args.bulge_e Shape of bulge [e1, e2]. Args.bulge_frac Fraction of flux in bulge at 550 nm rest-frame. Args.T_flux Total flux in the galaxy. Args.disk_n Sersic index of disk. Args.disk_HLR Half-light-radius of the disk. Args.disk_e Shape of disk [e1, e2]. Args.b_SED SED of bulge. Args.d_SED SED of disk. @return galaxy with CG """ bulge = galsim.Sersic(n=Args.bulge_n, half_light_radius=Args.bulge_HLR, flux=Args.T_flux * Args.bulge_frac) bulge = bulge.shear(e1=Args.bulge_e[0], e2=Args.bulge_e[1]) disk = galsim.Sersic(n=Args.disk_n, half_light_radius=Args.disk_HLR, flux=Args.T_flux * (1 - Args.bulge_frac)) disk = disk.shear(e1=Args.disk_e[0], e2=Args.disk_e[1]) gal = bulge * Args.b_SED + disk * Args.d_SED return gal
def _get_gals(self, mode, dx, dy): # mode = self['Mode'] #Cen = galsim.Gaussian(half_light_radius=self['Cen']['hlr'],flux=self['Cen']['Flux']) #Neigh = galsim.Exponential(half_light_radius=self['Neigh']['hlr'],flux=self['Neigh']['Flux']) n = rng.uniform(low=0.5, high=4) Cen = galsim.Sersic(n, half_light_radius=self['Cen']['hlr'], flux=self['Cen']['Flux']) n = rng.uniform(low=0.5, high=4) Neigh = galsim.Sersic(n, half_light_radius=self['Neigh']['hlr'], flux=self['Neigh']['Flux']) Cen = Cen.shear(g1=np.random.normal(scale=0.02), g2=np.random.normal(scale=0.02)) Neigh = Neigh.shear(g1=np.random.normal(scale=0.02), g2=np.random.normal(scale=0.02)) #cen position if self['Cen']['Pos'] == 'Fixed': dx1, dy1 = self['Cen']['dx'], self['Cen']['dy'] elif self['Cen']['Pos'] == 'Rand_Circle': r = self['Cen']['r'] theta = 2. * np.pi * np.random.random() dx1, dy1 = r * np.cos(theta), r * np.sin(theta) #neigh position if self['Neigh']['Pos'] == 'Fixed': dx2, dy2 = self['Neigh']['dx'], self['Neigh']['dy'] elif self['Neigh']['Pos'] == 'Rand_circle': r = self['Neigh']['r'] theta = 2. * np.pi * np.random.random() dx2, dy2 = r * np.cos(theta), r * np.sin(theta) dx1 += np.random.uniform(low=-0.5, high=0.5) dy1 += np.random.uniform(low=-0.5, high=0.5) dx2 += np.random.uniform(low=-0.5, high=0.5) dy2 += np.random.uniform(low=-0.5, high=0.5) #Cen = Cen.shift(dx=dx1, dy=dy1) #Neigh = Neigh.shift(dx=dx2, dy=dy2) if mode == 'scarlet' or mode == 'minimof': Cen = Cen.shift(dx=dx1, dy=dy1) Neigh = Neigh.shift(dx=dx2, dy=dy2) gals = [Cen, Neigh] objs = galsim.Add(gals) elif mode == 'control': Cen = Cen.shift(dx=dx, dy=dy) gals = [Cen] objs = galsim.Add(gals) dx1, dy1 = dx, dy shear1, shear2 = self['Shear']['Shear1'], self['Shear']['Shear2'] #objs = objs.shear(g1=shear1, g2=shear2) return objs, dx1, dy1, dx2, dy2
def get_snr(self, obs_list, res): size = res['pars'][4] flux = res['flux'] model_ = galsim.Sersic( 1, half_light_radius=1. * size, flux=flux * (1. - res['pars'][5])) + galsim.Sersic( 4, half_light_radius=1. * size, flux=flux * res['pars'][5]) for i in range(len(obs_list)): obs = obs_list[i] im = obs.psf.image.copy() im *= 1.0 / im.sum() / len(obs_list) psf_gsimage = galsim.Image(im, wcs=obs.psf.jacobian.get_galsim_wcs()) psf_ii = galsim.InterpolatedImage(psf_gsimage, x_interpolant='lanczos15') model = galsim.Convolve(model_, psf_ii) gal_stamp = galsim.Image(np.shape(obs.image)[0], np.shape(obs.image)[1], wcs=obs.jacobian.get_galsim_wcs()) model.drawImage(image=gal_stamp) if i == 0: image = gal_stamp.array * obs.weight else: image += gal_stamp.array * obs.weight return image.sum()
def fcn2min(params, data, Args, psf): """Function given as input to lmfit, to compute residual of fit and true galaxy (galaxy with no CG) @param params fit parameters @param data true data @param Args @param mod_psf psf @returns difference betwwen fit and true""" g1 = params['g1'].value # shear of galaxy g2 = params['g2'].value # shear of galaxy rb = params['rb'].value # half light radius of buldge rd = params['rd'].value # half light radius disk bf = params['bf'].value # ratio Flux of buldge to total flux mod_bulge = galsim.Sersic(n=Args.bulge_n, half_light_radius=rb, flux=Args.T_flux * bf) mod_disk = galsim.Sersic(n=Args.disk_n, half_light_radius=rd, flux=Args.T_flux * (1 - bf)) mod_gal = (mod_bulge + mod_disk) * Args.c_SED mod_gal = mod_gal.shear(g1=g1, g2=g2) obj_con = galsim.Convolve(mod_gal, psf) mod_im = (obj_con.drawImage(bandpass=Args.bp, scale=Args.scale, nx=Args.npix, ny=Args.npix)).array model1 = mod_im.flatten() resid = model1 - data return resid
def test_sersic(): """ Test that InclinedSersic looks identical to a Sersic when inclination is zero. """ ns = (1.1, 1.1, 2.5, 2.5) truncs = (0, 13.5, 0, 18.0) scale_radius = 3.0 hlr = 1.7 mode = "InclinedSersic" for n, trunc in zip(ns, truncs): # Construct from scale_radius sersic_profile = galsim.Sersic(n=n, scale_radius=scale_radius, trunc=trunc) inc_profile = get_prof(mode, n=n, trunc=trunc, inclination=0 * galsim.radians, scale_radius=scale_radius, scale_height=hlr / 10.) np.testing.assert_almost_equal(inc_profile.scale_radius, sersic_profile.scale_radius) np.testing.assert_almost_equal(inc_profile.disk_half_light_radius, sersic_profile.half_light_radius) # Construct from half-light radius sersic_profile = galsim.Sersic(n=n, half_light_radius=hlr, trunc=trunc) inc_profile = get_prof(mode, n=n, trunc=trunc, inclination=0 * galsim.radians, half_light_radius=hlr, scale_height=hlr / 10.) np.testing.assert_almost_equal(inc_profile.scale_radius, sersic_profile.scale_radius) np.testing.assert_almost_equal(inc_profile.disk_half_light_radius, sersic_profile.half_light_radius) sersic_image = galsim.Image(image_nx, image_ny, scale=1.0) sersic_profile.drawImage(sersic_image) inc_image = galsim.Image(image_nx, image_ny, scale=1.0) inc_profile.drawImage(inc_image) if save_profiles: sersic_image.write("test_sersic.fits", image_dir, clobber=True) inc_image.write("test_inclined_sersic.fits", image_dir, clobber=True) # Check that they're the same. Note that since the inclined Sersic profile isn't # Real-space analytic and has hard edges in the truncated case, # we have to be a bit lax on rtol and atol if trunc != 0: rtol = 5e-3 atol = 5e-5 else: rtol = 1e-3 atol = 1e-5 np.testing.assert_allclose(inc_image.array, sersic_image.array, rtol=rtol, atol=atol) # The face-on version should get the max_sb value exactly right np.testing.assert_almost_equal(inc_profile.max_sb, sersic_profile.max_sb) check_basic(inc_profile, "Face-on " + mode)
def test_rotate(): """Test the 45 degree rotation of a sheared Sersic profile against a known result. """ import time t1 = time.time() mySBP = galsim.SBSersic(n=2.5, flux=1, half_light_radius=1) myShear = galsim.Shear(e1=0.2, e2=0.0) mySBP.applyShear(myShear._shear) mySBP.applyRotation(45.0 * galsim.degrees) savedImg = galsim.fits.read(os.path.join(imgdir, "sersic_ellip_rotated.fits")) myImg = galsim.ImageF(savedImg.bounds, scale=0.2) mySBP.draw(myImg.view()) printval(myImg, savedImg) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="45-degree rotated elliptical Gaussian disagrees with expected result") # Repeat with the GSObject version of this: gal = galsim.Sersic(n=2.5, flux=1, half_light_radius=1) gal.applyShear(myShear) gal.applyRotation(45.0 * galsim.degrees) gal.draw(myImg,dx=0.2, normalization="surface brightness", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="Using GSObject applyRotation disagrees with expected result") # Check with default_params gal = galsim.Sersic(n=2.5, flux=1, half_light_radius=1, gsparams=default_params) gal.applyShear(myShear) gal.applyRotation(45.0 * galsim.degrees) gal.draw(myImg,dx=0.2, normalization="surface brightness", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="Using GSObject applyRotation with default_params disagrees with expected " "result") gal = galsim.Sersic(n=2.5, flux=1, half_light_radius=1, gsparams=galsim.GSParams()) gal.applyShear(myShear) gal.applyRotation(45.0 * galsim.degrees) gal.draw(myImg,dx=0.2, normalization="surface brightness", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="Using GSObject applyRotation with GSParams() disagrees with expected result") # Test photon shooting. # Convolve with a small gaussian to smooth out the central peak. gal2 = galsim.Convolve(gal, galsim.Gaussian(sigma=0.3)) do_shoot(gal2,myImg,"rotated sheared Sersic") # Test kvalues do_kvalue(gal,"rotated sheared Sersic") t2 = time.time() print 'time for %s = %.2f'%(funcname(),t2-t1)
def test_sersic_05(): """Test the equivalence of Sersic with n=0.5 and Gaussian """ # hlr/sigma = sqrt(2 ln(2)) = 1.177410022515475 hlr_sigma = 1.177410022515475 test_flux = 1.8 # cf test_gaussian() savedImg = galsim.fits.read(os.path.join(imgdir, "gauss_1.fits")) savedImg.setCenter(0, 0) dx = 0.2 myImg = galsim.ImageF(savedImg.bounds, scale=dx) sersic = galsim.Sersic(n=0.5, flux=1, half_light_radius=1 * hlr_sigma) myImg = sersic.drawImage(myImg, method="sb", use_true_center=False) print('saved image center = ', savedImg(0, 0)) print('image center = ', myImg(0, 0)) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg= "Using Sersic with n=0.5 disagrees with expected result for Gaussian") check_basic(sersic, "n=0.5 Sersic") do_kvalue(sersic, myImg, "n=0.5 Sersic") # cf test_gaussian_properties() test_sigma = 1.8 sersic = galsim.Sersic(n=0.5, flux=test_flux, half_light_radius=test_sigma * hlr_sigma) cen = galsim.PositionD(0, 0) np.testing.assert_equal(sersic.centroid, cen) np.testing.assert_almost_equal(sersic.kValue(cen), (1 + 0j) * test_flux) np.testing.assert_almost_equal(sersic.flux, test_flux) import math np.testing.assert_almost_equal(sersic.xValue(cen), 1. / (2. * math.pi) * test_flux / test_sigma**2, decimal=5) np.testing.assert_almost_equal(sersic.xValue(cen), sersic.max_sb) # Also test some random values other than the center: gauss = galsim.Gaussian(flux=test_flux, sigma=test_sigma) for (x, y) in [(0.1, 0.2), (-0.5, 0.4), (0, 0.9), (1.2, 0.1), (2, 2)]: pos = galsim.PositionD(x, y) np.testing.assert_almost_equal(sersic.xValue(pos), gauss.xValue(pos), decimal=5) np.testing.assert_almost_equal(sersic.kValue(pos), gauss.kValue(pos), decimal=5)
def test_sersic_flux_scaling(): """Test flux scaling for Sersic. """ import time t1 = time.time() # loop through sersic n for test_n in test_sersic_n: # loop through sersic truncation for test_trunc in test_sersic_trunc: # init with hlr and flux only (should be ok given last tests) obj = galsim.Sersic(test_n, half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) obj *= 2. np.testing.assert_almost_equal( obj.getFlux(), test_flux * 2., decimal=param_decimal, err_msg="Flux param inconsistent after __imul__.") obj = galsim.Sersic(test_n, half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) obj /= 2. np.testing.assert_almost_equal( obj.getFlux(), test_flux / 2., decimal=param_decimal, err_msg="Flux param inconsistent after __idiv__.") obj = galsim.Sersic(test_n, half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) obj2 = obj * 2. # First test that original obj is unharmed... (also tests that .copy() is working) np.testing.assert_almost_equal( obj.getFlux(), test_flux, decimal=param_decimal, err_msg="Flux param inconsistent after __rmul__ (original).") # Then test new obj2 flux np.testing.assert_almost_equal( obj2.getFlux(), test_flux * 2., decimal=param_decimal, err_msg="Flux param inconsistent after __rmul__ (result).") obj = galsim.Sersic(test_n, half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) obj2 = 2. * obj # First test that original obj is unharmed... (also tests that .copy() is working) np.testing.assert_almost_equal( obj.getFlux(), test_flux, decimal=param_decimal, err_msg="Flux param inconsistent after __mul__ (original).") # Then test new obj2 flux np.testing.assert_almost_equal( obj2.getFlux(), test_flux * 2., decimal=param_decimal, err_msg="Flux param inconsistent after __mul__ (result).") obj = galsim.Sersic(test_n, half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) obj2 = obj / 2. # First test that original obj is unharmed... (also tests that .copy() is working) np.testing.assert_almost_equal( obj.getFlux(), test_flux, decimal=param_decimal, err_msg="Flux param inconsistent after __div__ (original).") # Then test new obj2 flux np.testing.assert_almost_equal( obj2.getFlux(), test_flux / 2., decimal=param_decimal, err_msg="Flux param inconsistent after __div__ (result).") t2 = time.time() print 'time for %s = %.2f'%(funcname(),t2-t1)
def doubleSersic(xcen1, ycen1, flux1, reff1, nser1, q1, pa1, xcen2, ycen2, flux2, reff2, nser2, q2, pa2, nx, ny, psf=None, scale=1.0, exptime=1.0, trunc=0, max_fft=None): """Generate image for double Sersic component.""" ser = galsim.Add([ galsim.Sersic( n=nser1, half_light_radius=reff1, flux=(flux1 * exptime), trunc=trunc).shear(q=q1, beta=(0.0 * galsim.degrees)).rotate( (90.0 - pa1) * galsim.degrees).shift((xcen1 - (nx / 2.0)), (ycen1 - (ny / 2.0))), galsim.Sersic( n=nser2, half_light_radius=reff2, flux=(flux2 * exptime), trunc=trunc).shear(q=q2, beta=(0.0 * galsim.degrees)).rotate( (90.0 - pa2) * galsim.degrees).shift((xcen2 - (nx / 2.0)), (ycen2 - (ny / 2.0))) ]) if psf is not None: if max_fft is not None: gsparams = galsim.GSParams(maximum_fft_size=max_fft) return (galsim.Convolve([ser, psf], gsparams=gsparams).drawImage( nx=nx, ny=ny, method='no_pixel', scale=scale)).array else: return (galsim.Convolve([ser, psf]).drawImage(nx=nx, ny=ny, method='no_pixel', scale=scale)).array else: return (ser.drawImage(nx=nx, ny=ny, method='no_pixel', scale=scale)).array
def test_sersic_1(): """Test the equivalence of Sersic with n=1 and Exponential """ # cf test_exponential() test_flux = 17.9 re = 1.0 r0 = re / 1.67839 # The real value of re/r0 = 1.6783469900166605 hlr_r0 = 1.6783469900166605 savedImg = galsim.fits.read(os.path.join(imgdir, "exp_1.fits")) dx = 0.2 myImg = galsim.ImageF(savedImg.bounds, scale=dx) sersic = galsim.Sersic(n=1, flux=1., half_light_radius=r0 * hlr_r0) sersic.drawImage(myImg, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg= "Using Sersic n=1 disagrees with expected result for Exponential") check_basic(sersic, "n=1 Sersic") do_kvalue(sersic, myImg, "n=1 Sersic") # cf test_exponential_properties() test_scale = 1.8 sersic = galsim.Sersic(n=1, flux=test_flux, half_light_radius=test_scale * hlr_r0) cen = galsim.PositionD(0, 0) np.testing.assert_equal(sersic.centroid, cen) np.testing.assert_almost_equal(sersic.kValue(cen), (1 + 0j) * test_flux) np.testing.assert_almost_equal(sersic.flux, test_flux) import math np.testing.assert_almost_equal(sersic.xValue(cen), 1. / (2. * math.pi) * test_flux / test_scale**2, decimal=5) np.testing.assert_almost_equal(sersic.xValue(cen), sersic.max_sb) # Also test some random values other than the center: expon = galsim.Exponential(flux=test_flux, scale_radius=test_scale) for (x, y) in [(0.1, 0.2), (-0.5, 0.4), (0, 0.9), (1.2, 0.1), (2, 2)]: pos = galsim.PositionD(x, y) np.testing.assert_almost_equal(sersic.xValue(pos), expon.xValue(pos), decimal=5) np.testing.assert_almost_equal(sersic.kValue(pos), expon.kValue(pos), decimal=5)
def test_ne(): """Test base.py GSObjects for not-equals.""" # Define some universal gsps gsp = galsim.GSParams(maxk_threshold=1.1e-3, folding_threshold=5.1e-3) # Sersic. Params include n, half_light_radius, scale_radius, flux, trunc, flux_untruncated # and gsparams. # The following should all test unequal: gals = [galsim.Sersic(n=1.1, half_light_radius=1.0), galsim.Sersic(n=1.2, half_light_radius=1.0), galsim.Sersic(n=1.1, half_light_radius=1.1), galsim.Sersic(n=1.1, scale_radius=1.0), galsim.Sersic(n=1.1, half_light_radius=1.0, flux=1.1), galsim.Sersic(n=1.1, half_light_radius=1.0, trunc=1.8), galsim.Sersic(n=1.1, half_light_radius=1.0, trunc=1.8, flux_untruncated=True), galsim.Sersic(n=1.1, half_light_radius=1.0, gsparams=gsp)] all_obj_diff(gals) # DeVaucouleurs. Params include half_light_radius, scale_radius, flux, trunc, flux_untruncated, # and gsparams. # The following should all test unequal: gals = [galsim.DeVaucouleurs(half_light_radius=1.0), galsim.DeVaucouleurs(half_light_radius=1.1), galsim.DeVaucouleurs(scale_radius=1.0), galsim.DeVaucouleurs(half_light_radius=1.0, flux=1.1), galsim.DeVaucouleurs(half_light_radius=1.0, trunc=2.0), galsim.DeVaucouleurs(half_light_radius=1.0, trunc=2.0, flux_untruncated=True), galsim.DeVaucouleurs(half_light_radius=1.0, gsparams=gsp)] all_obj_diff(gals)
def test_near_05(): """Test from issue #1041, where some values of n near but not exactly equal to 0.5 would fail to converge in bracketUpper() """ ser1 = galsim.Sersic(n=0.5, half_light_radius=1) ser2 = galsim.Sersic(n=0.499999999999, half_light_radius=1) ser3 = galsim.Sersic(n=0.500000000001, half_light_radius=1) im1 = ser1.drawImage() im2 = ser2.drawImage() im3 = ser3.drawImage() np.testing.assert_allclose(im2.array, im1.array, atol=1.e-12) np.testing.assert_allclose(im3.array, im1.array, atol=1.e-12)
def test_rotate(): """Test the 45 degree rotation of a sheared Sersic profile against a known result. """ myShear = galsim.Shear(e1=0.2, e2=0.0) savedImg = galsim.fits.read(os.path.join(imgdir, "sersic_ellip_rotated.fits")) dx = 0.2 myImg = galsim.ImageF(savedImg.bounds, scale=dx) myImg.setCenter(0,0) gal = galsim.Sersic(n=2.5, flux=1, half_light_radius=1) gal = gal.shear(myShear).rotate(45.0 * galsim.degrees) gal.drawImage(myImg,scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="Using GSObject rotate disagrees with expected result") np.testing.assert_almost_equal( myImg.array.max(), gal.max_sb, 5, err_msg="rotated profile max_sb did not match maximum pixel value") # Check with default_params gal = galsim.Sersic(n=2.5, flux=1, half_light_radius=1, gsparams=default_params) gal = gal.shear(myShear).rotate(45.0 * galsim.degrees) gal.drawImage(myImg,scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="Using GSObject rotate with default_params disagrees with expected " "result") gal = galsim.Sersic(n=2.5, flux=1, half_light_radius=1, gsparams=galsim.GSParams()) gal = gal._shear(myShear).rotate(45.0 * galsim.degrees) gal.drawImage(myImg,scale=dx, method="sb", use_true_center=False) np.testing.assert_array_almost_equal( myImg.array, savedImg.array, 5, err_msg="Using GSObject rotate with GSParams() disagrees with expected result") # Convolve with a small gaussian to smooth out the central peak. gal2 = galsim.Convolve(gal, galsim.Gaussian(sigma=0.3)) check_basic(gal2, "rotated sheared Sersic") # Test photon shooting. do_shoot(gal2,myImg,"rotated sheared Sersic") # Test kvalues do_kvalue(gal,myImg,"rotated sheared Sersic") # Check picklability do_pickle(gal, lambda x: x.drawImage()) do_pickle(gal) assert_raises(TypeError, gal.rotate) assert_raises(TypeError, gal.rotate, 34)
def get_model(type="disc", size=1.0, g1=0, g2=0, flux=None): if type is "disc": gal = galsim.Sersic(n=1, half_light_radius=size) if type is "bulge": gal = galsim.Sersic(n=4, half_light_radius=size) if type is "gaussian": gal = galsim.Gaussian(fwhm=size) shear = galsim.Shear(g1=g1, g2=g2) gal = gal.shear(shear) if flux is not None: gal = gal.withFlux(flux) return gal
def test_sersic_shoot(): """Test Sersic with photon shooting. Particularly the flux of the final image. """ rng = galsim.BaseDeviate(1234) obj = galsim.Sersic(n=1.5, half_light_radius=3.5, flux=1.e4) im = galsim.Image(100, 100, scale=1) im.setCenter(0, 0) added_flux, photons = obj.drawPhot(im, poisson_flux=False, rng=rng.duplicate()) print('obj.flux = ', obj.flux) print('added_flux = ', added_flux) print('photon fluxes = ', photons.flux.min(), '..', photons.flux.max()) print('image flux = ', im.array.sum()) assert np.isclose(added_flux, obj.flux) assert np.isclose(im.array.sum(), obj.flux) photons2 = obj.makePhot(poisson_flux=False, rng=rng) assert photons2 == photons, "Sersic makePhot not equivalent to drawPhot" obj = galsim.DeVaucouleurs(half_light_radius=3.5, flux=1.e4) # Need a larger image for devauc wings im = galsim.Image(1000, 1000, scale=1) im.setCenter(0, 0) added_flux, photons = obj.drawPhot(im, poisson_flux=False, rng=rng.duplicate()) print('obj.flux = ', obj.flux) print('added_flux = ', added_flux) print('photon fluxes = ', photons.flux.min(), '..', photons.flux.max()) print('image flux = ', im.array.sum()) assert np.isclose(added_flux, obj.flux) assert np.isclose(im.array.sum(), obj.flux) photons2 = obj.makePhot(poisson_flux=False, rng=rng) assert photons2 == photons, "Sersic makePhot not equivalent to drawPhot" # Can do up to around n=6 with this image if hlr is smaller. obj = galsim.Sersic(half_light_radius=0.9, n=6.2, flux=1.e4) added_flux, photons = obj.drawPhot(im, poisson_flux=False, rng=rng.duplicate()) print('obj.flux = ', obj.flux) print('added_flux = ', added_flux) print('photon fluxes = ', photons.flux.min(), '..', photons.flux.max()) print('image flux = ', im.array.sum()) assert np.isclose(added_flux, obj.flux) assert np.isclose(im.array.sum(), obj.flux) photons2 = obj.makePhot(poisson_flux=False, rng=rng) assert photons2 == photons, "Sersic makePhot not equivalent to drawPhot"
def test_comparison_object(np): logging.basicConfig(level=logging.WARNING, stream=sys.stdout) logger = logging.getLogger("test_comparison_object") logger.info("Running basic tests of comparison scripts using objects") # Build a trial galaxy gal = galsim.Sersic(galn, half_light_radius=galhlr) gal.applyShear(g1=g1gal, g2=g2gal) # And an example PSF psf = galsim.Moffat(beta=psfbeta, fwhm=psffwhm) psf.applyShear(g1=g1psf, g2=g2psf) # Try a single core run print "Starting tests using config file with N_PHOTONS = " + str(np) res1 = galsim.utilities.compare_dft_vs_photon_object( gal, psf_object=psf, rng=galsim.BaseDeviate(rseed), size=imsize, pixel_scale=dx, abs_tol_ellip=tol_ellip, abs_tol_size=tol_size, n_photons_per_trial=np) print res1 return
def draw_sersic_model(mag=-10, r=1, pixel_scale=1, q=0.2, beta=0.0, n=1, xc=0, yc=0, x_size=64, y_size=64): k = 64 big_fft_params = galsim.GSParams(maximum_fft_size=int(512 * k)) flux_gal = 10**(-0.4 * mag) # Lensed documentation: L_tot = 10**(-0.4m) size_gal = r # In arcseconds q_gal = q beta_gal = beta n = n #random_seed=1534225 #rng = galsim.BaseDeviate(random_seed) xc = xc yc = yc gal = galsim.Sersic(n=n, half_light_radius=size_gal, flux=flux_gal, gsparams=big_fft_params).shear(q=q_gal, beta=beta_gal * galsim.degrees) base_size_x = x_size base_size_y = y_size im = gal.drawImage(image=galsim.ImageF(base_size_x, base_size_y), scale=pixel_scale, offset=(xc, yc)) return im.array
def test_lens(): """Test the lensing (shear, magnification) of a Sersic profile carried out 2 ways. """ re = 1.0 n = 3. g1 = 0.12 g2 = -0.4 mu = 1.2 pix_scale = 0.1 imsize = 100 ser = galsim.Sersic(n, half_light_radius = re) ser1 = ser.shear(g1=g1, g2=g2).magnify(mu) im1 = galsim.ImageF(imsize, imsize, scale=pix_scale) im1 = ser1.drawImage(im1, method='no_pixel') ser2 = ser.lens(g1, g2, mu) im2 = galsim.ImageF(imsize, imsize, scale=pix_scale) im2 = ser2.drawImage(im2, method='no_pixel') np.testing.assert_array_almost_equal(im2.array, im1.array, 5, err_msg="Lensing of Sersic profile done in two different ways gives different answer") # _lens is equivalent in this case. ser3 = ser._lens(g1, g2, mu) im3 = galsim.ImageF(imsize, imsize, scale=pix_scale) im3 = ser3.drawImage(im3, method='no_pixel') np.testing.assert_array_almost_equal(im3.array, im1.array, 5, err_msg="Lensing of Sersic profile with _lens gives different answer")
def singleSersic(xcen, ycen, flux, reff, nser, q, pa, nx, ny, psf=None, scale=1.0, exptime=1.0, trunc=0, max_fft=None): """Generate image for single Sersic component.""" ser = galsim.Sersic(n=nser, half_light_radius=reff, flux=(flux * exptime), trunc=trunc).shear( q=q, beta=(0.0 * galsim.degrees)).rotate( (90.0 - pa) * galsim.degrees).shift( (xcen - (nx / 2.0)), (ycen - (ny / 2.0))) if psf is not None: if max_fft is not None: gsparams = galsim.GSParams(maximum_fft_size=max_fft) else: gsparams = galsim.GSParams() return (galsim.Convolve([ser, psf], gsparams=gsparams).drawImage( nx=nx, ny=ny, method='no_pixel', scale=scale)).array else: return (ser.drawImage(nx=nx, ny=ny, method='no_pixel', scale=scale)).array
def drawSersic(self, gsObject): """ Draw the image of a Sersic profile. @param [in] gsObject is an instantiation of the GalSimCelestialObject class carrying information about the object whose image is to be drawn """ # create a Sersic profile centeredObj = galsim.Sersic(n=float(gsObject.sindex), half_light_radius=float( gsObject.halfLightRadiusArcsec)) # Turn the Sersic profile into an ellipse centeredObj = centeredObj.shear( q=gsObject.minorAxisRadians / gsObject.majorAxisRadians, beta=(0.5 * np.pi + gsObject.positionAngleRadians) * galsim.radians) # Apply weak lensing distortion. centeredObj = centeredObj.lens(gsObject.g1, gsObject.g2, gsObject.mu) # Apply the PSF. if self.PSF is not None: centeredObj = self.PSF.applyPSF(xPupil=gsObject.xPupilArcsec, yPupil=gsObject.yPupilArcsec, obj=centeredObj) return centeredObj
def makeGalaxy(cc, gal_indices, chromatic=False, gsparams=None, trunc_factor=0.): """Return Sersic profile specified by Cosmos Catalog (cc) and gal_indeces""" galaxies = [] sersicfit = cc.param_cat['sersicfit'] for gal_id in gal_indices: gal_n = sersicfit[gal_id, 2] gal_q = sersicfit[gal_id, 3] gal_phi = sersicfit[gal_id, 7] gal_hlr = sersicfit[gal_id, 1] * np.sqrt(gal_q) * 0.03 # in arcsec b_n = 1.992 * gal_n - 0.3271 gal_flux = 2 * np.pi * gal_n * scipy.special.gamma(2*gal_n)*\ np.exp(b_n) * gal_q * (sersicfit[gal_id, 1]**2)*\ (sersicfit[gal_id, 0])/(b_n**(2. * gal_n)) # print gal_n, gal_hlr, gal_flux, gal_q, gal_phi gal = galsim.Sersic(n=gal_n, half_light_radius=gal_hlr, flux=gal_flux, trunc=trunc_factor * gal_hlr, gsparams=gsparams).shear(q=gal_q, beta=gal_phi * galsim.radians) galaxies.append(gal) return galaxies
def createSource(self, galaxyIndex, shifted=False, lensed=False): """ Returns a GalSim model of the source for the specified galaxy index with optional centroid shifts and weak lensing distortion. """ params = self.getTruthCatalog()[galaxyIndex] # Create the bulge component. bulge = galsim.Sersic(flux=params['bulge_flux'], half_light_radius=params['bulge_hlr'], n=params['bulge_n'], gsparams=Observation.getGSParams()) bulge.applyShear(q=params['bulge_q'], beta=params['bulge_beta_radians'] * galsim.radians) # Is there a disk component? if params['disk_flux'] > 0: disk = galsim.Exponential(flux=params['disk_flux'], half_light_radius=params['disk_hlr'], gsparams=Observation.getGSParams()) disk.applyShear(q=params['disk_q'], beta=params['disk_beta_radians'] * galsim.radians) source = galsim.Add(bulge, disk) else: source = bulge # Apply optional lensing. if lensed: source = source.lens(g1=params['g1'], g2=params['g2'], mu=params['mu']) # Apply optional centroid shift. if shifted: source = source.shift(dx=params['xshift'] * self.pixelScale, dy=params['yshift'] * self.pixelScale) return source
def test_lens(): """Test the lensing (shear, magnification) of a Sersic profile carried out 2 ways. """ import time t1 = time.time() re = 1.0 n = 3. g1 = 0.12 g2 = -0.4 mu = 1.2 pix_scale = 0.1 imsize = 100 ser = galsim.Sersic(n, half_light_radius = re) ser2 = ser.createLensed(g1, g2, mu) ser.applyShear(g1=g1, g2=g2) ser.applyMagnification(mu) im = galsim.ImageF(imsize, imsize, scale=pix_scale) im = ser.draw(im) im2 = galsim.ImageF(imsize, imsize, scale=pix_scale) im2 = ser2.draw(im2) np.testing.assert_array_almost_equal(im.array, im2.array, 5, err_msg="Lensing of Sersic profile done in two different ways gives different answer") t2 = time.time() print 'time for %s = %.2f'%(funcname(),t2-t1)
def makeSersic(gal_n, gal_hlr, gal_flux, gal_q, gal_phi, gsparams): """Return a Sersic profile with given n, circ. hlr, flux, axis ratio q, orientation angle phi in radians.""" gal = galsim.Sersic(n=gal_n, half_light_radius=gal_hlr, flux=gal_flux, gsparams=gsparams).shear(q=gal_q, beta=gal_phi * galsim.radians) return gal
def draw_bulge_plus_disk_model(mag_b=-10, r_b=1, q_b=0.2, beta_b=0.0, n_b=1, mag_d=-10, r_d=1, q_d=0.2, beta_d=0.0, n_d=1, pixel_scale=1, xc=0, yc=0, x_size=64, y_size=64): k = 64 big_fft_params = galsim.GSParams(maximum_fft_size=int(512 * k)) flux_b = 10**(-0.4 * mag_b) bulge = galsim.Sersic(n=n_b, half_light_radius=r_b, flux=flux_b, gsparams=big_fft_params).shear(q=q_b, beta=beta_b * galsim.degrees) flux_d = 10**(-0.4 * mag_d) disk = galsim.Sersic(n=n_d, half_light_radius=r_d, flux=flux_d, gsparams=big_fft_params).shear(q=q_d, beta=beta_d * galsim.degrees) gal = disk + bulge xc = xc yc = yc base_size_x = x_size base_size_y = y_size im = gal.drawImage(image=galsim.ImageF(base_size_x, base_size_y), scale=pixel_scale, offset=(xc, yc)) return im.array
def lrg(self,objinfo,siminfo): """Create an LRG (spheroidal) galaxy.""" obj = galsim.Sersic(float(objinfo['SERSICN_1']),half_light_radius= float(objinfo['R50_1']), flux=self.objflux,gsparams=siminfo.gsparams) obj = obj.shear(q=float(objinfo['BA_1']),beta= float(objinfo['PHI_1'])*galsim.degrees) stamp = self.convolve_and_draw(obj) return stamp
def make_bdf(half_light_radius=None, flux=None, fracdev=None, trunc=0.0, gsparams=None): """ a bulge+disk maker for equal hlr for bulge and disk Parameters ---------- half_light_radius: float hlr flux: float Total flux in the profile fracdev: float fraction of light in the bulge """ import galsim assert half_light_radius is not None, 'send half_light_ratio' assert flux is not None, 'send flux' assert fracdev is not None, 'send fracdev' if trunc > 0: flux_untruncated = True else: flux_untruncated = False """ bulge = galsim.DeVaucouleurs( half_light_radius=half_light_radius, flux=fracdev, flux_untruncated=flux_untruncated , trunc=trunc, gsparams=gsparams, ) """ bulge = galsim.Sersic( n=2, half_light_radius=half_light_radius, flux=fracdev, flux_untruncated=flux_untruncated, trunc=trunc, gsparams=gsparams, ) disk = galsim.Exponential( half_light_radius=half_light_radius, flux=(1 - fracdev), gsparams=gsparams, ) return galsim.Add( bulge, disk, gsparams=gsparams, ).withFlux(flux)
def _get_gal_exp(self): flux = 10**(0.4 * (30 - 20)) half_light_radius = 1e-5 obj = galsim.Sersic( half_light_radius=half_light_radius, n=1, ).withFlux(flux) return [obj]
def test_sersic_flux_scaling(): """Test flux scaling for Sersic. """ # decimal point to go to for parameter value comparisons param_decimal = 12 test_hlr = 1.8 test_flux = 17.9 test_sersic_trunc = [0., 8.5] if __name__ != "__main__": # If doing a pytest run, we don't actually need to do all 4 sersic n values. # Two should be enough to notice if there is a problem, and the full list will be tested # when running python test_base.py to try to diagnose the problem. test_sersic_n = [1.5, -4] else: test_sersic_n = [1.5, 2.5, 4, -4] # -4 means use explicit DeVauc rather than n=4 # loop through sersic n for test_n in test_sersic_n: # loop through sersic truncation for test_trunc in test_sersic_trunc: # init with hlr and flux only (should be ok given last tests) # n=-4 is code to use explicit DeVaucouleurs rather than Sersic(n=4). # It should be identical. if test_n == -4: init_obj = galsim.DeVaucouleurs(half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) else: init_obj = galsim.Sersic(test_n, half_light_radius=test_hlr, flux=test_flux, trunc=test_trunc) obj2 = init_obj * 2. np.testing.assert_almost_equal( init_obj.flux, test_flux, decimal=param_decimal, err_msg="Flux param inconsistent after __rmul__ (original).") np.testing.assert_almost_equal( obj2.flux, test_flux * 2., decimal=param_decimal, err_msg="Flux param inconsistent after __rmul__ (result).") obj2 = 2. * init_obj np.testing.assert_almost_equal( init_obj.flux, test_flux, decimal=param_decimal, err_msg="Flux param inconsistent after __mul__ (original).") np.testing.assert_almost_equal( obj2.flux, test_flux * 2., decimal=param_decimal, err_msg="Flux param inconsistent after __mul__ (result).") obj2 = init_obj / 2. np.testing.assert_almost_equal( init_obj.flux, test_flux, decimal=param_decimal, err_msg="Flux param inconsistent after __div__ (original).") np.testing.assert_almost_equal( obj2.flux, test_flux / 2., decimal=param_decimal, err_msg="Flux param inconsistent after __div__ (result).")