residual_map_path = result_path + "/image/fits/fit_residual_map.fits" chi_squared_map_path = result_path + "/image/fits/fit_chi_squared_map.fits" # Now, lets load this arrays as a hyper arrays. A hyper arrays is an ordinary NumPy arrays, but it also includes a pixel # scale which allows us to convert the axes of the arrays to arc-second coordinates. image = al.array.from_fits(file_path=image_path, hdu=0, pixel_scales=0.03) # Now, lets load this image as a hyper arrays. A hyper arrays is an ordinary NumPy arrays, but it also includes a pixel # scale which allows us to convert the axes of the image to arc-second coordinates. residual_map = al.array.from_fits(file_path=residual_map_path, hdu=0, pixel_scales=0.03) # We can now use an arrays plotter to plotters the residual map. plotter = aplt.Plotter(labels=aplt.Labels(title="SLACS1430+4105 Residual Map")) aplt.array(array=residual_map, plotter=plotter) # A useful way to really dig into the residuals is to set upper and lower limits on the normalization of the colorbar. plotter = aplt.Plotter( labels=aplt.Labels(title="SLACS1430+4105 Residual Map"), cmap=aplt.ColorMap(norm_min=-0.02, norm_max=0.02), ) aplt.array(array=residual_map, plotter=plotter) # Or, alternatively, use a symmetric logarithmic colormap plotter = aplt.Plotter( labels=aplt.Labels(title="SLACS1430+4105 Residual Map"), cmap=aplt.ColorMap(norm="symmetric_log", linthresh=0.02, linscale=0.02),
phi=45.0, einstein_radius=0.5) interp_deflections = mass_profile.deflections_from_grid( grid=interpolator.interp_grid) deflections = np.zeros((masked_imaging.grid.shape[0], 2)) deflections[:, 0] = interpolator.interpolated_values_from_values( values=interp_deflections[:, 0]) deflections[:, 1] = interpolator.interpolated_values_from_values( values=interp_deflections[:, 1]) true_deflections = mass_profile.deflections_from_grid(grid=masked_imaging.grid) difference_y = deflections[:, 0] - true_deflections[:, 0] difference_x = deflections[:, 1] - true_deflections[:, 1] print("interpolation y error: ", np.mean(difference_y)) print("interpolation y uncertainty: ", np.std(difference_y)) print("interpolation y max error: ", np.max(difference_y)) print("interpolation x error: ", np.mean(difference_x)) print("interpolation x uncertainty: ", np.std(difference_x)) print("interpolation x max error: ", np.max(difference_x)) difference_y_2d = masked_imaging.grid.array_stored_1d_from_sub_array_1d( sub_array_1d=difference_y) difference_x_2d = masked_imaging.grid.array_stored_1d_from_sub_array_1d( sub_array_1d=difference_x) aplt.array(array=difference_y_2d) aplt.array(array=difference_x_2d)
# Lets look at a few contribution maps, generated using hyper-galaxy's with different contribution factors. source_contribution_factor_1 = al.Galaxy( redshift=1.0, hyper_galaxy=al.HyperGalaxy(contribution_factor=1.0), hyper_galaxy_image=hyper_image, hyper_model_image=hyper_image, ) contribution_map = source_contribution_factor_1.hyper_galaxy.contribution_map_from_hyper_images( hyper_model_image=hyper_image, hyper_galaxy_image=hyper_image) aplt.array( array=contribution_map, mask=mask, plotter=aplt.Plotter(labels=aplt.Labels(title="Contribution Map")), ) source_contribution_factor_3 = al.Galaxy( redshift=1.0, hyper_galaxy=al.HyperGalaxy(contribution_factor=3.0), hyper_galaxy_image=hyper_image, hyper_model_image=hyper_image, ) contribution_map = source_contribution_factor_3.hyper_galaxy.contribution_map_from_hyper_images( hyper_model_image=hyper_image, hyper_galaxy_image=hyper_image) aplt.array( array=contribution_map,
norm_min=1.0e-4, norm_max=0.4 * np.max(image), linthresh=0.05, linscale=0.1, ) scribbler = scribbler.Scribbler(image=image.in_2d, cmap=cmap) mask = scribbler.show_mask() mask = al.mask.manual(mask_2d=mask, pixel_scales=pixel_scales) # Next, load the imaging noise-map, which we will use the scale the noise-map. noise_map = al.array.from_fits( file_path=dataset_path + "noise_map.fits", pixel_scales=pixel_scales ) # Now lets plotters the image and mask, so we can check that the mask includes the regions of the image we want. # data_plotters.plot_signal_to_noise_map(signal_to_noise_map=image / noise_map) # Here, we manually increase the noise values to extremely large values, such that the analysis essentially omits them. noise_map = np.where(mask, 1.0e8, noise_map.in_2d) noise_map = al.array.manual_2d(array=noise_map, pixel_scales=pixel_scales) # The signal to noise map is the best way to determine if these regions are appropriately masked out. aplt.array(array=image / noise_map) # Now we're happy with the mask, lets output it to the dataset folder of the lens, so that we can load it from a .fits # file in our pipelines! noise_map.output_to_fits( file_path=dataset_path + "noise_map_scaled.fits", overwrite=True )
workspace_path = "{}/../../../".format( os.path.dirname(os.path.realpath(__file__))) # The 'dataset label' is the name of the dataset folder and 'dataset_name' the folder the positions are stored in e.g, # the positions will be output as '/autolens_workspace/dataset/dataset_label/dataset_name/positions.dat'. dataset_label = "imaging" dataset_name = "lens_sie__source_sersic" # Create the path where the mask will be output, which in this case is # '/autolens_workspace/dataset/imaging/lens_sie__source_sersic/' dataset_path = af.path_util.make_and_return_path_from_path_and_folder_names( path=workspace_path, folder_names=["dataset", dataset_label, dataset_name]) # If you use this tool for your own dataset, you *must* double check this pixel scale is correct! pixel_scales = 0.1 # First, load the imaging dataset, so that the positions can be plotted over the strong lens image. image = al.array.from_fits(file_path=dataset_path + "image.fits", pixel_scales=pixel_scales) # Now, create a set of positions, which is a python list of (y,x) values. lens_light_centre = al.coordinates([[(0.0, 0.0)]]) # Now lets plotters the image and positions, so we can check that the positions overlap different regions of the source. aplt.array(array=image, light_profile_centres=lens_light_centre) # Now we're happy with the positions, lets output them to the dataset folder of the lens, so that we can load them from a # .dat file in our pipelines! lens_light_centre.output_to_file(file_path=dataset_path + "lens_light_centre.dat")
# Create the path where the mask will be output, which in this case is # '/autolens_workspace/dataset/imaging/lens_sie__source_sersic/' dataset_path = af.path_util.make_and_return_path_from_path_and_folder_names( path=workspace_path, folder_names=["dataset", dataset_label, dataset_name]) # If you use this tool for your own dataset, you *must* double check this pixel scale is correct! pixel_scales = 0.1 # First, load the imaging dataset, so that the mask can be plotted over the strong lens image. image = al.array.from_fits(file_path=dataset_path + "image.fits", pixel_scales=pixel_scales) # Now, create a mask for this dataset, using the mask function's we're used to. I'll use a circular-annular mask here, # but I've commented over options you might want to use (feel free to experiment!) mask = al.mask.circular_annular( shape_2d=image.shape_2d, pixel_scales=image.pixel_scales, sub_size=1, inner_radius=0.5, outer_radius=2.5, centre=(0.0, 0.0), ) # Now lets plotters the image and mask, so we can check that the mask includes the regions of the image we want. aplt.array(array=image, mask=mask) # Now we're happy with the mask, lets output it to the dataset folder of the lens, so that we can load it from a .fits # file in our pipelines! mask.output_to_fits(file_path=dataset_path + "mask.fits", overwrite=True)
hyper_model_image= hyper_image_source, # <- The source get its own hyper-galaxy image. ) fit = fit_masked_imaging_with_lens_and_source_galaxy( masked_imaging=masked_imaging, lens_galaxy=lens_galaxy, source_galaxy=source_magnification, ) lens_contribution_map = lens_galaxy_hyper.hyper_galaxy.contribution_map_from_hyper_images( hyper_model_image=hyper_image, hyper_galaxy_image=hyper_image_lens) aplt.array( array=lens_contribution_map, mask=mask, plotter=aplt.Plotter(labels=aplt.Labels(title="Lens Contribution Map")), ) source_contribution_map = source_magnification_hyper.hyper_galaxy.contribution_map_from_hyper_images( hyper_model_image=hyper_image, hyper_galaxy_image=hyper_image_source) aplt.array( array=source_contribution_map, mask=mask, plotter=aplt.Plotter(labels=aplt.Labels(title="Source Contribution Map")), ) # The contribution maps decomposes the image into its different components. Next, we use each contribution # map to scale different regions of the noise-map. From the fit above it was clear that both the lens and source # required the noise to be scaled, but their different chi-squared values ( > 150 and ~ 30) means they require different
# First, load the imaging dataset and noise-map, so that the mask can be plotted over the strong lens image. image = al.array.from_fits(file_path=dataset_path + "image.fits", pixel_scales=pixel_scales) noise_map = al.array.from_fits(file_path=dataset_path + "noise_map.fits", pixel_scales=pixel_scales) # Create the 2D Gaussian that the image is blurred with. This blurring is an attempt to smooth over noise in the # image, which will lead unmasked values with in individual pixels if not smoothed over correctly. blurring_gaussian = al.kernel.from_gaussian(shape_2d=(31, 31), pixel_scales=pixel_scales, sigma=blurring_gaussian_sigma) blurred_image = blurring_gaussian.convolved_array_from_array(array=image) aplt.array(array=blurred_image) # Now compute the absolute signal-to-noise map of this blurred image, given the noise-map of the observed dataset. blurred_signal_to_noise_map = blurred_image / noise_map aplt.array(array=blurred_signal_to_noise_map) # Now create the mask in sall pixels where the signal to noise is above some threshold value. mask = np.where(blurred_signal_to_noise_map.in_2d > signal_to_noise_threshold, False, True) mask = al.mask.manual(mask_2d=mask, pixel_scales=pixel_scales, sub_size=1) aplt.array(array=image, mask=mask) # Now we're happy with the mask, lets output it to the dataset folder of the lens, so that we can load it from a .fits
# '/autolens_workspace/dataset/imaging/lens_sie__source_sersic_intervening_objects/' dataset_path = af.path_util.make_and_return_path_from_path_and_folder_names( path=workspace_path, folder_names=["dataset", dataset_label, dataset_name]) # If you use this tool for your own dataset, you *must* double check this pixel scale is correct! pixel_scales = 0.1 # First, load the imaging dataset, so that the location of galaxies is clear when scaling the noise-map. image = al.array.from_fits(file_path=dataset_path + "image.fits", pixel_scales=pixel_scales) # Next, load the imaging noise-map, which we will use the scale the noise-map. noise_map = al.array.from_fits(file_path=dataset_path + "noise_map.fits", pixel_scales=pixel_scales) # Now lets plotters the image and mask, so we can check that the mask includes the regions of the image we want. # data_plotters.plot_signal_to_noise_map(signal_to_noise_map=image / noise_map) # Here, we manually increase the noise values to extremely large values, such that the analysis essentially omits them. noise_map = noise_map.in_2d noise_map[25:55, 77:96] = 1.0e8 noise_map[55:85, 3:27] = 1.0e8 # The signal to noise map is the best way to determine if these regions are appropriately masked out. aplt.array(array=image / noise_map.in_1d) # Now we're happy with the mask, lets output it to the dataset folder of the lens, so that we can load it from a .fits # file in our pipelines! noise_map.output_to_fits(file_path=dataset_path + "noise_map_scaled.fits", overwrite=True)
# 16 to 24. # 3) For the same reason, we increase the size of the colorbar ticks from the default value 10 to 20. plotter = aplt.Plotter( figure=aplt.Figure(figsize=(12, 12)), labels=aplt.Labels(title="SLACS1430+4105 Image", titlesize=24, ysize=24, xsize=24), ticks=aplt.Ticks(ysize=24, xsize=24), cmap=aplt.ColorMap(norm="cold", norm_max=0.8), cb=aplt.ColorBar(ticksize=20), ) aplt.array(array=image, plotter=plotter) # The colormap of the arrays can be changed to any of the standard matplotlib colormaps. plotter = aplt.Plotter(labels=aplt.Labels(title="SLACS1430+4105 Image"), cmap=aplt.ColorMap(cmap="spring")) aplt.array(array=image, plotter=plotter) # We can change the x / y axis unit_label from arc-seconds to kiloparsec, by inputting a kiloparsec to arcsecond conversion # factor (for SLACS1430+4105, the lens galaxy is at redshift 0.285, corresponding to the conversion factor below). plotter = aplt.Plotter( labels=aplt.Labels(title="SLACS1430+4105 Image"), units=aplt.Units(in_kpc=True, conversion_factor=6.2), )
# Lets look at this in action. We'll inspect 3 cluster_weight_maps, using a weight_power of 0.0, 5.0 and 10.0, # setting the weight_floor to 0.0 such that it does not change the cluster weight map. source_weight_power_0 = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=500, weight_floor=0.0, weight_power=0.0), regularization=al.reg.Constant(coefficient=1.0), hyper_galaxy_image=hyper_image, ) cluster_weight_power_0 = source_weight_power_0.pixelization.weight_map_from_hyper_image( hyper_image=source_weight_power_0.hyper_galaxy_image) aplt.array(array=cluster_weight_power_0, mask=mask) source_weight_power_5 = al.Galaxy( redshift=1.0, pixelization=al.pix.VoronoiBrightnessImage(pixels=500, weight_floor=0.0, weight_power=5.0), regularization=al.reg.Constant(coefficient=1.0), hyper_galaxy_image=hyper_image, ) cluster_weight_power_5 = source_weight_power_5.pixelization.weight_map_from_hyper_image( hyper_image=source_weight_power_5.hyper_galaxy_image) aplt.array(array=cluster_weight_power_5, mask=mask)
# Now, create a set of positions, which is a python list of (y,x) values. positions = al.coordinates([[(0.8, 1.45), (1.78, -0.4), (-0.95, 1.38), (-0.83, -1.04)]]) # These are the positions for the example lens 'lens_sersic_sie__source_sersic__2' # positions = al.coordinates([[(0.44, 0.60), (-1.4, -0.41), (0.15, -1.45)]]) # These are the positions for the example lens 'lens_sie__source_sersic__2' # positions = al.coordinates([[(1.28, -1.35), (-0.5, 0.7)]]) # These are the positions for the example lens 'lens_sie__source_sersic_x2' # positions = al.coordinates([[(2.16, -1.3), (-0.65, 0.45)]]) # We can infact input multiple lists of positions (commented out below), which corresponds to pixels which are \ # anticipated to map to different multiply imaged regions of the source-plane (e.g. you would need something like \ # spectra to be able to do this) # Images of source 1 # Images of source 2 # positions = [[(1.0, 1.0), (2.0, 0.5)], [(-1.0, -0.1), (2.0, 2.0), (3.0, 3.0)]] # Now lets plotters the image and positions, so we can check that the positions overlap different regions of the source. aplt.array(array=image, positions=positions) # Now we're happy with the positions, lets output them to the dataset folder of the lens, so that we can load them from a # .dat file in our pipelines! positions.output_to_file(file_path=dataset_path + "positions.dat") # These commented out lines would create the positions for the example_multi_plane dataset. # lens_name = 'example_multi_plane' # pixel_scales = 0.05 # positions = [[(0.8, 1.12), (-0.64, 1.13), (1.38, -0.2), (-0.72, -0.83)]]