Automated Strong Gravitational Lens Modeling
Project description
PyAutoLens
When two or more galaxies are aligned perfectly down our line-of-sight, the background galaxy appears multiple times. This is called strong gravitational lensing, & PyAutoLens makes it simple to model strong gravitational lenses, like this one:
.. image:: https://github.com/Jammy2211/PyAutoLens/blob/development/imageaxis.png
Installation
PyAutoLens requires Python 3.6+ and you can install it via pip
or conda
(see
this link <https://pyautolens.readthedocs.io/en/latest/general/installation.html#installation-with-conda>
_
for conda
instructions).
.. code-block:: bash
pip install autolens
Next, clone the autolens_workspace <https://github.com/Jammy2211/autolens_workspace>
_, which includes
PyAutoLens configuration files, example scripts and more!
.. code-block:: bash
cd /path/on/your/computer/you/want/to/put/the/autolens_workspace git clone https://github.com/Jammy2211/autolens_workspace --depth 1 cd autolens_workspace
Finally, run welcome.py
in the autolens_workspace
to get started!
.. code-block:: bash
python3 welcome.py
If your installation had an error, check the
troubleshooting section <https://pyautolens.readthedocs.io/en/latest/general/installation.html#trouble-shooting>
_ on
our readthedocs.
If you would prefer to Fork or Clone the PyAutoLens GitHub repo, checkout the
cloning section <https://pyautolens.readthedocs.io/en/latest/general/installation.html#forking-cloning>
_ on our
readthedocs.
API Overview
Lensing calculations are performed in PyAutoLens by building a Tracer
object from LightProfile
,
MassProfile
and Galaxy
objects. Below, we create a simple strong lens system where a redshift 0.5
lens Galaxy
with an EllipticalIsothermal
MassProfile
lenses a background source at redshift 1.0 with an
EllipticalExponential
LightProfile
representing a disk.
.. code-block:: python
import autolens as al
import autolens.plot as aplt
"""
To describe the deflection of light by mass, two-dimensional grids of (y,x) Cartesian
coordinates are used.
"""
grid = al.Grid.uniform(
shape_2d=(50, 50),
pixel_scales=0.05, # <- Conversion from pixel units to arc-seconds.
)
"""The lens galaxy has an EllipticalIsothermal MassProfile and is at redshift 0.5."""
mass = al.mp.EllipticalIsothermal(
centre=(0.0, 0.0), elliptical_comps=(0.1, 0.05), einstein_radius=1.6
)
lens_galaxy = al.Galaxy(redshift=0.5, mass=mass)
"""The source galaxy has an EllipticalExponential LightProfile and is at redshift 1.0."""
disk = al.lp.EllipticalExponential(
centre=(0.3, 0.2),
elliptical_comps=(0.05, 0.25),
intensity=0.05,
effective_radius=0.5,
)
source_galaxy = al.Galaxy(redshift=1.0, disk=disk)
"""
We create the strong lens using a Tracer, which uses the galaxies, their redshifts
and an input cosmology to determine how light is deflected on its path to Earth.
"""
tracer = al.Tracer.from_galaxies(
galaxies=[lens_galaxy, source_galaxy], cosmology=cosmo.Planck15
)
"""
We can use the Grid and Tracer to perform many lensing calculations, for example
plotting the image of the lensed source.
"""
aplt.Tracer.image(tracer=tracer, grid=grid)
With PyAutoLens, you can begin modeling a lens in just a couple of minutes. The example below demonstrates a simple analysis which fits the foreground lens galaxy's mass & the background source galaxy's light.
.. code-block:: python
import autofit as af
import autolens as al
import autolens.plot as aplt
"""Use the dataset path and lens name to load the imaging data."""
imaging = al.Imaging.from_fits(
image_path="/path/to/dataset/image.fits",
noise_map_path="/path/to/dataset/noise_map.fits",
psf_path="/path/to/dataset/psf.fits",
pixel_scales=0.1,
)
"""Create a mask for the data, which we setup as a 3.0" circle."""
mask = al.Mask2D.circular(
shape_2d=imaging.shape_2d, pixel_scales=imaging.pixel_scales, radius=3.0
)
"""
We model our lens galaxy using an EllipticalIsothermal MassProfile &
our source galaxy as an EllipticalSersic LightProfile.
"""
lens_mass_profile = al.mp.EllipticalIsothermal
source_light_profile = al.lp.EllipticalSersic
"""
To setup our model galaxies, we use the GalaxyModel class, which represents a
galaxy whose parameters are free & fitted for by PyAutoLens.
"""
lens_galaxy_model = al.GalaxyModel(redshift=0.5, mass=lens_mass_profile)
source_galaxy_model = al.GalaxyModel(redshift=1.0, disk=source_light_profile)
"""
To perform the analysis we set up a phase, which takes our galaxy models & fits
their parameters using a `NonLinearSearch` (in this case, Dynesty).
"""
phase = al.PhaseImaging(
search=af.DynestyStatic(name="phase[example]",n_live_points=50),
galaxies=dict(lens=lens_galaxy_model, source=source_galaxy_model),
)
"""
We pass the imaging `data` and `mask` to the phase, thereby fitting it with the lens
model & plot the resulting fit.
"""
result = phase.run(dataset=imaging, mask=mask)
aplt.FitImaging.subplot_fit_imaging(fit=result.max_log_likelihood_fit)
Getting Started
To get started checkout our readthedocs <https://pyautolens.readthedocs.io/>
,
where you'll find the installation guide, a complete overview of PyAutoLens's features, examples
scripts and tutorials, detailed API documentation and
the HowToLens Jupyter notebook lecture series <https://pyautolens.readthedocs.io/en/latest/howtolens/howtolens.html>
on which introduces new users to strong gravitational lensing with PyAutoLens.
Support
Support for installation issues, help with lens modeling and using PyAutoLens is available by
raising an issue on the autolens_workspace GitHub page <https://github.com/Jammy2211/autolens_workspace/issues>
. or
joining the PyAutoLens Slack channel <https://pyautolens.slack.com/>
, where we also provide the latest updates on
PyAutoLens.
Slack is invitation-only, so if you'd like to join send an email <https://github.com/Jammy2211>
_ requesting an
invite.
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.