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)