def make_lens_image(): ccd_data = ccd.CCDData(np.array(np.zeros(shape)), pixel_scale=1.0, psf=ccd.PSF(np.ones((3, 3)), pixel_scale=1.0), noise_map=ccd.NoiseMap(np.ones(shape), pixel_scale=1.0)) mask = msk.Mask.circular(shape=shape, pixel_scale=1, radius_arcsec=3.0) return li.LensData(ccd_data=ccd_data, mask=mask)
def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles( self, ccd_data): lens_galaxy = g.Galaxy(light=lp.EllipticalSersic(intensity=0.1)) source_galaxy = g.Galaxy( pixelization=pix.Rectangular(shape=(4, 4)), regularization=reg.Constant(coefficients=(1.0, ))) phase = ph.LensPlanePhase(lens_galaxies=[lens_galaxy], mask_function=ph.default_mask_function, cosmology=cosmo.FLRW, phase_name='test_phase') analysis = phase.make_analysis(data=ccd_data) instance = phase.constant fit_figure_of_merit = analysis.fit(instance=instance) mask = phase.mask_function(image=ccd_data.image) lens_data = li.LensData(ccd_data=ccd_data, mask=mask) tracer = analysis.tracer_for_instance(instance=instance) fit = lens_fit.LensProfileFit(lens_data=lens_data, tracer=tracer) assert fit.likelihood == fit_figure_of_merit phase = ph.LensSourcePlanePhase(lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], mask_function=ph.default_mask_function, cosmology=cosmo.FLRW, phase_name='test_phase') analysis = phase.make_analysis(data=ccd_data) instance = phase.constant fit_figure_of_merit = analysis.fit(instance=instance) mask = phase.mask_function(image=ccd_data.image) lens_data = li.LensData(ccd_data=ccd_data, mask=mask) tracer = analysis.tracer_for_instance(instance=instance) fit = lens_fit.LensProfileInversionFit(lens_data=lens_data, tracer=tracer) assert fit.evidence == fit_figure_of_merit
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 test__constructor_inputs(self): psf = ccd.PSF(np.ones((7, 7)), 1) image = ccd.CCDData(np.ones((51, 51)), pixel_scale=3., psf=psf, noise_map=np.ones((51, 51))) mask = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=(51, 51), pixel_scale=1.0, invert=True) mask[26, 26] = False lens_data = ld.LensData(image, mask, sub_grid_size=8, image_psf_shape=(5, 5), mapping_matrix_psf_shape=(3, 3), positions=[np.array([[1.0, 1.0]])]) assert lens_data.sub_grid_size == 8 assert lens_data.convolver_image.psf_shape == (5, 5) assert lens_data.convolver_mapping_matrix.psf_shape == (3, 3) assert (lens_data.positions[0] == np.array([[1.0, 1.0]])).all() assert lens_data.image_psf_shape == (5,5) assert lens_data.mapping_matrix_psf_shape == (3,3)
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 make_lens_data_blur(): psf = ccd.PSF(array=(np.array([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])), pixel_scale=1.0, renormalize=False) im = ccd.CCDData(image=5.0 * np.ones((6, 6)), pixel_scale=1.0, psf=psf, noise_map=np.ones((6, 6)), exposure_time_map=3.0 * np.ones((6, 6)), background_sky_map=4.0 * np.ones((6, 6))) ma = np.array([[True, True, True, True, True, True], [True, False, False, False, False, True], [True, False, False, False, False, True], [True, False, False, False, False, True], [True, False, False, False, False, True], [True, True, True, True, True, True]]) ma = mask.Mask(array=ma, pixel_scale=1.0) return ld.LensData(ccd_data=im, mask=ma, sub_grid_size=2)
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 make_lens_image(image, mask): return li.LensData(ccd_data=image, mask=mask)
# Again, before we checkout the pipeline, lets import it, and get it running. from workspace.howtolens.chapter_3_pipelines import tutorial_3_pipeline_complex_source pipeline_complex_source = tutorial_3_pipeline_complex_source.make_pipeline( pipeline_path='/howtolens/c3_t3_complex_source/') pipeline_complex_source.run(data=ccd_data) # Okay, so with 4 sources, we still couldn't get a good a fit to the source that didn't leave residuals. The thing is, # I did infact simulate the lens with 4 sources. This means that there is a 'perfect fit', somewhere in that parameter # space, that we unfortunately missed using the pipeline above. # # Lets confirm this, by manually fitting the ccd data with the true input model. lens_data = ld.LensData(ccd_data=ccd_data, mask=msk.Mask.circular( shape=ccd_data.shape, pixel_scale=ccd_data.pixel_scale, radius_arcsec=3.0)) 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_0 = g.Galaxy(light=lp.EllipticalSersic(centre=(0.1, 0.1), axis_ratio=0.8, phi=90.0, intensity=0.2, effective_radius=1.0, sersic_index=1.5)) source_galaxy_1 = g.Galaxy(light=lp.EllipticalSersic(centre=(-0.25, 0.25), axis_ratio=0.7, phi=45.0, intensity=0.1,
def make_lens_ccd(ccd, mask): return ld.LensData(ccd_data=ccd, mask=mask)
pixelization = pix.AdaptiveMagnification(shape=pixelization_shape) source_galaxy = g.Galaxy(pixelization=pixelization, regularization=reg.Constant(coefficients=(1.0, ))) for image_type in ['LSST', 'Euclid', 'HST', 'HST_Up', 'AO']: ccd_data = tools.load_profiling_ccd_data(image_type=image_type, lens_name='no_lens_source_smooth', psf_shape=psf_shape) mask = msk.Mask.circular(shape=ccd_data.shape, pixel_scale=ccd_data.pixel_scale, radius_arcsec=radius_arcsec) lens_data = ld.LensData(ccd_data=ccd_data, mask=mask, sub_grid_size=sub_grid_size) print('AdaptiveMagnification Inversion fit run times for image type ' + image_type + '\n') print('Number of points = ' + str(lens_data.grid_stack.sub.shape[0]) + '\n') start_overall = time.time() start = time.time() for i in range(repeats): tracer = ray_tracing.TracerImageSourcePlanes( lens_galaxies=[lens_galaxy], source_galaxies=[source_galaxy], image_plane_grid_stack=lens_data.grid_stack)
# Now we've loaded the ccd data and created a mask, we use them to create a 'lens data' object, which we'll perform # using the lens_data module (imported as 'ld'). # A lens data object is a 'package' of all parts of a data-set we need in order to fit it with a lens model: # 1) The ccd-data, e.g. the image, PSF (so that when we compare a tracer's image-plane image to the image data we # can include blurring due to the telescope optics) and noise-map (so our goodness-of-fit measure accounts for # noise in the observations). # 2) The mask, so that only the regions of the image with a signal are fitted. # 3) A grid-stack aligned to the ccd-imaging data's pixels: so the tracer's image-plane image is generated on the same # (masked) grid as the image. lens_data = ld.LensData(ccd_data=ccd_data, mask=mask) ccd_plotters.plot_image(ccd_data=ccd_data) # By printing its attribute, we can see that it does indeed contain the image, mask, psf and so on print('Image:') print(lens_data.image) print('Noise-Map:') print(lens_data.noise_map) print('PSF:') print(lens_data.psf) print('Mask') print(lens_data.mask) print('Grid') print(lens_data.grid_stack.regular) # The image, noise-map and grids are masked using the mask and mapped to 1D arrays for fast calcuations.
def test_default_mask_function(self, phase, ccd_data): lens_data = li.LensData(ccd_data=ccd_data, mask=phase.mask_function(ccd_data.image)) assert len(lens_data.image_1d) == 32
radius_arcsec=2.0) # lens_data = ld.LensData(ccd_data=ccd_data_small_stamp, mask=mask) # Gives an error due to the mask's blurring region hitting an edge # We can overcome this using the same input as before. However, now, the resized regular shape is bigger than the regular, # thus a padding of zeros is introduced to the edges. ccd_data_small_stamp_padded = ccd.load_ccd_data_from_fits( image_path=path + 'data/image_small_stamp/image.fits', pixel_scale=0.1, noise_map_path=path + 'data/image_small_stamp/noise_map.fits', psf_path=path + 'data/image_small_stamp/psf.fits', resized_ccd_shape=(140, 140)) mask = ma.Mask.circular(shape=ccd_data_small_stamp_padded.shape, pixel_scale=ccd_data_small_stamp_padded.pixel_scale, radius_arcsec=2.0) ccd_plotters.plot_ccd_subplot(ccd_data=ccd_data_small_stamp_padded, mask=mask) lens_data = ld.LensData(ccd_data=ccd_data_small_stamp_padded, mask=mask) # No error anymore! ########## IVE INCLUDED THE TEXT FOR 5 BELOW SO YOU CAN BE AWARE OF CENTERING, BUT THE BUILT IN FUNCTIONALITY FOR ##### ########## RECENTERING CURRENTLY DOES NOT WORK :( ########### # 5) Lens Galaxy Centering - The regular should place the lens galaxy in the origin of the regular, as opposed to a # corner. This ensures the origin of the lens galaxy's light and mass profiles will be near the origin (0.0", 0.0"), # as wel as the origin of the masks, which is a more intuitive coordinate system. The priors on the light # profiles and mass profile also assume a origin of (0.0", 0.0"), as well as the default masks origin. # Lets look at an off-center regular - clearly both the lens galaxy and Einstein ring are offset in the positive y and x d # directions. # ccd_data_offset_centre = ccd.load_ccd_data_from_fits(image_path=path+'data/image_offset_centre/image.fits', pixel_scale=0.1, # noise_map_path=path+'data/image_offset_centre/noise_map.fits', # psf_path=path+'data/image_offset_centre/psf.fits')
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)