import autoarray as aa
from autolens.lens.ray_tracing import Tracer
[docs]class SimulatorImaging(aa.SimulatorImaging):
[docs] def __init__(
self,
exposure_time: float,
background_sky_level: float = 0.0,
psf: aa.Kernel2D = None,
normalize_psf: bool = True,
read_noise: float = None,
add_poisson_noise: bool = True,
noise_if_add_noise_false: float = 0.1,
noise_seed: int = -1,
):
"""
A class representing a Imaging observation, using the shape of the image, the pixel scale,
psf, exposure time, etc.
Parameters
----------
psf : Kernel2D
An arrays describing the PSF kernel of the image.
exposure_time
The exposure time of the simulated imaging.
background_sky_level
The level of the background sky of the simulated imaging.
normalize_psf
If `True`, the PSF kernel is normalized so all values sum to 1.0.
read_noise
The level of read-noise added to the simulated imaging by drawing from a Gaussian distribution with
sigma equal to the value `read_noise`.
add_poisson_noise
Whether Poisson noise corresponding to photon count statistics on the imaging observation is added.
noise_if_add_noise_false
If noise is not added to the simulated dataset a `noise_map` must still be returned. This value gives
the value of noise assigned to every pixel in the noise-map.
noise_seed
The random seed used to add random noise, where -1 corresponds to a random seed every run.
"""
super().__init__(
psf=psf,
exposure_time=exposure_time,
background_sky_level=background_sky_level,
normalize_psf=normalize_psf,
read_noise=read_noise,
add_poisson_noise=add_poisson_noise,
noise_if_add_noise_false=noise_if_add_noise_false,
noise_seed=noise_seed,
)
def via_tracer_from(self, tracer, grid, name=None):
"""
Returns a realistic simulated image by applying effects to a plain simulated image.
Parameters
----------
name
image
The image before simulating (e.g. the lens and source galaxies before optics blurring and Imaging read-out).
pixel_scales
The scale of each pixel in arc seconds
exposure_time_map
An arrays representing the effective exposure time of each pixel.
psf: PSF
An arrays describing the PSF the simulated image is blurred with.
background_sky_map
The value of background sky in every image pixel (electrons per second).
add_poisson_noise: Bool
If `True` poisson noise_maps is simulated and added to the image, based on the total counts in each image
pixel
noise_seed: int
A seed for random noise_maps generation
"""
tracer.set_snr_of_snr_light_profiles(
grid=grid,
exposure_time=self.exposure_time,
background_sky_level=self.background_sky_level,
)
image = tracer.padded_image_2d_from(
grid=grid, psf_shape_2d=self.psf.shape_native
)
imaging = self.via_image_from(image=image.binned, name=name)
return imaging.trimmed_after_convolution_from(
kernel_shape=self.psf.shape_native
)
def via_galaxies_from(self, galaxies, grid, name=None):
"""
Simulate imaging data for this data, as follows:
1) Setup the image-plane grid of the Imaging arrays, which defines the coordinates used for the ray-tracing.
2) Use this grid and the lens and source galaxies to setup a tracer, which generates the image of \
the simulated imaging data.
3) Simulate the imaging data, using a special image which ensures edge-effects don't
degrade simulator of the telescope optics (e.g. the PSF convolution).
4) Plot the image using Matplotlib, if the plot_imaging bool is True.
5) Output the dataset to .fits format if a dataset_path and data_name are specified. Otherwise, return the simulated \
imaging data instance.
"""
tracer = Tracer.from_galaxies(galaxies=galaxies)
return self.via_tracer_from(tracer=tracer, grid=grid, name=name)
def via_deflections_and_galaxies_from(self, deflections, galaxies, name=None):
grid = aa.Grid2D.uniform(
shape_native=deflections.shape_native,
pixel_scales=deflections.pixel_scales,
sub_size=1,
)
deflected_grid = grid - deflections.binned
image = sum(map(lambda g: g.image_2d_from(grid=deflected_grid), galaxies))
return self.via_image_from(image=image, name=name)