def simulator_from_instrument(instrument):
"""Determine the pixel scale from an instrument based on real observations.
These options are representative of VRO, Euclid, HST, over-sampled HST and Adaptive Optics image.
Parameters
----------
instrument : str
A string giving the resolution of the desired instrument (VRO | Euclid | HST | HST_Up | AO).
"""
uv_wavelengths = instrument_util.uv_wavelengths_from_instrument(
instrument=instrument
)
grid = instrument_util.grid_from_instrument(instrument=instrument)
if instrument in "sma":
return al.SimulatorInterferometer(
uv_wavelengths=uv_wavelengths,
exposure_time_map=al.Array.full(fill_value=100.0, shape_2d=grid.shape_2d),
background_sky_map=al.Array.full(fill_value=1.0, shape_2d=grid.shape_2d),
noise_sigma=0.01,
)
else:
raise ValueError("An invalid data_name resolution was entered - ", instrument)
def test__from_tracer__same_as_tracer_input(self):
grid = al.Grid2D.uniform(shape_native=(20, 20),
pixel_scales=0.05,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(intensity=1.0),
mass=al.mp.EllIsothermal(einstein_radius=1.6),
)
source_galaxy = al.Galaxy(redshift=1.0,
light=al.lp.EllSersic(intensity=0.3))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
exposure_time=10000.0,
noise_sigma=0.1,
noise_seed=1,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer_via_image = simulator.via_image_from(
image=tracer.image_2d_from(grid=grid))
assert (interferometer.visibilities ==
interferometer_via_image.visibilities).all()
assert (interferometer.uv_wavelengths ==
interferometer_via_image.uv_wavelengths).all()
assert (interferometer.noise_map == interferometer_via_image.noise_map
).all()
def test__simulate_interferometer_from_lens__source_galaxy__compare_to_interferometer(
self):
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllipticalIsothermal(centre=(0.0, 0.0),
einstein_radius=1.6,
elliptical_comps=(0.17647, 0.0)),
)
source_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(
centre=(0.1, 0.1),
elliptical_comps=(0.096225, -0.055555),
intensity=0.3,
effective_radius=1.0,
sersic_index=2.5,
),
)
grid = al.Grid.uniform(shape_2d=(11, 11),
pixel_scales=0.05,
sub_size=1)
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
exposure_time_map=al.Array.full(fill_value=10000.0,
shape_2d=grid.shape_2d),
background_sky_map=al.Array.full(fill_value=100.0,
shape_2d=grid.shape_2d),
noise_sigma=0.1,
noise_seed=1,
)
interferometer = simulator.from_galaxies_and_grid(
galaxies=[lens_galaxy, source_galaxy], grid=grid)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
interferometer_via_image = simulator.from_image(
image=tracer.image_from_grid(grid=grid))
assert interferometer.visibilities == pytest.approx(
interferometer_via_image.visibilities, 1.0e-4)
assert (interferometer.uv_wavelengths ==
interferometer_via_image.uv_wavelengths).all()
assert (interferometer_via_image.noise_map == interferometer.noise_map
).all()
def test__simulate_interferometer_data_and_fit__known_likelihood():
mask = al.Mask2D.circular(radius=3.0,
shape_native=(31, 31),
pixel_scales=0.2,
sub_size=1)
grid = al.Grid2D.from_mask(mask=mask)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.8),
)
source_galaxy_0 = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(16, 16)),
regularization=al.reg.Constant(coefficient=(1.0)),
)
source_galaxy_1 = al.Galaxy(
redshift=2.0,
pixelization=al.pix.Rectangular(shape=(16, 16)),
regularization=al.reg.Constant(coefficient=(1.0)),
)
tracer = al.Tracer.from_galaxies(
galaxies=[lens_galaxy, source_galaxy_0, source_galaxy_1])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_seed=1,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(
transformer_class=al.TransformerDFT))
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit.figure_of_merit == pytest.approx(-5.433894158056919, 1.0e-2)
def simulate_function(instance):
"""
Set up the `Tracer` which is used to simulate the strong lens interferometer, which may include the subhalo in
addition to the lens and source galaxy.
"""
tracer = al.Tracer.from_galaxies(
galaxies=[
instance.galaxies.lens,
instance.perturbation,
instance.galaxies.source,
]
)
"""
Set up the grid, uv_wavelengths and simulator settings used to simulate interferometer dataset of the strong lens.
These should be tuned to match the S/N and noise properties of the observed data you are performing sensitivity
mapping on.
"""
grid = al.Grid2DIterate.uniform(
shape_native=real_space_mask.shape_native,
pixel_scales=real_space_mask.pixel_scales,
fractional_accuracy=0.9999,
sub_steps=[2, 4, 8, 16, 24],
)
simulator = al.SimulatorInterferometer(
uv_wavelengths=interferometer.uv_wavelengths,
exposure_time=300.0,
background_sky_level=0.1,
noise_sigma=0.1,
transformer_class=al.TransformerNUFFT,
)
simulated_interferometer = simulator.from_tracer_and_grid(tracer=tracer, grid=grid)
"""
The data generated by the simulate function is that which is fitted, so we should apply the mask for the analysis
here before we return the simulated data.
"""
return al.Interferometer(
visibilities=simulated_interferometer.visibilities,
noise_map=simulated_interferometer.noise_map,
uv_wavelengths=simulated_interferometer.uv_wavelengths,
real_space_mask=real_space_mask,
)
def test__from_deflections_and_galaxies__same_as_calculation_using_tracer(
self):
grid = al.Grid.uniform(shape_2d=(20, 20),
pixel_scales=0.05,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5, mass=al.mp.EllipticalIsothermal(einstein_radius=1.6))
source_galaxy = al.Galaxy(redshift=1.0,
light=al.lp.EllipticalSersic(intensity=0.3))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
exposure_time_map=al.Array.full(fill_value=10000.0,
shape_2d=grid.shape_2d),
background_sky_map=al.Array.full(fill_value=100.0,
shape_2d=grid.shape_2d),
noise_sigma=0.1,
noise_seed=1,
)
interferometer = simulator.from_deflections_and_galaxies(
deflections=tracer.deflections_from_grid(grid=grid),
galaxies=[source_galaxy],
)
interferometer_via_image = simulator.from_image(
image=tracer.image_from_grid(grid=grid))
assert (interferometer.visibilities ==
interferometer_via_image.visibilities).all()
assert (interferometer_via_image.uv_wavelengths ==
interferometer.uv_wavelengths).all()
assert (interferometer.noise_map == interferometer_via_image.noise_map
).all()
def test__simulate_interferometer_data_and_fit__chi_squared_is_0__noise_normalization_correct(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
light=al.lp.EllExponential(centre=(0.1, 0.1),
intensity=0.5))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.from_tracer_and_grid(tracer=tracer, grid=grid)
file_path = path.join(
"{}".format(path.dirname(path.realpath(__file__))),
"data_temp",
"simulate_and_fit",
)
try:
shutil.rmtree(file_path)
except FileNotFoundError:
pass
if path.exists(file_path) is False:
os.makedirs(file_path)
interferometer.output_to_fits(
visibilities_path=path.join(file_path, "visibilities.fits"),
noise_map_path=path.join(file_path, "noise_map.fits"),
uv_wavelengths_path=path.join(file_path, "uv_wavelengths.fits"),
)
real_space_mask = al.Mask2D.unmasked(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=2)
interferometer = al.Interferometer.from_fits(
visibilities_path=path.join(file_path, "visibilities.fits"),
noise_map_path=path.join(file_path, "noise_map.fits"),
uv_wavelengths_path=path.join(file_path, "uv_wavelengths.fits"),
real_space_mask=real_space_mask,
)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(
transformer_class=al.TransformerDFT))
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
interferometer=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert fit.chi_squared == pytest.approx(0.0)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0001)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
interferometer=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert abs(fit.chi_squared) < 1.0e-4
file_path = path.join("{}".format(path.dirname(path.realpath(__file__))),
"data_temp")
if path.exists(file_path) is True:
shutil.rmtree(file_path)
To perform the Fourier transform we need the wavelengths of the baselines, which we'll load from the fits file below.
By default we use baselines from the Square Mile Array (SMA), which produces low resolution interferometer data that
can be fitted extremely efficiently. The `autolens_workspace` includes ALMA uv_wavelengths files for simulating
much high resolution datasets (which can be performed by replacing "sma.fits" below with "alma.fits").
"""
uv_wavelengths_path = path.join("dataset", dataset_type, "uv_wavelengths")
uv_wavelengths = al.util.array_1d.numpy_array_1d_via_fits_from(
file_path=path.join(uv_wavelengths_path, "sma.fits"), hdu=0)
"""
To simulate the interferometer dataset we first create a simulator, which defines the exposure time, noise levels
and Fourier transform method used in the simulation.
"""
simulator = al.SimulatorInterferometer(
uv_wavelengths=uv_wavelengths,
exposure_time=300.0,
noise_sigma=1000.0,
transformer_class=al.TransformerDFT,
)
"""
__Ray Tracing__
Setup the lens galaxy's mass (SIE+Shear) and source galaxy light (elliptical Sersic) for this simulated lens.
For lens modeling, defining ellipticity in terms of the `elliptical_comps` improves the model-fitting procedure.
However, for simulating a strong lens you may find it more intuitive to define the elliptical geometry using the
axis-ratio of the profile (axis_ratio = semi-major axis / semi-minor axis = b/a) and position angle, where angle is
in degrees and defined counter clockwise from the positive x-axis.
We can use the **PyAutoLens** `convert` module to determine the elliptical components from the axis-ratio and angle.
"""
def test__simulate_interferometer_data_and_fit__linear_light_profiles_and_pixelization(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=100.0),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(intensity=0.1, sersic_index=1.0),
disk=al.lp.EllSersic(intensity=0.2, sersic_index=4.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.array([
[0.04, 200.0, 0.3, 400000.0, 60000000.0],
[0.00003, 500.0, 600000.0, 0.1, 75555555],
]),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(grid_class=al.Grid2D,
transformer_class=al.TransformerDFT,
sub_size=1))
lens_galaxy_linear = al.Galaxy(
redshift=0.5,
light=al.lp_linear.EllSersic(centre=(0.1, 0.1)),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy_pix = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(coefficient=0.01),
)
tracer_linear = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_linear, source_galaxy_pix])
fit_linear = al.FitInterferometer(
dataset=interferometer,
tracer=tracer_linear,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_linear.inversion.reconstruction == pytest.approx(
np.array([
1.00338472e02,
9.55074606e-02,
9.24767167e-02,
9.45392540e-02,
1.41969109e-01,
1.41828976e-01,
1.41521130e-01,
1.84257307e-01,
1.85507562e-01,
1.83726575e-01,
]),
1.0e-2,
)
assert fit_linear.figure_of_merit == pytest.approx(-29.20551989, 1.0e-4)
lens_galaxy_image = lens_galaxy.image_2d_from(grid=interferometer.grid)
assert fit_linear.galaxy_model_image_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_image, 1.0e-2)
traced_grid_2d_list = tracer.traced_grid_2d_list_from(
grid=interferometer.grid)
source_galaxy_image = source_galaxy.image_2d_from(
grid=traced_grid_2d_list[1])
def test__simulate_interferometer_data_and_fit__linear_light_profiles_agree_with_standard_light_profiles(
):
grid = al.Grid2D.uniform(shape_native=(51, 51),
pixel_scales=0.1,
sub_size=1)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(intensity=0.1, sersic_index=1.0),
disk=al.lp.EllSersic(intensity=0.2, sersic_index=4.0),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.array([
[0.04, 200.0, 0.3, 400000.0, 60000000.0],
[0.00003, 500.0, 600000.0, 0.1, 75555555],
]),
transformer_class=al.TransformerDFT,
exposure_time=300.0,
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=grid)
interferometer = interferometer.apply_settings(
settings=al.SettingsInterferometer(grid_class=al.Grid2D,
transformer_class=al.TransformerDFT,
sub_size=1))
fit = al.FitInterferometer(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
lens_galaxy_linear = al.Galaxy(
redshift=0.5,
light=al.lp_linear.EllSersic(centre=(0.1, 0.1)),
mass=al.mp.EllIsothermal(centre=(0.1, 0.1), einstein_radius=1.0),
)
source_galaxy_linear = al.Galaxy(
redshift=1.0,
bulge=al.lp_linear.EllSersic(sersic_index=1.0),
disk=al.lp_linear.EllSersic(sersic_index=4.0),
)
tracer_linear = al.Tracer.from_galaxies(
galaxies=[lens_galaxy_linear, source_galaxy_linear])
fit_linear = al.FitInterferometer(
dataset=interferometer,
tracer=tracer_linear,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=False),
)
assert fit_linear.inversion.reconstruction == pytest.approx(
np.array([0.1, 0.1, 0.2]), 1.0e-4)
assert fit_linear.linear_light_profile_intensity_dict[
lens_galaxy_linear.light] == pytest.approx(0.1, 1.0e-2)
assert fit_linear.linear_light_profile_intensity_dict[
source_galaxy_linear.bulge] == pytest.approx(0.1, 1.0e-2)
assert fit_linear.linear_light_profile_intensity_dict[
source_galaxy_linear.disk] == pytest.approx(0.2, 1.0e-2)
assert fit.log_likelihood == fit_linear.log_likelihood
lens_galaxy_image = lens_galaxy.image_2d_from(grid=interferometer.grid)
assert fit_linear.galaxy_model_image_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_image, 1.0e-4)
traced_grid_2d_list = tracer.traced_grid_2d_list_from(
grid=interferometer.grid)
source_galaxy_image = source_galaxy.image_2d_from(
grid=traced_grid_2d_list[1])
assert fit_linear.galaxy_model_image_dict[
source_galaxy_linear] == pytest.approx(source_galaxy_image, 1.0e-4)
lens_galaxy_visibilities = lens_galaxy.visibilities_via_transformer_from(
grid=interferometer.grid, transformer=interferometer.transformer)
assert fit_linear.galaxy_model_visibilities_dict[
lens_galaxy_linear] == pytest.approx(lens_galaxy_visibilities, 1.0e-4)
source_galaxy_visibilities = source_galaxy.visibilities_via_transformer_from(
grid=traced_grid_2d_list[1], transformer=interferometer.transformer)
assert fit_linear.galaxy_model_visibilities_dict[
source_galaxy_linear] == pytest.approx(source_galaxy_visibilities,
1.0e-4)
can be fitted extremely efficiently. The `autolens_workspace` includes ALMA uv_wavelengths files for simulating
much high resolution datasets (which can be performed by replacing "sma.fits" below with "alma.fits").
"""
uv_wavelengths_path = path.join("dataset", dataset_type, "uv_wavelengths")
uv_wavelengths = al.util.array_1d.numpy_array_1d_from_fits(
file_path=path.join(uv_wavelengths_path, "sma.fits"), hdu=0
)
"""
To simulate the interferometer dataset we first create a simulator, which defines the shape, resolution and pixel-scale
of the visibilities that are simulated, as well as its exposure time, noise levels and uv-wavelengths.
"""
simulator = al.SimulatorInterferometer(
uv_wavelengths=uv_wavelengths,
exposure_time=300.0,
background_sky_level=0.1,
noise_sigma=0.1,
transformer_class=al.TransformerNUFFT,
)
"""
__Ray Tracing__
Setup the lens galaxy's mass (SIE+Shear), subhalo (NFW) and source galaxy light (elliptical Sersic) for this
simulated lens.
For lens modeling, defining ellipticity in terms of the `elliptical_comps` improves the model-fitting procedure.
However, for simulating a strong lens you may find it more intuitive to define the elliptical geometry using the
axis-ratio of the profile (axis_ratio = semi-major axis / semi-minor axis = b/a) and position angle, where angle is
in degrees and defined counter clockwise from the positive x-axis.
def test__simulate_interferometer_data_and_fit__chi_squared_is_0__noise_normalization_correct(
):
grid = al.Grid.uniform(shape_2d=(51, 51), pixel_scales=0.1, sub_size=2)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllipticalIsothermal(centre=(0.1, 0.1),
einstein_radius=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalExponential(centre=(0.1, 0.1), intensity=0.5),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
simulator = al.SimulatorInterferometer(
uv_wavelengths=np.ones(shape=(7, 2)),
transformer_class=al.TransformerDFT,
exposure_time_map=al.Array.full(fill_value=300.0,
shape_2d=grid.shape_2d),
background_sky_map=al.Array.zeros(shape_2d=grid.shape_2d),
noise_if_add_noise_false=1.0,
noise_sigma=None,
)
interferometer = simulator.from_tracer_and_grid(tracer=tracer, grid=grid)
path = "{}/data_temp/simulate_and_fit".format(
os.path.dirname(os.path.realpath(
__file__))) # Setup path so we can output the simulated image.
try:
shutil.rmtree(path)
except FileNotFoundError:
pass
if os.path.exists(path) is False:
os.makedirs(path)
interferometer.output_to_fits(
visibilities_path=path + "/visibilities.fits",
noise_map_path=f"{path}/noise_map.fits",
uv_wavelengths_path=path + "/uv_wavelengths.fits",
)
interferometer = al.Interferometer.from_fits(
visibilities_path=path + "/visibilities.fits",
noise_map_path=f"{path}/noise_map.fits",
uv_wavelengths_path=path + "/uv_wavelengths.fits",
)
visibilities_mask = np.full(fill_value=False, shape=(7, 2))
real_space_mask = al.Mask.unmasked(shape_2d=(51, 51),
pixel_scales=0.1,
sub_size=2)
masked_interferometer = al.MaskedInterferometer(
interferometer=interferometer,
visibilities_mask=visibilities_mask,
real_space_mask=real_space_mask,
settings=al.SettingsMaskedInterferometer(
transformer_class=al.TransformerDFT),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert fit.chi_squared == pytest.approx(0.0)
pix = al.pix.Rectangular(shape=(7, 7))
reg = al.reg.Constant(coefficient=0.0001)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1),
mass=al.mp.EllipticalIsothermal(centre=(0.1, 0.1),
einstein_radius=1.0),
)
source_galaxy = al.Galaxy(redshift=1.0,
pixelization=pix,
regularization=reg)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.FitInterferometer(
masked_interferometer=masked_interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
assert abs(fit.chi_squared) < 1.0e-4
path = "{}/data_temp".format(os.path.dirname(os.path.realpath(
__file__))) # Setup path so we can output the simulated image.
if os.path.exists(path) == True:
shutil.rmtree(path)
The **PyAutoLens** visualization library and `FitInterferometer` object includes specific methods for plotting the
results.
"""
fit_interferometer_plotter = aplt.FitInterferometerPlotter(
fit=result.max_log_likelihood_fit)
fit_interferometer_plotter.subplot_fit_interferometer()
fit_interferometer_plotter.subplot_fit_dirty_images()
"""
__Simulation__3
Simulated interferometer datasets can be generated using the ``SimulatorInterferometer`` object, which includes adding
Gaussian noise to the visibilities:
"""
simulator = al.SimulatorInterferometer(
uv_wavelengths=interferometer.uv_wavelengths,
exposure_time=300.0,
background_sky_level=1.0,
noise_sigma=0.01,
)
real_space_grid = al.Grid2D.uniform(shape_native=real_space_mask.shape_native,
pixel_scales=real_space_mask.pixel_scales)
interferometer = simulator.via_tracer_from(tracer=tracer, grid=real_space_grid)
"""
__Wrap Up__
The `interferometer` package of the `autolens_workspace` contains numerous example scripts for performing
interferometer modeling and simulating strong lens interferometer datasets.
"""
