def test__determines_if_pixelization_is_same_as_previous_phase(
self, imaging_7x7, mask_7x7):
results = mock_pipeline.MockResults()
results.last.hyper_combined.preload_sparse_grids_of_planes = 1
phase_imaging_7x7 = al.PhaseImaging(phase_name="test_phase")
results.last.pixelization = None
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
phase_imaging_7x7 = al.PhaseImaging(phase_name="test_phase")
results.last.pixelization = al.pix.Rectangular
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=[
al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular,
regularization=al.reg.Constant,
)
],
)
results.last.pixelization = None
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes is None
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=[
al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular,
regularization=al.reg.Constant,
)
],
)
results.last.pixelization = al.pix.Rectangular
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.preload_sparse_grids_of_planes == 1
slacs = slacs.drop([lens_name[i]], axis=0)
## calculating errors on power law slope
for i in range(len(lens)):
lower_error = results.loc[lens[i]]['param']['slope'] - results.loc[
lens[i]]['-error']['slope']
upper_error = results.loc[lens[i]]['+error']['slope'] - results.loc[
lens[i]]['param']['slope']
error_low.append(lower_error)
error_hi.append(upper_error)
for i in range(len(lens)):
lens_galaxy = al.Galaxy(mass=al.mp.EllipticalPowerLaw(
centre=(results.loc[lens[i]]['param']['centre_0'],
results.loc[lens[i]]['param']['centre_1']),
axis_ratio=results.loc[lens[i]]['param']['axis_ratio'],
phi=results.loc[lens[i]]['param']['phi'],
einstein_radius=results.loc[lens[i]]['param']['einstein_radius'],
slope=results.loc[lens[i]]['param']['slope']),
redshift=slacs['z_lens'][i])
einstein_radius = lens_galaxy.einstein_radius_in_units(
unit_length='arcsec')
gamma = results.loc[lens[i]]['param']['slope']
axis_ratio = results.loc[lens[i]]['param']['axis_ratio']
gamma_diff_frac = (results.loc[lens[i]]['param']['slope'] -
slacs['gamma'][i]) / slacs['gamma'][i]
gamma_diff = results.loc[lens[i]]['param']['slope'] - slacs['gamma'][i]
axis_ratio_diff = results.loc[
lens[i]]['param']['axis_ratio'] - slacs['q_SIE'][i]
def test__gal_data_7x7_convergence(self, gal_data_7x7, sub_mask_7x7):
galaxy_fit_data = al.GalaxyFitData(galaxy_data=gal_data_7x7,
mask=sub_mask_7x7,
use_convergence=True)
assert galaxy_fit_data.pixel_scale == 1.0
assert (galaxy_fit_data.image(return_in_2d=True,
return_masked=False) == np.ones(
(7, 7))).all()
assert (galaxy_fit_data.noise_map(return_in_2d=True,
return_masked=False) == 2.0 *
np.ones((7, 7))).all()
assert (galaxy_fit_data._image_1d == np.ones(9)).all()
assert (galaxy_fit_data._noise_map_1d == 2.0 * np.ones(9)).all()
assert (galaxy_fit_data._mask_1d == np.full(fill_value=False,
shape=(9))).all()
assert (galaxy_fit_data.mask == np.array([
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
[True, True, False, False, False, True, True],
[True, True, False, False, False, True, True],
[True, True, False, False, False, True, True],
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
])).all()
assert (galaxy_fit_data.image(return_in_2d=True) == np.array([
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
])).all()
assert (galaxy_fit_data.noise_map(return_in_2d=True) == np.array([
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0],
[0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0],
[0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
])).all()
galaxy = mock_galaxy.MockGalaxy(value=1, shape=36)
convergence = galaxy_fit_data.profile_quantity_from_galaxies(
galaxies=[galaxy])
assert (convergence == np.ones(9)).all()
galaxy = al.Galaxy(
redshift=0.5,
mass=al.mass_profiles.SphericalIsothermal(einstein_radius=1.0))
convergence_gal = galaxy.convergence_from_grid(
grid=galaxy_fit_data.grid, return_in_2d=False, return_binned=True)
convergence_gd = galaxy_fit_data.profile_quantity_from_galaxies(
galaxies=[galaxy])
assert (convergence_gal == convergence_gd).all()
# The pixel scale of the image to be simulated
pixel_scales = 0.1
grid = al.Grid.uniform(shape_2d=(50, 50),
pixel_scales=pixel_scales,
sub_size=1)
print(grid)
# Setup the lens galaxy's light (elliptical Sersic), mass (SIE+Shear) and source galaxy light (elliptical Sersic) for
# this simulated lens.
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllipticalIsothermal(centre=(0.0, 0.0),
phi=45.0,
axis_ratio=0.8,
einstein_radius=1.0),
shear=al.mp.ExternalShear(magnitude=0.05, phi=90.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalSersic(
centre=(0.1, 0.1),
axis_ratio=0.8,
phi=60.0,
intensity=0.3,
effective_radius=1.0,
sersic_index=2.5,
),
)
# %%
"""
Okay, so lets first look at our _Mapper_ without using a border using our annular _Mask_.
First, note how we set up the border. We use a _SettingsPixelization_ object, which is analogous to the
_SettingsMaskedImaging_ and _SettingsLens_ objects we used in previous tutorials. Later, you'll see how these
settings can also be passed to a _SettingsPhaseImaging_ object, to control the behaviour of the pixelization during a
model-fit.
"""
# %%
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(40, 40)),
regularization=al.reg.Constant(coefficient=1.0),
)
fit = perform_fit_with_source_galaxy_mask_and_border(
imaging=imaging,
source_galaxy=source_galaxy,
mask=mask_annular,
settings_pixelization=al.SettingsPixelization(use_border=False),
)
aplt.Inversion.reconstruction(inversion=fit.inversion,
include=aplt.Include(inversion_grid=True))
# %%
"""
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.
"""
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllIsothermal(
centre=(0.0, 0.0),
einstein_radius=1.6,
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.9,
angle=45.0),
),
subhalo=al.mp.SphNFWTruncatedMCRLudlow(centre=(1.601, 0.0),
mass_at_200=1.0e10),
shear=al.mp.ExternalShear(elliptical_comps=(0.05, 0.05)),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(
centre=(0.0, 0.0),
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.8,
angle=60.0),
intensity=0.3,
effective_radius=0.3,
sersic_index=2.5,
def test__uses_auto_update_factor(self, image_7x7, noise_map_7x7,
mask_7x7):
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5),
al.Galaxy(redshift=1.0)])
# Auto positioning is OFF, so use input positions + threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.1)),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.settings.settings_lens.positions_threshold == 0.1
# Auto positioning is ON, but there are no previous results, so use separate of postiions x positions factor..
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.1, auto_positions_factor=1.0)),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.settings.settings_lens.positions_threshold == 2.0
# Auto position is ON, and same as above but with a factor of 3.0 which increases the threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=3.0)),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer,
updated_positions_threshold=0.2)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.settings.settings_lens.positions_threshold == 6.0
# Auto position is ON, and same as above but with a minimum auto positions threshold that rounds the value up.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 0.0), (-1.0, 0.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2,
auto_positions_factor=3.0,
auto_positions_minimum_threshold=10.0,
)),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer,
updated_positions_threshold=0.2)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.settings.settings_lens.positions_threshold == 10.0
# Auto positioning is ON, but positions are None and it cannot find new positions so no threshold.
imaging_7x7 = al.Imaging(image=image_7x7,
noise_map=noise_map_7x7,
positions=None)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
auto_positions_factor=1.0)),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
phase_imaging_7x7.modify_settings(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.settings.settings_lens.positions_threshold == None
imaging = al.Imaging.from_fits(
image_path=path.join(dataset_path, "image.fits"),
noise_map_path=path.join(dataset_path, "noise_map.fits"),
psf_path=path.join(dataset_path, "psf.fits"),
pixel_scales=0.1,
)
mask = al.Mask2D.circular(
shape_2d=imaging.shape_2d, pixel_scales=imaging.pixel_scales, sub_size=2, radius=3.0
)
masked_imaging = al.MaskedImaging(imaging=imaging, mask=mask)
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=1.0,
bulge=al.lp.EllipticalSersic(
centre=(0.1, 0.1),
elliptical_comps=(0.0, 0.111111),
intensity=1.0,
effective_radius=1.0,
sersic_index=4.0,
),
disk=al.lp.EllipticalSersic(
centre=(0.1, 0.1),
elliptical_comps=(0.0, 0.111111),
intensity=5.0,
effective_radius=0.5,
inclination=30.0,
phi=50.0,
turnover_radius=0.05,
maximum_velocity=200.0,
velocity_dispersion=50.0)
cube = src_model.profile_cube_from_grid(grid=grid_3d.grid_2d,
shape_3d=grid_3d.shape_3d,
z_step_kms=z_step_kms)
lensed_cube = autolens_tracer_utils.lensed_cube_from_tracer(
tracer=al.Tracer.from_galaxies(galaxies=[
al.Galaxy(
redshift=lens_redshift,
mass=lens_mass_profile,
),
al.Galaxy(redshift=source_redshift, light=al.lp.LightProfile())
]),
grid=grid_3d.grid_2d,
cube=cube)
transformers = []
for i in range(uv_wavelengths.shape[0]):
transformer = transformer_class(uv_wavelengths=uv_wavelengths[i],
grid=grid_3d.grid_2d.in_radians)
transformers.append(transformer)
visibilities = np.zeros(shape=uv_wavelengths.shape)
for i in range(visibilities.shape[0]):
visibilities[i] = transformers[i].visibilities_from_image(image=Image(
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 phi, where phi 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 phi.
"""
lens_galaxy_0 = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(
centre=(0.0, -1.0),
elliptical_comps=(0.25, 0.1),
intensity=0.1,
effective_radius=0.8,
sersic_index=2.5,
),
mass=al.mp.EllipticalIsothermal(
centre=(0.0, -1.0), elliptical_comps=(0.17647, 0.0), einstein_radius=1.0
),
)
lens_galaxy_1 = al.Galaxy(
redshift=0.5,
light=al.lp.EllipticalSersic(
centre=(0.0, 1.0),
elliptical_comps=(0.0, 0.1),
intensity=0.1,
effective_radius=0.6,
sersic_index=3.0,
import autolens as al
import autolens.plot as aplt
plotter = aplt.Plotter()
sub_plotter = aplt.SubPlotter()
grid = al.Grid.uniform(shape_2d=(100, 100), pixel_scales=0.05, sub_size=2)
lens_galaxy = al.Galaxy(
redshift=0.5,
light=al.lp.SphericalExponential(centre=(0.0, 0.0), intensity=1.0),
light_1=al.lp.SphericalExponential(centre=(1.0, 1.0), intensity=1.0),
light_2=al.lp.SphericalExponential(centre=(-1.0, 0.5), intensity=1.0),
)
source_galaxy = al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalExponential(centre=(0.02, 0.01),
intensity=1.0,
effective_radius=0.5),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
aplt.LightProfile.image(light_profile=lens_galaxy.light, grid=grid)
aplt.Galaxy.image(galaxy=lens_galaxy, grid=grid)
aplt.Plane.image(plane=tracer.image_plane, grid=grid)
aplt.Tracer.image(
tracer=tracer,
grid=grid,
def test__likelihood_function_is_same_as_normal_phase_likelihood_function(
self, imaging_7x7, mask_7x7
):
hyper_image_sky = al.hyper_data.HyperImageSky(sky_scale=1.0)
hyper_background_noise = al.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
lens_galaxy = al.Galaxy(
redshift=0.5, light=al.lp.EllipticalSersic(intensity=0.1)
)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(lens=lens_galaxy),
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
sub_size=2,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7, mask=mask_7x7)
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
mask = phase_imaging_7x7.meta_dataset.mask_with_phase_sub_size_from_mask(
mask=mask_7x7
)
assert mask.sub_size == 2
masked_imaging = al.masked_imaging(imaging=imaging_7x7, mask=mask)
tracer = analysis.tracer_for_instance(instance=instance)
fit = ImagingFit(
masked_imaging=masked_imaging,
tracer=tracer,
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
)
phase_imaging_7x7_hyper = phase_imaging_7x7.extend_with_multiple_hyper_phases(
hyper_galaxy=True
)
instance = phase_imaging_7x7_hyper.model.instance_from_unit_vector([])
instance.hyper_galaxy = al.HyperGalaxy(noise_factor=0.0)
analysis = phase_imaging_7x7_hyper.hyper_phases[0].Analysis(
masked_imaging=masked_imaging,
hyper_model_image=fit.model_image,
hyper_galaxy_image=fit.model_image,
image_path="",
)
fit_hyper = analysis.fit_for_hyper_galaxy(
hyper_galaxy=al.HyperGalaxy(noise_factor=0.0),
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
)
assert fit_hyper.likelihood == fit.likelihood
fit_hyper = analysis.fit_for_hyper_galaxy(
hyper_galaxy=al.HyperGalaxy(noise_factor=1.0),
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
)
assert fit_hyper.likelihood != fit.likelihood
instance.hyper_galaxy = al.HyperGalaxy(noise_factor=0.0)
likelihood = analysis.fit(instance=instance)
assert likelihood == fit.likelihood
# %cd $workspace_path
# print(f"Working Directory has been set to `{workspace_path}`")
import autolens as al
import autolens.plot as aplt
"""
__Initial Setup__
we'll use 3 sources whose `effective_radius` and `sersic_index` are changed such that each is more compact that the last.
"""
source_galaxy_flat = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(
centre=(0.0, 0.0),
elliptical_comps=(0.0, 0.15),
intensity=0.2,
effective_radius=0.5,
sersic_index=1.0,
),
)
source_galaxy_compact = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(
centre=(0.0, 0.0),
elliptical_comps=(0.0, 0.15),
intensity=0.2,
effective_radius=0.2,
sersic_index=2.5,
),
)
),
),
shear=al.mp.ExternalShear(elliptical_comps=(0.05, 0.05)),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
return al.FitImaging(imaging=imaging, tracer=tracer)
"""
And now, we'll use the same magnification based source to fit this data.
"""
source_magnification = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiMagnification(shape=(30, 30)),
regularization=al.reg.Constant(coefficient=3.3),
)
fit = fit_imaging_with_source_galaxy(
imaging=imaging, source_galaxy=source_magnification
)
include_2d = aplt.Include2D(mapper_data_pixelization_grid=True, mask=True)
fit_imaging_plotter = aplt.FitImagingPlotter(fit=fit, include_2d=include_2d)
fit_imaging_plotter.subplot_fit_imaging()
inversion_plotter = fit_imaging_plotter.inversion_plotter_of_plane(plane_index=1)
inversion_plotter.figures_2d(reconstruction=True)
print(grid)
# Setup the lens galaxy's light (elliptical Sersic), mass (SIE+Shear) and source galaxy light (elliptical Sersic) for
# this simulated lens.
lens_galaxy = al.Galaxy(
redshift=0.5,
bulge=al.mp.EllipticalSersic(
mass_to_light_ratio=10.1,
centre=(-0.001, 0.005),
axis_ratio=0.772905559673341,
phi=58.07795357623584,
intensity=2.699624610354442,
effective_radius=0.1441552587870802,
sersic_index=20.8030328467225003,
),
disk=al.mp.EllipticalExponential(
mass_to_light_ratio=10.1,
centre=(0.077, 0.047),
axis_ratio=0.3,
phi=69.43012371637823,
intensity=0.29617161783298507,
effective_radius=2.3339416498752623,
),
dark=al.mp.SphericalNFW(kappa_s=0.2, scale_radius=30.0),
shear=al.mp.ExternalShear(elliptical_comps=(0.0, 0.05)),
)
source_galaxy = al.Galaxy(
redshift=1.0,
light=al.lp.EllipticalSersic(
centre=(0.1, 0.1),
mass_profile = mass_profile_model.random_instance()
"""
Only the `LightProfile` centre is used by the position solver, but a light profile is used to visalize the
lensed source.
"""
exponential_light_profile = al.lp.EllipticalExponential(
centre=(0.0, 0.0),
elliptical_comps=(0.2, 0.0),
intensity=0.05,
effective_radius=0.2,
)
"""Setup the lens, source and _Tracer_."""
lens_galaxy = al.Galaxy(redshift=0.5, mass=mass_profile)
source_galaxy = al.Galaxy(redshift=1.0, light=exponential_light_profile)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
"""Solve for the positions via the _Tracer_."""
positions = solver.solve(
lensing_obj=tracer,
source_plane_coordinate=tracer.source_plane.galaxies[0].light.centre,
)
"""Visually inspect the positions (comment this out if you are confident the code is behaving as expected)."""
visuals_2d = aplt.Visuals2D(positions=positions)
tracer_plotter = aplt.TracerPlotter(tracer=tracer,
grid=grid,
visuals_2d=visuals_2d)
# Lets take another look at the rectangular grid, and think about its weakness.
# Lets quickly remind ourselves of the image, and the 3.0" circular mask we'll use to mask it.
imaging = simulate_util.load_test_imaging(
data_type="lens_mass__source_cuspy", data_resolution="hst"
)
mask = al.mask.circular(
shape_2d=imaging.shape_2d,
pixel_scales=imaging.pixel_scales,
radius=3.0,
centre=(0.0, 0.0),
sub_size=4,
)
lens_galaxy = al.Galaxy(
redshift=0.5, mass=al.mp.SphericalIsothermal(centre=(0.1, 0.2), einstein_radius=1.5)
)
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiMagnification(shape=(20, 20)),
regularization=al.reg.Constant(coefficient=1.0),
)
masked_imaging = al.masked.imaging(imaging=imaging, mask=mask)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
fit = al.fit(masked_dataset=masked_imaging, tracer=tracer)
print(fit.inversion.reconstruction)
print(fit.inversion.mapper)
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)
def test__updates_correct_using_factor(self, imaging_7x7, image_7x7,
noise_map_7x7, mask_7x7):
tracer = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5),
al.Galaxy(redshift=1.0)])
# Auto positioning is OFF, so use input positions + threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.1)),
)
results = mock.MockResults(max_log_likelihood_tracer=tracer)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]]
# Auto positioning is ON, but there are no previous results, so use input positions.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=2.0)),
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]]
# Auto positioning is ON, there are previous results so use their new positions and threshold (which is
# multiplied by the auto_positions_factor). However, only one set of positions is computed from the previous
# result, to use input positions.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=2.0)),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
updated_positions=al.GridCoordinates(coordinates=[[(2.0, 2.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]]
# Auto positioning is ON, but the tracer only has a single plane and thus no lensing, so use input positions.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=1.0)),
)
tracer_x1_plane = al.Tracer.from_galaxies(
galaxies=[al.Galaxy(redshift=0.5)])
results = mock.MockResults(
max_log_likelihood_tracer=tracer_x1_plane,
updated_positions=al.GridCoordinates(coordinates=[[(2.0,
2.0), (3.0,
3.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.positions.in_list == [[(1.0, 1.0)]]
# Auto positioning is ON, there are previous results so use their new positions and threshold (which is
# multiplied by the auto_positions_factor). Multiple positions are available so these are now used.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(1.0, 1.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.2, auto_positions_factor=2.0)),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
updated_positions=al.GridCoordinates(coordinates=[[(2.0,
2.0), (3.0,
3.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.positions.in_list == [[(2.0, 2.0),
(3.0, 3.0)]]
# Auto positioning is Off, but there are previous results with updated positions relative to the input
# positions, so use those with their positions threshold.
imaging_7x7 = al.Imaging(
image=image_7x7,
noise_map=noise_map_7x7,
positions=al.GridCoordinates([[(2.0, 2.0)]]),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
search=mock.MockSearch(),
settings=al.SettingsPhaseImaging(settings_lens=al.SettingsLens(
positions_threshold=0.1)),
)
results = mock.MockResults(
max_log_likelihood_tracer=tracer,
positions=al.GridCoordinates(coordinates=[[(3.0, 3.0), (4.0,
4.0)]]),
updated_positions_threshold=0.3,
)
phase_imaging_7x7.modify_dataset(dataset=imaging_7x7, results=results)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=results)
assert analysis.masked_dataset.positions.in_list == [[(3.0, 3.0),
(4.0, 4.0)]]
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__use_border__determines_if_border_pixel_relocation_is_used(
self, imaging_7x7, mask_7x7):
# noinspection PyTypeChecker
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.SphericalIsothermal(einstein_radius=100.0))
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(coefficient=1.0),
)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=[lens_galaxy, source_galaxy],
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_inversion_class=al.Grid),
settings_pixelization=al.SettingsPixelization(use_border=True),
),
search=mock.MockSearch(),
)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
analysis.masked_dataset.grid_inversion[4] = np.array([[500.0, 0.0]])
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
fit = analysis.masked_imaging_fit_for_tracer(
tracer=tracer, hyper_image_sky=None, hyper_background_noise=None)
assert fit.inversion.mapper.grid[4][0] == pytest.approx(
97.19584, 1.0e-2)
assert fit.inversion.mapper.grid[4][1] == pytest.approx(
-3.699999, 1.0e-2)
phase_imaging_7x7 = al.PhaseImaging(
phase_name="test_phase",
galaxies=[lens_galaxy, source_galaxy],
settings=al.SettingsPhaseImaging(
settings_masked_imaging=al.SettingsMaskedImaging(
grid_inversion_class=al.Grid),
settings_pixelization=al.SettingsPixelization(
use_border=False),
),
search=mock.MockSearch(),
)
analysis = phase_imaging_7x7.make_analysis(dataset=imaging_7x7,
mask=mask_7x7,
results=mock.MockResults())
analysis.masked_dataset.grid_inversion[4] = np.array([300.0, 0.0])
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
fit = analysis.masked_imaging_fit_for_tracer(
tracer=tracer, hyper_image_sky=None, hyper_background_noise=None)
assert fit.inversion.mapper.grid[4][0] == pytest.approx(200.0, 1.0e-4)
def test__perfect_fit__chi_squared_0():
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.via_tracer_from(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(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=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(
dataset=interferometer,
tracer=tracer,
settings_pixelization=al.SettingsPixelization(use_border=False),
settings_inversion=al.SettingsInversion(use_w_tilde=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)
add_poisson_noise=True)
"""
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 phi, where phi 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 phi.
"""
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllipticalIsothermal(centre=(0.0, 0.0),
elliptical_comps=(0.1, 0.0),
einstein_radius=1.6),
)
source_galaxy_0 = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllipticalSersic(
centre=(0.1, 0.1),
elliptical_comps=(0.1, 0.0),
intensity=0.2,
effective_radius=1.0,
sersic_index=1.5,
),
)
source_galaxy_1 = al.Galaxy(
def model_data_from_instance(self, instance):
len_profiles = []
src_profiles = []
for profile in instance.profiles:
if isinstance(profile, al.mp.MassProfile):
len_profiles.append(profile)
else:
src_profiles.append(profile)
galaxies = []
for profile in len_profiles:
galaxies.append(
al.Galaxy(
redshift=self.lens_redshift,
mass=profile,
))
src_cont_profiles = []
src_line_profiles = []
for profile in src_profiles:
if not profile.is_3d_profile:
src_cont_profiles.append(profile)
else:
src_line_profiles.append(profile)
# tracer_cont = al.Tracer.from_galaxies(
# galaxies=[
# *galaxies,
# *[
# al.Galaxy(
# redshift=self.source_redshift,
# light=profile,
# )
# for profile in src_cont_profiles
# ]
# ]
# )
#
# lensed_image = tracer_cont.profile_image_from_grid(
# grid=self.masked_dataset.grid_3d.grid_2d
# )
# # plt.figure()
# # plt.imshow(lensed_image.in_2d_binned)
# # plt.show()
# # exit()
#
# lensed_cube = autolens_tracer_utils.lensed_cube_from_tracer(
# tracer=al.Tracer.from_galaxies(
# galaxies=[
# *galaxies,
# al.Galaxy(
# redshift=self.source_redshift,
# light=al.lp.LightProfile()
# )
# ]
# ),
# grid=self.masked_dataset.grid_3d.grid_2d,
# cube=self.src_model_from_profiles(
# profiles=src_line_profiles
# )
# )
# # plot_utils.plot_cube(
# # cube=lensed_cube,
# # ncols=8
# # )
# # exit()
#
#
# model_data_cont = self.transformer_continuum.visibilities_from_image(
# image=lensed_image
# )
# #print(model_data_cont.shape)
#
# # TODO: subtract the continuum
#
# return {
# "continuum":model_data_cont
# }
lensed_cube_cont = autolens_tracer_utils.lensed_cube_from_tracer(
tracer=al.Tracer.from_galaxies(galaxies=[
*galaxies,
al.Galaxy(redshift=self.source_redshift,
light=al.lp.LightProfile())
]),
grid=self.masked_dataset.grid_3d.grid_2d,
cube=self.src_model_from_profiles(profiles=src_cont_profiles))
# plot_utils.plot_cube(
# cube=lensed_cube_cont,
# ncols=8
# )
# exit()
model_data_cont = self.transformer_continuum.visibilities_from_image(
image=Image(array_2d=lensed_cube_cont[0]))
return {"continuum": model_data_cont}
#exit()
"""
noise_map_path=path.join(dataset_path, "noise_map.fits"),
pixel_scales=0.1,
)
"""
Now, lets set up a `Grid2D` (using the image of this imaging).
"""
grid = al.Grid2D.uniform(shape_native=imaging.shape_native,
pixel_scales=imaging.pixel_scales)
"""
The `Mapper` maps pixels from the image-plane of our `Imaging` data to its source plane, via a lens model.
Lets create a `Tracer` which we will use to create the `Mapper`.
"""
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllIsothermal(centre=(0.0, 0.0),
elliptical_comps=(0.111111, 0.0),
einstein_radius=1.6),
)
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.VoronoiMagnification(shape=(25, 25)),
regularization=al.reg.Regularization(),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
"""
We can extract the `Mapper` from the `Tracer` by passig it the `Grid2D`.
"""
mapper = tracer.mappers_of_planes_from_grid(grid=grid)[1]
"""
We now pass the mapper to a `MapperPlotter` and call various `figure_*` methods to plot different attributes.
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.
"""
lens_galaxy = al.Galaxy(
redshift=0.5,
bulge=al.lp.EllSersic(
centre=(0.0, 0.0),
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.9,
angle=45.0),
intensity=1.0,
effective_radius=0.8,
sersic_index=4.0,
),
mass=al.mp.EllIsothermal(
centre=(0.0, 0.0),
einstein_radius=1.6,
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.9,
angle=45.0),
),
shear=al.mp.ExternalShear(elliptical_comps=(0.05, 0.05)),
)
source_galaxy = al.Galaxy(
redshift=1.0,
bulge=al.lp.EllSersic(
centre=(0.0, 0.0),
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.8,
angle=60.0),
import autolens as al
import autolens.plot as aplt
# %%
"""
Lets setup a lensed source-plane grid, using a lens galaxy and `Tracer` (our source galaxy doesn`t have a
`LightProfile`,as we're going to reconstruct its light using a pixelization).
"""
# %%
grid = al.Grid.uniform(shape_2d=(100, 100), pixel_scales=0.05, sub_size=2)
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllipticalIsothermal(centre=(0.0, 0.0),
elliptical_comps=(0.0, -0.111111),
einstein_radius=1.6),
)
tracer = al.Tracer.from_galaxies(
galaxies=[lens_galaxy, al.Galaxy(redshift=1.0)])
source_plane_grid = tracer.traced_grids_of_planes_from_grid(grid=grid)[1]
# %%
"""
Next, lets set up a `Pixelization`.sing the `pixelization` module, which is imported as `pix` for short.
There are multiple `Pixelization`'s available in **PyAutoLens**. For now, we'll keep it simple and use a uniform
rectangular grid. As usual, the grid`s `shape` defines its $(y,x)$ dimensions.
"""
sub_size=2,
radius=3.0,
)
imaging_plotter = aplt.ImagingPlotter(imaging=imaging,
visuals_2d=aplt.Visuals2D(mask=mask))
imaging_plotter.subplot_imaging()
"""
The lines of code below do everything we're used to, that is, setup an image, mask it, trace it via a tracer,
setup the rectangular mapper, etc.
"""
lens_galaxy = al.Galaxy(
redshift=0.5,
mass=al.mp.EllIsothermal(
centre=(0.0, 0.0),
einstein_radius=1.6,
elliptical_comps=al.convert.elliptical_comps_from(axis_ratio=0.9,
angle=45.0),
),
shear=al.mp.ExternalShear(elliptical_comps=(0.05, 0.05)),
)
imaging = imaging.apply_mask(mask=mask)
source_galaxy = al.Galaxy(
redshift=1.0,
pixelization=al.pix.Rectangular(shape=(40, 40)),
regularization=al.reg.Constant(coefficient=0.5),
)
tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
def test__gal_data_7x7_deflections_y(self, gal_data_7x7, sub_mask_7x7):
galaxy_fit_data = al.GalaxyFitData(galaxy_data=gal_data_7x7,
mask=sub_mask_7x7,
use_deflections_y=True)
assert galaxy_fit_data.pixel_scale == 1.0
assert (galaxy_fit_data.image(return_in_2d=True,
return_masked=False) == np.ones(
(7, 7))).all()
assert (galaxy_fit_data.noise_map(return_in_2d=True,
return_masked=False) == 2.0 *
np.ones((7, 7))).all()
assert (galaxy_fit_data._image_1d == np.ones(9)).all()
assert (galaxy_fit_data._noise_map_1d == 2.0 * np.ones(9)).all()
assert (galaxy_fit_data._mask_1d == np.full(fill_value=False,
shape=(9))).all()
assert (galaxy_fit_data.mask == np.array([
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
[True, True, False, False, False, True, True],
[True, True, False, False, False, True, True],
[True, True, False, False, False, True, True],
[True, True, True, True, True, True, True],
[True, True, True, True, True, True, True],
])).all()
assert (galaxy_fit_data.image(return_in_2d=True) == np.array([
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
])).all()
assert (galaxy_fit_data.noise_map(return_in_2d=True) == np.array([
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0],
[0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0],
[0.0, 0.0, 2.0, 2.0, 2.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
])).all()
galaxy = mock_galaxy.MockGalaxy(value=1, shape=36)
deflections_y = galaxy_fit_data.profile_quantity_from_galaxies(
galaxies=[galaxy])
assert (deflections_y == np.ones(9)).all()
galaxy = al.Galaxy(
redshift=0.5,
mass=al.mass_profiles.SphericalIsothermal(einstein_radius=1.0))
deflections_gal = galaxy.deflections_from_grid(
grid=galaxy_fit_data.grid, return_in_2d=False, return_binned=False)
deflections_gal = np.asarray([
galaxy_fit_data.grid.mapping.array_1d_binned_from_sub_array_1d(
deflections_gal[:, 0]),
galaxy_fit_data.grid.mapping.array_1d_binned_from_sub_array_1d(
deflections_gal[:, 1]),
]).T
deflections_gd = galaxy_fit_data.profile_quantity_from_galaxies(
galaxies=[galaxy])
assert (deflections_gal[:, 0] == deflections_gd).all()
def test__inversion_resolution_error_raised_if_above_inversion_pixel_limit(
self, phase_imaging_7x7, imaging_7x7, mask_7x7):
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(4, 4)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
with pytest.raises(exc.PixelizationException):
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
analysis.fit(instance=instance)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(3, 3)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
phase_imaging_7x7 = al.PhaseImaging(
galaxies=dict(source=al.Galaxy(
redshift=0.5,
pixelization=al.pix.Rectangular(shape=(4, 4)),
regularization=al.reg.Constant(),
)),
inversion_pixel_limit=10,
cosmology=cosmo.FLRW,
phase_name="test_phase",
)
analysis = phase_imaging_7x7.make_analysis(
dataset=imaging_7x7,
mask=mask_7x7,
results=mock_pipeline.MockResults())
instance = phase_imaging_7x7.model.instance_from_unit_vector([])
tracer = analysis.tracer_for_instance(instance=instance)
with pytest.raises(exc.PixelizationException):
analysis.masked_dataset.check_inversion_pixels_are_below_limit_via_tracer(
tracer=tracer)
analysis.fit(instance=instance)
