def addNoise(self, config, base, im, rng, current_var, draw_method,
logger):
# Get how much extra sky to assume from the image.noise attribute.
sky = GetSky(base['image'], base)
extra_sky = GetSky(config, base)
total_sky = sky + extra_sky # for the return value
if isinstance(total_sky, galsim.Image):
var = np.mean(total_sky.array)
else:
var = total_sky
# (This could be zero, in which case we only add poisson noise for the object photons)
# If we already have some variance in the image (from whitening), then we subtract this
# much off of the sky level. It's not precisely accurate, since the existing variance is
# Gaussian, rather than Poisson, but it's the best we can do.
if current_var:
logger.debug(
'image %d, obj %d: Target variance is %f, current variance is %f',
base.get('image_num', 0), base.get('obj_num', 0), var,
current_var)
if isinstance(total_sky, galsim.Image):
test = np.any(total_sky.image.array < current_var)
else:
test = (total_sky < current_var)
if test:
raise RuntimeError(
"Whitening already added more noise than the requested Poisson noise."
)
total_sky -= current_var
extra_sky -= current_var
# At this point, there is a slight difference between fft and phot. For photon shooting,
# the galaxy already has Poisson noise, so we want to make sure not to add that again!
if draw_method == 'phot':
# Only add in the noise from the sky.
if isinstance(total_sky, galsim.Image):
noise_im = total_sky.copy()
noise_im.addNoise(galsim.PoissonNoise(rng))
noise_im -= total_sky
# total_sky should now have zero mean, but with the noise of the total sky level.
im += noise_im
else:
im.addNoise(
galsim.DeviateNoise(
galsim.PoissonDeviate(rng, mean=total_sky)))
# This deviate adds a noisy version of the sky, so need to subtract the mean
# back off.
im -= total_sky
else:
im += extra_sky
# Do the normal PoissonNoise calculation.
im.addNoise(galsim.PoissonNoise(rng))
im -= extra_sky
logger.debug('image %d, obj %d: Added Poisson noise',
base.get('image_num', 0), base.get('obj_num', 0))
return var
def observe(self, psf_fwhm=None, exp_time=60*20*u.s, sky_sb=20,
area=subaru_area, pixscale=0.168*u.arcsec/u.pixel,
img_dims=[None, None]):
if psf_fwhm is not None:
if psf_fwhm != self.psf_fwhm or pixscale != self.pixscale:
self.psf_fwhm = psf_fwhm
self.pixscale = pixscale
self.gauss_psf = galsim.Gaussian(
flux=1.0, fwhm=psf_fwhm.to('arcsec').value)
self._reset_gal()
self.gal = galsim.Convolve([self.gal, self.gauss_psf])
nx = 2*int(8 * self.gauss_psf.sigma/pixscale.value) - 1
self.psf_array = self.gauss_psf.drawImage(
nx=nx, ny=nx, scale=pixscale.value).array
self.psf_array /= self.psf_array.sum()
self.image = self.gal.drawImage(area=area.to('cm2').value,
exptime=exp_time.to('s').value,
scale=pixscale.value,
nx=img_dims[0], ny=img_dims[1])
self.effective_exp_time = exp_time * area.to('cm2').value
self.sky_level_flux = sb_to_photon_flux_per_pixel(
sky_sb, pixscale=pixscale)
self.sky_level_count = self.sky_level_flux.value *\
self.effective_exp_time.to('s').value
self.image.addNoise(
galsim.PoissonNoise(sky_level=self.sky_level_count))
self.image = self.image / self.effective_exp_time.value
max_sb = self.gal.max_sb * self.pars.phot_flux_to_fnu.value
self.mu_0_model = -2.5 * np.log10(max_sb) - mAB0
def draw_images(galaxies_psf, band, img_size, filter_name,sky_level_pixel, real_or_param = 'param'):
'''
Return single galaxy noiseless images as well as the blended noisy one
Parameters:
----------
galaxies_psf: PSF to add on the image
band: filter number in which the image is drawn
img_size: size of the drawn image
filter_name: name of the filter
sky_level_pixel: sky level pixel for noise realization
real_or_param: the galaxy generation use real image or parametric model
'''
# Create image in r bandpass filter to do the peak detection
blend_img = galsim.ImageF(img_size, img_size, scale=pixel_scale[band])
images = []
for j, gal in enumerate(galaxies_psf):
temp_img = galsim.ImageF(img_size, img_size, scale=pixel_scale[band])
# Parametric image
if real_or_param == 'param':
gal.drawImage(filters[filter_name], image=temp_img)
# Real image
elif real_or_param == "real":
gal.drawImage(image=temp_img)
images.append(temp_img)
blend_img += temp_img
# add noise
poissonian_noise = galsim.PoissonNoise(rng, sky_level=sky_level_pixel)
blend_img.addNoise(poissonian_noise)
return images, blend_img
def galSimDrawImage(galObj, size=0, scale=1.0, method="no_pixel",
addPoisson=False):
"""
"Draw" a GalSim Object into an GalSim Image using certain method, and with
certain size
TODO : Think about the scale here:
By default scale=None
According to GalSim Doxygen :
If provided, use this as the pixel scale for the image. If scale is None
and image != None, then take the provided image's pixel scale.
If scale is None and image == None, then use the Nyquist scale.
If scale <= 0 (regardless of image), then use the Nyquist scale.
"""
# Generate an "Image" object for the model
if size > 0:
imgTemp = galsim.image.Image(size, size)
galImg = galObj.drawImage(imgTemp, scale=scale, method=method)
else:
galImg = galObj.drawImage(scale=scale, method=method)
# Just an option for test
if addPoisson:
galImg.addNoise(galsim.PoissonNoise())
# Return the Numpy array version of the image
return galImg.array
def run_single_band(Args, blend_catalog, obs_cond, band):
"""Draws image of isolated galaxies along with the blend image in the
single input band.
The WLDeblending package (descwl) renders galaxies corresponding to the
blend_catalog entries and with observing conditions determined by
obs_cond. The rendered objects are stored in the the observing conditions
class. So as to not overwrite images across different blends, we make a
copies of the obs_cond while drawing each galaxy. Images of isolated
galaxies are drawn with the WLDeblending and them summed to produce the
blend image.
A column 'not_drawn_{band}' is added to blend_catalog initialized as zero.
If a galaxy was not drawn by descwl, then this flag is set to 1.
Args:
Args: Class containing input parameters.
blend_catalog: Catalog with entries corresponding to one blend.
obs_cond: `descwl.survey.Survey` class describing observing conditions.
band(string): Name of band to draw images in.
Returns:
Images of blend and isolated galaxies as `numpy.ndarray`.
"""
blend_catalog.add_column(
Column(np.zeros(len(blend_catalog)), name='not_drawn_' + band))
galaxy_builder = descwl.model.GalaxyBuilder(obs_cond,
no_disk=False,
no_bulge=False,
no_agn=False,
verbose_model=False)
stamp_size = np.int(Args.stamp_size / Args.pixel_scale)
iso_image = np.zeros((Args.max_number, stamp_size, stamp_size))
# define temporary galsim image to hold isolated galaxy images that will be summed
blend_image_temp = galsim.Image(np.zeros((stamp_size, stamp_size)))
for k, entry in enumerate(blend_catalog):
iso_obs = copy.deepcopy(obs_cond)
try:
galaxy = galaxy_builder.from_catalog(entry, entry['ra'],
entry['dec'], band)
iso_render = draw_isolated(Args, galaxy, iso_obs)
iso_image[k] = iso_render.image.array
blend_image_temp += iso_render.image
except descwl.render.SourceNotVisible:
if Args.verbose:
print("Source not visible")
blend_catalog['not_drawn_' + band][k] = 1
continue
if Args.add_noise:
if Args.verbose:
print("Noise added to blend image")
generator = galsim.random.BaseDeviate(
seed=np.random.randint(99999999))
noise = galsim.PoissonNoise(rng=generator,
sky_level=iso_obs.mean_sky_level)
blend_image_temp.addNoise(noise)
blend_image = blend_image_temp.array
return blend_image, iso_image
def makeStars(nstar, beta, size=None, g1=None, g2=None, seed=12345):
rng = galsim.BaseDeviate(seed)
np_rng = np.random.default_rng(seed)
flux = 1.e6
sky_level = 200.0 # For noise
# Use a random DECam CCD for the wcs
decaminfo = piff.des.DECamInfo()
wcs = decaminfo.get_nominal_wcs(chipnum=10)
# pick random size, shape if not given
if size is None:
size = np_rng.uniform(0.5, 0.9, nstar)
else:
size = np.array([size] * nstar)
if g1 is None:
g1 = np_rng.uniform(-0.1, 0.1, nstar)
else:
g1 = np.array([g1] * nstar)
if g2 is None:
g2 = np_rng.uniform(-0.1, 0.1, nstar)
else:
g2 = np.array([g2] * nstar)
noiseless_stars = []
noisy_stars = []
for i in range(nstar):
# Use Moffat profile
prof = galsim.Moffat(half_light_radius=size[i],
beta=beta).shear(g1=g1[i], g2=g2[i])
# make the star with no noise.
noiseless_star = piff.Star.makeTarget(x=0, y=0, wcs=wcs, stamp_size=19)
prof = prof.shift(noiseless_star.fit.center).withFlux(flux)
im = noiseless_star.image
prof.drawImage(image=im, center=noiseless_star.image_pos)
noiseless_stars.append(noiseless_star)
# Generate a Poisson noise model, with some foreground (assumes that this foreground
# was already subtracted)
poisson_noise = galsim.PoissonNoise(rng, sky_level=sky_level)
im = im.copy()
im.addNoise(poisson_noise) # adds in place
# get new weight in photo-electrons (not an array)
inverse_weight = im + sky_level
weight = 1.0 / inverse_weight
# make new noisy star by resetting data in the noiseless star
noisy_star = copy.deepcopy(noiseless_star)
noisy_star.data.image = im
noisy_star.data.weight = weight
noisy_stars.append(noisy_star)
return noiseless_stars, noisy_stars
def allDetectorEffects(img, rng=None, exptime=None):
"""
This utility applies all sources of noise and detector effects for WFIRST that are implemented
in GalSim. In terms of noise, this includes the Poisson noise due to the signal (sky +
background), dark current, and read noise. The detector effects that are included are
reciprocity failure, quantization, nonlinearity, and interpixel capacitance. It also includes
the necessary factors of gain. In short, the user should be able to pass in an Image with all
sources of signal (background plus astronomical objects), and the Image will be modified to
include all subsequent steps in the image generation process for WFIRST that are implemented in
GalSim.
@param img The Image to be modified.
@param rng An optional galsim.BaseDeviate to use for the addition of noise. If None, a
new one will be initialized. [default: None]
@param exptime The exposure time, in seconds. If None, then the WFIRST default exposure time
will be used. [default: None]
"""
# Deal appropriately with passed-in RNG, exposure time.
if rng is None:
rng = galsim.BaseDeviate()
elif not isinstance(rng, galsim.BaseDeviate):
raise TypeError(
"The rng provided to RealGalaxy constructor is not a BaseDeviate")
if exptime is None:
exptime = galsim.wfirst.exptime
# Add Poisson noise.
poisson_noise = galsim.PoissonNoise(rng)
img.addNoise(poisson_noise)
# Reciprocity failure (use WFIRST routine, with the supplied exposure time).
addReciprocityFailure(img, exptime=exptime)
# Quantize.
img.quantize()
# Dark current (use exposure time).
dark_current = galsim.wfirst.dark_current * exptime
dark_noise = galsim.DeviateNoise(galsim.PoissonDeviate(rng, dark_current))
img.addNoise(dark_noise)
# Nonlinearity (use WFIRST routine).
applyNonlinearity(img)
# IPC (use WFIRST routine).
applyIPC(img)
# Read noise.
read_noise = galsim.GaussianNoise(rng, sigma=galsim.wfirst.read_noise)
img.addNoise(read_noise)
# Gain.
img /= galsim.wfirst.gain
# Quantize.
img.quantize()
def add_poisson_noise(self, rng, im, sky_image, phot=False):
noise = galsim.PoissonNoise(rng)
# Add poisson noise to image
if phot:
sky_image_ = sky_image.copy()
sky_image_.addNoise(noise)
im += sky_image_
else:
im.addNoise(noise)
return im
def draw_images(galaxies_psf,
band,
img_size,
filter_name,
sky_level_pixel,
rng_shear=None,
real_or_param='param'):
'''
Return single galaxy noiseless images as well as the blended noisy one
Parameters:
----------
galaxies_psf: PSF to add on the image
band: filter number in which the image is drawn
img_size: size of the drawn image
filter_name: name of the filter
sky_level_pixel: sky level pixel for noise realization
real_or_param: the galaxy generation use real image or parametric model
'''
# Create image in r bandpass filter to do the peak detection
blend_img = galsim.ImageF(img_size, img_size, scale=pixel_scale[band])
images = []
for j, gal in enumerate(galaxies_psf):
temp_img = galsim.ImageF(img_size, img_size, scale=pixel_scale[band])
# Parametric image
if real_or_param == 'param':
gal.drawImage(filters[filter_name], image=temp_img)
# Real image
elif real_or_param == "real":
gal.drawImage(image=temp_img)
images.append(temp_img)
blend_img += temp_img
# add noise
if rng_shear is None:
poissonian_noise = galsim.PoissonNoise(rng, sky_level=sky_level_pixel)
blend_img.addNoise(poissonian_noise)
#blend_img = np.array(blend_img.array.data)
else:
poissonian_noise = galsim.GaussianNoise(
rng=rng_shear, sigma=np.sqrt(sky_level_pixel)
) #PoissonNoise(rng_shear, sky_level=sky_level_pixel)
blend_img.addNoise(poissonian_noise)
#np.random.seed(rng_shear)
#rng = np.random.RandomState(rng_shear)
#blend_img = rng.poisson(np.array(blend_img.array.data)+sky_level_pixel).astype(float) - sky_level_pixel
return images, blend_img
def test_dep_noise():
"""Test the deprecated methods in galsim/deprecated/noise.py
"""
import time
t1 = time.time()
rng = galsim.BaseDeviate(123)
gn = galsim.GaussianNoise(rng=rng, sigma=0.3)
rng2 = galsim.BaseDeviate(999)
check_dep(gn.setRNG, rng2)
assert gn.rng is rng2
check_dep(gn.setVariance, 1.7)
np.testing.assert_almost_equal(gn.getVariance(), 1.7)
check_dep(gn.scaleVariance, 1.9)
np.testing.assert_almost_equal(gn.getVariance(), 1.7 * 1.9)
check_dep(gn.setSigma, 2.3)
np.testing.assert_almost_equal(gn.getSigma(), 2.3)
pn = galsim.PoissonNoise(rng=rng, sky_level=0.3)
check_dep(pn.setSkyLevel, 2.3)
np.testing.assert_almost_equal(pn.getSkyLevel(), 2.3)
cn = galsim.CCDNoise(rng=rng, gain=1.7, read_noise=0.5, sky_level=0.3)
np.testing.assert_almost_equal(cn.getSkyLevel(), 0.3)
np.testing.assert_almost_equal(cn.getGain(), 1.7)
np.testing.assert_almost_equal(cn.getReadNoise(), 0.5)
check_dep(cn.setSkyLevel, 2.3)
np.testing.assert_almost_equal(cn.getSkyLevel(), 2.3)
np.testing.assert_almost_equal(cn.getGain(), 1.7)
np.testing.assert_almost_equal(cn.getReadNoise(), 0.5)
check_dep(cn.setGain, 0.9)
np.testing.assert_almost_equal(cn.getSkyLevel(), 2.3)
np.testing.assert_almost_equal(cn.getGain(), 0.9)
np.testing.assert_almost_equal(cn.getReadNoise(), 0.5)
check_dep(cn.setReadNoise, 11)
np.testing.assert_almost_equal(cn.getSkyLevel(), 2.3)
np.testing.assert_almost_equal(cn.getGain(), 0.9)
np.testing.assert_almost_equal(cn.getReadNoise(), 11)
t2 = time.time()
print 'time for %s = %.2f'%(funcname(),t2-t1)
def generate_sample(args):
"""Generate one valid sample and write it to the destination arrays.
"""
i, flux, bulge_n, bulge_re, g1, g2, psf_re, noise = args
with counter.get_lock():
# Increment the global iteration counter
counter.value += 1
# Initialize the random number generators
random.seed(random_seed + counter.value)
rng = galsim.BaseDeviate(random_seed + counter.value + 1)
gal = galsim.Sersic(bulge_n, half_light_radius=bulge_re)
gal = gal.withFlux(flux)
gal = gal.shear(g1=g1, g2=g2)
psf = galsim.Moffat(beta=psf_beta, flux=1.0, fwhm=psf_re)
final = galsim.Convolve([psf, gal])
image = galsim.ImageF(image_size, image_size, scale=pixel_scale)
final.drawImage(image=image)
# signal to noise ratio
snr = np.sqrt((image.array**2).sum()) / noise
image_nonoise = copy.deepcopy(image.array)
image.addNoise(galsim.PoissonNoise(rng, sky_level=0.0))
# noise map for bkgr gaussian noise
image.addNoise(galsim.GaussianNoise(rng, sigma=noise))
# Optionally: generate a PSF image
if i == 0:
psf_image = galsim.ImageF(image_size, image_size, scale=pixel_scale)
psf.drawImage(image=psf_image)
data["psf_img"][i] = psf_image.array
data["img"][i] = image.array # final noised image
data["img_nonoise"][i] = image_nonoise # noiseless image
data["gal_flux"][i] = flux
data["bulge_re"][i] = bulge_re
data["bulge_n"][i] = bulge_n
data["psf_r"][i] = psf_re
data["snr"][i] = snr
data["sigma"][i] = noise
data["g_1"][i] = g1
data["g_2"][i] = g2
def getFitsFile(flux,
nser,
reff,
ba,
pa,
zp=26.0,
scale=1.0,
method='auto',
psfConv=False,
addNoise=False,
fwhm=2.0):
if psfConv:
psfObj = galsim.Gaussian(fwhm=fwhm)
# psfImg = psfObj.drawImage(scale=scale)
# galsim.fits.write(psfImg, file_name='psf.fits')
trunc = int(10.0 * reff)
serTrun = galsim.Sersic(nser, half_light_radius=reff, trunc=trunc)
serTrun = serTrun.withFlux(flux)
serTrun = serTrun.shear(q=ba, beta=0.0 * galsim.degrees)
serTrun = serTrun.rotate(pa * galsim.degrees)
if psfConv:
serTrun = galsim.Convolve([serTrun, psfObj])
serImg = serTrun.drawImage(method=method, scale=scale)
if addNoise:
serImg.addNoise(galsim.PoissonNoise())
galsim.fits.write(serImg, file_name="temp.fits")
xs, ys = serImg.array.shape
if (xs % 2 == 0):
xc = (xs + 1) / 2.0
else:
xc = xs / 2.0
if (ys % 2 == 0):
yc = (ys + 1) / 2.0
else:
yc = ys / 2.0
return xs, ys, xc, yc
def _make_band_dobs_old(self, catalog, pos_yx, band, add_noise=True):
"""
make the image, which goes into 'dobs' and
WeakLensingDeblending Survey instance
"""
import descwl
dobs, engine, builder = self._get_dobs_engine_builder(band)
for i,entry in enumerate(catalog):
# offsets in arcmin
dy, dx = pos_yx[i]
dy = dy*60.0
dx = dx*60.0
galaxy = builder.from_catalog(entry,dx,dy,dobs.filter_band)
# this writes into the image contained in dobs
# we throw away stamp,bounds
try:
stamps,bounds = engine.render_galaxy(
galaxy,
no_partials=True,
calculate_bias=False,
)
except descwl.render.SourceNotVisible as err:
pass
#print(str(err))
if add_noise:
noise = galsim.PoissonNoise(
rng=self.gs_rng,
sky_level = dobs.mean_sky_level,
)
dobs.image.addNoise(noise)
#print('sky level:',dobs.mean_sky_level)
#print('image median:',np.median(dobs.image.array))
#dobs.image.array[:,:] -= dobs.mean_sky_level*dobs.pixel_scale**2
return dobs
def _make_band_dobs(self, catalog, pos_yx, band, add_noise=True):
"""
make the image, which goes into 'dobs' and
WeakLensingDeblending Survey instance
In this version we render them ourselves, all sheared together
"""
import descwl
assert self['shear_all'],'currently only using new shear all method'
dobs, engine, builder = self._get_dobs_engine_builder(band)
objs=[]
for i,entry in enumerate(catalog):
# offsets in arcmin
dy, dx = pos_yx[i]
dy = dy*60.0
dx = dx*60.0
galaxy = builder.from_catalog(entry,dx,dy,dobs.filter_band)
objs.append(galaxy.model)
objs=galsim.Add(objs)
objs=objs.shear(
g1=self['shear'][0],
g2=self['shear'][1],
)
objs=galsim.Convolve([ objs, dobs.psf_model])
objs.drawImage(image=dobs.image)
if add_noise:
noise = galsim.PoissonNoise(
rng=self.gs_rng,
sky_level = dobs.mean_sky_level,
)
dobs.image.addNoise(noise)
return dobs
def generate_image(psf_re, bulge_re, bulge_n, gal_q, gal_beta, noise,
gal_flux):
A = (1 - gal_q) / (gal_q + 1)
g_1 = A * np.cos(2 * gal_beta)
g_2 = A * np.sin(2 * gal_beta)
gal = galsim.Sersic(bulge_n, half_light_radius=bulge_re)
gal = gal.withFlux(gal_flux)
gal = gal.shear(g1=g_1, g2=g_2)
psf = galsim.Moffat(beta=psf_beta, flux=1.0, fwhm=psf_re)
final = galsim.Convolve([psf, gal])
image = galsim.ImageF(image_size, image_size, scale=pixel_scale)
final.drawImage(image=image)
image_nonoise = copy.deepcopy(image.array)
# signal to noise ratio, after generating data, choose data with snr [10,100]
snr = np.sqrt((image.array**2).sum()) / noise
image.addNoise(galsim.PoissonNoise(sky_level=0.0))
noisemap = np.random.normal(0, noise,
64 * 64) # noise map for bkgr gaussian noise
noisemap = noisemap.reshape((64, 64))
img_fv = image.array + noisemap
# you can also use add noise to add gaussian noise by using
# 'image.addNoise(galsim.GaussianNoise(sigma=noise)) '
final_2 = psf
image_2 = galsim.ImageF(image_size, image_size, scale=pixel_scale)
final_2.drawImage(image=image_2)
outcome = {
"noised": img_fv,
"psf": image_2.array,
"noiseless": image_nonoise,
"snr": snr,
"g1": g_1,
"g2": g_2,
}
return outcome
def gen_exponential(_gal_flux,
_gal_hlight,
_psf_fwhm=0.0,
sky_level_pixel=0.0,
pixel_scale=0.263,
nx=90,
ny=90,
shear=False,
position_angle=0.0,
psf_ell=0.0):
model = galsim.Exponential(flux=_gal_flux, half_light_radius=_gal_hlight)
# All inputs are convolved to the final profile.
cmodel, psf = Convolve(model,
_psf_fwhm,
pixel_scale=pixel_scale,
nx=nx,
ny=ny,
shear=shear,
position_angle=position_angle,
psf_ell=psf_ell)
# The returned image has a member, added_flux, that gives the total flux added.
cmodel = cmodel.drawImage(scale=pixel_scale, nx=nx, ny=ny)
noise = galsim.PoissonNoise(rng, sky_level=sky_level_pixel)
if sky_level_pixel > 0.0:
ivar = np.ones_like(cmodel.array) / sky_level_pixel
else:
ivar = np.ones_like(cmodel.array)
image = galsim.Image(cmodel, copy=True)
image.addNoise(noise)
return model, psf, cmodel.array, ivar, image.array, image
def main(argv):
"""
Make a fits image cube where each frame has two images of the same galaxy drawn
with regular FFT convolution and with photon shooting.
We do this for 5 different PSFs and 5 different galaxies, each with 4 different (random)
fluxes, sizes, and shapes.
"""
logging.basicConfig(format="%(message)s",
level=logging.INFO,
stream=sys.stdout)
logger = logging.getLogger("demo7")
# To turn off logging:
#logger.propagate = False
# To turn on the debugging messages:
#logger.setLevel(logging.DEBUG)
# Define some parameters we'll use below.
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
file_name = os.path.join('output', 'cube_phot.fits.gz')
random_seed = 553728
sky_level = 1.e4 # ADU / arcsec^2
pixel_scale = 0.28 # arcsec
nx = 64
ny = 64
gal_flux_min = 1.e4 # Range for galaxy flux
gal_flux_max = 1.e5
gal_hlr_min = 0.3 # arcsec
gal_hlr_max = 1.3 # arcsec
gal_e_min = 0. # Range for ellipticity
gal_e_max = 0.8
psf_fwhm = 0.65 # arcsec
# This script is set up as a comparison between using FFTs for doing the convolutions and
# shooting photons. The two methods have trade-offs in speed and accuracy which vary
# with the kind of profile being drawn and the S/N of the object, among other factors.
# In addition, for each method, there are a number of parameters GalSim uses that control
# aspects of the calculation that further affect the speed and accuracy.
#
# We encapsulate these parameters with an object called GSParams. The default values
# are intended to be accurate enough for normal precision shear tests, without sacrificing
# too much speed.
#
# Any PSF or galaxy object can be given a gsparams argument on construction that can
# have different values to make the calculation more or less accurate (typically trading
# off for speed or memory).
#
# In this script, we adjust some of the values slightly, just to show you how it works.
# You could play around with these values and see what effect they have on the drawn images.
# Usually, it requires a pretty drastic change in these parameters for you to be able to
# notice the difference by eye. But subtle effects that may impact the shapes of galaxies
# can happen well before then.
# Type help(galsim.GSParams) for the complete list of parameters and more detailed
# documentation, including the default values for each parameter.
gsparams = galsim.GSParams(
folding_threshold=
1.e-2, # maximum fractional flux that may be folded around edge of FFT
maxk_threshold=
2.e-3, # k-values less than this may be excluded off edge of FFT
xvalue_accuracy=
1.e-4, # approximations in real space aim to be this accurate
kvalue_accuracy=
1.e-4, # approximations in fourier space aim to be this accurate
shoot_accuracy=
1.e-4, # approximations in photon shooting aim to be this accurate
minimum_fft_size=64) # minimum size of ffts
logger.info('Starting demo script 7')
# Make the PSF profiles:
psf1 = galsim.Gaussian(fwhm=psf_fwhm, gsparams=gsparams)
psf2 = galsim.Moffat(fwhm=psf_fwhm, beta=2.4, gsparams=gsparams)
psf3_inner = galsim.Gaussian(fwhm=psf_fwhm, flux=0.8, gsparams=gsparams)
psf3_outer = galsim.Gaussian(fwhm=2 * psf_fwhm,
flux=0.2,
gsparams=gsparams)
psf3 = psf3_inner + psf3_outer
atmos = galsim.Gaussian(fwhm=psf_fwhm, gsparams=gsparams)
# The OpticalPSF and set of Zernike values chosen below correspond to a reasonably well aligned,
# smallish ~0.3m / 12 inch diameter telescope with a central obscuration of ~0.12m or 5 inches
# diameter, being used in optical wavebands.
# In the Noll convention, the value of the Zernike coefficient also gives the RMS optical path
# difference across a circular pupil. An RMS difference of ~0.5 or larger indicates that parts
# of the wavefront are in fully destructive interference, and so we might expect aberrations to
# become strong when Zernike aberrations summed in quadrature approach 0.5 wave.
# The aberrations chosen in this case correspond to operating close to a 0.25 wave RMS optical
# path difference. Unlike in demo3, we specify the aberrations by making a list that we pass
# in using the 'aberrations' kwarg. The order of aberrations starting from index 4 is defocus,
# astig1, astig2, coma1, coma2, trefoil1, trefoil2, spher as in the Noll convention.
# We ignore the first 4 values so that the index number corresponds to the Zernike index
# in the Noll convention. This will be particularly convenient once we start allowing
# coefficients beyond spherical (index 11). c.f. The Wikipedia page about the Noll indices:
#
# http://en.wikipedia.org/wiki/Zernike_polynomials#Zernike_polynomials
aberrations = [0.0] * 12 # Set the initial size.
aberrations[4] = 0.06 # Noll index 4 = Defocus
aberrations[5:7] = [0.12, -0.08] # Noll index 5,6 = Astigmatism
aberrations[7:9] = [0.07, 0.04] # Noll index 7,8 = Coma
aberrations[11] = -0.13 # Noll index 11 = Spherical
# You could also define these all at once if that is more convenient:
#aberrations = [0.0, 0.0, 0.0, 0.0, 0.06, 0.12, -0.08, 0.07, 0.04, 0.0, 0.0, -0.13]
optics = galsim.OpticalPSF(lam_over_diam=0.6 * psf_fwhm,
obscuration=0.4,
aberrations=aberrations,
gsparams=gsparams)
psf4 = galsim.Convolve([atmos, optics
]) # Convolve inherits the gsparams from the first
# item in the list. (Or you can supply a gsparams
# argument explicitly if you want to override this.)
atmos = galsim.Kolmogorov(fwhm=psf_fwhm, gsparams=gsparams)
optics = galsim.Airy(lam_over_diam=0.3 * psf_fwhm, gsparams=gsparams)
psf5 = galsim.Convolve([atmos, optics])
psfs = [psf1, psf2, psf3, psf4, psf5]
psf_names = [
"Gaussian", "Moffat", "Double Gaussian", "OpticalPSF",
"Kolmogorov * Airy"
]
psf_times = [0, 0, 0, 0, 0]
psf_fft_times = [0, 0, 0, 0, 0]
psf_phot_times = [0, 0, 0, 0, 0]
# Make the galaxy profiles:
gal1 = galsim.Gaussian(half_light_radius=1, gsparams=gsparams)
gal2 = galsim.Exponential(half_light_radius=1, gsparams=gsparams)
gal3 = galsim.DeVaucouleurs(half_light_radius=1, gsparams=gsparams)
gal4 = galsim.Sersic(half_light_radius=1, n=2.5, gsparams=gsparams)
# A Sersic profile may be truncated if desired.
# The units for this are expected to be arcsec (or specifically -- whatever units
# you are using for all the size values as defined by the pixel_scale).
bulge = galsim.Sersic(half_light_radius=0.7,
n=3.2,
trunc=8.5,
gsparams=gsparams)
disk = galsim.Sersic(half_light_radius=1.2, n=1.5, gsparams=gsparams)
gal5 = 0.4 * bulge + 0.6 * disk # Net half-light radius is only approximate for this one.
gals = [gal1, gal2, gal3, gal4, gal5]
gal_names = [
"Gaussian", "Exponential", "Devaucouleurs", "n=2.5 Sersic",
"Bulge + Disk"
]
gal_times = [0, 0, 0, 0, 0]
gal_fft_times = [0, 0, 0, 0, 0]
gal_phot_times = [0, 0, 0, 0, 0]
# Other times to keep track of:
setup_times = 0
fft_times = 0
phot_times = 0
noise_times = 0
# Loop over combinations of psf, gal, and make 4 random choices for flux, size, shape.
all_images = []
k = 0
for ipsf in range(len(psfs)):
psf = psfs[ipsf]
psf_name = psf_names[ipsf]
logger.info('psf %d: %s', ipsf + 1, psf)
# Note that this implicitly calls str(psf). We've made an effort to give all GalSim
# objects an informative but relatively succinct str representation. Some details may
# be missing, but it should look essentially like how you would create the object.
logger.debug('repr = %r', psf)
# The repr() version are a bit more pedantic in form and should be completely informative,
# to the point where two objects that are not identical should never have equal repr
# strings. As such the repr strings may in some cases be somewhat unwieldy. For instance,
# since we set non-default gsparams in these, the repr includes that information, but
# it is omitted from the str for brevity.
for igal in range(len(gals)):
gal = gals[igal]
gal_name = gal_names[igal]
logger.info(' galaxy %d: %s', igal + 1, gal)
logger.debug(' repr = %r', gal)
for i in range(4):
logger.debug(' Start work on image %d', i)
t1 = time.time()
# Initialize the random number generator we will be using.
rng = galsim.UniformDeviate(random_seed + k)
# Generate random variates:
flux = rng() * (gal_flux_max - gal_flux_min) + gal_flux_min
# Use a new variable name, since we'll want to keep the original unmodified.
this_gal = gal.withFlux(flux)
hlr = rng() * (gal_hlr_max - gal_hlr_min) + gal_hlr_min
this_gal = this_gal.dilate(hlr)
beta_ellip = rng() * 2 * math.pi * galsim.radians
ellip = rng() * (gal_e_max - gal_e_min) + gal_e_min
gal_shape = galsim.Shear(e=ellip, beta=beta_ellip)
this_gal = this_gal.shear(gal_shape)
# Build the final object by convolving the galaxy and PSF.
final = galsim.Convolve([this_gal, psf])
# Create the large, double width output image
# Rather than provide a scale= argument to the drawImage commands, we can also
# set the pixel scale in the image constructor.
# Note: You can also change it after the construction with im.scale=pixel_scale
image = galsim.ImageF(2 * nx + 2, ny, scale=pixel_scale)
# Assign the following two Image "views", fft_image and phot_image.
# Using the syntax below, these are views into the larger image.
# Changes/additions to the sub-images referenced by the views are automatically
# reflected in the original image.
fft_image = image[galsim.BoundsI(1, nx, 1, ny)]
phot_image = image[galsim.BoundsI(nx + 3, 2 * nx + 2, 1, ny)]
logger.debug(
' Read in training sample galaxy and PSF from file')
t2 = time.time()
# Draw the profile
# This default rendering method (method='auto') usually defaults to FFT, since
# that is normally the most efficient method. However, we can also set method
# to 'fft' explicitly to force it to always use FFTs for the convolution
# by the pixel response. (In this case, it doesn't have any effect, since
# the 'auto' method would have always chosen 'fft' anyway, so this is just
# for illustrative purposes.)
final.drawImage(fft_image, method='fft')
logger.debug(
' Drew fft image. Total drawn flux = %f. .flux = %f',
fft_image.array.sum(), final.getFlux())
t3 = time.time()
# Add Poisson noise
sky_level_pixel = sky_level * pixel_scale**2
fft_image.addNoise(
galsim.PoissonNoise(rng, sky_level=sky_level_pixel))
t4 = time.time()
# The next two lines are just to get the output from this demo script
# to match the output from the parsing of demo7.yaml.
rng = galsim.UniformDeviate(random_seed + k)
rng()
rng()
rng()
rng()
# Repeat for photon shooting image.
# The max_extra_noise parameter indicates how much extra noise per pixel we are
# willing to tolerate. The sky noise will be adding a variance of sky_level_pixel,
# so we allow up to 1% of that extra.
final.drawImage(phot_image,
method='phot',
max_extra_noise=sky_level_pixel / 100,
rng=rng)
t5 = time.time()
# For photon shooting, galaxy already has Poisson noise, so we want to make
# sure not to add that noise again! Thus, we just add sky noise, which
# is Poisson with the mean = sky_level_pixel
pd = galsim.PoissonDeviate(rng, mean=sky_level_pixel)
# DeviateNoise just adds the action of the given deviate to every pixel.
phot_image.addNoise(galsim.DeviateNoise(pd))
# For PoissonDeviate, the mean is not zero, so for a background-subtracted
# image, we need to subtract the mean back off when we are done.
phot_image -= sky_level_pixel
logger.debug(
' Added Poisson noise. Image fluxes are now %f and %f',
fft_image.array.sum(), phot_image.array.sum())
t6 = time.time()
# Store that into the list of all images
all_images += [image]
k = k + 1
logger.info(
' %d: flux = %.2e, hlr = %.2f, ellip = (%.2f,%.2f)',
k, flux, hlr, gal_shape.getE1(), gal_shape.getE2())
logger.debug(' Times: %f, %f, %f, %f, %f', t2 - t1,
t3 - t2, t4 - t3, t5 - t4, t6 - t5)
psf_times[ipsf] += t6 - t1
psf_fft_times[ipsf] += t3 - t2
psf_phot_times[ipsf] += t5 - t4
gal_times[igal] += t6 - t1
gal_fft_times[igal] += t3 - t2
gal_phot_times[igal] += t5 - t4
setup_times += t2 - t1
fft_times += t3 - t2
phot_times += t5 - t4
noise_times += t4 - t3 + t6 - t5
logger.info('Done making images of galaxies')
logger.info('')
logger.info('Some timing statistics:')
logger.info(' Total time for setup steps = %f', setup_times)
logger.info(' Total time for regular fft drawing = %f', fft_times)
logger.info(' Total time for photon shooting = %f', phot_times)
logger.info(' Total time for adding noise = %f', noise_times)
logger.info('')
logger.info('Breakdown by PSF type:')
for ipsf in range(len(psfs)):
logger.info(' %s: Total time = %f (fft: %f, phot: %f)',
psf_names[ipsf], psf_times[ipsf], psf_fft_times[ipsf],
psf_phot_times[ipsf])
logger.info('')
logger.info('Breakdown by Galaxy type:')
for igal in range(len(gals)):
logger.info(' %s: Total time = %f (fft: %f, phot: %f)',
gal_names[igal], gal_times[igal], gal_fft_times[igal],
gal_phot_times[igal])
logger.info('')
# Now write the image to disk.
# With any write command, you can optionally compress the file using several compression
# schemes:
# 'gzip' uses gzip on the full output file.
# 'bzip2' uses bzip2 on the full output file.
# 'rice' uses rice compression on the image, leaving the fits headers readable.
# 'gzip_tile' uses gzip in tiles on the output image, leaving the fits headers readable.
# 'hcompress' uses hcompress on the image, but it is only valid for 2-d data, so it
# doesn't work for writeCube.
# 'plio' uses plio on the image, but it is only valid for positive integer data.
# Furthermore, the first three have standard filename extensions associated with them,
# so if you don't specify a compression, but the filename ends with '.gz', '.bz2' or '.fz',
# the corresponding compression will be selected automatically.
# In other words, the `compression='gzip'` specification is actually optional here:
galsim.fits.writeCube(all_images, file_name, compression='gzip')
logger.info('Wrote fft image to fits data cube %r', file_name)
def main(argv):
# Where to find and output data.
path, filename = os.path.split(__file__)
outpath = os.path.abspath(os.path.join(path, "output/"))
# Just use a few galaxies, to save time. Note that we are going to put 4000 galaxy images into
# our big image, so if we have n_use=10, each galaxy will appear 400 times. Users who want a
# more interesting image with greater variation in the galaxy population can change `n_use` to
# something larger (but it should be <=100, the number of galaxies in this small example
# catalog). With 4000 galaxies in a 4k x 4k image with the WFIRST pixel scale, the effective
# galaxy number density is 74/arcmin^2. This is not the number density that is expected for a
# sample that is so bright (I<23.5) but it makes the image more visually interesting. One could
# think of it as what you'd get if you added up several images at once, making the images for a
# sample that is much deeper have the same S/N as that for an I<23.5 sample in a single image.
n_use = 10
n_tot = 4000
# Default is to use all filters. Specify e.g. 'YJH' to only do Y106, J129, and H158.
use_filters = None
# quick and dirty command line parsing.
for var in argv:
if var.startswith('data='): datapath = var[5:]
if var.startswith('out='): outpath = var[4:]
if var.startswith('nuse='): n_use = int(var[5:])
if var.startswith('ntot='): n_tot = int(var[5:])
if var.startswith('filters='): use_filters = var[8:].upper()
# Make output directory if not already present.
if not os.path.isdir(outpath):
os.mkdir(outpath)
# In non-script code, use getLogger(__name__) at module scope instead.
logging.basicConfig(format="%(message)s", level=logging.INFO, stream=sys.stdout)
logger = logging.getLogger("demo13")
# Initialize (pseudo-)random number generator.
random_seed = 123456
rng = galsim.BaseDeviate(random_seed)
# Generate a Poisson noise model.
poisson_noise = galsim.PoissonNoise(rng)
logger.info('Poisson noise model created.')
# Read in the WFIRST filters, setting an AB zeropoint appropriate for this telescope given its
# diameter and (since we didn't use any keyword arguments to modify this) using the typical
# exposure time for WFIRST images. By default, this routine truncates the parts of the
# bandpasses that are near 0 at the edges, and thins them by the default amount.
filters = wfirst.getBandpasses(AB_zeropoint=True)
logger.debug('Read in WFIRST imaging filters.')
logger.info('Reading from a parametric COSMOS catalog.')
# Read in a galaxy catalog - just a random subsample of 100 galaxies for F814W<23.5 from COSMOS.
cat_file_name = 'real_galaxy_catalog_23.5_example_fits.fits'
dir = 'data'
# Use the routine that can take COSMOS real or parametric galaxy information, and tell it we
# want parametric galaxies that represent an I<23.5 sample.
cat = galsim.COSMOSCatalog(cat_file_name, dir=dir, use_real=False)
logger.info('Read in %d galaxies from catalog'%cat.nobjects)
# Here we carry out the initial steps that are necessary to get a fully chromatic PSF. We use
# the getPSF() routine in the WFIRST module, which knows all about the telescope parameters
# (diameter, bandpasses, obscuration, etc.). Note that we arbitrarily choose a single SCA
# (Sensor Chip Assembly) rather than all of them, for faster calculations, and use a simple
# representation of the struts for faster calculations. To do a more exact calculation of the
# chromaticity and pupil plane configuration, remove the `approximate_struts` and the `n_waves`
# keyword from the call to getPSF():
use_SCA = 7 # This could be any number from 1...18
logger.info('Doing expensive pre-computation of PSF.')
t1 = time.time()
logger.setLevel(logging.DEBUG)
# Need to make a separate PSF for each filter. We are, however, ignoring the
# position-dependence of the PSF within each SCA, just using the PSF at the center of the SCA
# (default kwargs).
PSFs = {}
for filter_name, filter_ in filters.items():
logger.info('PSF pre-computation for SCA %d, filter %s.'%(use_SCA, filter_name))
PSFs[filter_name] = wfirst.getPSF(use_SCA, filter_name,
approximate_struts=True, n_waves=10, logger=logger)
logger.setLevel(logging.INFO)
t2 = time.time()
logger.info('Done PSF precomputation in %.1f seconds!'%(t2-t1))
# Define the size of the postage stamp that we use for each individual galaxy within the larger
# image, and for the PSF images.
stamp_size = 256
# We choose a particular (RA, dec) location on the sky for our observation.
ra_targ = 90.*galsim.degrees
dec_targ = -10.*galsim.degrees
targ_pos = galsim.CelestialCoord(ra=ra_targ, dec=dec_targ)
# Get the WCS for an observation at this position. We are not supplying a date, so the routine
# will assume it's the vernal equinox. We are also not supplying a position angle for the
# observatory, which means that it will just find the optimal one (the one that has the solar
# panels pointed most directly towards the Sun given this targ_pos and date). The output of
# this routine is a dict of WCS objects, one for each SCA. We then take the WCS for the SCA
# that we are using.
wcs_list = wfirst.getWCS(world_pos=targ_pos, SCAs=use_SCA)
wcs = wcs_list[use_SCA]
# We need to find the center position for this SCA. We'll tell it to give us a CelestialCoord
# corresponding to (X, Y) = (wfirst.n_pix/2, wfirst.n_pix/2).
SCA_cent_pos = wcs.toWorld(galsim.PositionD(wfirst.n_pix/2, wfirst.n_pix/2))
# We randomly distribute points in (X, Y) on the CCD.
# If we had a real galaxy catalog with positions in terms of RA, dec we could use wcs.toImage()
# to find where those objects should be in terms of (X, Y).
pos_rng = galsim.UniformDeviate(random_seed)
# Make a list of (X, Y, F814W magnitude, n_rot, flip) values.
# (X, Y) give the position of the galaxy centroid (or the center of the postage stamp into which
# we draw the galaxy) in the big image.
# F814W magnitudes are randomly drawn from the catalog, and are used to create a more realistic
# flux distribution for the galaxies instead of just having the 10 flux values for the galaxies
# we have chosen to draw.
# n_rot says how many 90 degree rotations to include for a given realization of each galaxy, so
# it doesn't appear completely identical each time we put it in the image.
# flip is a random number that will determine whether we include an x-y flip for this appearance
# of the galaxy or not.
x_stamp = []
y_stamp = []
mag_stamp = []
n_rot_stamp = []
flip_stamp = []
for i_gal in range(n_tot):
x_stamp.append(pos_rng()*wfirst.n_pix)
y_stamp.append(pos_rng()*wfirst.n_pix)
# Note that we could use wcs.toWorld() to get the (RA, dec) for these (x, y) positions. Or,
# if we had started with (RA, dec) positions, we could have used wcs.toImage() to get the
# CCD coordinates for those positions.
mag_stamp.append(cat.param_cat['mag_auto'][int(pos_rng()*cat.nobjects)])
n_rot_stamp.append(int(4*pos_rng()))
flip_stamp.append(pos_rng())
# Make the 2-component parametric GSObjects for each object, including chromaticity (roughly
# appropriate SEDs per galaxy component, at the appropriate galaxy redshift). Note that since
# the PSF is position-independent within the SCA, we can simply do the convolution with that PSF
# now instead of using a different one for each position. We also have to include the correct
# flux scaling: The catalog returns objects that would be observed by HST in 1 second
# exposures. So for our telescope we scale up by the relative area and exposure time. Note that
# what is important is the *effective* area after taking into account obscuration.
logger.info('Processing the objects in the catalog to get GSObject representations')
# Choose a random set of unique indices in the catalog (will be the same each time script is
# run, due to use of the same random seed):
rand_indices = []
while len(rand_indices)<n_use:
tmp_ind = int(pos_rng()*cat.nobjects)
if tmp_ind not in rand_indices:
rand_indices.append(tmp_ind)
obj_list = cat.makeGalaxy(rand_indices, chromatic=True, gal_type='parametric')
hst_eff_area = 2.4**2 * (1.-0.33**2)
wfirst_eff_area = galsim.wfirst.diameter**2 * (1.-galsim.wfirst.obscuration**2)
flux_scaling = (wfirst_eff_area/hst_eff_area) * wfirst.exptime
mag_list = []
for ind in range(len(obj_list)):
# First, let's check what magnitude this object has in F814W. We want to do this because
# (to inject some variety into our images) we are going to rescale the fluxes in all bands
# for different instances of this galaxy in the final image in order to get a reasonable S/N
# distribution. So we need to save the original magnitude in F814W, to compare with a
# randomly drawn one from the catalog. This is not something that most users would need to
# do.
mag_list.append(cat.param_cat['mag_auto'][cat.orig_index[rand_indices[ind]]])
# Calculate the sky level for each filter, and draw the PSF and the galaxies through the
# filters.
for filter_name, filter_ in filters.items():
if use_filters is not None and filter_name[0] not in use_filters:
logger.info('Skipping filter {0}.'.format(filter_name))
continue
logger.info('Beginning work for {0}.'.format(filter_name))
# Drawing PSF. Note that the PSF object intrinsically has a flat SED, so if we convolve it
# with a galaxy, it will properly take on the SED of the galaxy. For the sake of this demo,
# we will simply convolve with a 'star' that has a flat SED and unit flux in this band, so
# that the PSF image will be normalized to unit flux. This does mean that the PSF image
# being drawn here is not quite the right PSF for the galaxy. Indeed, the PSF for the
# galaxy effectively varies within it, since it differs for the bulge and the disk. To make
# a real image, one would have to choose SEDs for stars and convolve with a star that has a
# reasonable SED, but we just draw with a flat SED for this demo.
out_filename = os.path.join(outpath, 'demo13_PSF_{0}.fits'.format(filter_name))
# Generate a point source.
point = galsim.DeltaFunction(flux=1.)
# Use a flat SED here, but could use something else. A stellar SED for instance.
# Or a typical galaxy SED. Depending on your purpose for drawing the PSF.
star_sed = galsim.SED(lambda x:1, 'nm', 'flambda').withFlux(1.,filter_) # Give it unit flux in this filter.
star = galsim.Convolve(point*star_sed, PSFs[filter_name])
img_psf = galsim.ImageF(64,64)
star.drawImage(bandpass=filter_, image=img_psf, scale=wfirst.pixel_scale)
img_psf.write(out_filename)
logger.debug('Created PSF with flat SED for {0}-band'.format(filter_name))
# Set up the full image that will contain all the individual galaxy images, with information
# about WCS:
final_image = galsim.ImageF(wfirst.n_pix,wfirst.n_pix, wcs=wcs)
# Draw the galaxies into the image.
for i_gal in range(n_use):
logger.info('Drawing image for the object at row %d in the input catalog'%i_gal)
# We want to only draw the galaxy once (for speed), not over and over with different
# sub-pixel offsets. For this reason we ignore the sub-pixel offset entirely. Note
# that we are setting the postage stamp to have the average WFIRST pixel scale. This is
# simply an approximation for the purpose of speed; really, one should draw directly
# into final_image, which has the appropriate WCS for WFIRST. In that case, the image
# of the galaxy might look different in different parts of the detector due to the WCS
# (including distortion), and we would have to re-draw each time. To keep the demo
# relatively quick, we are just using the approximate average pixel scale and drawing
# once.
stamp = galsim.Image(stamp_size, stamp_size, scale=wfirst.pixel_scale)
# Convolve the chromatic galaxy and the chromatic PSF for this bandpass, and rescale flux.
final = galsim.Convolve(flux_scaling*obj_list[ind], PSFs[filter_name])
final.drawImage(filter_, image=stamp)
# Have to find where to place it:
for i_gal_use in range(i_gal*n_tot//n_use, (i_gal+1)*n_tot//n_use):
# Account for the fractional part of the position:
ix = int(math.floor(x_stamp[i_gal_use]+0.5))
iy = int(math.floor(y_stamp[i_gal_use]+0.5))
# We don't actually use this offset.
offset = galsim.PositionD(x_stamp[i_gal]-ix, y_stamp[i_gal]-iy)
# Create a nominal bound for the postage stamp given the integer part of the
# position.
stamp_bounds = galsim.BoundsI(ix-0.5*stamp_size, ix+0.5*stamp_size-1,
iy-0.5*stamp_size, iy+0.5*stamp_size-1)
# Find the overlapping bounds between the large image and the individual postage
# stamp.
bounds = stamp_bounds & final_image.bounds
# Just to inject a bit of variety into the image, so it isn't *quite* as obvious
# that we've repeated the same 10 objects over and over, we randomly rotate the
# postage stamp by some factor of 90 degrees and possibly include a random flip.
if flip_stamp[i_gal_use] > 0.5:
new_arr = numpy.ascontiguousarray(
numpy.rot90(stamp.array, n_rot_stamp[i_gal_use]))
else:
new_arr = numpy.ascontiguousarray(
numpy.fliplr(numpy.rot90(stamp.array, n_rot_stamp[i_gal_use])))
stamp_rot = galsim.Image(new_arr, scale=stamp.scale)
stamp_rot.setOrigin(galsim.PositionI(stamp_bounds.xmin, stamp_bounds.ymin))
# Rescale the flux to match that of a randomly chosen galaxy in the galaxy, but
# keeping the same SED as for this particular galaxy. This gives a bit more
# variety in the flux values and SNR of the galaxies in the image without having
# to render images of many more objects.
flux_scaling = 10**(-0.4*(mag_stamp[i_gal_use]-mag_list[i_gal]))
# Copy the image into the right place in the big image.
final_image[bounds] += flux_scaling * stamp_rot[bounds]
# Now we're done with the per-galaxy drawing for this image. The rest will be done for the
# entire image at once.
logger.info('Postage stamps of all galaxies drawn on a single big image for this filter.')
logger.info('Adding the sky level, noise and detector non-idealities.')
# First we get the amount of zodaical light for a position corresponding to the center of
# this SCA. The results are provided in units of e-/arcsec^2, using the default WFIRST
# exposure time since we did not explicitly specify one. Then we multiply this by a factor
# >1 to account for the amount of stray light that is expected. If we do not provide a date
# for the observation, then it will assume that it's the vernal equinox (sun at (0,0) in
# ecliptic coordinates) in 2025.
sky_level = wfirst.getSkyLevel(filters[filter_name], world_pos=SCA_cent_pos)
sky_level *= (1.0 + wfirst.stray_light_fraction)
# Make a image of the sky that takes into account the spatially variable pixel scale. Note
# that makeSkyImage() takes a bit of time. If you do not care about the variable pixel
# scale, you could simply compute an approximate sky level in e-/pix by multiplying
# sky_level by wfirst.pixel_scale**2, and add that to final_image.
sky_image = final_image.copy()
wcs.makeSkyImage(sky_image, sky_level)
# This image is in units of e-/pix. Finally we add the expected thermal backgrounds in this
# band. These are provided in e-/pix/s, so we have to multiply by the exposure time.
sky_image += wfirst.thermal_backgrounds[filter_name]*wfirst.exptime
# Adding sky level to the image.
final_image += sky_image
# Now that all sources of signal (from astronomical objects and background) have been added
# to the image, we can start adding noise and detector effects. There is a utility,
# galsim.wfirst.allDetectorEffects(), that can apply ALL implemented noise and detector
# effects in the proper order. Here we step through the process and explain these in a bit
# more detail without using that utility.
# First, we include the expected Poisson noise:
final_image.addNoise(poisson_noise)
# The subsequent steps account for the non-ideality of the detectors.
# 1) Reciprocity failure:
# Reciprocity, in the context of photography, is the inverse relationship between the
# incident flux (I) of a source object and the exposure time (t) required to produce a given
# response(p) in the detector, i.e., p = I*t. However, in NIR detectors, this relation does
# not hold always. The pixel response to a high flux is larger than its response to a low
# flux. This flux-dependent non-linearity is known as 'reciprocity failure', and the
# approximate amount of reciprocity failure for the WFIRST detectors is known, so we can
# include this detector effect in our images.
if diff_mode:
# Save the image before applying the transformation to see the difference
save_image = final_image.copy()
# If we had wanted to, we could have specified a different exposure time than the default
# one for WFIRST, but otherwise the following routine does not take any arguments.
wfirst.addReciprocityFailure(final_image)
logger.debug('Included reciprocity failure in {0}-band image'.format(filter_name))
if diff_mode:
# Isolate the changes due to reciprocity failure.
diff = final_image-save_image
out_filename = os.path.join(outpath,'demo13_RecipFail_{0}.fits'.format(filter_name))
final_image.write(out_filename)
out_filename = os.path.join(outpath,
'demo13_diff_RecipFail_{0}.fits'.format(filter_name))
diff.write(out_filename)
# At this point in the image generation process, an integer number of photons gets
# detected, hence we have to round the pixel values to integers:
final_image.quantize()
# 2) Adding dark current to the image:
# Even when the detector is unexposed to any radiation, the electron-hole pairs that
# are generated within the depletion region due to finite temperature are swept by the
# high electric field at the junction of the photodiode. This small reverse bias
# leakage current is referred to as 'dark current'. It is specified by the average
# number of electrons reaching the detectors per unit time and has an associated
# Poisson noise since it is a random event.
dark_current = wfirst.dark_current*wfirst.exptime
dark_noise = galsim.DeviateNoise(galsim.PoissonDeviate(rng, dark_current))
final_image.addNoise(dark_noise)
# NOTE: Sky level and dark current might appear like a constant background that can be
# simply subtracted. However, these contribute to the shot noise and matter for the
# non-linear effects that follow. Hence, these must be included at this stage of the
# image generation process. We subtract these backgrounds in the end.
# 3) Applying a quadratic non-linearity:
# In order to convert the units from electrons to ADU, we must use the gain factor. The gain
# has a weak dependency on the charge present in each pixel. This dependency is accounted
# for by changing the pixel values (in electrons) and applying a constant nominal gain
# later, which is unity in our demo.
# Save the image before applying the transformation to see the difference:
if diff_mode:
save_image = final_image.copy()
# Apply the WFIRST nonlinearity routine, which knows all about the nonlinearity expected in
# the WFIRST detectors.
wfirst.applyNonlinearity(final_image)
# Note that users who wish to apply some other nonlinearity function (perhaps for other NIR
# detectors, or for CCDs) can use the more general nonlinearity routine, which uses the
# following syntax:
# final_image.applyNonlinearity(NLfunc=NLfunc)
# with NLfunc being a callable function that specifies how the output image pixel values
# should relate to the input ones.
logger.debug('Applied nonlinearity to {0}-band image'.format(filter_name))
if diff_mode:
diff = final_image-save_image
out_filename = os.path.join(outpath,'demo13_NL_{0}.fits'.format(filter_name))
final_image.write(out_filename)
out_filename = os.path.join(outpath,'demo13_diff_NL_{0}.fits'.format(filter_name))
diff.write(out_filename)
# Save this image to do the diff after applying IPC.
save_image = final_image.copy()
# 4) Including Interpixel capacitance:
# The voltage read at a given pixel location is influenced by the charges present in the
# neighboring pixel locations due to capacitive coupling of sense nodes. This interpixel
# capacitance effect is modeled as a linear effect that is described as a convolution of a
# 3x3 kernel with the image. The WFIRST IPC routine knows about the kernel already, so the
# user does not have to supply it.
wfirst.applyIPC(final_image)
logger.debug('Applied interpixel capacitance to {0}-band image'.format(filter_name))
if diff_mode:
# Isolate the changes due to the interpixel capacitance effect.
diff = final_image-save_image
out_filename = os.path.join(outpath,'demo13_IPC_{0}.fits'.format(filter_name))
final_image.write(out_filename)
out_filename = os.path.join(outpath,'demo13_diff_IPC_{0}.fits'.format(filter_name))
diff.write(out_filename)
# 5) Adding read noise:
# Read noise is the noise due to the on-chip amplifier that converts the charge into an
# analog voltage. We already applied the Poisson noise due to the sky level, so read noise
# should just be added as Gaussian noise:
read_noise = galsim.GaussianNoise(rng, sigma=wfirst.read_noise)
final_image.addNoise(read_noise)
logger.debug('Added readnoise to {0}-band image'.format(filter_name))
# We divide by the gain to convert from e- to ADU. Currently, the gain value in the WFIRST
# module is just set to 1, since we don't know what the exact gain will be, although it is
# expected to be approximately 1. Eventually, this may change when the camera is assembled,
# and there may be a different value for each SCA. For now, there is just a single number,
# which is equal to 1.
final_image /= wfirst.gain
# Finally, the analog-to-digital converter reads in an integer value.
final_image.quantize()
# Note that the image type after this step is still a float. If we want to actually
# get integer values, we can do new_img = galsim.Image(final_image, dtype=int)
# Since many people are used to viewing background-subtracted images, we provide a
# version with the background subtracted (also rounding that to an int).
sky_image.quantize()
tot_sky_image = (sky_image + round(dark_current))/wfirst.gain
tot_sky_image.quantize()
final_image -= tot_sky_image
logger.debug('Subtracted background for {0}-band image'.format(filter_name))
# Write the final image to a file.
out_filename = os.path.join(outpath,'demo13_{0}.fits'.format(filter_name))
final_image.write(out_filename)
logger.info('Completed {0}-band image.'.format(filter_name))
logger.info('You can display the output in ds9 with a command line that looks something like:')
logger.info('ds9 -zoom 0.5 -scale limits -500 1000 -rgb '+
'-red output/demo13_H158.fits '+
'-green output/demo13_J129.fits '+
'-blue output/demo13_Y106.fits')
def main(argv):
"""
Make a fits image cube using real COSMOS galaxies from a catalog describing the training
sample.
- The number of images in the cube matches the number of rows in the catalog.
- Each image size is computed automatically by GalSim based on the Nyquist size.
- Both galaxies and stars.
- PSF is a double Gaussian, the same for each galaxy.
- Galaxies are randomly rotated to remove the imprint of any lensing shears in the COSMOS
data.
- The same shear is applied to each galaxy.
- Noise is Poisson using a nominal sky value of 1.e6 ADU/arcsec^2,
the noise in the original COSMOS data.
"""
logging.basicConfig(format="%(message)s", level=logging.INFO, stream=sys.stdout)
logger = logging.getLogger("demo6")
# Define some parameters we'll use below.
cat_file_name = 'real_galaxy_catalog_23.5_example.fits'
dir = 'data'
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
cube_file_name = os.path.join('output','cube_real.fits')
psf_file_name = os.path.join('output','psf_real.fits')
random_seed = 1512413
sky_level = 1.e6 # ADU / arcsec^2
pixel_scale = 0.16 # arcsec
gal_flux = 1.e5 # arbitrary choice, makes nice (not too) noisy images
gal_g1 = -0.027 #
gal_g2 = 0.031 #
gal_mu = 1.082 # mu = ( (1-kappa)^2 - g1^2 - g2^2 )^-1
psf_inner_fwhm = 0.6 # arcsec
psf_outer_fwhm = 2.3 # arcsec
psf_inner_fraction = 0.8 # fraction of total PSF flux in the inner Gaussian
psf_outer_fraction = 0.2 # fraction of total PSF flux in the inner Gaussian
ngal = 100
logger.info('Starting demo script 6 using:')
logger.info(' - real galaxies from catalog %r',cat_file_name)
logger.info(' - double Gaussian PSF')
logger.info(' - pixel scale = %.2f',pixel_scale)
logger.info(' - Applied gravitational shear = (%.3f,%.3f)',gal_g1,gal_g2)
logger.info(' - Poisson noise (sky level = %.1e).', sky_level)
# Read in galaxy catalog
# Note: dir is the directory both for the catalog itself and also the directory prefix
# for the image files listed in the catalog.
# If the images are in a different directory, you may also specify image_dir, which gives
# the relative path from dir to wherever the images are located.
real_galaxy_catalog = galsim.RealGalaxyCatalog(cat_file_name, dir=dir)
logger.info('Read in %d real galaxies from catalog', real_galaxy_catalog.nobjects)
# Make the double Gaussian PSF
psf1 = galsim.Gaussian(fwhm = psf_inner_fwhm, flux = psf_inner_fraction)
psf2 = galsim.Gaussian(fwhm = psf_outer_fwhm, flux = psf_outer_fraction)
psf = psf1+psf2
# Draw the PSF with no noise.
psf_image = psf.drawImage(scale = pixel_scale)
# write to file
psf_image.write(psf_file_name)
logger.info('Created PSF and wrote to file %r',psf_file_name)
# Build the images
all_images = []
for k in range(ngal):
logger.debug('Start work on image %d',k)
t1 = time.time()
# Initialize the random number generator we will be using.
rng = galsim.UniformDeviate(random_seed+k+1)
gal = galsim.RealGalaxy(real_galaxy_catalog, index = k)
logger.debug(' Read in training sample galaxy and PSF from file')
t2 = time.time()
# Set the flux
gal = gal.withFlux(gal_flux)
# Rotate by a random angle
theta = 2.*math.pi * rng() * galsim.radians
gal = gal.rotate(theta)
# Apply the desired shear
gal = gal.shear(g1=gal_g1, g2=gal_g2)
# Also apply a magnification mu = ( (1-kappa)^2 - |gamma|^2 )^-1
# This conserves surface brightness, so it scales both the area and flux.
gal = gal.magnify(gal_mu)
# Make the combined profile
final = galsim.Convolve([psf, gal])
# Offset by up to 1/2 pixel in each direction
# We had previously (in demo4 and demo5) used shift(dx,dy) as a way to shift the center of
# the image. Since that is applied to the galaxy, the units are arcsec (since the galaxy
# profile itself doesn't know about the pixel scale). Here, the offset applies to the
# drawn image, which does know about the pixel scale, so the units of offset are pixels,
# not arcsec. Here, we apply an offset of up to half a pixel in each direction.
dx = rng() - 0.5
dy = rng() - 0.5
# Draw the profile
if k == 0:
# Note that the offset argument may be a galsim.PositionD object or a tuple (dx,dy).
im = final.drawImage(scale=pixel_scale, offset=(dx,dy))
xsize, ysize = im.array.shape
else:
im = galsim.ImageF(xsize,ysize)
final.drawImage(im, scale=pixel_scale, offset=(dx,dy))
logger.debug(' Drew image')
t3 = time.time()
# Add a constant background level
background = sky_level * pixel_scale**2
im += background
# Add Poisson noise. This time, we don't give a sky_level, since we have already
# added it to the image, so we don't want any more added. The sky_level parameter
# really defines how much _extra_ sky should be added above what is already in the image.
im.addNoise(galsim.PoissonNoise(rng))
logger.debug(' Added Poisson noise')
t4 = time.time()
# Store that into the list of all images
all_images += [im]
t5 = time.time()
logger.debug(' Times: %f, %f, %f, %f',t2-t1, t3-t2, t4-t3, t5-t4)
logger.info('Image %d: size = %d x %d, total time = %f sec', k, xsize, ysize, t5-t1)
logger.info('Done making images of galaxies')
# Now write the image to disk.
# We write the images to a fits data cube.
galsim.fits.writeCube(all_images, cube_file_name)
logger.info('Wrote image to fits data cube %r',cube_file_name)
def image_generator_real(cosmos_cat_dir,
training_or_test,
isolated_or_blended,
constants_dir,
used_idx=None,
nmax_blend=4,
max_try=3,
mag_cut=28.,
method_first_shift='noshift',
do_peak_detection=True):
"""
Return numpy arrays: noiseless and noisy image of single galaxy and of blended galaxies as well as the pandaframe including data about the image and the shifts in the test sample generation configuration
Parameters:
----------
cosmos_cat_dir: COSMOS catalog directory
training_or_test: choice for generating a training or testing dataset
isolated_or_blended: choice for generation of samples of isolated galaxy images or blended galaxies images
constants_dir: directory where normalization constants are saved
used_idx: indexes to use in the catalog (to use different parts of the catalog for training/validation/test)
nmax_blend: maximum number of galaxies in a blended galaxies image
max_try: maximum number of try before leaving the function (to avoir infinite loop)
mag_cut: cut in magnitude to select function below this magnitude
method_first_shift: chosen method for shifting the centered galaxy
do_peak_detection: boolean to do the peak detection
"""
# Import the COSMOS catalog
cosmos_cat = galsim.COSMOSCatalog('real_galaxy_catalog_25.2.fits',
dir=cosmos_cat_dir)
counter = 0
np.random.seed() # important for multiprocessing !
assert training_or_test in ['training', 'validation', 'test']
assert isolated_or_blended in ['blended', 'isolated']
while counter < max_try:
try:
ud = galsim.UniformDeviate()
real_gal_list = []
nb_blended_gal = np.random.randint(nmax_blend) + 1
data = {}
galaxies = []
mag = []
mag_ir = []
j = 0
while j < nb_blended_gal:
# Chose the part of the catalog used for generation
if used_idx is not None:
idx = np.random.choice(used_idx)
else:
idx = np.random.randint(cosmos_cat.nobject)
# Generate galaxy
gal = cosmos_cat.makeGalaxy(idx,
gal_type='parametric',
chromatic=True,
noise_pad_size=0)
# Compute the magnitude of the galaxy
_mag_temp = gal.calculateMagnitude(
filters['r'].withZeropoint(28.13))
# Magnitude cut
if _mag_temp < mag_cut:
gal = gal.rotate(ud() * 360. * galsim.degrees)
galaxies.append(gal)
mag.append(_mag_temp)
mag_ir.append(
gal.calculateMagnitude(
filters['H'].withZeropoint(24.92 -
22.35 * coeff_noise_h)))
j += 1
# Take the real galaxy image only if parametric galaxy is actually created
if len(galaxies) == (len(real_gal_list) + 1):
bp_file = os.path.join(galsim.meta_data.share_dir,
'wfc_F814W.dat.gz')
bandpass = galsim.Bandpass(
bp_file, wave_type='ang').thin().withZeropoint(25.94)
real_gal = cosmos_cat.makeGalaxy(
idx,
gal_type='real',
noise_pad_size=max_stamp_size * pixel_scale_lsst)
real_gal_list.append(real_gal)
# Optionally, find the brightest and put it first in the list
if center_brightest:
_idx = np.argmin(mag)
galaxies.insert(0, galaxies.pop(_idx))
real_gal_list.insert(0, real_gal_list.pop(_idx))
mag.insert(0, mag.pop(_idx))
mag_ir.insert(0, mag_ir.pop(_idx))
# Shift galaxies
shift = np.zeros((nmax_blend, 2))
# Shift the lowest magnitude galaxy
galaxies[0], shift[0] = shift_gal(galaxies[0],
method=method_first_shift,
max_dx=0.1)
# Shift all the other galaxies
for j, gal in enumerate(galaxies[1:]):
galaxies[j + 1], shift[j + 1] = shift_gal(gal,
shift_x0=shift[0, 0],
shift_y0=shift[0, 1],
min_r=0.65 / 2.,
max_r=1.5,
method='annulus')
# Compute distances of the neighbour galaxies to the lowest magnitude galaxy
if nb_blended_gal > 1:
distances = [
shift[j][0]**2 + shift[j][1]**2
for j in range(1, nb_blended_gal)
]
idx_closest_to_peak_galaxy = np.argmin(distances) + 1
else:
idx_closest_to_peak_galaxy = 0
galaxy_noiseless = np.zeros((10, max_stamp_size, max_stamp_size))
blend_noisy = np.zeros((10, max_stamp_size, max_stamp_size))
galaxy_noiseless_real = np.zeros(
(10, max_stamp_size, max_stamp_size))
blend_noisy_real = np.zeros((10, max_stamp_size, max_stamp_size))
# Realize peak detection in r-band filter if asked
if do_peak_detection:
band = 6
galaxies_psf = [
galsim.Convolve([gal * coeff_exp[band], PSF[band]])
for gal in galaxies
]
images, blend_img = draw_images(galaxies_psf, band,
max_stamp_size * 2, 'r',
sky_level_pixel[band])
blend_noisy_temp = blend_img.array.data
peak_detection_output = peak_detection(blend_noisy_temp,
band,
shift,
max_stamp_size * 2,
4,
nb_blended_gal,
training_or_test,
dist_cut=0.65 / 2.)
if not peak_detection_output:
print('No peak detected')
raise RuntimeError
else:
idx_closest_to_peak, idx_closest_to_peak_galaxy, center_pix_x, center_pix_y, center_arc_x, center_arc_y, n_peak = peak_detection_output
# Modify galaxies and shift accordingly
galaxies = [
gal.shift(-center_arc_x, -center_arc_y) for gal in galaxies
]
shift[:nb_blended_gal] -= np.array(
[center_arc_x, center_arc_y])
# shift galaxies for centered configuration 'noshift'
for k, gal in enumerate(real_gal_list):
real_gal_list[k], shift[k] = shift_gal(gal,
shift_x0=shift[k, 0],
shift_y0=shift[k, 1],
method='noshift')
# Draw real images
galaxies_real_psf = [
galsim.Convolve([real_gal * coeff_exp[6], PSF_lsst])
for real_gal in real_gal_list
]
images_real, _ = draw_images(galaxies_real_psf,
6,
max_stamp_size,
'r',
sky_level_pixel[6],
real_or_param='real')
# Now draw image in all bands
for i, filter_name in enumerate(filter_names_all):
galaxies_psf = [
galsim.Convolve([gal * coeff_exp[i], PSF[i]])
for gal in galaxies
]
images, blend_img = draw_images(galaxies_psf, i,
max_stamp_size, filter_name,
sky_level_pixel[i])
if isolated_or_blended == 'isolated' or not do_peak_detection:
idx_closest_to_peak = 0
n_peak = 1
galaxy_noiseless[i] = images[idx_closest_to_peak].array.data
blend_noisy[i] = blend_img.array.data
# Rescale real images by flux
images_real_array = np.zeros(
(len(images_real), max_stamp_size, max_stamp_size))
for jj, image_real in enumerate(images_real):
img_temp = images[jj]
image_real -= np.min(image_real.array)
images_real_array[jj] = image_real.array * np.sum(
img_temp.array) / np.sum(image_real.array)
# real galaxies
galaxy_noiseless_real[i] = images_real_array[
idx_closest_to_peak].data
for image_real_array in images_real_array:
blend_noisy_real[i] += image_real_array\
# Add noise
blend_noisy_real_temp = galsim.Image(blend_noisy_real[i],
dtype=np.float64)
poissonian_noise = galsim.PoissonNoise(
rng, sky_level=sky_level_pixel[i])
blend_noisy_real_temp.addNoise(poissonian_noise)
blend_noisy_real[i] = blend_noisy_real_temp.array.data
# get data for the test sample
if training_or_test == 'test' and filter_name == 'r':
# need psf to compute ellipticities
psf_image = PSF[i].drawImage(nx=max_stamp_size,
ny=max_stamp_size,
scale=pixel_scale[i])
data['redshift'], data['moment_sigma'], data['e1'], data[
'e2'], data['mag'] = get_data(
galaxies[idx_closest_to_peak],
images[idx_closest_to_peak],
psf_image,
param_or_real='param'
) #real_gal_list[idx_closest_to_peak_galaxy], images_real
# Compute data and blendedness
if nb_blended_gal > 1:
data['closest_redshift'], data[
'closest_moment_sigma'], data['closest_e1'], data[
'closest_e2'], data['closest_mag'] = get_data(
galaxies[idx_closest_to_peak_galaxy],
images[idx_closest_to_peak_galaxy],
psf_image,
param_or_real='param'
) #real_gal_list[idx_closest_to_peak_galaxy]
img_central = images[idx_closest_to_peak].array
img_others = np.zeros_like(img_central)
for _h, image in enumerate(images):
if _h != idx_closest_to_peak:
img_others += image.array
img_closest_neighbour = images[
idx_closest_to_peak_galaxy].array
data[
'blendedness_total_lsst'] = utils.compute_blendedness_total(
img_central, img_others)
data[
'blendedness_closest_lsst'] = utils.compute_blendedness_single(
img_central, img_closest_neighbour)
data[
'blendedness_aperture_lsst'] = utils.compute_blendedness_aperture(
img_central, img_others, data['moment_sigma'])
else:
data['closest_redshift'] = np.nan
data['closest_moment_sigma'] = np.nan
data['closest_e1'] = np.nan
data['closest_e2'] = np.nan
data['closest_mag'] = np.nan
data['blendedness_total_lsst'] = np.nan
data['blendedness_closest_lsst'] = np.nan
data['blendedness_aperture_lsst'] = np.nan
break
except RuntimeError as e:
print(e)
# For training/validation, return normalized images only
if training_or_test in ['training', 'validation']:
galaxy_noiseless_real = utils.norm(galaxy_noiseless_real[None, :],
bands=range(10),
path=constants_dir)[0]
blend_noisy_real = utils.norm(blend_noisy_real[None, :],
bands=range(10),
path=constants_dir)[0]
return galaxy_noiseless_real, blend_noisy_real
# For testing, return unormalized images and data
elif training_or_test == 'test':
data['nb_blended_gal'] = nb_blended_gal
data['mag'] = mag[0]
data['mag_ir'] = mag_ir[0]
if nb_blended_gal > 1:
data['closest_mag'] = mag[idx_closest_to_peak_galaxy]
data['closest_mag_ir'] = mag_ir[idx_closest_to_peak_galaxy]
data['closest_x'] = shift[idx_closest_to_peak_galaxy][0]
data['closest_y'] = shift[idx_closest_to_peak_galaxy][1]
else:
data['closest_mag'] = np.nan
data['closest_mag_ir'] = np.nan
data['closest_x'] = np.nan
data['closest_y'] = np.nan
data['idx_closest_to_peak'] = idx_closest_to_peak
data['n_peak_detected'] = n_peak
data['SNR'] = utils.SNR(galaxy_noiseless, sky_level_pixel, band=6)[1]
data['SNR_peak'] = utils.SNR_peak(galaxy_noiseless,
sky_level_pixel,
band=6)[1]
return galaxy_noiseless_real, blend_noisy_real, data, shift
else:
raise ValueError
def main(argv):
"""
Make images using variable PSF and shear:
- The main image is 10 x 10 postage stamps.
- Each postage stamp is 48 x 48 pixels.
- The second HDU has the corresponding PSF image.
- Applied shear is from a power spectrum P(k) ~ k^1.8.
- Galaxies are real galaxies oriented in a ring test of 20 each.
- The PSF is Gaussian with FWHM, ellipticity and position angle functions of (x,y)
- Noise is Poisson using a nominal sky value of 1.e6.
"""
logging.basicConfig(format="%(message)s",
level=logging.INFO,
stream=sys.stdout)
logger = logging.getLogger("demo10")
# Define some parameters we'll use below.
# Normally these would be read in from some parameter file.
n_tiles = 10 # number of tiles in each direction.
stamp_size = 48 # pixels
pixel_scale = 0.44 # arcsec / pixel
sky_level = 1.e6 # ADU / arcsec^2
# The random seed is used for both the power spectrum realization and the random properties
# of the galaxies.
random_seed = 3339201
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
file_name = os.path.join('output', 'power_spectrum.fits')
# These will be created for each object below. The values we'll use will be functions
# of (x,y) relative to the center of the image. (r = sqrt(x^2+y^2))
# psf_fwhm = 0.9 + 0.5 * (r/100)^2 -- arcsec
# psf_e = 0.4 * (r/100)^1.5 -- large value at the edge, so visible by eye.
# psf_beta = atan2(y/x) + pi/2 -- tangential pattern
gal_dilation = 3 # Make the galaxies a bit larger than their original size.
gal_signal_to_noise = 100 # Pretty high.
psf_signal_to_noise = 1000 # Even higher.
logger.info('Starting demo script 10')
# Read in galaxy catalog
cat_file_name = 'real_galaxy_catalog_23.5_example.fits'
dir = 'data'
real_galaxy_catalog = galsim.RealGalaxyCatalog(cat_file_name, dir=dir)
logger.info('Read in %d real galaxies from catalog',
real_galaxy_catalog.nobjects)
# List of IDs to use. We select 5 particularly irregular galaxies for this demo.
# Then we'll choose randomly from this list.
id_list = [106416, 106731, 108402, 116045, 116448]
# Make the 5 galaxies we're going to use here rather than remake them each time.
# This means the Fourier transforms of the real galaxy images don't need to be recalculated
# each time, so it's a bit more efficient.
gal_list = [
galsim.RealGalaxy(real_galaxy_catalog, id=id) for id in id_list
]
# Grab the index numbers before we transform them and lose the index attribute.
cosmos_index = [gal.index for gal in gal_list]
# Make the galaxies a bit larger than their original observed size.
gal_list = [gal.dilate(gal_dilation) for gal in gal_list]
# Setup the PowerSpectrum object we'll be using:
ps = galsim.PowerSpectrum(lambda k: k**1.8)
# The argument here is "e_power_function" which defines the E-mode power to use.
# There is also a b_power_function if you want to include any B-mode power:
# ps = galsim.PowerSpectrum(e_power_function, b_power_function)
# You may even omit the e_power_function argument and have a pure B-mode power spectrum.
# ps = galsim.PowerSpectrum(b_power_function = b_power_function)
# All the random number generator classes derive from BaseDeviate.
# When we construct another kind of deviate class from any other
# kind of deviate class, the two share the same underlying random number
# generator. Sometimes it can be clearer to just construct a BaseDeviate
# explicitly and then construct anything else you need from that.
# Note: A BaseDeviate cannot be used to generate any values. It can
# only be used in the constructor for other kinds of deviates.
# The seeds for the objects are random_seed+1..random_seed+nobj.
# The seeds for things at the image or file level use random_seed itself.
nobj = n_tiles * n_tiles
rng = galsim.BaseDeviate(random_seed)
# Have the PowerSpectrum object build a grid of shear values for us to use.
grid_g1, grid_g2 = ps.buildGrid(grid_spacing=stamp_size * pixel_scale,
ngrid=n_tiles,
rng=rng)
# Setup the images:
gal_image = galsim.ImageF(stamp_size * n_tiles, stamp_size * n_tiles)
psf_image = galsim.ImageF(stamp_size * n_tiles, stamp_size * n_tiles)
# Update the image WCS to use the image center as the origin of the WCS.
# The class that acts like a PixelScale except for this offset is called OffsetWCS.
im_center = gal_image.true_center
wcs = galsim.OffsetWCS(scale=pixel_scale, origin=im_center)
gal_image.wcs = wcs
psf_image.wcs = wcs
# We will place the tiles in a random order. To do this, we make two lists for the
# ix and iy values. Then we apply a random permutation to the lists (in tandem).
ix_list = []
iy_list = []
for ix in range(n_tiles):
for iy in range(n_tiles):
ix_list.append(ix)
iy_list.append(iy)
# This next function will use the given random number generator, rng, and use it to
# randomly permute any number of lists. All lists will have the same random permutation
# applied.
galsim.random.permute(rng, ix_list, iy_list)
# Initialize the OutputCatalog for the truth values
names = [
'gal_num', 'x_image', 'y_image', 'psf_e1', 'psf_e2', 'psf_fwhm',
'cosmos_id', 'cosmos_index', 'theta', 'g1', 'g2', 'shift_x', 'shift_y'
]
types = [
int, float, float, float, float, float, str, int, float, float, float,
float, float
]
truth_catalog = galsim.OutputCatalog(names, types)
# Build each postage stamp:
for k in range(nobj):
# The usual random number generator using a different seed for each galaxy.
rng = galsim.BaseDeviate(random_seed + k + 1)
# Determine the bounds for this stamp and its center position.
ix = ix_list[k]
iy = iy_list[k]
b = galsim.BoundsI(ix * stamp_size + 1, (ix + 1) * stamp_size,
iy * stamp_size + 1, (iy + 1) * stamp_size)
sub_gal_image = gal_image[b]
sub_psf_image = psf_image[b]
pos = wcs.toWorld(b.true_center)
# The image comes out as about 211 arcsec across, so we define our variable
# parameters in terms of (r/100 arcsec), so roughly the scale size of the image.
rsq = (pos.x**2 + pos.y**2)
r = math.sqrt(rsq)
psf_fwhm = 0.9 + 0.5 * rsq / 100**2 # arcsec
psf_e = 0.4 * (r / 100.)**1.5
psf_beta = (math.atan2(pos.y, pos.x) + math.pi / 2) * galsim.radians
# Define the PSF profile
psf = galsim.Gaussian(fwhm=psf_fwhm)
psf_shape = galsim.Shear(e=psf_e, beta=psf_beta)
psf = psf.shear(psf_shape)
# Define the galaxy profile:
# For this demo, we are doing a ring test where the same galaxy profile is drawn at many
# orientations stepped uniformly in angle, making a ring in e1-e2 space.
# We're drawing each profile at 20 different orientations and then skipping to the
# next galaxy in the list. So theta steps by 1/20 * 360 degrees:
theta_deg = (k % 20) * 360. / 20
theta = theta_deg * galsim.degrees
# The index needs to increment every 20 objects so we use k/20 using integer math.
index = k // 20
gal = gal_list[index]
# This makes a new copy so we're not changing the object in the gal_list.
gal = gal.rotate(theta)
# Apply the shear from the power spectrum. We should either turn the gridded shears
# grid_g1[iy, ix] and grid_g2[iy, ix] into gridded reduced shears using a utility called
# galsim.lensing.theoryToObserved, or use ps.getShear() which by default gets the reduced
# shear. ps.getShear() is also more flexible because it can get the shear at positions that
# are not on the original grid, as long as they are contained within the bounds of the full
# grid. So in this example we'll use ps.getShear().
alt_g1, alt_g2 = ps.getShear(pos)
gal = gal.shear(g1=alt_g1, g2=alt_g2)
# Apply half-pixel shift in a random direction.
shift_r = pixel_scale * 0.5
ud = galsim.UniformDeviate(rng)
t = ud() * 2. * math.pi
dx = shift_r * math.cos(t)
dy = shift_r * math.sin(t)
gal = gal.shift(dx, dy)
# Make the final image, convolving with the psf
final = galsim.Convolve([psf, gal])
# Draw the image
final.drawImage(sub_gal_image)
# For the PSF image, we don't match the galaxy shift. Rather, we use the offset
# parameter to drawImage to apply a random offset of up to 0.5 pixels in each direction.
# Note the difference in units between shift and offset. The shift is applied to the
# surface brightness profile, so it is in sky coordinates (as all dimension are for
# GSObjects), which are arcsec here. The offset though is applied to the image itself,
# so it is in pixels. Hence, we don't multiply by pixel_scale.
psf_dx = ud() - 0.5
psf_dy = ud() - 0.5
psf_offset = galsim.PositionD(psf_dx, psf_dy)
# Draw the PSF image:
# We use real space integration over the pixels to avoid some of the
# artifacts that can show up with Fourier convolution.
# The level of the artifacts is quite low, but when drawing with
# so little noise, they are apparent with ds9's zscale viewing.
psf.drawImage(sub_psf_image, method='real_space', offset=psf_offset)
# Build the noise model: Poisson noise with a given sky level.
sky_level_pixel = sky_level * pixel_scale**2
noise = galsim.PoissonNoise(rng, sky_level=sky_level_pixel)
# Add noise to the PSF image, using the normal noise model, but scaling the
# PSF flux high enough to reach the desired signal-to-noise.
# See demo5.py for more info about how this works.
sub_psf_image.addNoiseSNR(noise, psf_signal_to_noise)
# And also to the galaxy image using its signal-to-noise.
sub_gal_image.addNoiseSNR(noise, gal_signal_to_noise)
# Add the truth values to the truth catalog
row = [
k, b.true_center.x, b.true_center.y, psf_shape.e1,
psf_shape.e2, psf_fwhm, id_list[index], cosmos_index[index],
(theta_deg % 360.), alt_g1, alt_g2, dx, dy
]
truth_catalog.addRow(row)
logger.info('Galaxy (%d,%d): position relative to center = %s', ix, iy,
str(pos))
logger.info('Done making images of postage stamps')
# In this case, we'll attach the truth catalog as an additional HDU in the same file as
# the image data.
truth_hdu = truth_catalog.writeFitsHdu()
# Now write the images to disk.
images = [gal_image, psf_image, truth_hdu]
# Any items in the "images" list that is already an hdu is just used directly.
# The actual images are converted to FITS hdus that contain the image data.
galsim.fits.writeMulti(images, file_name)
logger.info('Wrote image to %r', file_name)
rng = galsim.UniformDeviate(random_seed + k + 1)
flux = rng() * (gal_flux_max - gal_flux_min) + gal_flux_min
this_gal = gal[j].withFlux(flux)
hlr = rng() * (gal_hlr_max - gal_hlr_min) + gal_hlr_min
this_gal = this_gal.dilate(hlr)
this_gal = this_gal.shear(e1=xz[p] * e10[l],
e2=xz[p] * e20[l]).shear(g1=g10[i],
g2=g20[i])
final = galsim.Convolve([this_gal, psf])
print(rng())
image = galsim.ImageF(nx, ny, scale=pixel_scale)
fft_image = image[galsim.BoundsI(1, nx, 1, ny)]
final.drawImage(fft_image, method='fft')
sky_level_pixel = sky_level * pixel_scale**2
fft_image.addNoise(
galsim.PoissonNoise(rng,
sky_level=sky_level_pixel)) #add noise
#image
rst = hsm.EstimateShear(image,
final_epsf_image,
shear_est='BJ')
BJe1array[j].append(rst.corrected_e1)
BJe2array[j].append(rst.corrected_e2)
rst = hsm.EstimateShear(image,
final_epsf_image,
shear_est='REGAUSS')
RGe1array[j].append(rst.corrected_e1)
RGe2array[j].append(rst.corrected_e2)
e1, e2 = elli(image.array)
Me1array[j].append(e1)
Me2array[j].append(e2)
BJe1 = []
def main(argv):
"""
Make images similar to that done for the Great08 challenge:
- Each fits file is 10 x 10 postage stamps.
(The real Great08 images are 100x100, but in the interest of making the Demo
script a bit quicker, we only build 100 stars and 100 galaxies.)
- Each postage stamp is 40 x 40 pixels.
- One image is all stars.
- A second image is all galaxies.
- Applied shear is the same for each galaxy.
- Galaxies are oriented randomly, but in pairs to cancel shape noise.
- Noise is Poisson using a nominal sky value of 1.e6.
- Galaxies are Exponential profiles.
"""
logging.basicConfig(format="%(message)s", level=logging.INFO, stream=sys.stdout)
logger = logging.getLogger("demo5")
# Define some parameters we'll use below.
# Normally these would be read in from some parameter file.
nx_tiles = 10 #
ny_tiles = 10 #
stamp_xsize = 40 #
stamp_ysize = 40 #
random_seed = 6424512 #
pixel_scale = 1.0 # arcsec / pixel
sky_level = 1.e6 # ADU / arcsec^2
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
psf_file_name = os.path.join('output','g08_psf.fits')
psf_beta = 3 #
psf_fwhm = 2.85 # arcsec (=pixels)
psf_trunc = 2.*psf_fwhm # arcsec (=pixels)
psf_e1 = -0.019 #
psf_e2 = -0.007 #
gal_file_name = os.path.join('output','g08_gal.fits')
gal_signal_to_noise = 200 # Great08 "LowNoise" run
gal_resolution = 0.98 # r_gal / r_psf (use r = half_light_radius)
# Note: Great08 defined their resolution as r_obs / r_psf, using the convolved
# size rather than the pre-convolved size.
# Therefore, our r_gal/r_psf = 0.98 approximately corresponds to
# their r_obs / r_psf = 1.4.
gal_ellip_rms = 0.2 # using "distortion" definition of ellipticity:
# e = (a^2-b^2)/(a^2+b^2), where a and b are the
# semi-major and semi-minor axes, respectively.
gal_ellip_max = 0.6 # Maximum value of e, to avoid getting near e=1.
gal_g1 = 0.013 # Applied shear, using normal shear definition:
gal_g2 = -0.008 # g = (a-b)/(a+b)
shift_radius = 1.0 # arcsec (=pixels)
logger.info('Starting demo script 5 using:')
logger.info(' - image with %d x %d postage stamps',nx_tiles,ny_tiles)
logger.info(' - postage stamps of size %d x %d pixels',stamp_xsize,stamp_ysize)
logger.info(' - Moffat PSF (beta = %.1f, FWHM = %.2f, trunc = %.2f),',
psf_beta,psf_fwhm,psf_trunc)
logger.info(' - PSF ellip = (%.3f,%.3f)',psf_e1,psf_e2)
logger.info(' - Exponential galaxies')
logger.info(' - Resolution (r_gal / r_psf) = %.2f',gal_resolution)
logger.info(' - Ellipticities have rms = %.1f, max = %.1f',
gal_ellip_rms, gal_ellip_max)
logger.info(' - Applied gravitational shear = (%.3f,%.3f)',gal_g1,gal_g2)
logger.info(' - Poisson noise (sky level = %.1e).', sky_level)
logger.info(' - Centroid shifts up to = %.2f pixels',shift_radius)
# Define the PSF profile
psf = galsim.Moffat(beta=psf_beta, fwhm=psf_fwhm, trunc=psf_trunc)
# When something can be constructed from multiple sizes, e.g. Moffat, then
# you can get any size out even if it wasn't the way the object was constructed.
# In this case, we extract the half-light radius, even though we built it with fwhm.
# We'll use this later to set the galaxy's half-light radius in terms of a resolution.
psf_re = psf.getHalfLightRadius()
psf = psf.shear(e1=psf_e1,e2=psf_e2)
logger.debug('Made PSF profile')
# Define the galaxy profile
# First figure out the size we need from the resolution
gal_re = psf_re * gal_resolution
# Make the galaxy profile starting with flux = 1.
gal = galsim.Exponential(flux=1., half_light_radius=gal_re)
logger.debug('Made galaxy profile')
# This profile is placed with different orientations and noise realizations
# at each postage stamp in the gal image.
gal_image = galsim.ImageF(stamp_xsize * nx_tiles-1 , stamp_ysize * ny_tiles-1,
scale=pixel_scale)
psf_image = galsim.ImageF(stamp_xsize * nx_tiles-1 , stamp_ysize * ny_tiles-1,
scale=pixel_scale)
shift_radius_sq = shift_radius**2
first_in_pair = True # Make pairs that are rotated by 90 degrees
k = 0
for iy in range(ny_tiles):
for ix in range(nx_tiles):
# The normal procedure for setting random numbers in GalSim is to start a new
# random number generator for each object using sequential seed values.
# This sounds weird at first (especially if you were indoctrinated by Numerical
# Recipes), but for the boost random number generator we use, the "random"
# number sequences produced from sequential initial seeds are highly uncorrelated.
#
# The reason for this procedure is that when we use multiple processes to build
# our images, we want to make sure that the results are deterministic regardless
# of the way the objects get parcelled out to the different processes.
#
# Of course, this script isn't using multiple processes, so it isn't required here.
# However, we do it nonetheless in order to get the same results as the config
# version of this demo script (demo5.yaml).
ud = galsim.UniformDeviate(random_seed+k+1)
# Any kind of random number generator can take another RNG as its first
# argument rather than a seed value. This makes both objects use the same
# underlying generator for their pseudo-random values.
gd = galsim.GaussianDeviate(ud, sigma=gal_ellip_rms)
# The -1's in the next line are to provide a border of
# 1 pixel between postage stamps
b = galsim.BoundsI(ix*stamp_xsize+1 , (ix+1)*stamp_xsize-1,
iy*stamp_ysize+1 , (iy+1)*stamp_ysize-1)
sub_gal_image = gal_image[b]
sub_psf_image = psf_image[b]
# Great08 randomized the locations of the two galaxies in each pair,
# but for simplicity, we just do them in sequential postage stamps.
if first_in_pair:
# Use a random orientation:
beta = ud() * 2. * math.pi * galsim.radians
# Determine the ellipticity to use for this galaxy.
ellip = 1
while (ellip > gal_ellip_max):
# Don't do `ellip = math.fabs(gd())`
# Python basically implements this as a macro, so gd() is called twice!
val = gd()
ellip = math.fabs(val)
# Make a new copy of the galaxy with an applied e1/e2-type distortion
# by specifying the ellipticity and a real-space position angle
ellip_gal = gal.shear(e=ellip, beta=beta)
first_in_pair = False
else:
# Use the previous ellip_gal profile and rotate it by 90 degrees
ellip_gal = ellip_gal.rotate(90 * galsim.degrees)
first_in_pair = True
# Apply the gravitational reduced shear by specifying g1/g2
this_gal = ellip_gal.shear(g1=gal_g1, g2=gal_g2)
# Apply a random shift_radius:
rsq = 2 * shift_radius_sq
while (rsq > shift_radius_sq):
dx = (2*ud()-1) * shift_radius
dy = (2*ud()-1) * shift_radius
rsq = dx**2 + dy**2
this_gal = this_gal.shift(dx,dy)
# Note that the shifted psf that we create here is purely for the purpose of being able
# to draw a separate, shifted psf image. We do not use it when convolving the galaxy
# with the psf.
this_psf = psf.shift(dx,dy)
# Make the final image, convolving with the (unshifted) psf
final_gal = galsim.Convolve([psf,this_gal])
# Draw the image
final_gal.drawImage(sub_gal_image)
# Now add an appropriate amount of noise to get our desired S/N
# There are lots of definitions of S/N, but here is the one used by Great08
# We use a weighted integral of the flux:
# S = sum W(x,y) I(x,y) / sum W(x,y)
# N^2 = Var(S) = sum W(x,y)^2 Var(I(x,y)) / (sum W(x,y))^2
# Now we assume that Var(I(x,y)) is constant so
# Var(I(x,y)) = noise_var
# We also assume that we are using a matched filter for W, so W(x,y) = I(x,y).
# Then a few things cancel and we find that
# S/N = sqrt( sum I(x,y)^2 / noise_var )
#
# The above procedure is encapsulated in the function image.addNoiseSNR which
# sets the flux appropriately given the variance of the noise model.
# In our case, noise_var = sky_level_pixel
sky_level_pixel = sky_level * pixel_scale**2
noise = galsim.PoissonNoise(ud, sky_level=sky_level_pixel)
sub_gal_image.addNoiseSNR(noise, gal_signal_to_noise)
# Draw the PSF image
# No noise on PSF images. Just draw it as is.
this_psf.drawImage(sub_psf_image)
# For first instance, measure moments
if ix==0 and iy==0:
psf_shape = sub_psf_image.FindAdaptiveMom()
temp_e = psf_shape.observed_shape.e
if temp_e > 0.0:
g_to_e = psf_shape.observed_shape.g / temp_e
else:
g_to_e = 0.0
logger.info('Measured best-fit elliptical Gaussian for first PSF image: ')
logger.info(' g1, g2, sigma = %7.4f, %7.4f, %7.4f (pixels)',
g_to_e*psf_shape.observed_shape.e1,
g_to_e*psf_shape.observed_shape.e2, psf_shape.moments_sigma)
x = b.center().x
y = b.center().y
logger.info('Galaxy (%d,%d): center = (%.0f,%0.f) (e,beta) = (%.4f,%.3f)',
ix,iy,x,y,ellip,beta/galsim.radians)
k = k+1
logger.info('Done making images of postage stamps')
# Now write the images to disk.
psf_image.write(psf_file_name)
logger.info('Wrote PSF file %s',psf_file_name)
gal_image.write(gal_file_name)
logger.info('Wrote image to %r',gal_file_name) # using %r adds quotes around filename for us
def build_file(seed, file_name, mass, nobj, rng, truth_file_name, halo_id,
first_obj_id):
"""A function that does all the work to build a single file.
Returns the total time taken.
"""
t1 = time.time()
# Build the image onto which we will draw the galaxies.
full_image = galsim.ImageF(image_size, image_size)
# The "true" center of the image is allowed to be halfway between two pixels, as is the
# case for even-sized images. full_image.bounds.center() is an integer position,
# which would be 1/2 pixel up and to the right of the true center in this case.
im_center = full_image.bounds.trueCenter()
# For the WCS, this time we use UVFunction, which lets you define arbitrary u(x,y)
# and v(x,y) functions. We use a simple cubic radial function to create a
# pincushion distortion. This is a typical kind of telescope distortion, although
# we exaggerate the magnitude of the effect to make it more apparent.
# The pixel size in the center of the image is 0.05, but near the corners (r=362),
# the pixel size is approximately 0.075, which is much more distortion than is
# normally present in typical telescopes. But it makes the effect of the variable
# pixel area obvious when you look at the weight image in the output files.
ufunc1 = lambda x, y: 0.05 * x * (1. + 2.e-6 * (x**2 + y**2))
vfunc1 = lambda x, y: 0.05 * y * (1. + 2.e-6 * (x**2 + y**2))
# It's not required to provide the inverse functions. However, if we don't, then
# you will only be able to do toWorld operations, not the inverse toImage.
# The inverse function does not have to be exact either. For example, you could provide
# a function that does some kind of iterative solution to whatever accuracy you care
# about. But in this case, we can do the exact inverse.
#
# Let w = sqrt(u**2 + v**2) and r = sqrt(x**2 + y**2). Then the solutions are:
# x = (u/w) r and y = (u/w) r, and we use Cardano's method to solve for r given w:
# See http://en.wikipedia.org/wiki/Cubic_function#Cardano.27s_method
#
# w = 0.05 r + 2.e-6 * 0.05 * r**3
# r = 100 * ( ( 5 sqrt(w**2 + 5.e3/27) + 5 w )**(1./3.) -
# - ( 5 sqrt(w**2 + 5.e3/27) - 5 w )**(1./3.) )
def xfunc1(u, v):
import math
wsq = u * u + v * v
if wsq == 0.:
return 0.
else:
w = math.sqrt(wsq)
temp = 5. * math.sqrt(wsq + 5.e3 / 27)
r = 100. * ((temp + 5 * w)**(1. / 3.) -
(temp - 5 * w)**(1. / 3))
return u * r / w
def yfunc1(u, v):
import math
wsq = u * u + v * v
if wsq == 0.:
return 0.
else:
w = math.sqrt(wsq)
temp = 5. * math.sqrt(wsq + 5.e3 / 27)
r = 100. * ((temp + 5 * w)**(1. / 3.) -
(temp - 5 * w)**(1. / 3))
return v * r / w
# You could pass the above functions to UVFunction, and normally we would do that.
# The only down side to doing so is that the specification of the WCS in the FITS
# file is rather ugly. GalSim is able to turn the python byte code into strings,
# but they are basically a really ugly mess of random-looking characters. GalSim
# will be able to read it back in, but human readers will have no idea what WCS
# function was used. To see what they look like, uncomment this line and comment
# out the later wcs line.
#wcs = galsim.UVFunction(ufunc1, vfunc1, xfunc1, yfunc1, origin=im_center)
# If you provide the functions as strings, then those strings will be preserved
# in the FITS header in a form that is more legible to human readers.
# It also has the extra benefit of matching the output from demo9.yaml, which we
# always try to do. The config file has no choice but to specify the functions
# as strings.
ufunc = '0.05 * x * (1. + 2.e-6 * (x**2 + y**2))'
vfunc = '0.05 * y * (1. + 2.e-6 * (x**2 + y**2))'
xfunc = (
'( lambda w: ( 0 if w==0 else ' +
'100.*u/w*(( 5*(w**2 + 5.e3/27.)**0.5 + 5*w )**(1./3.) - ' +
'( 5*(w**2 + 5.e3/27.)**0.5 - 5*w )**(1./3.))))( (u**2+v**2)**0.5 )'
)
yfunc = (
'( lambda w: ( 0 if w==0 else ' +
'100.*v/w*(( 5*(w**2 + 5.e3/27.)**0.5 + 5*w )**(1./3.) - ' +
'( 5*(w**2 + 5.e3/27.)**0.5 - 5*w )**(1./3.))))( (u**2+v**2)**0.5 )'
)
# The origin parameter defines where on the image should be considered (x,y) = (0,0)
# in the WCS functions.
wcs = galsim.UVFunction(ufunc, vfunc, xfunc, yfunc, origin=im_center)
# Assign this wcs to full_image
full_image.wcs = wcs
# The weight image will hold the inverse variance for each pixel.
# We can set the wcs directly on construction with the wcs parameter.
weight_image = galsim.ImageF(image_size, image_size, wcs=wcs)
# It is common for astrometric images to also have a bad pixel mask. We don't have any
# defect simulation currently, so our bad pixel masks are currently all zeros.
# But someday, we plan to add defect functionality to GalSim, at which point, we'll
# be able to mark those defects on a bad pixel mask.
# Note: the S in ImageS means to use "short int" for the data type.
# This is a typical choice for a bad pixel image.
badpix_image = galsim.ImageS(image_size, image_size, wcs=wcs)
# We also draw a PSF image at the location of every galaxy. This isn't normally done,
# and since some of the PSFs overlap, it's not necessarily so useful to have this kind
# of image. But in this case, it's fun to look at the psf image, especially with
# something like log scaling in ds9 to see how crazy an aberrated OpticalPSF with
# struts can look when there is no atmospheric component to blur it out.
psf_image = galsim.ImageF(image_size, image_size, wcs=wcs)
# We will also write some truth information to an output catalog.
# In real simulations, it is often useful to have a catalog of the truth values
# to compare to measurements either directly or as cuts on the galaxy sample to
# find where systematic errors are largest.
# For now, we just make an empty OutputCatalog object with the names and types of the
# columns.
names = [
'object_id', 'halo_id', 'flux', 'radius', 'h_over_r',
'inclination.rad', 'theta.rad', 'mu', 'redshift', 'shear.g1',
'shear.g2', 'pos.x', 'pos.y', 'image_pos.x', 'image_pos.y',
'halo_mass', 'halo_conc', 'halo_redshift'
]
types = [
int, int, float, float, float, float, float, float, float, float,
float, float, float, float, float, float, float, float
]
truth_cat = galsim.OutputCatalog(names, types)
# Setup the NFWHalo stuff:
nfw = galsim.NFWHalo(mass=mass,
conc=nfw_conc,
redshift=nfw_z_halo,
omega_m=omega_m,
omega_lam=omega_lam)
# Note: the last two are optional. If they are omitted, then (omega_m=0.3, omega_lam=0.7)
# are actually the defaults. If you only specify one of them, the other is set so that
# the total is 1. But you can define both values so that the total is not 1 if you want.
# Radiation is assumed to be zero and dark energy equation of state w = -1.
# If you want to include either radiation or more complicated dark energy models,
# you can define your own cosmology class that defines the functions a(z), E(a), and
# Da(z_source, z_lens). Then you can pass this to NFWHalo as a `cosmo` parameter.
# Make the PSF profile outside the loop to minimize the (significant) OpticalPSF
# construction overhead.
psf = galsim.OpticalPSF(lam=psf_lam,
diam=psf_D,
obscuration=psf_obsc,
nstruts=psf_nstruts,
strut_thick=psf_strut_thick,
strut_angle=psf_strut_angle,
defocus=psf_defocus,
astig1=psf_astig1,
astig2=psf_astig2,
coma1=psf_coma1,
coma2=psf_coma2,
trefoil1=psf_trefoil1,
trefoil2=psf_trefoil2)
for k in range(nobj):
# Initialize the random number generator we will be using for this object:
ud = galsim.UniformDeviate(seed + k + 1)
# Determine where this object is going to go.
# We choose points randomly within a donut centered at the center of the main image
# in order to avoid placing galaxies too close to the halo center where the lensing
# is not weak. We use an inner radius of 3 arcsec and an outer radius of 12 arcsec,
# which takes us essentially to the edge of the image.
radius = 12
inner_radius = 3
max_rsq = radius**2
min_rsq = inner_radius**2
while True: # (This is essentially a do..while loop.)
x = (2. * ud() - 1) * radius
y = (2. * ud() - 1) * radius
rsq = x**2 + y**2
if rsq >= min_rsq and rsq <= max_rsq: break
pos = galsim.PositionD(x, y)
# We also need the position in pixels to determine where to place the postage
# stamp on the full image.
image_pos = wcs.toImage(pos)
# For even-sized postage stamps, the nominal center (returned by stamp.bounds.center())
# cannot be at the true center (returned by stamp.bounds.trueCenter()) of the postage
# stamp, since the nominal center values have to be integers. Thus, the nominal center
# is 1/2 pixel up and to the right of the true center.
# If we used odd-sized postage stamps, we wouldn't need to do this.
x_nominal = image_pos.x + 0.5
y_nominal = image_pos.y + 0.5
# Get the integer values of these which will be the actual nominal center of the
# postage stamp image.
ix_nominal = int(math.floor(x_nominal + 0.5))
iy_nominal = int(math.floor(y_nominal + 0.5))
# The remainder will be accounted for in an offset when we draw.
dx = x_nominal - ix_nominal
dy = y_nominal - iy_nominal
offset = galsim.PositionD(dx, dy)
# Draw the flux from a power law distribution: N(f) ~ f^-1.5
# For this, we use the class DistDeviate which can draw deviates from an arbitrary
# probability distribution. This distribution can be defined either as a functional
# form as we do here, or as tabulated lists of x and p values, from which the
# function is interpolated.
flux_dist = galsim.DistDeviate(ud,
function=lambda x: x**-1.5,
x_min=gal_flux_min,
x_max=gal_flux_max)
flux = flux_dist()
# We introduce here another surface brightness profile, called InclinedExponential.
# It represents a typical 3D galaxy disk profile inclined at an arbitrary angle
# relative to face on.
#
# inclination = 0 degrees corresponds to a face-on disk, which is equivalent to
# the regular Exponential profile.
# inclination = 90 degrees corresponds to an edge-on disk.
#
# A random orientation corresponds to the inclination angle taking the probability
# distribution:
#
# P(inc) = 0.5 sin(inc)
#
# so we again use a DistDeviate to generate these values.
inc_dist = galsim.DistDeviate(ud,
function=lambda x: 0.5 * math.sin(x),
x_min=0,
x_max=math.pi)
inclination = inc_dist() * galsim.radians
# The parameters scale_radius and scale_height give the scale distances in the
# 3D distribution:
#
# I(R,z) = I_0 / (2 scale_height) * sech^2(z/scale_height) * exp(-r/scale_radius)
#
# These values can be given separately if desired. However, it is often easier to
# give the ratio scale_h_over_r as an independent value, since the radius and height
# values are correlated, while h/r is approximately independent of h or r.
h_over_r = ud() * (gal_h_over_r_max -
gal_h_over_r_min) + gal_h_over_r_min
radius = ud() * (gal_r_max - gal_r_min) + gal_r_min
# The inclination is around the x-axis, so we want to rotate the galaxy by a
# random angle.
theta = ud() * math.pi * 2. * galsim.radians
# Make the galaxy profile with these values:
gal = galsim.InclinedExponential(scale_radius=radius,
scale_h_over_r=h_over_r,
inclination=inclination,
flux=flux)
gal = gal.rotate(theta)
# Now apply the appropriate lensing effects for this position from
# the NFW halo mass.
try:
g1, g2 = nfw.getShear(pos, nfw_z_source)
nfw_shear = galsim.Shear(g1=g1, g2=g2)
except:
# This shouldn't happen, since we exclude the inner 10 arcsec, but it's a
# good idea to use the try/except block here anyway.
import warnings
warnings.warn(
"Warning: NFWHalo shear is invalid -- probably strong lensing! "
+ "Using shear = 0.")
nfw_shear = galsim.Shear(g1=0, g2=0)
nfw_mu = nfw.getMagnification(pos, nfw_z_source)
if nfw_mu < 0:
import warnings
warnings.warn(
"Warning: mu < 0 means strong lensing! Using mu=25.")
nfw_mu = 25
elif nfw_mu > 25:
import warnings
warnings.warn(
"Warning: mu > 25 means strong lensing! Using mu=25.")
nfw_mu = 25
# Calculate the total shear to apply
# Since shear addition is not commutative, it is worth pointing out that
# the order is in the sense that the second shear is applied first, and then
# the first shear. i.e. The field shear is taken to be behind the cluster.
# Kind of a cosmic shear contribution between the source and the cluster.
# However, this is not quite the same thing as doing:
# gal.shear(field_shear).shear(nfw_shear)
# since the shear addition ignores the rotation that would occur when doing the
# above lines. This is normally ok, because the rotation is not observable, but
# it is worth keeping in mind.
total_shear = nfw_shear + field_shear
# Apply the magnification and shear to the galaxy
gal = gal.magnify(nfw_mu)
gal = gal.shear(total_shear)
# Build the final object
final = galsim.Convolve([psf, gal])
# Draw the stamp image
# To draw the image at a position other than the center of the image, you can
# use the offset parameter, which applies an offset in pixels relative to the
# center of the image.
# We also need to provide the local wcs at the current position.
local_wcs = wcs.local(image_pos)
stamp = final.drawImage(wcs=local_wcs, offset=offset)
# Recenter the stamp at the desired position:
stamp.setCenter(ix_nominal, iy_nominal)
# Find overlapping bounds
bounds = stamp.bounds & full_image.bounds
full_image[bounds] += stamp[bounds]
# Also draw the PSF
psf_stamp = galsim.ImageF(
stamp.bounds) # Use same bounds as galaxy stamp
psf.drawImage(psf_stamp, wcs=local_wcs, offset=offset)
psf_image[bounds] += psf_stamp[bounds]
# Add the truth information for this object to the truth catalog
row = ((first_obj_id + k), halo_id, flux, radius, h_over_r,
inclination.rad(), theta.rad(), nfw_mu, nfw_z_source,
total_shear.g1, total_shear.g2, pos.x, pos.y, image_pos.x,
image_pos.y, mass, nfw_conc, nfw_z_halo)
truth_cat.addRow(row)
# Add Poisson noise to the full image
# Note: The normal calculation of Poission noise isn't quite correct right now.
# The pixel area is variable, which means the amount of sky flux that enters each
# pixel is also variable. The wcs classes have a function `makeSkyImage` which
# will fill an image with the correct amount of sky flux given the sky level
# in units of ADU/arcsec^2. We use the weight image as our work space for this.
wcs.makeSkyImage(weight_image, sky_level)
# Add this to the current full_image (temporarily).
full_image += weight_image
# Add Poisson noise, given the current full_image.
# The config parser uses a different random number generator for file-level and
# image-level values than for the individual objects. This makes it easier to
# parallelize the calculation if desired. In fact, this is why we've been adding 1
# to each seed value all along. The seeds for the objects take the values
# random_seed+1 .. random_seed+nobj. The seed for the image is just random_seed,
# which we built already (below) when we calculated how many objects need to
# be in each file. Use the same rng again here, since this is also at image scope.
full_image.addNoise(galsim.PoissonNoise(rng))
# Subtract the sky back off.
full_image -= weight_image
# The weight image is nominally the inverse variance of the pixel noise. However, it is
# common to exclude the Poisson noise from the objects themselves and only include the
# noise from the sky photons. The variance of the noise is just the sky level, which is
# what is currently in the weight_image. (If we wanted to include the variance from the
# objects too, then we could use the full_image before we added the PoissonNoise to it.)
# So all we need to do now is to invert the values in weight_image.
weight_image.invertSelf()
# Write the file to disk:
galsim.fits.writeMulti(
[full_image, badpix_image, weight_image, psf_image], file_name)
# And write the truth catalog file
truth_cat.write(truth_file_name)
t2 = time.time()
return t2 - t1
def allDetectorEffects(img, rng=None, exptime=None, prev_exposures=[]):
"""
This utility applies all sources of noise and detector effects for WFIRST that are implemented
in GalSim. In terms of noise, this includes the Poisson noise due to the signal (sky +
background), dark current, and read noise. The detector effects that are included are
reciprocity failure, quantization, persistence, nonlinearity, and interpixel capacitance. It
also includes the necessary factors of gain. In short, the user should be able to pass in an
Image with all sources of signal (background plus astronomical objects), and the Image will be
modified to include all subsequent steps in the image generation process for WFIRST that are
implemented in GalSim. However, to include the effect of persistence, the user needs to provide
a list of up to {ncoeff} recent exposures (without the readout effects such nonlinearity and
interpixel capacitance included) and the routine returns an updated list of up to {ncoeff}
recent exposures.
@param img The Image to be modified.
@param rng An optional galsim.BaseDeviate to use for the addition of noise. If
None, a new one will be initialized. [default: None]
@param exptime The exposure time, in seconds. If None, then the WFIRST default
exposure time will be used. [default: None]
@param prev_exposures List of up to {ncoeff} Image instances in the order of exposures, with
the recent exposure being the first element. [default: []]
@returns prev_exposures Updated list of previous exposures containing up to {ncoeff} Image
instances.
""".format(ncoeff=galsim.wfirst.persistence_coefficients)
# Deal appropriately with passed-in RNG, exposure time.
if rng is None:
rng = galsim.BaseDeviate()
elif not isinstance(rng, galsim.BaseDeviate):
raise TypeError(
"The rng provided to RealGalaxy constructor is not a BaseDeviate")
if exptime is None:
exptime = galsim.wfirst.exptime
# Add Poisson noise.
poisson_noise = galsim.PoissonNoise(rng)
img.addNoise(poisson_noise)
# Reciprocity failure (use WFIRST routine, with the supplied exposure time).
addReciprocityFailure(img, exptime=exptime)
# Quantize.
img.quantize()
# Dark current (use exposure time).
dark_current = galsim.wfirst.dark_current * exptime
dark_noise = galsim.DeviateNoise(galsim.PoissonDeviate(rng, dark_current))
img.addNoise(dark_noise)
# Persistence (use WFIRST coefficients)
applyPersistence(img, prev_exposures)
# Update the 'prev_exposures' queue
if len(prev_exposures) >= len(galsim.wfirst.persistence_coefficients):
prev_exposures.pop()
prev_exposures.insert(0, img.copy())
# Nonlinearity (use WFIRST routine).
applyNonlinearity(img)
# IPC (use WFIRST routine).
applyIPC(img)
# Read noise.
read_noise = galsim.GaussianNoise(rng, sigma=galsim.wfirst.read_noise)
img.addNoise(read_noise)
# Gain.
img /= galsim.wfirst.gain
# Quantize.
img.quantize()
return prev_exposures
def main(argv):
"""
Make a fits image cube using real COSMOS galaxies from a catalog describing the training
sample.
- The number of images in the cube matches the number of rows in the catalog.
- Each image size is computed automatically by GalSim based on the Nyquist size.
- Both galaxies and stars.
- PSF is a double Gaussian, the same for each galaxy.
- Galaxies are randomly rotated to remove the imprint of any lensing shears in the COSMOS
data.
- The same shear is applied to each galaxy.
- Noise is Poisson using a nominal sky value of 1.e6 ADU/arcsec^2,
the noise in the original COSMOS data.
"""
logging.basicConfig(format="%(message)s",
level=logging.INFO,
stream=sys.stdout)
logger = logging.getLogger("demo6")
# Define some parameters we'll use below.
cat_file_name = 'real_galaxy_catalog_example.fits'
# This script is designed to be run from the examples directory so dir is a relative path.
# But the '../examples/' part lets bin/demo6 also be run from the bin directory.
dir = '../examples/data'
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
cube_file_name = os.path.join('output', 'cube_real.fits')
psf_file_name = os.path.join('output', 'psf_real.fits')
random_seed = 1512413
sky_level = 1.e6 # ADU / arcsec^2
pixel_scale = 0.15 # arcsec
gal_flux = 1.e5 # arbitrary choice, makes nice (not too) noisy images
gal_g1 = -0.027 #
gal_g2 = 0.031 #
gal_mu = 1.082 # mu = ( (1-kappa)^2 - g1^2 - g2^2 )^-1
psf_inner_fwhm = 0.6 # arcsec
psf_outer_fwhm = 2.3 # arcsec
psf_inner_fraction = 0.8 # fraction of total PSF flux in the inner Gaussian
psf_outer_fraction = 0.2 # fraction of total PSF flux in the inner Gaussian
ngal = 100
logger.info('Starting demo script 6 using:')
logger.info(' - real galaxies from catalog %r', cat_file_name)
logger.info(' - double Gaussian PSF')
logger.info(' - pixel scale = %.2f', pixel_scale)
logger.info(' - Applied gravitational shear = (%.3f,%.3f)', gal_g1,
gal_g2)
logger.info(' - Poisson noise (sky level = %.1e).', sky_level)
# Read in galaxy catalog
# Note: dir is the directory both for the catalog itself and also the directory prefix
# for the image files listed in the catalog.
# If the images are in a different directory, you may also specify image_dir, which gives
# the relative path from dir to wherever the images are located.
real_galaxy_catalog = galsim.RealGalaxyCatalog(cat_file_name, dir=dir)
# Preloading the header information usually speeds up subsequent access.
# Basically, it tells pyfits to read all the headers in once and save them, rather
# than re-open the galaxy catalog fits file each time you want to access a new galaxy.
# If you are doing more than a few galaxies, then it seems to be worthwhile.
real_galaxy_catalog.preload()
logger.info('Read in %d real galaxies from catalog',
real_galaxy_catalog.nobjects)
# Make the ePSF
# first make the double Gaussian PSF
psf1 = galsim.Gaussian(fwhm=psf_inner_fwhm, flux=psf_inner_fraction)
psf2 = galsim.Gaussian(fwhm=psf_outer_fwhm, flux=psf_outer_fraction)
psf = psf1 + psf2
# make the pixel response
pix = galsim.Pixel(pixel_scale)
# convolve PSF and pixel response function to get the effective PSF (ePSF)
epsf = galsim.Convolve([psf, pix])
# Draw this one with no noise.
epsf_image = epsf.draw(dx=pixel_scale)
# write to file
epsf_image.write(psf_file_name)
logger.info('Created ePSF and wrote to file %r', psf_file_name)
# Build the images
all_images = []
for k in range(ngal):
logger.debug('Start work on image %d', k)
t1 = time.time()
# Initialize the random number generator we will be using.
rng = galsim.UniformDeviate(random_seed + k)
gal = galsim.RealGalaxy(real_galaxy_catalog, index=k)
logger.debug(' Read in training sample galaxy and PSF from file')
t2 = time.time()
# Set the flux
gal.setFlux(gal_flux)
# Rotate by a random angle
theta = 2. * math.pi * rng() * galsim.radians
gal.applyRotation(theta)
# Apply the desired shear
gal.applyShear(g1=gal_g1, g2=gal_g2)
# Also apply a magnification mu = ( (1-kappa)^2 - |gamma|^2 )^-1
# This conserves surface brightness, so it scales both the area and flux.
gal.applyMagnification(gal_mu)
# Make the combined profile
final = galsim.Convolve([psf, pix, gal])
# Draw the profile
if k == 0:
im = final.draw(dx=pixel_scale)
xsize, ysize = im.array.shape
else:
im = galsim.ImageF(xsize, ysize)
final.draw(im, dx=pixel_scale)
logger.debug(' Drew image')
t3 = time.time()
# Add a constant background level
background = sky_level * pixel_scale**2
im += background
# Add Poisson noise. This time, we don't give a sky_level, since we have already
# added it to the image, so we don't want any more added. The sky_level parameter
# really defines how much _extra_ sky should be added above what is already in the image.
im.addNoise(galsim.PoissonNoise(rng))
logger.debug(' Added Poisson noise')
t4 = time.time()
# Store that into the list of all images
all_images += [im]
t5 = time.time()
logger.debug(' Times: %f, %f, %f, %f', t2 - t1, t3 - t2, t4 - t3,
t5 - t4)
logger.info('Image %d: size = %d x %d, total time = %f sec', k, xsize,
ysize, t5 - t1)
logger.info('Done making images of galaxies')
# Now write the image to disk.
# We write the images to a fits data cube.
galsim.fits.writeCube(all_images, cube_file_name)
logger.info('Wrote image to fits data cube %r', cube_file_name)
def main(argv):
"""
Make a fits image cube where each frame has two images of the same galaxy drawn
with regular FFT convolution and with photon shooting.
We do this for 5 different PSFs and 5 different galaxies, each with 4 different (random)
fluxes, sizes, and shapes.
"""
logging.basicConfig(format="%(message)s",
level=logging.INFO,
stream=sys.stdout)
logger = logging.getLogger("demo7")
# To turn off logging:
#logger.propagate = False
# Define some parameters we'll use below.
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
file_name = os.path.join('output', 'cube_phot.fits.gz')
random_seed = 553728
sky_level = 1.e4 # ADU / arcsec^2
pixel_scale = 0.28 # arcsec
nx = 64
ny = 64
gal_flux_min = 1.e4 # Range for galaxy flux
gal_flux_max = 1.e5
gal_hlr_min = 0.3 # arcsec
gal_hlr_max = 1.3 # arcsec
gal_e_min = 0. # Range for ellipticity
gal_e_max = 0.8
psf_fwhm = 0.65 # arcsec
# This script is set up as a comparison between using FFTs for doing the convolutions and
# shooting photons. The two methods have trade-offs in speed and accuracy which vary
# with the kind of profile being drawn and the S/N of the object, among other factors.
# In addition, for each method, there are a number of parameters GalSim uses that control
# aspects of the calculation that further affect the speed and accuracy.
#
# We encapsulate these parameters with an object called GSParams. The default values
# are intended to be accurate enough for normal precision shear tests, without sacrificing
# too much speed.
#
# Any PSF or galaxy object can be given a gsparams argument on construction that can
# have different values to make the calculation more or less accurate (typically trading
# off for speed or memory).
#
# In this script, we adjust some of the values slightly, just to show you how it works.
# You could play around with these values and see what effect they have on the drawn images.
# Usually, it requires a pretty drastic change in these parameters for you to be able to
# notice the difference by eye. But subtle effects that may impact the shapes of galaxies
# can happen well before then.
# Type help(galsim.GSParams) for the complete list of parameters and more detailed
# documentation, including the default values for each parameter.
gsparams = galsim.GSParams(
alias_threshold=
1.e-2, # maximum fractional flux that may be aliased around edge of FFT
maxk_threshold=
2.e-3, # k-values less than this may be excluded off edge of FFT
xvalue_accuracy=
1.e-4, # approximations in real space aim to be this accurate
kvalue_accuracy=
1.e-4, # approximations in fourier space aim to be this accurate
shoot_accuracy=
1.e-4, # approximations in photon shooting aim to be this accurate
minimum_fft_size=64) # minimum size of ffts
logger.info('Starting demo script 7')
# Make the pixel:
pix = galsim.Pixel(xw=pixel_scale)
# Make the PSF profiles:
psf1 = galsim.Gaussian(fwhm=psf_fwhm, gsparams=gsparams)
psf2 = galsim.Moffat(fwhm=psf_fwhm, beta=2.4, gsparams=gsparams)
psf3_inner = galsim.Gaussian(fwhm=psf_fwhm, flux=0.8, gsparams=gsparams)
psf3_outer = galsim.Gaussian(fwhm=2 * psf_fwhm,
flux=0.2,
gsparams=gsparams)
psf3 = psf3_inner + psf3_outer
atmos = galsim.Gaussian(fwhm=psf_fwhm, gsparams=gsparams)
optics = galsim.OpticalPSF(lam_over_diam=0.6 * psf_fwhm,
obscuration=0.4,
defocus=0.1,
astig1=0.3,
astig2=-0.2,
coma1=0.2,
coma2=0.1,
spher=-0.3,
gsparams=gsparams)
psf4 = galsim.Convolve([atmos, optics
]) # Convolve inherits the gsparams from the first
# item in the list. (Or you can supply a gsparams
# argument explicitly if you want to override this.)
atmos = galsim.Kolmogorov(fwhm=psf_fwhm, gsparams=gsparams)
optics = galsim.Airy(lam_over_diam=0.3 * psf_fwhm, gsparams=gsparams)
psf5 = galsim.Convolve([atmos, optics])
psfs = [psf1, psf2, psf3, psf4, psf5]
psf_names = [
"Gaussian", "Moffat", "Double Gaussian", "OpticalPSF",
"Kolmogorov * Airy"
]
psf_times = [0, 0, 0, 0, 0]
psf_fft_times = [0, 0, 0, 0, 0]
psf_phot_times = [0, 0, 0, 0, 0]
# Make the galaxy profiles:
gal1 = galsim.Gaussian(half_light_radius=1, gsparams=gsparams)
gal2 = galsim.Exponential(half_light_radius=1, gsparams=gsparams)
gal3 = galsim.DeVaucouleurs(half_light_radius=1, gsparams=gsparams)
gal4 = galsim.Sersic(half_light_radius=1, n=2.5, gsparams=gsparams)
bulge = galsim.Sersic(half_light_radius=0.7, n=3.2, gsparams=gsparams)
disk = galsim.Sersic(half_light_radius=1.2, n=1.5, gsparams=gsparams)
gal5 = 0.4 * bulge + 0.6 * disk # Net half-light radius is only approximate for this one.
gals = [gal1, gal2, gal3, gal4, gal5]
gal_names = [
"Gaussian", "Exponential", "Devaucouleurs", "n=2.5 Sersic",
"Bulge + Disk"
]
gal_times = [0, 0, 0, 0, 0]
gal_fft_times = [0, 0, 0, 0, 0]
gal_phot_times = [0, 0, 0, 0, 0]
# Other times to keep track of:
setup_times = 0
fft_times = 0
phot_times = 0
noise_times = 0
# Loop over combinations of psf, gal, and make 4 random choices for flux, size, shape.
all_images = []
k = 0
for ipsf in range(len(psfs)):
psf = psfs[ipsf]
psf_name = psf_names[ipsf]
for igal in range(len(gals)):
gal = gals[igal]
gal_name = gal_names[igal]
for i in range(4):
logger.debug('Start work on image %d', i)
t1 = time.time()
# Initialize the random number generator we will be using.
rng = galsim.UniformDeviate(random_seed + k)
# Get a new copy, we'll want to keep the original unmodified.
gal1 = gal.copy()
# Generate random variates:
flux = rng() * (gal_flux_max - gal_flux_min) + gal_flux_min
gal1.setFlux(flux)
hlr = rng() * (gal_hlr_max - gal_hlr_min) + gal_hlr_min
gal1.applyDilation(hlr)
beta_ellip = rng() * 2 * math.pi * galsim.radians
ellip = rng() * (gal_e_max - gal_e_min) + gal_e_min
gal_shape = galsim.Shear(e=ellip, beta=beta_ellip)
gal1.applyShear(gal_shape)
# Build the final object by convolving the galaxy, PSF and pixel response.
final = galsim.Convolve([psf, pix, gal1])
# For photon shooting, need a version without the pixel (see below).
final_nopix = galsim.Convolve([psf, gal1])
# Create the large, double width output image
image = galsim.ImageF(2 * nx + 2, ny)
# Rather than provide a dx= argument to the draw commands, we can also
# set the pixel scale in the image itself with setScale.
image.setScale(pixel_scale)
# Assign the following two "ImageViews", fft_image and phot_image.
# Using the syntax below, these are views into the larger image.
# Changes/additions to the sub-images referenced by the views are automatically
# reflected in the original image.
fft_image = image[galsim.BoundsI(1, nx, 1, ny)]
phot_image = image[galsim.BoundsI(nx + 3, 2 * nx + 2, 1, ny)]
logger.debug(
' Read in training sample galaxy and PSF from file')
t2 = time.time()
# Draw the profile
final.draw(fft_image)
logger.debug(
' Drew fft image. Total drawn flux = %f. .flux = %f',
fft_image.array.sum(), final.getFlux())
t3 = time.time()
# Add Poisson noise
sky_level_pixel = sky_level * pixel_scale**2
fft_image.addNoise(
galsim.PoissonNoise(rng, sky_level=sky_level_pixel))
t4 = time.time()
# The next two lines are just to get the output from this demo script
# to match the output from the parsing of demo7.yaml.
rng = galsim.UniformDeviate(random_seed + k)
rng()
rng()
rng()
rng()
# Repeat for photon shooting image.
# Photon shooting automatically convolves by the pixel, so we've made sure not
# to include it in the profile!
final_nopix.drawShoot(phot_image,
max_extra_noise=sky_level_pixel / 100,
rng=rng)
t5 = time.time()
# For photon shooting, galaxy already has Poisson noise, so we want to make
# sure not to add that noise again! Thus, we just add sky noise, which
# is Poisson with the mean = sky_level_pixel
pd = galsim.PoissonDeviate(rng, mean=sky_level_pixel)
# DeviateNoise just adds the action of the given deviate to every pixel.
phot_image.addNoise(galsim.DeviateNoise(pd))
# For PoissonDeviate, the mean is not zero, so for a background-subtracted
# image, we need to subtract the mean back off when we are done.
phot_image -= sky_level_pixel
logger.debug(
' Added Poisson noise. Image fluxes are now %f and %f',
fft_image.array.sum(), phot_image.array.sum())
t6 = time.time()
# Store that into the list of all images
all_images += [image]
k = k + 1
logger.info(
'%d: %s * %s, flux = %.2e, hlr = %.2f, ellip = (%.2f,%.2f)',
k, gal_name, psf_name, flux, hlr, gal_shape.getE1(),
gal_shape.getE2())
logger.debug(' Times: %f, %f, %f, %f, %f', t2 - t1, t3 - t2,
t4 - t3, t5 - t4, t6 - t5)
psf_times[ipsf] += t6 - t1
psf_fft_times[ipsf] += t3 - t2
psf_phot_times[ipsf] += t5 - t4
gal_times[igal] += t6 - t1
gal_fft_times[igal] += t3 - t2
gal_phot_times[igal] += t5 - t4
setup_times += t2 - t1
fft_times += t3 - t2
phot_times += t5 - t4
noise_times += t4 - t3 + t6 - t5
logger.info('Done making images of galaxies')
logger.info('')
logger.info('Some timing statistics:')
logger.info(' Total time for setup steps = %f', setup_times)
logger.info(' Total time for regular fft drawing = %f', fft_times)
logger.info(' Total time for photon shooting = %f', phot_times)
logger.info(' Total time for adding noise = %f', noise_times)
logger.info('')
logger.info('Breakdown by PSF type:')
for ipsf in range(len(psfs)):
logger.info(' %s: Total time = %f (fft: %f, phot: %f)',
psf_names[ipsf], psf_times[ipsf], psf_fft_times[ipsf],
psf_phot_times[ipsf])
logger.info('')
logger.info('Breakdown by Galaxy type:')
for igal in range(len(gals)):
logger.info(' %s: Total time = %f (fft: %f, phot: %f)',
gal_names[igal], gal_times[igal], gal_fft_times[igal],
gal_phot_times[igal])
logger.info('')
# Now write the image to disk.
# With any write command, you can optionally compress the file using several compression
# schemes:
# 'gzip' uses gzip on the full output file.
# 'bzip2' uses bzip2 on the full output file.
# 'rice' uses rice compression on the image, leaving the fits headers readable.
# 'gzip_tile' uses gzip in tiles on the output image, leaving the fits headers readable.
# 'hcompress' uses hcompress on the image, but it is only valid for 2-d data, so it
# doesn't work for writeCube.
# 'plio' uses plio on the image, but it is only valid for positive integer data.
# Furthermore, the first three have standard filename extensions associated with them,
# so if you don't specify a compression, but the filename ends with '.gz', '.bz2' or '.fz',
# the corresponding compression will be selected automatically.
# In other words, the `compression='gzip'` specification is actually optional here:
galsim.fits.writeCube(all_images, file_name, compression='gzip')
logger.info('Wrote fft image to fits data cube %r', file_name)
def main(argv):
"""
Make images to be used for characterizing the brighter-fatter effect
- Each fits file is 5 x 5 postage stamps.
- Each postage stamp is 40 x 40 pixels.
- There are 3 sets of 5 images each. The 5 images are at 5 different flux levels
- The three sets are (bf_1) B-F off, (bf_2) B-F on, diffusion off, (bf_3) B-F and diffusion on
- Each image is in output/bf_set/bf_nfile.fits, where set ranges from 1-3 and nfile ranges from 1-5.
"""
logging.basicConfig(format="%(message)s", level=logging.INFO, stream=sys.stdout)
logger = logging.getLogger("bf_plots")
# Add the wavelength info
bppath = "../../share/bandpasses/"
sedpath = "../../share/"
sed = galsim.SED(os.path.join(sedpath, 'CWW_E_ext.sed'), 'nm', 'flambda').thin()
# Add the directions (seems to work - CL)
fratio = 1.2
obscuration = 0.2
seed = 12345
assigner = galsim.FRatioAngles(fratio, obscuration, seed)
bandpass = galsim.Bandpass(os.path.join(bppath, 'LSST_r.dat'), 'nm').thin()
rng3 = galsim.BaseDeviate(1234)
sampler = galsim.WavelengthSampler(sed, bandpass, rng3)
# Define some parameters we'll use below.
# Normally these would be read in from some parameter file.
nx_tiles = 10 #
ny_tiles = 10 #
stamp_xsize = 40 #
stamp_ysize = 40 #
random_seed = 6424512 #
pixel_scale = 0.2 # arcsec / pixel
sky_level = 0.01 # ADU / arcsec^2
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
gal_sigma = 0.2 # arcsec
psf_sigma = 0.01 # arcsec
pixel_scale = 0.2 # arcsec / pixel
noise = 0.01 # standard deviation of the counts in each pixel
shift_radius = 0.2 # arcsec (=pixels)
logger.info('Starting bf_plots using:')
logger.info(' - image with %d x %d postage stamps',nx_tiles,ny_tiles)
logger.info(' - postage stamps of size %d x %d pixels',stamp_xsize,stamp_ysize)
logger.info(' - Centroid shifts up to = %.2f pixels',shift_radius)
rng = galsim.BaseDeviate(5678)
sensor1 = galsim.Sensor()
sensor2 = galsim.SiliconSensor(rng=rng, diffusion_factor=0.0)
sensor3 = galsim.SiliconSensor(rng=rng)
for set in range(1,4):
starttime = time.time()
exec("sensor = sensor%d"%set)
for nfile in range(1,6):
# Make bf_x directory if not already present.
if not os.path.isdir('output/bf_%d'%set):
os.mkdir('output/bf_%d'%set)
gal_file_name = os.path.join('output','bf_%d/bf_%d.fits'%(set,nfile))
sex_file_name = os.path.join('output','bf_%d/bf_%d_SEX.fits.cat.reg'%(set,nfile))
sexfile = open(sex_file_name, 'w')
gal_flux = 2.0e5 * nfile # total counts on the image
# Define the galaxy profile
gal = galsim.Gaussian(flux=gal_flux, sigma=gal_sigma)
logger.debug('Made galaxy profile')
# Define the PSF profile
psf = galsim.Gaussian(flux=1., sigma=psf_sigma) # PSF flux should always = 1
logger.debug('Made PSF profile')
# This profile is placed with different orientations and noise realizations
# at each postage stamp in the gal image.
gal_image = galsim.ImageF(stamp_xsize * nx_tiles-1 , stamp_ysize * ny_tiles-1,
scale=pixel_scale)
psf_image = galsim.ImageF(stamp_xsize * nx_tiles-1 , stamp_ysize * ny_tiles-1,
scale=pixel_scale)
shift_radius_sq = shift_radius**2
first_in_pair = True # Make pairs that are rotated by 90 degrees
k = 0
for iy in range(ny_tiles):
for ix in range(nx_tiles):
# The normal procedure for setting random numbers in GalSim is to start a new
# random number generator for each object using sequential seed values.
# This sounds weird at first (especially if you were indoctrinated by Numerical
# Recipes), but for the boost random number generator we use, the "random"
# number sequences produced from sequential initial seeds are highly uncorrelated.
#
# The reason for this procedure is that when we use multiple processes to build
# our images, we want to make sure that the results are deterministic regardless
# of the way the objects get parcelled out to the different processes.
#
# Of course, this script isn't using multiple processes, so it isn't required here.
# However, we do it nonetheless in order to get the same results as the config
# version of this demo script (demo5.yaml).
ud = galsim.UniformDeviate(random_seed+k)
# Any kind of random number generator can take another RNG as its first
# argument rather than a seed value. This makes both objects use the same
# underlying generator for their pseudo-random values.
#gd = galsim.GaussianDeviate(ud, sigma=gal_ellip_rms)
# The -1's in the next line are to provide a border of
# 1 pixel between postage stamps
b = galsim.BoundsI(ix*stamp_xsize+1 , (ix+1)*stamp_xsize-1,
iy*stamp_ysize+1 , (iy+1)*stamp_ysize-1)
sub_gal_image = gal_image[b]
sub_psf_image = psf_image[b]
# Great08 randomized the locations of the two galaxies in each pair,
# but for simplicity, we just do them in sequential postage stamps.
if first_in_pair:
# Use a random orientation:
beta = ud() * 2. * math.pi * galsim.radians
# Determine the ellipticity to use for this galaxy.
ellip = 0.0
first_in_pair = False
else:
# Use the previous ellip and beta + 90 degrees
beta += 90 * galsim.degrees
first_in_pair = True
# Make a new copy of the galaxy with an applied e1/e2-type distortion
# by specifying the ellipticity and a real-space position angle
this_gal = gal#gal.shear(e=ellip, beta=beta)
# Apply a random shift_radius:
rsq = 2 * shift_radius_sq
while (rsq > shift_radius_sq):
dx = (2*ud()-1) * shift_radius
dy = (2*ud()-1) * shift_radius
rsq = dx**2 + dy**2
this_gal = this_gal.shift(dx,dy)
# Note that the shifted psf that we create here is purely for the purpose of being able
# to draw a separate, shifted psf image. We do not use it when convolving the galaxy
# with the psf.
this_psf = psf.shift(dx,dy)
# Make the final image, convolving with the (unshifted) psf
final_gal = galsim.Convolve([psf,this_gal])
# Draw the image
if ix == 0 and iy == 0:
final_gal.drawImage(sub_gal_image, method = 'phot', sensor=sensor, surface_ops=[sampler, assigner], rng = rng, save_photons = True)
photon_file = os.path.join('output','bf_%d/bf_%d_nx_%d_ny_%d_photon_file.fits'%(set,nfile,ix,iy))
sub_gal_image.photons.write(photon_file)
else:
final_gal.drawImage(sub_gal_image, method = 'phot', sensor=sensor, surface_ops=[sampler, assigner], rng = rng)
# Now add an appropriate amount of noise to get our desired S/N
# There are lots of definitions of S/N, but here is the one used by Great08
# We use a weighted integral of the flux:
# S = sum W(x,y) I(x,y) / sum W(x,y)
# N^2 = Var(S) = sum W(x,y)^2 Var(I(x,y)) / (sum W(x,y))^2
# Now we assume that Var(I(x,y)) is constant so
# Var(I(x,y)) = noise_var
# We also assume that we are using a matched filter for W, so W(x,y) = I(x,y).
# Then a few things cancel and we find that
# S/N = sqrt( sum I(x,y)^2 / noise_var )
#
# The above procedure is encapsulated in the function image.addNoiseSNR which
# sets the flux appropriately given the variance of the noise model.
# In our case, noise_var = sky_level_pixel
sky_level_pixel = sky_level * pixel_scale**2
noise = galsim.PoissonNoise(ud, sky_level=sky_level_pixel)
#sub_gal_image.addNoiseSNR(noise, gal_signal_to_noise)
# Draw the PSF image
# No noise on PSF images. Just draw it as is.
this_psf.drawImage(sub_psf_image)
# For first instance, measure moments
"""
if ix==0 and iy==0:
psf_shape = sub_psf_image.FindAdaptiveMom()
temp_e = psf_shape.observed_shape.e
if temp_e > 0.0:
g_to_e = psf_shape.observed_shape.g / temp_e
else:
g_to_e = 0.0
logger.info('Measured best-fit elliptical Gaussian for first PSF image: ')
logger.info(' g1, g2, sigma = %7.4f, %7.4f, %7.4f (pixels)',
g_to_e*psf_shape.observed_shape.e1,
g_to_e*psf_shape.observed_shape.e2, psf_shape.moments_sigma)
"""
x = b.center().x
y = b.center().y
logger.info('Galaxy (%d,%d): center = (%.0f,%0.f) (e,beta) = (%.4f,%.3f)',
ix,iy,x,y,ellip,beta/galsim.radians)
k = k+1
sexline = 'circle %f %f %f\n'%(x+dx/pixel_scale,y+dy/pixel_scale,gal_sigma/pixel_scale)
sexfile.write(sexline)
sexfile.close()
logger.info('Done making images of postage stamps')
# Now write the images to disk.
#psf_image.write(psf_file_name)
#logger.info('Wrote PSF file %s',psf_file_name)
gal_image.write(gal_file_name)
logger.info('Wrote image to %r',gal_file_name) # using %r adds quotes around filename for us
finishtime = time.time()
print("Time to complete set %d = %.2f seconds\n"%(set, finishtime-starttime))
rng = galsim.UniformDeviate(random_seed + k + 1)
flux = rng() * (gal_flux_max - gal_flux_min) + gal_flux_min
this_gal = gal1.withFlux(flux)
hlr = rng() * (gal_hlr_max - gal_hlr_min) + gal_hlr_min
this_gal = this_gal.dilate(hlr)
this_gal = this_gal.shear(e1=e10[i], e2=e20[i]) #.shear(g1=gm1,g2=gm2)
final = galsim.Convolve([this_gal, psf])
print(rng())
image = galsim.ImageF(2 * nx + 2, ny, scale=pixel_scale)
fft_image = image[galsim.BoundsI(1, nx, 1, ny)]
phot_image = image[galsim.BoundsI(nx + 3, 2 * nx + 2, 1, ny)]
final.drawImage(fft_image, method='fft')
sky_level_pixel = sky_level * pixel_scale**2
fft_image.addNoise(galsim.PoissonNoise(
rng, sky_level=sky_level_pixel)) #add noise
rng = galsim.UniformDeviate(random_seed + k + 1)
rng()
rng()
rng()
rng()
final.drawImage(phot_image,method='phot',max_extra_noise=sky_level_pixel/100,\
rng=rng)
pd = galsim.PoissonDeviate(rng, mean=sky_level_pixel)
phot_image.addNoise(galsim.DeviateNoise(pd))
phot_image -= sky_level_pixel
imagea = image.array
galarray1.append(imagea[0:64, 0:64])
for i in range(n):
def main(argv):
"""
Make images using variable PSF and shear:
- The main image is 10 x 10 postage stamps.
- Each postage stamp is 48 x 48 pixels.
- The second HDU has the corresponding PSF image.
- Applied shear is from a power spectrum P(k) ~ k^1.8.
- Galaxies are real galaxies oriented in a ring test of 20 each.
- The PSF is Gaussian with FWHM, ellipticity and position angle functions of (x,y)
- Noise is Poisson using a nominal sky value of 1.e6.
"""
logging.basicConfig(format="%(message)s",
level=logging.INFO,
stream=sys.stdout)
logger = logging.getLogger("demo10")
# Define some parameters we'll use below.
# Normally these would be read in from some parameter file.
n_tiles = 10 # number of tiles in each direction.
stamp_size = 48 # pixels
pixel_scale = 0.44 # arcsec / pixel
sky_level = 1.e6 # ADU / arcsec^2
# The random seed is used for both the power spectrum realization and the random properties
# of the galaxies.
random_seed = 3339201
# Make output directory if not already present.
if not os.path.isdir('output'):
os.mkdir('output')
file_name = os.path.join('output', 'power_spectrum.fits')
# These will be created for each object below. The values we'll use will be functions
# of (x,y) relative to the center of the image. (r = sqrt(x^2+y^2))
# psf_fwhm = 0.9 + 0.5 * (r/100)^2 -- arcsec
# psf_e = 0.4 * (r/100)^1.5 -- large value at the edge, so visible by eye.
# psf_beta = atan2(y/x) + pi/2 -- tangential pattern
gal_dilation = 3 # Make the galaxies a bit larger than their original size.
gal_signal_to_noise = 100 # Pretty high.
psf_signal_to_noise = 1000 # Even higher.
logger.info('Starting demo script 10')
# Read in galaxy catalog
cat_file_name = 'real_galaxy_catalog_example.fits'
dir = 'data'
real_galaxy_catalog = galsim.RealGalaxyCatalog(cat_file_name, dir=dir)
logger.info('Read in %d real galaxies from catalog',
real_galaxy_catalog.nobjects)
# List of IDs to use. We select 5 particularly irregular galaxies for this demo.
# Then we'll choose randomly from this list.
id_list = [106416, 106731, 108402, 116045, 116448]
# Make the 5 galaxies we're going to use here rather than remake them each time.
# This means the Fourier transforms of the real galaxy images don't need to be recalculated
# each time, so it's a bit more efficient.
gal_list = [
galsim.RealGalaxy(real_galaxy_catalog, id=id) for id in id_list
]
# Make the galaxies a bit larger than their original observed size.
gal_list = [gal.dilate(gal_dilation) for gal in gal_list]
# Setup the PowerSpectrum object we'll be using:
ps = galsim.PowerSpectrum(lambda k: k**1.8)
# The argument here is "e_power_function" which defines the E-mode power to use.
# There is also a b_power_function if you want to include any B-mode power:
# ps = galsim.PowerSpectrum(e_power_function, b_power_function)
# You may even omit the e_power_function argument and have a pure B-mode power spectrum.
# ps = galsim.PowerSpectrum(b_power_function = b_power_function)
# All the random number generator classes derive from BaseDeviate.
# When we construct another kind of deviate class from any other
# kind of deviate class, the two share the same underlying random number
# generator. Sometimes it can be clearer to just construct a BaseDeviate
# explicitly and then construct anything else you need from that.
# Note: A BaseDeviate cannot be used to generate any values. It can
# only be used in the constructor for other kinds of deviates.
# The seeds for the objects are random_seed..random_seed+nobj-1 (which comes later),
# so use the next one.
nobj = n_tiles * n_tiles
rng = galsim.BaseDeviate(random_seed + nobj)
# Setup the images:
gal_image = galsim.ImageF(stamp_size * n_tiles, stamp_size * n_tiles)
psf_image = galsim.ImageF(stamp_size * n_tiles, stamp_size * n_tiles)
# Update the image WCS to use the image center as the origin of the WCS.
# The class that acts like a PixelScale except for this offset is called OffsetWCS.
im_center = gal_image.bounds.trueCenter()
wcs = galsim.OffsetWCS(scale=pixel_scale, origin=im_center)
gal_image.wcs = wcs
psf_image.wcs = wcs
# We will place the tiles in a random order. To do this, we make two lists for the
# ix and iy values. Then we apply a random permutation to the lists (in tandem).
ix_list = []
iy_list = []
for ix in range(n_tiles):
for iy in range(n_tiles):
ix_list.append(ix)
iy_list.append(iy)
# This next function will use the given random number generator, rng, and use it to
# randomly permute any number of lists. All lists will have the same random permutation
# applied.
galsim.random.permute(rng, ix_list, iy_list)
# Now have the PowerSpectrum object build a grid of shear values for us to use.
# Also, because of some technical details about how the config stuff handles the random
# number generator here, we need to duplicate the rng object if we want to have the
# two output files match. This means that technically, the same sequence of random numbers
# will be used in building the grid as will be used by the other uses of rng (permuting the
# postage stamps and adding noise). But since they are used in such completely different
# ways, it is hard to imagine how this could lead to any kind of bias in the images.
grid_g1, grid_g2 = ps.buildGrid(grid_spacing=stamp_size * pixel_scale,
ngrid=n_tiles,
rng=rng.duplicate())
# Build each postage stamp:
for k in range(nobj):
# The usual random number generator using a different seed for each galaxy.
rng = galsim.BaseDeviate(random_seed + k)
# Determine the bounds for this stamp and its center position.
ix = ix_list[k]
iy = iy_list[k]
b = galsim.BoundsI(ix * stamp_size + 1, (ix + 1) * stamp_size,
iy * stamp_size + 1, (iy + 1) * stamp_size)
sub_gal_image = gal_image[b]
sub_psf_image = psf_image[b]
pos = wcs.toWorld(b.trueCenter())
# The image comes out as about 211 arcsec across, so we define our variable
# parameters in terms of (r/100 arcsec), so roughly the scale size of the image.
r = math.sqrt(pos.x**2 + pos.y**2) / 100
psf_fwhm = 0.9 + 0.5 * r**2 # arcsec
psf_e = 0.4 * r**1.5
psf_beta = (math.atan2(pos.y, pos.x) + math.pi / 2) * galsim.radians
# Define the PSF profile
psf = galsim.Gaussian(fwhm=psf_fwhm)
psf = psf.shear(e=psf_e, beta=psf_beta)
# Define the galaxy profile:
# For this demo, we are doing a ring test where the same galaxy profile is drawn at many
# orientations stepped uniformly in angle, making a ring in e1-e2 space.
# We're drawing each profile at 20 different orientations and then skipping to the
# next galaxy in the list. So theta steps by 1/20 * 360 degrees:
theta = k / 20. * 360. * galsim.degrees
# The index needs to increment every 20 objects so we use k/20 using integer math.
index = k / 20
gal = gal_list[index]
# This makes a new copy so we're not changing the object in the gal_list.
gal = gal.rotate(theta)
# Apply the shear from the power spectrum. We should either turn the gridded shears
# grid_g1[iy, ix] and grid_g2[iy, ix] into gridded reduced shears using a utility called
# galsim.lensing.theoryToObserved, or use ps.getShear() which by default gets the reduced
# shear. ps.getShear() is also more flexible because it can get the shear at positions that
# are not on the original grid, as long as they are contained within the bounds of the full
# grid. So in this example we'll use ps.getShear().
alt_g1, alt_g2 = ps.getShear(pos)
gal = gal.shear(g1=alt_g1, g2=alt_g2)
# Apply half-pixel shift in a random direction.
shift_r = pixel_scale * 0.5
ud = galsim.UniformDeviate(rng)
theta = ud() * 2. * math.pi
dx = shift_r * math.cos(theta)
dy = shift_r * math.sin(theta)
gal = gal.shift(dx, dy)
# Make the final image, convolving with the psf
final = galsim.Convolve([psf, gal])
# Draw the image
final.drawImage(sub_gal_image)
# Now add noise to get our desired S/N
# See demo5.py for more info about how this works.
sky_level_pixel = sky_level * pixel_scale**2
noise = galsim.PoissonNoise(rng, sky_level=sky_level_pixel)
sub_gal_image.addNoiseSNR(noise, gal_signal_to_noise)
# For the PSF image, we also shift the PSF by the same amount.
psf = psf.shift(dx, dy)
# Draw the PSF image:
# We use real space integration over the pixels to avoid some of the
# artifacts that can show up with Fourier convolution.
# The level of the artifacts is quite low, but when drawing with
# so little noise, they are apparent with ds9's zscale viewing.
psf.drawImage(sub_psf_image, method='real_space')
# Again, add noise, but at higher S/N this time.
sub_psf_image.addNoiseSNR(noise, psf_signal_to_noise)
logger.info('Galaxy (%d,%d): position relative to center = %s', ix, iy,
str(pos))
logger.info('Done making images of postage stamps')
# Now write the images to disk.
images = [gal_image, psf_image]
galsim.fits.writeMulti(images, file_name)
logger.info('Wrote image to %r', file_name)
