def test_autocorrelate():
"""Test that auto-correlation works the same as convolution with the mirror image of itself.
(See the Signal processing Section of http://en.wikipedia.org/wiki/Autocorrelation)
"""
import time
t1 = time.time()
# Use a function that is NOT two-fold rotationally symmetric, e.g. two different flux Gaussians
myGauss1 = galsim.SBGaussian(sigma=3., flux=4)
myGauss1.applyShift(-0.2, -0.4)
myGauss2 = (galsim.SBGaussian(sigma=6., flux=1.3))
myGauss2.applyShift(0.3, 0.3)
mySBP1 = galsim.SBAdd([myGauss1, myGauss2])
mySBP2 = galsim.SBAdd([myGauss1, myGauss2])
# Here we rotate by 180 degrees to create mirror image
mySBP2.applyRotation(180. * galsim.degrees)
myConv = galsim.SBConvolve([mySBP1, mySBP2])
myImg1 = galsim.ImageF(80, 80, scale=0.7)
myConv.draw(myImg1.view())
myAutoCorr = galsim.SBAutoCorrelate(mySBP1)
myImg2 = galsim.ImageF(80, 80, scale=0.7)
myAutoCorr.draw(myImg2.view())
printval(myImg1, myImg2)
np.testing.assert_array_almost_equal(
myImg1.array,
myImg2.array,
4,
err_msg=
"Asymmetric sum of Gaussians convolved with mirror of self disagrees with "
+ "SBAutoCorrelate result")
# Repeat with the GSObject version of this:
obj1 = galsim.Gaussian(sigma=3., flux=4)
obj1.applyShift(-0.2, -0.4)
obj2 = galsim.Gaussian(sigma=6., flux=1.3)
obj2.applyShift(0.3, 0.3)
add1 = galsim.Add(obj1, obj2)
add2 = (galsim.Add(obj1, obj2)).createRotated(180. * galsim.degrees)
conv = galsim.Convolve([add1, add2])
conv.draw(myImg1)
corr = galsim.AutoCorrelate(add1)
corr.draw(myImg2)
printval(myImg1, myImg2)
np.testing.assert_array_almost_equal(
myImg1.array,
myImg2.array,
4,
err_msg=
"Asymmetric sum of Gaussians convolved with mirror of self disagrees with "
+ "AutoCorrelate result")
# Test photon shooting.
do_shoot(corr, myImg2, "AutoCorrelate")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_smallshear():
"""Test the application of a small shear to a Gaussian SBProfile against a known result.
"""
import time
t1 = time.time()
e1 = 0.02
e2 = 0.02
myShear = galsim.Shear(e1=e1, e2=e2)
# test the SBProfile version using applyShear
savedImg = galsim.fits.read(os.path.join(imgdir, "gauss_smallshear.fits"))
myImg = galsim.ImageF(savedImg.bounds, scale=0.2)
mySBP = galsim.SBGaussian(flux=1, sigma=1)
mySBP.applyShear(myShear._shear)
mySBP.draw(myImg.view())
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array, savedImg.array, 5,
err_msg="Small-shear Gaussian profile disagrees with expected result")
# Repeat with the GSObject version of this:
gauss = galsim.Gaussian(flux=1, sigma=1)
gauss.applyShear(myShear)
gauss.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 applyShear disagrees with expected result")
gauss = galsim.Gaussian(flux=1, sigma=1)
gauss2 = gauss.createSheared(myShear)
gauss2.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 createSheared disagrees with expected result")
# Check with default_params
gauss = galsim.Gaussian(flux=1, sigma=1, gsparams=default_params)
gauss.applyShear(myShear)
gauss.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 applyShear with default_params disagrees with expected result")
gauss = galsim.Gaussian(flux=1, sigma=1, gsparams=galsim.GSParams())
gauss.applyShear(myShear)
gauss.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 applyShear with GSParams() disagrees with expected result")
# Test photon shooting.
do_shoot(gauss,myImg,"sheared Gaussian")
# Test kvalues
do_kvalue(gauss,"sheared Gaussian")
t2 = time.time()
print 'time for %s = %.2f'%(funcname(),t2-t1)
def test_add():
"""Test the addition of two rescaled Gaussian profiles against a known double Gaussian result.
"""
import time
t1 = time.time()
mySBP = galsim.SBGaussian(flux=0.75, sigma=1)
mySBP2 = galsim.SBGaussian(flux=0.25, sigma=3)
myAdd = galsim.SBAdd([mySBP, mySBP2])
savedImg = galsim.fits.read(os.path.join(imgdir, "double_gaussian.fits"))
myImg = galsim.ImageF(savedImg.bounds, scale=0.2)
myAdd.draw(myImg.view())
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Addition of two rescaled Gaussian profiles disagrees with expected result"
)
# Repeat with the GSObject version of this:
gauss1 = galsim.Gaussian(flux=0.75, sigma=1)
gauss2 = galsim.Gaussian(flux=0.25, sigma=3)
sum = galsim.Add(gauss1, gauss2)
sum.draw(myImg,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Add(gauss1,gauss2) disagrees with expected result")
# Check with default_params
sum = galsim.Add(gauss1, gauss2, gsparams=default_params)
sum.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 Add(gauss1,gauss2) with default_params disagrees with "
"expected result")
sum = galsim.Add(gauss1, gauss2, gsparams=galsim.GSParams())
sum.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 Add(gauss1,gauss2) with GSParams() disagrees with "
"expected result")
# Other ways to do the sum:
sum = gauss1 + gauss2
sum.draw(myImg,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg="Using GSObject gauss1 + gauss2 disagrees with expected result"
)
sum = gauss1.copy()
sum += gauss2
sum.draw(myImg,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject sum = gauss1; sum += gauss2 disagrees with expected result"
)
sum = galsim.Add([gauss1, gauss2])
sum.draw(myImg,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject Add([gauss1,gauss2]) disagrees with expected result")
gauss1 = galsim.Gaussian(flux=1, sigma=1)
gauss2 = galsim.Gaussian(flux=1, sigma=3)
sum = 0.75 * gauss1 + 0.25 * gauss2
sum.draw(myImg,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject 0.75 * gauss1 + 0.25 * gauss2 disagrees with expected result"
)
sum = 0.75 * gauss1
sum += 0.25 * gauss2
sum.draw(myImg,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Using GSObject sum += 0.25 * gauss2 disagrees with expected result")
# Test photon shooting.
do_shoot(sum, myImg, "sum of 2 Gaussians")
# Test kvalues
do_kvalue(sum, "sum of 2 Gaussians")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_realspace_shearconvolve():
"""Test the real-space convolution of a sheared Gaussian and a Box SBProfile against a
known result.
"""
import time
t1 = time.time()
psf = galsim.SBGaussian(flux=1, sigma=1)
e1 = 0.04
e2 = 0.0
myShear = galsim.Shear(e1=e1, e2=e2)
psf.applyShear(myShear._shear)
pix = galsim.SBBox(xw=0.2, yw=0.2, flux=1.)
conv = galsim.SBConvolve([psf, pix], real_space=True)
saved_img = galsim.fits.read(
os.path.join(imgdir, "gauss_smallshear_convolve_box.fits"))
img = galsim.ImageF(saved_img.bounds, scale=0.2)
conv.draw(img.view())
printval(img, saved_img)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Sheared Gaussian convolved with Box SBProfile disagrees with expected result"
)
# Repeat with the GSObject version of this:
psf = galsim.Gaussian(flux=1, sigma=1)
psf.applyShear(e1=e1, e2=e2)
pixel = galsim.Pixel(xw=0.2, yw=0.2, flux=1.)
conv = galsim.Convolve([psf, pixel], real_space=True)
conv.draw(img,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) disagrees with expected result")
# Check with default_params
conv = galsim.Convolve([psf, pixel],
real_space=True,
gsparams=default_params)
conv.draw(img,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with default_params disagrees with "
"expected result")
conv = galsim.Convolve([psf, pixel],
real_space=True,
gsparams=galsim.GSParams())
conv.draw(img,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([psf,pixel]) with GSParams() disagrees with "
"expected result")
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel, real_space=True)
conv.draw(img,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve(psf,pixel) disagrees with expected result")
# The real-space convolution algorithm is not (trivially) independent of the order of
# the two things being convolved. So check the opposite order.
conv = galsim.Convolve([pixel, psf], real_space=True)
conv.draw(img,
dx=0.2,
normalization="surface brightness",
use_true_center=False)
np.testing.assert_array_almost_equal(
img.array,
saved_img.array,
5,
err_msg=
"Using GSObject Convolve([pixel,psf]) disagrees with expected result")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)
def test_shearconvolve():
"""Test the convolution of a sheared Gaussian and a Box SBProfile against a known result.
"""
import time
t1 = time.time()
e1 = 0.04
e2 = 0.0
myShear = galsim.Shear(e1=e1, e2=e2)
# test at SBProfile level using applyShear
mySBP = galsim.SBGaussian(flux=1, sigma=1)
mySBP.applyShear(myShear._shear)
mySBP2 = galsim.SBBox(xw=0.2, yw=0.2, flux=1.)
myConv = galsim.SBConvolve([mySBP, mySBP2])
savedImg = galsim.fits.read(
os.path.join(imgdir, "gauss_smallshear_convolve_box.fits"))
myImg = galsim.ImageF(savedImg.bounds, scale=0.2)
myConv.draw(myImg.view())
printval(myImg, savedImg)
np.testing.assert_array_almost_equal(
myImg.array,
savedImg.array,
5,
err_msg=
"Sheared Gaussian convolved with Box SBProfile disagrees with expected result"
)
# Repeat with the GSObject version of this:
psf = galsim.Gaussian(flux=1, sigma=1)
psf2 = psf.createSheared(e1=e1, e2=e2)
psf.applyShear(e1=e1, e2=e2)
pixel = galsim.Pixel(xw=0.2, yw=0.2, flux=1.)
conv = galsim.Convolve([psf, pixel])
conv.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 Convolve([psf,pixel]) disagrees with expected result")
conv2 = galsim.Convolve([psf2, pixel])
conv2.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 Convolve([psf,pixel]) disagrees with expected result")
# Check with default_params
conv = galsim.Convolve([psf, pixel], gsparams=default_params)
conv.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 Convolve([psf,pixel]) with default_params disagrees with "
"expected result")
conv = galsim.Convolve([psf, pixel], gsparams=galsim.GSParams())
conv.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 Convolve([psf,pixel]) with GSParams() disagrees with "
"expected result")
# Other ways to do the convolution:
conv = galsim.Convolve(psf, pixel)
conv.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 Convolve(psf,pixel) disagrees with expected result")
# Test photon shooting.
do_shoot(conv, myImg, "sheared Gaussian * Pixel")
t2 = time.time()
print 'time for %s = %.2f' % (funcname(), t2 - t1)