def from_galaxies(cls, galaxies, cosmology=cosmo.Planck15):
plane_redshifts = plane_util.ordered_plane_redshifts_from(
galaxies=galaxies)
galaxies_in_planes = plane_util.galaxies_in_redshift_ordered_planes_from(
galaxies=galaxies, plane_redshifts=plane_redshifts)
planes = []
for plane_index in range(0, len(plane_redshifts)):
planes.append(pl.Plane(galaxies=galaxies_in_planes[plane_index]))
return Tracer(planes=planes, cosmology=cosmology)
def grid_at_redshift_from_grid_and_redshift(self, grid, redshift):
"""For an input grid of (y,x) arc-second image-plane coordinates, ray-trace the coordinates to any redshift in \
the strong lens configuration.
This is performed using multi-plane ray-tracing and the existing redshifts and planes of the tracer. However, \
any redshift can be input even if a plane does not exist there, including redshifts before the first plane \
of the lens system.
Parameters
----------
grid : ndsrray or aa.Grid
The image-plane grid which is traced to the redshift.
redshift : float
The redshift the image-plane grid is traced to.
"""
if redshift <= self.plane_redshifts[0]:
return grid.copy()
plane_index_with_redshift = [
plane_index
for plane_index, plane in enumerate(self.planes)
if plane.redshift == redshift
]
if plane_index_with_redshift:
return self.traced_grids_of_planes_from_grid(grid=grid)[
plane_index_with_redshift[0]
]
for plane_index, plane_redshift in enumerate(self.plane_redshifts):
if redshift < plane_redshift:
plane_index_insert = plane_index
planes = self.planes
planes.insert(
plane_index_insert,
pl.Plane(redshift=redshift, galaxies=[], cosmology=self.cosmology),
)
tracer = Tracer(planes=planes, cosmology=self.cosmology)
return tracer.traced_grids_of_planes_from_grid(grid=grid)[plane_index_insert]
def from_galaxies_and_grid(self, galaxies, grid, name=None):
"""Simulate imaging data for this data, as follows:
1) Setup the image-plane grid of the Imaging arrays, which defines the coordinates used for the ray-tracing.
2) Use this grid and the lens and source galaxies to setup a plane, which generates the image of \
the simulated imaging data.
3) Simulate the imaging data, using a special image which ensures edge-effects don't
degrade simulator of the telescope optics (e.g. the PSF convolution).
4) Plot the image using Matplotlib, if the plot_imaging bool is True.
5) Output the dataset to .fits format if a dataset_path and data_name are specified. Otherwise, return the simulated \
imaging data instance."""
plane = pl.Plane(
redshift=float(np.mean([galaxy.redshift for galaxy in galaxies])),
galaxies=galaxies,
)
return self.from_plane_and_grid(plane=plane, grid=grid, name=name)
def sliced_tracer_from_lens_line_of_sight_and_source_galaxies(
cls,
lens_galaxies,
line_of_sight_galaxies,
source_galaxies,
planes_between_lenses,
cosmology=cosmo.Planck15,
):
"""Ray-tracer for a lens system with any number of planes.
The redshift of these planes are specified by the input parameters *lens_redshifts* and \
*slices_between_main_planes*. Every galaxy is placed in its closest plane in redshift-space.
To perform multi-plane ray-tracing, a cosmology must be supplied so that deflection-angles can be rescaled \
according to the lens-geometry of the multi-plane system. All galaxies input to the tracer must therefore \
have redshifts.
This tracer has only one grid (see gridStack) which is used for ray-tracing.
Parameters
----------
lens_galaxies : [Galaxy]
The list of galaxies in the ray-tracing calculation.
image_plane_grid : grid_stacks.GridStack
The image-plane grid which is traced. (includes the grid, sub-grid, blurring-grid, etc.).
planes_between_lenses : [int]
The number of slices between each main plane. The first entry in this list determines the number of slices \
between Earth (redshift 0.0) and main plane 0, the next between main planes 0 and 1, etc.
border : masks.GridBorder
The border of the grid, which is used to relocate demagnified traced pixels to the \
source-plane borders.
cosmology : astropy.cosmology
The cosmology of the ray-tracing calculation.
"""
lens_redshifts = plane_util.ordered_plane_redshifts_from(
galaxies=lens_galaxies)
plane_redshifts = plane_util.ordered_plane_redshifts_with_slicing_from(
lens_redshifts=lens_redshifts,
planes_between_lenses=planes_between_lenses,
source_plane_redshift=source_galaxies[0].redshift,
)
galaxies_in_planes = plane_util.galaxies_in_redshift_ordered_planes_from(
galaxies=lens_galaxies + line_of_sight_galaxies,
plane_redshifts=plane_redshifts,
)
plane_redshifts.append(source_galaxies[0].redshift)
galaxies_in_planes.append(source_galaxies)
planes = []
for plane_index in range(0, len(plane_redshifts)):
planes.append(
pl.Plane(
redshift=plane_redshifts[plane_index],
galaxies=galaxies_in_planes[plane_index],
))
return Tracer(planes=planes, cosmology=cosmology)
def plane_for_instance(self, instance):
return pl.Plane(galaxies=instance.galaxies)
