def test_kobs():
rng = np.random.RandomState(seed=11)
with pytest.raises(ValueError):
KObservation(kimage={})
with pytest.raises(ValueError):
KObservation(kimage=galsim.ImageD(rng.normal(size=(11, 13)), scale=0.3))
with pytest.raises(AssertionError):
KObservation(
kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3),
weight={},
)
with pytest.raises(ValueError):
KObservation(
kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3),
weight=galsim.ImageD(rng.normal(size=(11, 12)), scale=0.3),
)
obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
assert np.all(obs.weight.array == 1)
assert obs.weight.array.shape == (11, 13)
assert not obs.has_psf()
psf_obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
obs.set_psf(psf_obs)
assert obs.has_psf()
assert obs.psf is psf_obs
obs.set_psf(None)
assert not obs.has_psf()
with pytest.raises(AssertionError):
obs.set_psf({})
psf_obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 12)), scale=0.3))
with pytest.raises(ValueError):
obs.set_psf(psf_obs)
psf_obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.4))
with pytest.raises(AssertionError):
obs.set_psf(psf_obs)
assert isinstance(obs.jacobian, DiagonalJacobian)
assert np.allclose(obs.jacobian.scale, 0.3)
assert np.array_equal(obs.jacobian.cen, [5, 6])
obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(10, 12)), scale=0.3))
assert np.array_equal(obs.jacobian.cen, [5, 6])
obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(7, 12)), scale=0.3))
assert np.array_equal(obs.jacobian.cen, [3, 6])
obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(6, 11)), scale=0.3))
assert np.array_equal(obs.jacobian.cen, [3, 5])
def test_kobslist():
rng = np.random.RandomState(seed=11)
obs1 = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
obs2 = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
kobslist = KObsList()
kobslist.append(obs1)
assert np.all(kobslist[0].kimage.array == obs1.kimage.array)
kobslist.append(obs2)
assert np.all(kobslist[0].kimage.array == obs1.kimage.array)
assert np.all(kobslist[1].kimage.array == obs2.kimage.array)
kobslist[1] = obs1
assert np.all(kobslist[1].kimage.array == obs1.kimage.array)
with pytest.raises(AssertionError):
kobslist.append(None)
with pytest.raises(AssertionError):
kobslist[0] = None
def hparams(self, defaults, model_hparams):
p = defaults
p.pixel_scale = 0.168
p.img_len = 64
p.example_per_shard = 1000
p.modality = {"inputs": modalities.ModalityType.IDENTITY,
"targets": modalities.ModalityType.IDENTITY}
p.vocab_size = {"inputs": None,
"targets": None}
p.psf = galsim.InterpolatedKImage(galsim.ImageCD(fits.getdata(os.path.join(_COSMOS_DATA_DIR, 'hsc_hann_window.fits'))+0j, scale=0.2921868167401221))
p.rotation = True
def test_get_kmb_obs():
rng = np.random.RandomState(seed=11)
obs = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
mbobs = get_kmb_obs(obs)
rng = np.random.RandomState(seed=11)
assert np.all(mbobs[0][0].kimage.array == rng.normal(size=(11, 13)))
assert len(mbobs) == 1
assert len(mbobs[0]) == 1
rng = np.random.RandomState(seed=12)
obslist = KObsList()
for _ in range(3):
obslist.append(KObservation(
kimage=galsim.ImageCD(rng.normal(size=(12, 17)), scale=0.3)))
mbobs = get_kmb_obs(obslist)
rng = np.random.RandomState(seed=12)
for i in range(3):
assert np.all(mbobs[0][i].kimage.array == rng.normal(size=(12, 17)))
assert len(mbobs) == 1
assert len(mbobs[0]) == 3
rng = np.random.RandomState(seed=13)
mbobs = KMultiBandObsList()
for _ in range(5):
obslist = KObsList()
for _ in range(3):
obslist.append(KObservation(
kimage=galsim.ImageCD(rng.normal(size=(13, 15)), scale=0.3)))
mbobs.append(obslist)
new_mbobs = get_kmb_obs(mbobs)
rng = np.random.RandomState(seed=13)
for obslist in new_mbobs:
for obs in obslist:
assert np.all(obs.kimage.array == rng.normal(size=(13, 15)))
with pytest.raises(ValueError):
get_kmb_obs(None)
def test_kmbobslist():
rng = np.random.RandomState(seed=11)
obs1 = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
obs2 = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
obs3 = KObservation(kimage=galsim.ImageCD(rng.normal(size=(11, 13)), scale=0.3))
kobslist1 = KObsList()
kobslist1.append(obs1)
kobslist1.append(obs2)
kobslist2 = KObsList()
kobslist2.append(obs3)
kmbobs = KMultiBandObsList()
kmbobs.append(kobslist1)
assert all(
np.all(obs.kimage.array == _obs.kimage.array)
for obs, _obs in zip(kmbobs[0], kobslist1)
)
kmbobs.append(kobslist2)
assert all(
np.all(obs.kimage.array == _obs.kimage.array)
for obs, _obs in zip(kmbobs[0], kobslist1)
)
assert all(
np.all(obs.kimage.array == _obs.kimage.array)
for obs, _obs in zip(kmbobs[1], kobslist2)
)
kmbobs[1] = kobslist1
assert all(
np.all(obs.kimage.array == _obs.kimage.array)
for obs, _obs in zip(kmbobs[1], kobslist1)
)
with pytest.raises(AssertionError):
kmbobs.append(None)
with pytest.raises(AssertionError):
kmbobs[0] = None
def test_compound():
"""Check that transformations of transformations work the same whether they are compounded
automatically or not.
"""
gal1 = galsim.Gaussian(fwhm=1.7, flux=2.3)
gal2 = gal1.shear(g1=0.21, g2=0.12).rotate(33 * galsim.degrees).shift(0.1,0.4) * 1.1
gal3 = gal2.shear(g1=0.18, g2=0.09).rotate(12 * galsim.degrees).shift(-0.3,0.5) * 8.9
# These should have compounded automatically into a single transformation
print('gal3 = ',gal3)
print('gal3.original = ',gal3.original)
assert gal3.original == gal1
gal4 = gal2 + 0. * gal1 # Equivalent to gal2, but the sum kills the automatic compounding.
gal5 = gal4.shear(g1=0.18, g2=0.09).rotate(12 * galsim.degrees).shift(-0.3,0.5) * 8.9
print('gal5 = ',gal5)
print('gal5.original = ',gal5.original)
assert gal5.original != gal1
assert gal5.original == gal4
# Despite that, the gal3 and gal5 should draw the same in both real and k-space
im3_d = galsim.ImageD(8,8)
im5_d = galsim.ImageD(8,8)
im3_f = galsim.ImageF(8,8)
im5_f = galsim.ImageF(8,8)
im3_cd = galsim.ImageCD(8,8)
im5_cd = galsim.ImageCD(8,8)
im3_cf = galsim.ImageCF(8,8)
im5_cf = galsim.ImageCF(8,8)
# Note: these are not equal. gal5 lost track of the overall transformation and thinks it
# needs a bit larger maxk, smaller stepk. ~10% different.
print('gal3.stepk = ',gal3.stepk)
print('gal5.stepk = ',gal5.stepk)
print('gal3.maxk = ',gal3.maxk)
print('gal5.maxk = ',gal5.maxk)
gal3.drawImage(image=im3_d, method='sb', scale=0.2)
gal5.drawImage(image=im5_d, method='sb', scale=0.2)
np.testing.assert_almost_equal(im3_d[1,1], gal3.xValue(-0.7,-0.7), decimal=12)
np.testing.assert_almost_equal(im5_d[1,1], gal3.xValue(-0.7,-0.7), decimal=12)
np.testing.assert_almost_equal(im3_d.array[0,0], gal3.xValue(-0.7,-0.7), decimal=12)
np.testing.assert_almost_equal(im5_d.array[0,0], gal3.xValue(-0.7,-0.7), decimal=12)
np.testing.assert_array_almost_equal(im3_d.array, im5_d.array, decimal=12)
gal3.drawImage(image=im3_f, method='sb', scale=0.2)
gal5.drawImage(image=im5_f, method='sb', scale=0.2)
np.testing.assert_almost_equal(im3_f[1,1], gal3.xValue(-0.7,-0.7), decimal=4)
np.testing.assert_almost_equal(im5_f[1,1], gal3.xValue(-0.7,-0.7), decimal=4)
np.testing.assert_almost_equal(im3_f.array, im5_f.array, decimal=4)
np.testing.assert_almost_equal(im3_f.array, im3_d.array, decimal=4)
np.testing.assert_almost_equal(im5_f.array, im5_d.array, decimal=4)
gal3.drawKImage(image=im3_cd, scale=0.5)
gal5.drawKImage(image=im5_cd, scale=0.5)
np.testing.assert_almost_equal(im3_cd[-4,-4], gal3.kValue(-2.,-2.), decimal=12)
np.testing.assert_almost_equal(im5_cd[-4,-4], gal3.kValue(-2.,-2.), decimal=12)
np.testing.assert_almost_equal(im3_cd.array[0,0], gal3.kValue(-2.,-2.), decimal=12)
np.testing.assert_almost_equal(im5_cd.array[0,0], gal3.kValue(-2.,-2.), decimal=12)
np.testing.assert_array_almost_equal(im3_cd.array, im5_cd.array, decimal=12)
gal3.drawKImage(image=im3_cf, scale=0.5)
gal5.drawKImage(image=im5_cf, scale=0.5)
np.testing.assert_almost_equal(im3_cf[-4,-4], gal3.kValue(-2.,-2.), decimal=3)
np.testing.assert_almost_equal(im5_cf[-4,-4], gal3.kValue(-2.,-2.), decimal=3)
np.testing.assert_array_almost_equal(im3_cf.array, im5_cf.array, decimal=3)
np.testing.assert_array_almost_equal(im3_cf.array, im3_cd.array, decimal=3)
np.testing.assert_array_almost_equal(im5_cf.array, im5_cd.array, decimal=3)
def test_simple():
"""Test the default Sensor class that acts basically like not passing any sensor object.
"""
# Start with photon shooting, since that's the most typical way that sensors are used.
obj = galsim.Gaussian(flux=10000, sigma=1.3)
# We'll draw the same object using SiliconSensor, Sensor, and the default (sensor=None)
im1 = galsim.ImageD(64, 64, scale=0.3) # Refefence image with sensor=None
im2 = galsim.ImageD(64, 64, scale=0.3) # Use sensor=simple
rng1 = galsim.BaseDeviate(5678)
rng2 = galsim.BaseDeviate(5678)
simple = galsim.Sensor()
# Start with photon shooting, since that's more straightforward.
obj.drawImage(im1, method='phot', poisson_flux=False, rng=rng1)
obj.drawImage(im2, method='phot', poisson_flux=False, sensor=simple, rng=rng2)
# Should be exactly equal
np.testing.assert_array_equal(im2.array, im1.array)
# Fluxes should all equal obj.flux
np.testing.assert_almost_equal(im1.array.sum(), obj.flux, decimal=6)
np.testing.assert_almost_equal(im2.array.sum(), obj.flux, decimal=6)
np.testing.assert_almost_equal(im1.added_flux, obj.flux, decimal=6)
np.testing.assert_almost_equal(im2.added_flux, obj.flux, decimal=6)
# Now test fft drawing, which is more complicated with possible temporaries and subsampling.
im1 = galsim.ImageD(64, 64, scale=0.3) # Reference image with sensor=None
im2 = galsim.ImageD(64, 64, scale=0.3) # Use sensor=simple
im3 = galsim.ImageD(64, 64, scale=0.3) # Use sensor=simple, no subsampling
im4 = galsim.ImageCD(64, 64, scale=0.3) # Equivalent to image2, but checks using a temporary.
# Also check add_to_image=True with im5.
im5 = galsim.ImageD(64, 64, scale=0.3) # Check manually convolving by the pixel.
im6 = galsim.ImageD(64, 64, scale=0.3) # Check manually convolving by the pixel, n_subsample=1
# The rng shouldn't matter anymore for these, so just use the default rng=None
obj.drawImage(im1, method='fft')
obj.drawImage(im2, method='fft', sensor=simple)
obj.drawImage(im3, method='fft', sensor=simple, n_subsample=1)
obj.drawImage(im4, method='fft', sensor=simple, add_to_image=True)
obj_with_pixel = galsim.Convolve(obj, galsim.Pixel(0.3))
obj_with_pixel.drawImage(im5, method='no_pixel', sensor=simple)
obj_with_pixel.drawImage(im6, method='no_pixel', sensor=simple, n_subsample=1)
# Fluxes should all equal obj.flux
np.testing.assert_almost_equal(im1.array.sum(), obj.flux, decimal=3)
np.testing.assert_almost_equal(im2.array.sum(), obj.flux, decimal=3)
np.testing.assert_almost_equal(im3.array.sum(), obj.flux, decimal=3)
np.testing.assert_almost_equal(im4.array.sum(), obj.flux, decimal=3)
np.testing.assert_almost_equal(im5.array.sum(), obj.flux, decimal=3)
np.testing.assert_almost_equal(im6.array.sum(), obj.flux, decimal=3)
np.testing.assert_almost_equal(im1.added_flux, obj.flux, decimal=3)
np.testing.assert_almost_equal(im2.added_flux, obj.flux, decimal=3)
np.testing.assert_almost_equal(im3.added_flux, obj.flux, decimal=3)
np.testing.assert_almost_equal(im4.added_flux, obj.flux, decimal=3)
np.testing.assert_almost_equal(im5.added_flux, obj.flux, decimal=3)
np.testing.assert_almost_equal(im6.added_flux, obj.flux, decimal=3)
# im1 and im2 are not precisely equal, since im2 was made with subsampling and then binning,
# but with a largish object relative to the pixel, it's very close. (cf. similar test below
# in test_silicon_fft, where the agreement is not so good.)
print('max diff between im1, im2 with fft = ',np.max(np.abs(im2.array-im1.array)))
np.testing.assert_almost_equal(im2.array, im1.array, decimal=10)
# With no subsampling it should be nearly perfect (although this would be expected to be worse
# when done with a real Sensor model).
print('max diff without subsampling = ',np.max(np.abs(im3.array-im1.array)))
np.testing.assert_almost_equal(im3.array, im1.array, decimal=12)
# Using a temporary (and add_to_image) shouldn't affect anything for the D -> CD case.
print('max diff with temporary = ',np.max(np.abs(im4.array-im2.array)))
np.testing.assert_almost_equal(im4.array.real, im2.array, decimal=12)
# Manual convolution should be identical to what 'fft' does automatically.
print('max diff with manual pixel conv = ',np.max(np.abs(im5.array-im2.array)))
#np.testing.assert_almost_equal(im5.array, im2.array, decimal=12)
print('max diff with manual pixel conv, no subsampling = ',np.max(np.abs(im6.array-im3.array)))
np.testing.assert_almost_equal(im6.array, im3.array, decimal=12)
do_pickle(simple)
