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)