The strong lenses we’ve discussed so far have just a single lens galaxy responsible for the lensing, with a single source galaxy observed.
A strong lensing group is a system which has a distinct ‘primary’ lens galaxy and a handful of lower mass galaxies nearby. They typically contain just one or two lensed sources whose arcs are extended and visible. Their Einstein Radii range between typical values of 5.0” -> 10.0” and with care, it is feasible to fit the source’s extended emission in the imaging or interferometer data.
Strong lensing clusters, which contain many hundreds of lens and source galaxies, cannot be modeled with PyAutoLens. However, we are actively developing this functionality.
Lets begin by looking at a simulated group-scale strong lens which clearly has a distinct primary lens galaxy, but additional galaxies can be seen in and around the Einstein ring.
These galaxies are faint and small in number, but their lensing effects on the source are significant enough that we must ultimately include them in the lens model.
import autolens as al import autolens.plot as aplt dataset_name = "lens_x3__source_x1" dataset_path = path.join("dataset", "group", dataset_name) dataset = al.Imaging.from_fits( data_path=path.join(dataset_path, "data.fits"), noise_map_path=path.join(dataset_path, "noise_map.fits"), psf_path=path.join(dataset_path, "psf.fits"), pixel_scales=0.1, ) dataset_plotter = aplt.ImagingPlotter(dataset=dataset) dataset_plotter.subplot_dataset()
Here is what the group-scale lens looks like.
The Source’s ring is much larger than other examples (> 5.0”) and there are clearly additional galaxies in and around the main lens galaxy.
Modeling group scale lenses is challenging, because each individual galaxy must be included in the overall lens model. For this simple overview, we will therefore model the system as a point source, which reduces the complexity of the model and reduces the computational run-time of the model-fit.
Lets the lens’s point-source data, where the brightest pixels of the source are used as the locations of its centre.
point_dict = al.PointDict.from_json( file_path=path.join(dataset_path, "point_dict.json") )
We plot its positions over the observed image, using the
visuals = aplt.Visuals2D(positions=point_dict.positions_list) array_plotter = aplt.Array2DPlotter(array=dataset.data, visuals_2d=visuals) array_plotter.figure_2d()
Here is what it looks like:
Model via JSON#
We now compose the lens model. For groups there could be many lens and source galaxies in the model.
Whereas previous examples explicitly wrote the model out via Python code, for group modeling we opt to write it in .json files which are loaded in this script.
The code below loads a model from a
.json file created by the script
model includes all three lens galaxies where the priors on the centres have been paired to the brightest pixels in the
observed image, alongside a source galaxy which is modeled as a point source.
model_path = path.join("dataset", "group", "lens_x3__source_x1") lenses_file = path.join(model_path, "lenses.json") lenses = af.Collection.from_json(file=lenses_file) sources_file = path.join(model_path, "sources.json") sources = af.Collection.from_json(file=sources_file) galaxies = lenses + sources model = af.Collection(galaxies=galaxies)
This .json file contains all the information on this particular lens’s model, including priors which adjust their centre to the centre of light of each lens galaxy. The script used to make the model can be viewed at the following link.
The model can be displayed via its
Here is how the model appears when printed:
Total Free Parameters = 13 model Collection (N=13) galaxies Collection (N=13) lens_0 Galaxy (N=5) mass IsothermalSph (N=3) shear ExternalShear (N=2) lens_1 Galaxy (N=3) mass IsothermalSph (N=3) lens_2 Galaxy (N=3) mass IsothermalSph (N=3) source_0 Galaxy (N=2) point_0 PointSourceChi (N=2) galaxies lens_0 redshift 0.5 mass centre centre_0 GaussianPrior , mean = 0.0, sigma = 0.5 centre_1 GaussianPrior , mean = 0.0, sigma = 0.5 einstein_radius UniformPrior , lower_limit = 0.0, upper_limit = 8.0 shear gamma_1 UniformPrior , lower_limit = -0.2, upper_limit = 0.2 gamma_2 UniformPrior , lower_limit = -0.2, upper_limit = 0.2 lens_1 redshift 0.5 mass centre centre_0 GaussianPrior , mean = 3.5, sigma = 0.5 centre_1 GaussianPrior , mean = 2.5, sigma = 0.5 einstein_radius UniformPrior , lower_limit = 0.0, upper_limit = 8.0 lens_2 redshift 0.5 mass centre centre_0 GaussianPrior , mean = -4.4, sigma = 0.5 centre_1 GaussianPrior , mean = -5.0, sigma = 0.5 einstein_radius UniformPrior , lower_limit = 0.0, upper_limit = 8.0 source_0 redshift 1.0 point_0 centre centre_0 GaussianPrior , mean = 0.0, sigma = 3.0 centre_1 GaussianPrior , mean = 0.0, sigma = 3.0
The source does not use the
Point class discussed in the previous overview example, but instead uses
This object changes the behaviour of how the positions in the point dataset are fitted. For a normal
the positions are fitted in the image-plane, by mapping the source-plane back to the image-plane via the lens model
and iteratively searching for the best-fit solution.
PointSourceChi object instead fits the positions directly in the source-plane, by mapping the image-plane
positions to the source just one. This is a much faster way to fit the positions,and for group scale lenses it
typically sufficient to infer an accurate lens model.
We are now able to model this dataset as a point source, using the exact same tools we used in the point source overview.
search = af.Nautilus(name="overview_groups") analysis = al.AnalysisPoint(point_dict=point_dict, solver=None) result = search.fit(model=model, analysis=analysis)
The result contains information on every galaxy in our lens model:
print(result.max_log_likelihood_instance.galaxies.lens_0.mass) print(result.max_log_likelihood_instance.galaxies.lens_1.mass) print(result.max_log_likelihood_instance.galaxies.lens_2.mass)
Extended Source Fitting#
For group-scale lenses like this one, with a modest number of lens and source galaxies, PyAutoLens has all the tools you need to perform extended surface-brightness fitting to the source’s extended emission, including the use of a pixelized source reconstruction.
This will extract a lot more information from the data than the point-source model and the source reconstruction means that you can study the properties of the highly magnified source galaxy. Here is what the fit looks like:
For group-scale lenses like this one, with a modest number of lens and source galaxies it is feasible to perform extended surface-brightness fitting to the source’s extended emission. This includes using a pixelized source reconstruction.
This will extract a lot more information from the data than the point-source model and the source reconstruction means that you can study the properties of the highly magnified source galaxy.
This type of modeling uses a lot of PyAutoLens’s advanced model-fitting features which are described in chapters 3 and 4 of the HowToLens tutorials. An example performing this analysis to the lens above can be found at this link.