def run( module, test_name=None, optimizer_class=af.MultiNest, config_folder="config", positions=None, ): test_name = test_name or module.test_name test_path = "{}/../".format(os.path.dirname(os.path.realpath(__file__))) output_path = test_path + "output/" config_path = test_path + config_folder af.conf.instance = af.conf.Config(config_path=config_path, output_path=output_path) integration_util.reset_paths(test_name=test_name, output_path=output_path) imaging_data = simulation_util.load_test_imaging_data( data_type=module.data_type, data_resolution=module.data_resolution ) module.make_pipeline( name=test_name, phase_folders=[module.test_type, test_name], optimizer_class=optimizer_class, ).run(data=imaging_data, positions=positions)
sub_size = 2 inner_radius_arcsec = 0.2 outer_radius_arcsec = 4.0 print("sub grid size = " + str(sub_size)) print("annular inner mask radius = " + str(inner_radius_arcsec) + "\n") print("annular outer mask radius = " + str(outer_radius_arcsec) + "\n") for data_resolution in ["HST_Up"]: print() imaging_data = simulation_util.load_test_imaging_data( data_type="lens_mass__source_smooth", data_resolution=data_resolution, psf_shape=(3, 3), ) mask = al.Mask.circular_annular( shape=imaging_data.shape, pixel_scale=imaging_data.pixel_scale, inner_radius_arcsec=inner_radius_arcsec, outer_radius_arcsec=outer_radius_arcsec, ) lens_data = al.LensData(imaging_data=imaging_data, mask=mask, sub_size=sub_size) print("Deflection angle run times for image type " + data_resolution + "\n") print("Number of points = " + str(lens_data.grid.shape[0]) + "\n")
from autolens.array import mask as msk from test.simulation import simulation_util from autolens.plotters import array_plotters # In this tutorial, we'll introduce a new pixelization, called an adaptive-pixelization. This pixelization doesn't use # uniform grid of rectangular pixels, but instead uses ir'Voronoi' pixels. So, why would we want to do that? # Lets take another look at the rectangular grid, and think about its weakness. # Lets quickly remind ourselves of the image, and the 3.0" circular mask we'll use to mask it. imaging_data = simulation_util.load_test_imaging_data( data_type="lens_light_dev_vaucouleurs", data_resolution="LSST") array = imaging_data.image mask = al.Mask.circular( shape=imaging_data.shape, pixel_scale=imaging_data.pixel_scale, radius_arcsec=5.0, centre=(0.0, 0.0), ) array_plotters.plot_array( array=array, mask=mask, positions=[[[1.0, 1.0]]], centres=[[(0.0, 0.0)]], zoom_around_mask=True, extract_array_from_mask=True, ) imaging_data = simulation_util.load_test_imaging_data( data_type="lens_sis__source_smooth__offset_centre", data_resolution="LSST") array = imaging_data.image
from autolens.lens.plotters import lens_imaging_fit_plotters from test.simulation import simulation_util # In this tutorial, we'll introduce a new pixelization, called an adaptive-pixelization. This pixelization doesn't use # uniform grid of rectangular pixels, but instead uses ir'Voronoi' pixels. So, why would we want to do that? # Lets take another look at the rectangular grid, and think about its weakness. # Lets quickly remind ourselves of the image, and the 3.0" circular mask we'll use to mask it. imaging_data = simulation_util.load_test_imaging_data( data_type="lens_light_dev_vaucouleurs", data_resolution="LSST" ) mask = al.Mask.circular( shape=imaging_data.shape, pixel_scale=imaging_data.pixel_scale, radius_arcsec=3.0 ) # The lines of code below do everything we're used to, that is, setup an image and its al.ogrid, mask it, trace it # via a tracer, setup the rectangular mapper, etc. lens_galaxy = al.Galaxy( bulge=al.EllipticalDevVaucouleurs( centre=(0.0, 0.0), axis_ratio=0.9, phi=45.0, intensity=0.1, effective_radius=1.0 ) ) lens_data = al.LensData(imaging_data=imaging_data, mask=mask) tracer = al.Tracer.from_galaxies(galaxies=[lens_galaxy]) fit = al.LensImageFit.from_lens_data_and_tracer(lens_data=lens_data, tracer=tracer) lens_imaging_fit_plotters.plot_fit_subplot( fit=fit, should_plot_mask=True, extract_array_from_mask=True, zoom_around_mask=True )
# It is convinient to specify the lens name as a string, so that if the pipeline is applied to multiple images we \ # don't have to change all of the path entries in the load_imaging_data_from_fits function below. data_type = "no_lens_source_smooth" data_resolution = "Euclid" # Setup the size of the sub-grid and mask used for this precision analysis. sub_size = 2 inner_radius_arcsec = 0.0 outer_radius_arcsec = 3.0 # The pixel scale of the interpolation grid, where a smaller pixel scale gives a higher resolution grid and therefore # more precise interpolation of the sub-grid deflection angles. pixel_scale_interpolation_grid = 0.2 imaging_data = simulation_util.load_test_imaging_data( data_type=data_type, data_resolution=data_resolution, psf_shape=(21, 21)) # The phase is passed the mask we setup below using the radii specified above. mask = al.Mask.circular_annular( shape=imaging_data.shape, pixel_scale=imaging_data.pixel_scale, inner_radius_arcsec=inner_radius_arcsec, outer_radius_arcsec=outer_radius_arcsec, ) # Plot the Imaging data_type and mask. imaging_plotters.plot_imaging_subplot(imaging_data=imaging_data, mask=mask) # To perform the analysis, we set up a phase using the 'phase' module (imported as 'ph'). # A phase takes our galaxy models and fits their parameters using a non-linear search (in this case, MultiNest). phase = al.PhaseImaging(