So far, we have shown strongly lensed galaxies whose extended surface brightness is lensed into the awe-inspiring giant arcs and Einstein rings we see in high quality telescope imaging. There are many lenses where the background source is not extended but is instead a point-source, for example strongly lensed quasars and supernovae.
For these objects, we do not want to model the source using a
LightProfile which implicitly assumes an extended
surface brightness distribution. Instead, we assume that our source is a point source with a centre (y,x). Our
ray-tracing calculations no longer trace extended light rays from the source plane to the image-plane, but instead
now find the locations the point-source’s multiple images appear in the image-plane.
Here is an example of a compact source that has been simulated in PyAutoLens, with the positions of its four multiple images marked using stars:
For point source modeling, our goal is to find the multiple images of a lens mass model given a (y,x) coordinate in the
source plane. This is an iterative problem performed in a very different way to ray-tracing used when evaluating a
To treat a source as a point source, we create it as a galaxy using
Point object and pass it to a tracer:
lens_galaxy = al.Galaxy( redshift=0.5, mass=al.mp.Isothermal( centre=(0.001, 0.001), einstein_radius=1.0, ell_comps=(0.0, 0.111111) ) ) point_source = al.ps.Point(centre=(0.07, 0.07)) source_galaxy = al.Galaxy(redshift=1.0, point_0=point_source) tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy, source_galaxy])
This tracer allows us to compute deflection angles and therefore map image-pixels to the source-plane. We can therefore
pass it to the
PositionSolver object to solve for the image-pixel coordinates which correspond to the source’s
source-plane position at (0.07”, 0.07”).
There are many options that can be passed to a
PositionsSovler, below we only specify the precision we want the
image-plane coordinates to be calculated too, which is 0.001”, much lower than the resolution fo the data we observed
the point-sources on!
solver = al.PointSolver( grid=grid_2d, pixel_scale_precision=0.001, ) positions = solver.solve(lensing_obj=tracer, source_plane_coordinate=(0.07, 0.07))
Here is what the solved positions look like, compared to the observe data. In this example, the data was simulated with the mass-model we used above, so the match is good:
Point Source Dataset#
PyAutoLens has full support for analysing strong lens datasetsas a point-source. This might be used for analysing strongly lensed quasars or supernovae, which are so compact we do not observe their extended emission.
To perform point-source analysing, we first create a
PointDataset containing the image-plane (y,x) positions
of each multiple image and their noise values (which would be the resolution of the imaging data they are observed).
The positions below correspond to those of an
Isothermal mass model.
point_dataset = al.PointDataset( name="point_0", positions=al.Grid2DIrregular( [[1.1488, -1.1488], [1.109, 1.109], [-1.109, -1.109], [-1.1488, 1.1488]] ), positions_noise_map=al.ArrayIrregular([0.05, 0.05, 0.05, 0.05]), )
In this simple example we model a single point source, which might correspond to one lensed quasar or supernovae. However, PyAutoLens supports model-fits to datasets with many lensed point-sources, which is used for analysing group-scale and cluster-scale strong lenses.
Each point source dataset is therefore passed into a
PointDict object before the model-fit is performed. For
this simple example only one dataset is passed in, but in the galaxy-cluster examples you’ll see this object makes it
straightforward to model datasets with many lensed sources.
point_dict = al.PointDict(point_dataset_list=[point_dataset])
We can print the
positions of this dictionary and dataset, as well as their noise-map values.
print("Point Source Dataset Name:") print(point_dict["point_0"].name) print("Point Source Multiple Image (y,x) Arc-second Coordinates:") print(point_dict["point_0"].positions.in_list) print("Point Source Multiple Image Noise-map Values:") print(point_dict["point_0"].positions_noise_map.in_list)
Every point-source dataset in the
PointDict has a name, which in this example was
pairs the dataset to the
Point in the model below. Because the name of the dataset is
Point object that is used to fit it must have the name
This ensures if a dataset has many point sources (e.g. galaxy clusters) it is clear how the model pairs the data.
Just like we used a
Tracer to fit imaging and interferometer data, we can use it to
fit point-source data via the
This uses the names of each point-source in the dataset and model to create individual fits to the
fluxes and other attributes that could be fitted. This allows us to inspect the residual-map,
chi-squared, likelihood, etc of every individual fit to part of our point source dataset.
fit = al.FitPointDict(point_dict=point_dict, tracer=tracer, point_solver=solver) print(fit["point_0"].positions.residual_map) print(fit["point_0"].positions.chi_squared_map) print(fit["point_0"].positions.log_likelihood)
It is straight forward to fit a lens model to a point source dataset, using the same API that we saw for imaging and interferometer datasets.
This uses an
AnalysisPoint object which fits the lens model in the correct way for a point source dataset.
This includes mapping the
name’s of each dataset in the
PointDict to the names of the point sources in
the lens model.
# Lens: bulge = af.Model(al.lp.Sersic) mass = af.Model(al.mp.Isothermal) lens = af.Model( al.Galaxy, redshift=0.5, bulge=bulge, mass=mass ) # Source: point_0 = af.Model(al.ps.Point) source = af.Model(al.Galaxy, redshift=1.0, point_0=point_0) # Overall Lens Model: galaxies = af.Collection(lens=lens, source=source) model = af.Collection(galaxies=galaxies) # Search + Analysis + Model-Fit search = af.DynestyStatic(name="overview_point_source") analysis = al.AnalysisPoint(point_dict=point_dict, solver=solver) result = search.fit(model=model, analysis=analysis)
The point_source package of the autolens_workspace contains numerous example scripts for performing point source modeling to datasets where there are only a couple of lenses and lensed sources, which fall under the category of ‘galaxy scale’ objects.
This also includes examples of how to add and fit other information that are observed by a point-source source, for example the flux of each image.