def tracer_via_instance_from(
self, instance: af.ModelInstance, profiling_dict: Optional[Dict] = None
) -> Tracer:
"""
Create a `Tracer` from the galaxies contained in a model instance.
If PyAutoFit's profiling tools are used with the analsyis class, this function may receive a `profiling_dict`
which times how long each set of the model-fit takes to perform.
Parameters
----------
instance
An instance of the model that is fitted to the data by this analysis (whose parameters may have been set
via a non-linear search).
Returns
-------
Tracer
An instance of the Tracer class that is used to then fit the dataset.
"""
if hasattr(instance, "perturbation"):
instance.galaxies.subhalo = instance.perturbation
# TODO : Need to think about how we do this without building it into the model attribute names.
# TODO : A Subhalo class that extends the Galaxy class maybe?
if hasattr(instance.galaxies, "subhalo"):
subhalo_centre = ray_tracing_util.grid_2d_at_redshift_from(
galaxies=instance.galaxies,
redshift=instance.galaxies.subhalo.redshift,
grid=aa.Grid2DIrregular(grid=[instance.galaxies.subhalo.mass.centre]),
cosmology=self.cosmology,
)
instance.galaxies.subhalo.mass.centre = tuple(subhalo_centre.in_list[0])
if hasattr(instance, "clumps"):
return Tracer.from_galaxies(
galaxies=instance.galaxies + instance.clumps,
cosmology=self.cosmology,
profiling_dict=profiling_dict,
)
if hasattr(instance, "cosmology"):
cosmology = instance.cosmology
else:
cosmology = self.cosmology
return Tracer.from_galaxies(
galaxies=instance.galaxies,
cosmology=cosmology,
profiling_dict=profiling_dict,
)
def _tracer_from(fit: af.Fit, galaxies: List[ag.Galaxy]) -> Tracer:
"""
Returns a `Tracer` object from a PyAutoFit database `Fit` object and an instance of galaxies from a non-linear
search model-fit.
This function adds the `hyper_model_image` and `hyper_galaxy_image_path_dict` to the galaxies before constructing
the `Tracer`, if they were used.
Parameters
----------
fit
A PyAutoFit database Fit object containing the generators of the results of PyAutoGalaxy model-fits.
galaxies
A list of galaxies corresponding to a sample of a non-linear search and model-fit.
Returns
-------
Tracer
The tracer computed via an instance of galaxies.
"""
hyper_model_image = fit.value(name="hyper_model_image")
hyper_galaxy_image_path_dict = fit.value(
name="hyper_galaxy_image_path_dict")
galaxies_with_hyper = []
if hyper_galaxy_image_path_dict is not None:
galaxy_path_list = [
gal[0]
for gal in fit.instance.path_instance_tuples_for_class(ag.Galaxy)
]
for (galaxy_path, galaxy) in zip(galaxy_path_list, galaxies):
if galaxy_path in hyper_galaxy_image_path_dict:
galaxy.hyper_model_image = hyper_model_image
galaxy.hyper_galaxy_image = hyper_galaxy_image_path_dict[
galaxy_path]
galaxies_with_hyper.append(galaxy)
return Tracer.from_galaxies(galaxies=galaxies_with_hyper)
return Tracer.from_galaxies(galaxies=galaxies)
def via_galaxies_from(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 tracer, 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."""
tracer = Tracer.from_galaxies(galaxies=galaxies)
return self.via_tracer_from(tracer=tracer, grid=grid, name=name)