def simulate(): from autolens.data.array import grids from autolens.model.galaxy import galaxy as g from autolens.lens import ray_tracing psf = ccd.PSF.simulate_as_gaussian(shape=(11, 11), sigma=0.05, pixel_scale=0.05) image_plane_grid_stack = grids.GridStack.grid_stack_for_simulation( shape=(180, 180), pixel_scale=0.05, psf_shape=(11, 11)) lens_galaxy = g.Galaxy(mass=mp.EllipticalIsothermal( centre=(0.0, 0.0), axis_ratio=0.8, phi=135.0, einstein_radius=1.6)) source_galaxy = g.Galaxy(light=lp.EllipticalSersic(centre=(0., 0.), axis_ratio=0.8, phi=90.0, intensity=0.2, effective_radius=1.0, sersic_index=1.5)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=image_plane_grid_stack) return ccd.CCDData.simulate(array=tracer.image_plane_image_for_simulation, pixel_scale=0.05, exposure_time=300.0, psf=psf, background_sky_level=0.1, add_noise=True)
def simulate(): from autolens.data.array import grids from autolens.model.galaxy import galaxy as g from autolens.lens import ray_tracing psf = ccd.PSF.simulate_as_gaussian(shape=(11, 11), sigma=0.1, pixel_scale=0.1) image_plane_grid_stack = grids.GridStack.grid_stack_for_simulation( shape=(130, 130), pixel_scale=0.1, psf_shape=(11, 11)) lens_galaxy = g.Galaxy( mass=mp.SphericalIsothermal(centre=(0.0, 0.0), einstein_radius=1.6)) source_galaxy = g.Galaxy(light=lp.SphericalExponential( centre=(0.0, 0.0), intensity=0.2, effective_radius=0.2)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=image_plane_grid_stack) ccd_simulated = ccd.CCDData.simulate( array=tracer.image_plane_image_for_simulation, pixel_scale=0.1, exposure_time=300.0, psf=psf, background_sky_level=0.1, add_noise=True) return ccd_simulated
def make_fit(lens_data, galaxy_light, galaxy_mass): tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[galaxy_mass], source_galaxies=[galaxy_light], image_plane_grid_stack=lens_data.grid_stack, cosmology=cosmo.Planck15) return lens_fit.fit_lens_data_with_tracer(lens_data=lens_data, tracer=tracer)
def test__tracer_and_tracer_sensitive_are_identical__added__likelihood_is_noise_term( self, lens_data_blur): g0 = g.Galaxy(mass_profile=mp.SphericalIsothermal(einstein_radius=1.0)) g1 = g.Galaxy(light_profile=lp.EllipticalSersic(intensity=2.0)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[g0], source_galaxies=[g1], image_plane_grid_stack=lens_data_blur.grid_stack) fit = sensitivity_fit.SensitivityProfileFit(lens_data=lens_data_blur, tracer_normal=tracer, tracer_sensitive=tracer) assert (fit.fit_normal.image == lens_data_blur.image).all() assert (fit.fit_normal.noise_map == lens_data_blur.noise_map).all() model_image_1d = util.blurred_image_1d_from_1d_unblurred_and_blurring_images( unblurred_image_1d=tracer.image_plane_image_1d, blurring_image_1d=tracer.image_plane_blurring_image_1d, convolver=lens_data_blur.convolver_image) model_image = lens_data_blur.map_to_scaled_array( array_1d=model_image_1d) assert (fit.fit_normal.model_image == model_image).all() residual_map = fit_util.residual_map_from_data_mask_and_model_data( data=lens_data_blur.image, mask=lens_data_blur.mask, model_data=model_image) assert (fit.fit_normal.residual_map == residual_map).all() chi_squared_map = fit_util.chi_squared_map_from_residual_map_noise_map_and_mask( residual_map=residual_map, mask=lens_data_blur.mask, noise_map=lens_data_blur.noise_map) assert (fit.fit_normal.chi_squared_map == chi_squared_map).all() assert (fit.fit_sensitive.image == lens_data_blur.image).all() assert (fit.fit_sensitive.noise_map == lens_data_blur.noise_map).all() assert (fit.fit_sensitive.model_image == model_image).all() assert (fit.fit_sensitive.residual_map == residual_map).all() assert (fit.fit_sensitive.chi_squared_map == chi_squared_map).all() chi_squared = fit_util.chi_squared_from_chi_squared_map_and_mask( chi_squared_map=chi_squared_map, mask=lens_data_blur.mask) noise_normalization = fit_util.noise_normalization_from_noise_map_and_mask( mask=lens_data_blur.mask, noise_map=lens_data_blur.noise_map) assert fit.fit_normal.likelihood == -0.5 * (chi_squared + noise_normalization) assert fit.fit_sensitive.likelihood == -0.5 * (chi_squared + noise_normalization) assert fit.figure_of_merit == 0.0
def make_fit(lens_data): lens_galaxy = g.Galaxy(mass=mp.SphericalIsothermal(einstein_radius=1.0), redshift=1.0) lens_subhalo = g.Galaxy(mass=mp.SphericalIsothermal(einstein_radius=0.1), redshift=1.0) source_galaxy = g.Galaxy(light=lp.EllipticalSersic(intensity=1.0), redshift=2.0) tracer_normal = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, cosmology=cosmo.Planck15) tracer_sensitivity = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy, lens_subhalo], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, cosmology=cosmo.Planck15) return sensitivity_fit.SensitivityProfileFit( lens_data=lens_data, tracer_normal=tracer_normal, tracer_sensitive=tracer_sensitivity)
def perform_fit_with_lens_and_source_galaxy(lens_galaxy, source_galaxy): ccd_data = simulate() mask = msk.Mask.circular_annular(shape=ccd_data.shape, pixel_scale=ccd_data.pixel_scale, inner_radius_arcsec=0.5, outer_radius_arcsec=2.2) lens_data = ld.LensData(ccd_data=ccd_data, mask=mask) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, border=lens_data.border) return lens_fit.fit_lens_data_with_tracer(lens_data=lens_data, tracer=tracer)
def perform_fit_with_source_galaxy(source_galaxy): ccd_data = simulate() mask = msk.Mask.circular_annular(shape=ccd_data.shape, pixel_scale=ccd_data.pixel_scale, inner_radius_arcsec=0.5, outer_radius_arcsec=2.2) lens_data = ld.LensData(ccd_data=ccd_data, mask=mask) lens_galaxy = g.Galaxy(mass=mp.EllipticalIsothermal( centre=(0.0, 0.0), axis_ratio=0.8, phi=135.0, einstein_radius=1.6)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, border=lens_data.border) return lens_fit.fit_lens_data_with_tracer(lens_data=lens_data, tracer=tracer)
def perform_fit_with_source_galaxy_mask_and_border(source_galaxy, mask, use_border): ccd_data = simulate() lens_data = ld.LensData(ccd_data=ccd_data, mask=mask) lens_galaxy = g.Galaxy(mass=mp.EllipticalIsothermal( centre=(0.0, 0.0), axis_ratio=0.8, phi=135.0, einstein_radius=1.6)) if use_border: border = lens_data.border else: border = None tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, border=border) return lens_fit.fit_lens_data_with_tracer(lens_data=lens_data, tracer=tracer)
def simulate_image_from_galaxies_and_output_to_fits(lens_name, pixel_scale, shape, sub_grid_size, lens_galaxies, source_galaxies): # Simulate a simple Gaussian PSF for the image. psf = ccd.PSF.simulate_as_gaussian(shape=(51, 51), sigma=pixel_scale, pixel_scale=pixel_scale) # Setup the image-plane grid stack of the CCD array which will be used for generating the image-plane image of the # simulated strong lens. A high-res sub-grid is necessary to ensure we fully resolve the central regions of the # lens and source galaxy light. image_plane_grid_stack = grids.GridStack.grid_stack_for_simulation(shape=shape, pixel_scale=pixel_scale, psf_shape=psf.shape, sub_grid_size=sub_grid_size) # Use the input galaxies to setup a tracer, which will generate the image-plane image for the simulated CCD data. tracer = ray_tracing.TracerImageSourcePlanes(lens_galaxies=lens_galaxies, source_galaxies=source_galaxies, image_plane_grid_stack=image_plane_grid_stack) # Simulate the CCD data, remembering that we use a special image-plane image which ensures edge-effects don't # degrade our modeling of the telescope optics (e.g. the PSF convolution). simulated_ccd = ccd.CCDData.simulate(array=tracer.image_plane_image_for_simulation, pixel_scale=pixel_scale, exposure_time=300.0, psf=psf, background_sky_level=0.1, add_noise=True) # Now, lets output this simulated ccd-data to the test/profiling/data folder. path = '{}/'.format(os.path.dirname(os.path.realpath(__file__))) # The image_type tag tells us whether we are outputting an image at LSST, Euclid, HST or AO resolution. image_type = tools.image_type_from_pixel_scale(pixel_scale=pixel_scale) # Check a folder of the lens name and within that of the pixel scale tag exist in the data folder for the images to # be output. If it doesn't make it. if not os.path.exists(path + '/data/' + lens_name): os.makedirs(path + '/data/' + lens_name) if not os.path.exists(path + '/data/' + lens_name + '/' + image_type ): os.makedirs(path + '/data/' + lens_name + '/' + image_type ) ccd.output_ccd_data_to_fits(ccd_data=simulated_ccd, image_path=path + '/data/' + lens_name + '/' + image_type + '/image.fits', psf_path=path + '/data/' + lens_name + '/' + image_type + '/psf.fits', noise_map_path=path + '/data/' + lens_name + '/' + image_type + '/noise_map.fits', overwrite=True)
def perform_fit_x2_lenses_with_source_galaxy_mask_and_border( source_galaxy, mask, use_border): simulate_image_x2_lenses() lens_data = ld.LensData(ccd_data=ccd_data, mask=mask) lens_galaxy_0 = g.Galaxy(mass=mp.EllipticalIsothermal( centre=(1.1, 0.51), axis_ratio=0.9, phi=110.0, einstein_radius=1.07)) lens_galaxy_1 = g.Galaxy(mass=mp.EllipticalIsothermal( centre=(-0.20, -0.35), axis_ratio=0.56, phi=16.0, einstein_radius=0.71)) if use_border: border = lens_data.border else: border = None tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy_0, lens_galaxy_1], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, border=border) return lens_fit.fit_lens_data_with_tracer(lens_data=lens_data, tracer=tracer)
def simulate_image_with_offset_centre_psf(): from autolens.data.array import grids from autolens.model.galaxy import galaxy as g from autolens.lens import ray_tracing psf = im.PSF.simulate_as_gaussian(shape=(21, 21), sigma=0.05, pixel_scale=0.1, centre=(0.1, 0.1)) image_plane_grids = grids.GridStack.grid_stack_for_simulation( shape=(100, 100), pixel_scale=0.1, psf_shape=(21, 21)) lens_galaxy = g.Galaxy(light=lp.SphericalSersic(centre=(0.0, 0.0), intensity=0.3, effective_radius=1.0, sersic_index=2.0), mass=mp.SphericalIsothermal(centre=(0.0, 0.0), einstein_radius=1.2)) source_galaxy = g.Galaxy(light=lp.SphericalSersic(centre=(0.0, 0.0), intensity=0.2, effective_radius=1.0, sersic_index=1.5)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=[image_plane_grids]) return im.CCDData.simulate(array=tracer.image_plane_image_for_simulation, pixel_scale=0.1, exposure_time=300.0, psf=psf, background_sky_level=0.1, add_noise=True)
def test__tracers_are_different__likelihood_is_non_zero( self, lens_data_blur): pixelization = pix.Rectangular(shape=(3, 3)) regularization = reg.Constant(coefficients=(1.0, )) g0 = g.Galaxy(mass_profile=mp.SphericalIsothermal(einstein_radius=1.0)) g0_subhalo = g.Galaxy(subhalo=mp.SphericalIsothermal( einstein_radius=0.1)) g1 = g.Galaxy(pixelization=pixelization, regularization=regularization) tracer_normal = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[g0], source_galaxies=[g1], image_plane_grid_stack=lens_data_blur.grid_stack) tracer_sensitive = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[g0, g0_subhalo], source_galaxies=[g1], image_plane_grid_stack=lens_data_blur.grid_stack) fit = sensitivity_fit.SensitivityInversionFit( lens_data=lens_data_blur, tracer_normal=tracer_normal, tracer_sensitive=tracer_sensitive) assert (fit.fit_normal.image == lens_data_blur.image).all() assert (fit.fit_normal.noise_map == lens_data_blur.noise_map).all() mapper = pixelization.mapper_from_grid_stack_and_border( grid_stack=tracer_normal.source_plane.grid_stack, border=None) inversion = inv.inversion_from_image_mapper_and_regularization( mapper=mapper, regularization=regularization, image_1d=lens_data_blur.image_1d, noise_map_1d=lens_data_blur.noise_map_1d, convolver=lens_data_blur.convolver_mapping_matrix) assert fit.fit_normal.model_image == pytest.approx( inversion.reconstructed_data, 1.0e-4) residual_map = fit_util.residual_map_from_data_mask_and_model_data( data=lens_data_blur.image, mask=lens_data_blur.mask, model_data=inversion.reconstructed_data) assert fit.fit_normal.residual_map == pytest.approx( residual_map, 1.0e-4) chi_squared_map = fit_util.chi_squared_map_from_residual_map_noise_map_and_mask( residual_map=residual_map, mask=lens_data_blur.mask, noise_map=lens_data_blur.noise_map) assert fit.fit_normal.chi_squared_map == pytest.approx( chi_squared_map, 1.0e-4) assert (fit.fit_sensitive.image == lens_data_blur.image).all() assert (fit.fit_sensitive.noise_map == lens_data_blur.noise_map).all() mapper = pixelization.mapper_from_grid_stack_and_border( grid_stack=tracer_sensitive.source_plane.grid_stack, border=None) inversion = inv.inversion_from_image_mapper_and_regularization( mapper=mapper, regularization=regularization, image_1d=lens_data_blur.image_1d, noise_map_1d=lens_data_blur.noise_map_1d, convolver=lens_data_blur.convolver_mapping_matrix) assert fit.fit_sensitive.model_image == pytest.approx( inversion.reconstructed_data, 1.0e-4) residual_map = fit_util.residual_map_from_data_mask_and_model_data( data=lens_data_blur.image, mask=lens_data_blur.mask, model_data=inversion.reconstructed_data) assert fit.fit_sensitive.residual_map == pytest.approx( residual_map, 1.0e-4) chi_squared_map = fit_util.chi_squared_map_from_residual_map_noise_map_and_mask( residual_map=residual_map, mask=lens_data_blur.mask, noise_map=lens_data_blur.noise_map) assert fit.fit_sensitive.chi_squared_map == pytest.approx( chi_squared_map, 1.0e-4) chi_squared_normal = fit_util.chi_squared_from_chi_squared_map_and_mask( chi_squared_map=fit.fit_normal.chi_squared_map, mask=lens_data_blur.mask) chi_squared_sensitive = fit_util.chi_squared_from_chi_squared_map_and_mask( chi_squared_map=fit.fit_sensitive.chi_squared_map, mask=lens_data_blur.mask) noise_normalization = fit_util.noise_normalization_from_noise_map_and_mask( mask=lens_data_blur.mask, noise_map=lens_data_blur.noise_map) assert fit.fit_normal.likelihood == -0.5 * (chi_squared_normal + noise_normalization) assert fit.fit_sensitive.likelihood == -0.5 * (chi_squared_sensitive + noise_normalization) assert fit.figure_of_merit == fit.fit_sensitive.likelihood - fit.fit_normal.likelihood fit_from_factory = sensitivity_fit.fit_lens_data_with_sensitivity_tracers( lens_data=lens_data_blur, tracer_normal=tracer_normal, tracer_sensitive=tracer_sensitive) assert fit.figure_of_merit == fit_from_factory.figure_of_merit
print(lens_galaxy) # And for our source galaxy, the same Sersic light profile sersic_light_profile = light_profiles.SphericalSersic(centre=(0.0, 0.0), intensity=1.0, effective_radius=1.0, sersic_index=1.0) source_galaxy = galaxy.Galaxy(light=sersic_light_profile) print(source_galaxy) # Now, lets use the lens and source galaxies to ray-trace our grid-stack, using a 'tracer' from the ray-tracing # module. When we pass our galaxies and grid-stack into the Tracer below, the following happens: # 1) Using the lens-galaxy's mass-profile, the deflection angle of every image-plane grid coordinate is computed. # 2) These deflection angles are used to trace every image-plane coordinate to a source-plane coordinate. # 3) This creates the source-plane grid-stack of lensed coordinates. tracer = ray_tracing.TracerImageSourcePlanes(lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=image_plane_grid_stack) # The tracer is composed of an image-plane and source-plane, just like in the previous example! print('Regular-grid image-plane coordinate 1') print(tracer.image_plane.grid_stack.regular[0]) print('Regular-grid image-plane coordinate 2') print(tracer.image_plane.grid_stack.regular[1]) print('Regular-grid image-plane coordinate 3') print(tracer.image_plane.grid_stack.regular[2]) # And the source-plane's grid has been deflected. print('Regular-grid source-plane coordinate 1') print(tracer.source_plane.grid_stack.regular[0]) print('Regular-grid source-plane coordinate 2') print(tracer.source_plane.grid_stack.regular[1]) print('Regular-grid source-plane coordinate 3')
def make_tracer(galaxy_light, galaxy_mass, grid_stack): return ray_tracing.TracerImageSourcePlanes(lens_galaxies=[galaxy_mass, galaxy_light], source_galaxies=[galaxy_light], image_plane_grid_stack=grid_stack)
# results = pd.concat(list_) image_plane_grid_stack = grids.GridStack.from_shape_pixel_scale_and_sub_size( shape_2d=ccd_data.shape, pixel_scales=ccd_data.pixel_scales, sub_size=2) #print(data) #print(data.iloc[0,16]) lens_galaxy = al.Galaxy(mass=al.mp.EllipticalIsothermal( centre=(data.iloc[0, 5], data.iloc[0, 6]), axis_ratio=data.iloc[0, 7], phi=data.iloc[0, 8], einstein_radius=data.iloc[0, 9]), redshift=0.285) source_galaxy = al.Galaxy( pixelization=pix.AdaptiveMagnification(shape_2d=(data.iloc[0, 14], data.iloc[0, 15])), regularization=reg.Constant(data.iloc[0, 16]), redshift=0.575) #image_plane_grid_stack = grids.GridStack.from_shape_pixel_scale_and_sub_size(shape_2d=(301, 301), pixel_scales=0.03, # sub_size=2) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack, cosmology=cosmology.Planck15) print(np.log10(tracer.einstein_masses_of_planes[0]))
def test__simulate_lensed_source_and_fit__include_psf_blurring__chi_squared_is_0__noise_normalization_correct( ): psf = ccd.PSF.simulate_as_gaussian(shape=(3, 3), pixel_scale=0.2, sigma=0.75) grid_stack = grids.GridStack.grid_stack_for_simulation(shape=(11, 11), pixel_scale=0.2, psf_shape=psf.shape, sub_grid_size=1) lens_galaxy = g.Galaxy(light=lp.EllipticalSersic(centre=(0.1, 0.1), intensity=0.1), mass=mp.EllipticalIsothermal(centre=(0.1, 0.1), einstein_radius=1.8)) source_galaxy = g.Galaxy( light=lp.EllipticalExponential(centre=(0.1, 0.1), intensity=0.5)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=grid_stack) ccd_simulated = ccd.CCDData.simulate( array=tracer.image_plane_image_for_simulation, pixel_scale=0.2, exposure_time=300.0, psf=psf, background_sky_level=None, add_noise=False) ccd_simulated.noise_map = np.ones(ccd_simulated.image.shape) path = "{}/data/simulate_and_fit".format( os.path.dirname(os.path.realpath( __file__))) # Setup path so we can output the simulated image. try: shutil.rmtree(path) except FileNotFoundError: pass if os.path.exists(path) == False: os.makedirs(path) array_util.numpy_array_to_fits(array=ccd_simulated.image, file_path=path + '/image.fits') array_util.numpy_array_to_fits(array=ccd_simulated.noise_map, file_path=path + '/noise_map.fits') array_util.numpy_array_to_fits(array=psf, file_path=path + '/psf.fits') ccd_data = ccd.load_ccd_data_from_fits(image_path=path + '/image.fits', noise_map_path=path + '/noise_map.fits', psf_path=path + '/psf.fits', pixel_scale=0.2) mask = msk.Mask.circular(shape=ccd_data.image.shape, pixel_scale=0.2, radius_arcsec=0.8) lens_data = ld.LensData(ccd_data=ccd_data, mask=mask, sub_grid_size=1) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack) fitter = lens_fit.LensProfileFit(lens_data=lens_data, tracer=tracer) assert fitter.chi_squared == pytest.approx(0.0, 1e-4)
source_galaxy_2 = g.Galaxy(light=lp.EllipticalSersic(centre=(0.45, -0.35), axis_ratio=0.6, phi=90.0, intensity=0.03, effective_radius=0.3, sersic_index=3.5)) source_galaxy_3 = g.Galaxy(light=lp.EllipticalSersic(centre=(-0.05, -0.0), axis_ratio=0.9, phi=140.0, intensity=0.03, effective_radius=0.1, sersic_index=4.0)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[ source_galaxy_0, source_galaxy_1, source_galaxy_2, source_galaxy_3 ], image_plane_grid_stack=lens_data.grid_stack) true_fit = lens_fit.fit_lens_data_with_tracer(lens_data=lens_data, tracer=tracer) lens_fit_plotters.plot_fit_subplot(fit=true_fit) # And indeed, we see far improved residuals, chi-squareds, etc. # The morale of this story is that, if the source morphology is complex, there is no way we can build a pipeline to # fit it. For this tutorial, this was true even though our source model could actually fit the data perfectly. For # real lenses, the source will be *even more complex* and there is even less hope of getting a good fit :( # But fear not, PyAutoLens has you covered. In chapter 4, we'll introduce a completely new way to model the source
source_galaxy = al.Galaxy(light=al.lp.EllipticalSersic( centre=(results.loc[lens[i]]['param']['source_light_centre_0'], results.loc[lens[i]]['param']['source_light_centre_1']), axis_ratio=results.loc[lens[i]]['param']['source_light_axis_ratio'], phi=results.loc[lens[i]]['param']['source_light_phi'], intensity=results.loc[lens[i]]['param']['source_light_intensity'], effective_radius=results.loc[ lens[i]]['param']['source_light_effective_radius'], sersic_index=results.loc[ lens[i]]['param']['source_light_sersic_index']), redshift=slacs['z_source'][i]) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=image_plane_grid_stack, cosmology=cosmology.Planck15) tracer_error_hi = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy_hi], source_galaxies=[source_galaxy], image_plane_grid_stack=image_plane_grid_stack, cosmology=cosmology.Planck15) tracer_error_low = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy_low], source_galaxies=[source_galaxy], image_plane_grid_stack=image_plane_grid_stack, cosmology=cosmology.Planck15) einstein_mass = tracer.einstein_masses_in_solar_masses_of_planes[0] einstein_mass_error_hi = tracer_error_hi.einstein_masses_in_solar_masses_of_planes[
# Lets look at our source galaxies (before lensing) galaxy_plotters.plot_intensities(galaxy=source_galaxy_0, grid=image_plane_grid_stack.regular, title='Source Galaxy 0') galaxy_plotters.plot_intensities(galaxy=source_galaxy_1, grid=image_plane_grid_stack.regular, title='Source Galaxy 1') # Now lets pass these our 4 galaxies to the ray_tracing module, which means the following will occur: # 1) Using every mass-profile in each lens galaxy, the deflection angles are computed. # 2) These deflection angles are summed, such that the deflection of light due to every mass-profile and both # the lens galaxy and its satellite is computed. # 3) These deflection angles are used to trace every image-grid and sub-grid coordinate to a source-plane coordinate. # 4) The light of all source galaxies is ray-traced back forward to form our image-plane image. # Note that we've also supplied the tracer below with a Planck15 cosmology. tracer = ray_tracing.TracerImageSourcePlanes(lens_galaxies=[lens_galaxy, lens_satellite], source_galaxies=[source_galaxy_0, source_galaxy_1], image_plane_grid_stack=image_plane_grid_stack, cosmology=cosmology.Planck15) # As we did previously, we can inspect each grid. plane_plotters.plot_plane_grid(plane=tracer.image_plane, title='Image-plane Grid') plane_plotters.plot_plane_grid(plane=tracer.source_plane, title='Source-plane Grid') # We can zoom in on the 'centre' of the source-plane. plane_plotters.plot_plane_grid(plane=tracer.source_plane, axis_limits=[-0.2, 0.2, -0.2, 0.2], title='Source-plane Grid') # Lets plot the lensing quantities again. Note that, because we supplied our galaxies with redshifts and # our tracer with a cosmology, our units have been converted to kiloparsecs! # (This line can take a bit of time to run) ray_tracing_plotters.plot_ray_tracing_subplot(tracer=tracer) # In the previous example, we saw that the tracer had attributes we plotted (e.g. surface density, potential, etc.)
# Now, lets simulate the source, mask it, and use a plot to check the masking is appropriate. ccd_data = simulate() mask = msk.Mask.circular_annular(shape=ccd_data.shape, pixel_scale=ccd_data.pixel_scale, inner_radius_arcsec=1.0, outer_radius_arcsec=2.2) ccd_plotters.plot_image(ccd_data=ccd_data, mask=mask) # Next, lets set this image up as lens data, and setup a tracer using the input lens galaxy model (we don't need # to provide the source's light profile, as we're using a mapper to reconstruct it). lens_data = ld.LensData(ccd_data=ccd_data, mask=mask, sub_grid_size=1) lens_galaxy = g.Galaxy(mass=mp.EllipticalIsothermal( centre=(0.0, 0.0), axis_ratio=0.8, phi=135.0, einstein_radius=1.6)) tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[g.Galaxy()], image_plane_grid_stack=lens_data.grid_stack) # We'll use another rectangular pixelization and mapper to perform the reconstruction rectangular = pix.Rectangular(shape=(25, 25)) mapper = rectangular.mapper_from_grid_stack_and_border( grid_stack=tracer.source_plane.grid_stack, border=None) mapper_plotters.plot_image_and_mapper(ccd_data=ccd_data, mask=mask, mapper=mapper, should_plot_grid=True) # And now, finally, we're going to use our mapper to invert the image using the 'inversions' module, which is imported # as 'inv'. I'll explain how this works in a second - but lets just go ahead and perform the inversion first. # (Ignore the 'regularization' input below for now, we'll cover this in the next tutorial). inversion = inv.Inversion(image_1d=lens_data.image_1d,