def make_analysis(self, dataset, xy_mask): masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask) transformers = [] for i in range(masked_dataset.uv_wavelengths.shape[0]): transformers.append( self.transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths[i], grid=masked_dataset.grid_3d.grid_2d.in_radians)) """ def get_continuum(masked_dataset, regions): pass continuum = np.zeros( shape=(dataset.visibilities.shape[0], ), dtype=bool ) for region in self.regions: continuum += region def func(masked_dataset, continuum): argspec = inspect.getargspec(MaskedDatasetLite.__init__) args = {} for argname in argspec.args: if argname not in ["self"]: if hasattr(masked_dataset, argname): array = getattr(masked_dataset, argname) args[argname] = reshape_array( array=array[~continuum] ) return MaskedDatasetLite(**args) masked_dataset_continuum = func(masked_dataset, continuum) #print(masked_dataset_continuum.uv_wavelengths.shape) transformer_continuum = self.transformer_class( uv_wavelengths=masked_dataset_continuum.uv_wavelengths, grid=masked_dataset.grid_3d.grid_2d.in_radians ) # dirty_image = transformer_continuum.image_from_visibilities( # visibilities=masked_dataset_continuum.visibilities # ) # plt.figure() # plt.imshow(dirty_image[::-1], cmap="jet") # plt.xticks([]) # plt.yticks([]) # plt.show() """ return Analysis(masked_dataset=masked_dataset, transformers=transformers, transformer_continuum=None, lens_redshift=self.lens_redshift, source_redshift=self.source_redshift, image_path=self.optimizer.paths.image_path)
def make_analysis(self, dataset, xy_mask): # NOTE: Multiple lines can be present in a cube, in which # case region will be a list (renamed to regions) masked_dataset = MaskedDataset( dataset=dataset, xy_mask=xy_mask, region=self.region ) masked_dataset_continuum = RegionMaskedDataset( dataset=masked_dataset.dataset_outside_region, uv_mask=masked_dataset.uv_mask_outside_region, continuum=True ) masked_dataset_line = RegionMaskedDataset( dataset=masked_dataset.dataset_inside_region, uv_mask=masked_dataset.uv_mask_inside_region, continuum=False ) transformers = [] for i in range(masked_dataset.uv_wavelengths.shape[0]): transformers.append( self.transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths[i], grid=masked_dataset.grid_3d.grid_2d.in_radians ) ) transformer_continuum = self.transformer_class( uv_wavelengths=masked_dataset_continuum.uv_wavelengths, grid=masked_dataset.grid_3d.grid_2d.in_radians ) # # NOTE: EXPERIMENTAL # holder = RegionMaskedDatasetsHolder( # region_masked_datasets=[ # masked_dataset_continuum, # masked_dataset_line # ] # ) # exit() # TODO: region_masked_datasets can be a class that holds individual # masked datasets and it's only function will be to differentiate between # a masked_dataset corresponding to the continuum and the rest. return Analysis( masked_dataset=masked_dataset, region_masked_datasets=[ masked_dataset_continuum, masked_dataset_line ], transformers=transformers, transformer_continuum=transformer_continuum, image_path=self.optimizer.paths.image_path )
def make_analysis(self, dataset, xy_mask): masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask) transformer = self.transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths, grid=masked_dataset.grid.in_radians) return Analysis(masked_dataset=masked_dataset, transformer=transformer, self_calibration=self.self_calibration, image_path=self.optimizer.paths.image_path)
def make_analysis(self, dataset, xy_mask): masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask) transformers = [] for i in range(masked_dataset.uv_wavelengths.shape[0]): transformers.append( self.transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths[i], grid=masked_dataset.grid_3d.grid_2d.in_radians)) return Analysis(masked_dataset=masked_dataset, transformers=transformers, image_path=self.optimizer.paths.image_path)
def test(dataset, xy_mask, tracer, self_calibration, transformer_class=al.TransformerFINUFFT): masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask) grid = masked_dataset.grid transformer = transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths, grid=grid.in_radians) model_data = tracer.profile_visibilities_from_grid_and_transformer( grid=grid, transformer=transformer) if self_calibration: phase_errors = calibration_utils.phase_errors_from_A_and_B_matrices( phases=masked_dataset.phases, model_phases=model_data.phases, A=masked_dataset.A, B=masked_dataset.B) model_phases_corrected = np.add( model_data.phases, np.matmul(masked_dataset.f.T, phase_errors)) model_data = aa.structures.visibilities.Visibilities( visibilities_1d=np.stack(arrays=( model_data.amplitudes * np.cos(model_phases_corrected), model_data.amplitudes * np.sin(model_phases_corrected)), axis=-1)) fit_temp = fit.DatasetFit(masked_dataset=masked_dataset, model_data=model_data) # print("likelihood = ", fit_temp.likelihood) # # fit_plots.residual_map( # fit=fit_temp, # transformer=transformer, # output_filename=None, # output_path=None, # output_format="show", # ) return fit_temp.likelihood
def test(dataset, xy_mask, tracer, self_calibration, transformer_class=al.TransformerFINUFFT): masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask) grid = masked_dataset.grid transformer = transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths, grid=grid.in_radians) model_data = tracer.profile_visibilities_from_grid_and_transformer( grid=grid, transformer=transformer) fit_plots.residual_map(fit=fit.DatasetFit( masked_dataset=masked_dataset, model_data=model_data), transformer=transformer, output_format="show")
# ncols=8, # cube_contours=cube, # # ) # exit() line_emission_region = region( n=dataset.uv_wavelengths.shape[0], n_min=11, n_max=23, invert=False ) masked_dataset = MaskedDataset( dataset=dataset, xy_mask=xy_mask, region=line_emission_region ) # plot_utils.plot_cube( # cube=dirty_cube_from_visibilities( # visibilities=masked_dataset.visibilities_outside_region, # transformers=[transformer for (i, transformer) in enumerate(transformers) # if not masked_dataset.region[i] # ], # shape=(masked_dataset.visibilities_outside_region.shape[0], ) + grid_3d.shape_2d, # invert=True # ), # ncols=5, # # ) # exit()
# cube=autolens_plot_utils.dirty_cube_from_visibilities( # visibilities=dataset.visibilities, # transformers=transformers, # shape=cube.shape, # invert=True # ), # ncols=8, # cube_contours=lensed_cube, # # ) # exit() emission_line_region = Region.from_limits(n=n_channels, n_min=11, n_max=23) masked_dataset = MaskedDataset( dataset=dataset, xy_mask=xy_mask, ) # pixelization_shape_0 = 20 # pixelization_shape_1 = 20 # regularization_coefficient = 10.0 # # source_galaxy = al.Galaxy( # redshift=source_redshift, # pixelization=al.pix.VoronoiMagnification( # shape=(pixelization_shape_0, pixelization_shape_1) # ), # regularization=al.reg.Constant( # coefficient=regularization_coefficient # ), # )
def make_analysis(self, dataset, xy_mask): # NOTE: The masked_dataset is no longer being used, instead each compoent # (i.e. continuum + emission line regions) each have their own masked_dataset # which is initialized here. def masked_datasets_from_regions(masked_dataset, regions): args = { "continuum":{} } idx = np.zeros( shape=(masked_dataset.visibilities.shape[0], ), dtype=bool ) for i, region in enumerate(regions): idx += region.idx args["region_{}".format(i)] = {} if all(idx): continuum = False else: continuum = True argspec = inspect.getargspec(MaskedDatasetLite.__init__) #args = {} for argname in argspec.args: if argname not in ["self"]: if hasattr(masked_dataset, argname): array = getattr(masked_dataset, argname) if continuum: args["continuum"][argname] = reshape_array( array=array[~idx] ) for i, region in enumerate(regions): args["region_{}".format(i)][argname] = reshape_array( array=array[region.idx] ) #args["region_{}".format(i)][argname] = np.average(a=array[region.idx], axis=0) masked_datasets = { "continuum":MaskedDatasetLite(**args["continuum"]) if continuum else None } for i, region in enumerate(regions): masked_datasets["region_{}".format(i)] = MaskedDatasetLite(**args["region_{}".format(i)]) return masked_datasets # NOTE: Multiple lines can be present in a cube, in which # case region will be a list (renamed to regions) - DONE # NOTE: Can we skip the initialization of the masked dataset? masked_dataset = MaskedDataset( dataset=dataset, xy_mask=xy_mask, ) masked_datasets = masked_datasets_from_regions( masked_dataset=masked_dataset, regions=self.regions ) transformers = {} for key in masked_datasets.keys(): if masked_datasets[key] is not None: transformers[key] = self.transformer_class( uv_wavelengths=masked_datasets[key].uv_wavelengths, grid=masked_dataset.grid_3d.grid_2d.in_radians ) else: transformers[key] = None return Analysis( masked_datasets=masked_datasets, transformers=transformers, grid=masked_dataset.grid_3d.grid_2d, image_path=self.optimizer.paths.image_path )
def make_analysis(self, dataset, mask): masked_dataset = MaskedDataset(dataset=dataset, mask=mask) return Analysis(masked_dataset=masked_dataset, image_path=self.optimizer.paths.image_path)
def test(dataset, xy_mask, profiles, lens_redshift, source_redshift, transformer_class=al.TransformerFINUFFT): def src_model_from_profiles(profiles, masked_dataset): return sum([ profile.profile_cube_from_grid( grid=masked_dataset.grid_3d.grid_2d, shape_3d=masked_dataset.grid_3d.shape_3d, z_step_kms=masked_dataset.z_step_kms) for profile in profiles ]) masked_dataset = MaskedDataset(dataset=dataset, xy_mask=xy_mask) transformers = [] for i in range(masked_dataset.uv_wavelengths.shape[0]): transformers.append( transformer_class( uv_wavelengths=masked_dataset.uv_wavelengths[i], grid=masked_dataset.grid_3d.grid_2d.in_radians)) len_profiles = [] src_profiles = [] for profile in profiles: if isinstance(profile, al.mp.MassProfile): len_profiles.append(profile) else: src_profiles.append(profile) galaxies = [] for profile in len_profiles: galaxies.append(al.Galaxy( redshift=lens_redshift, mass=profile, )) galaxies.append( al.Galaxy(redshift=source_redshift, light=al.lp.LightProfile())) tracer = al.Tracer.from_galaxies(galaxies=galaxies) cube = src_model_from_profiles(profiles=src_profiles, masked_dataset=masked_dataset) lensed_cube = autolens_tracer_utils.lensed_cube_from_tracer( tracer=tracer, grid=masked_dataset.grid_3d.grid_2d, cube=cube) model_data = np.zeros(shape=masked_dataset.data.shape) for i in range(model_data.shape[0]): model_data[i] = transformers[i].visibilities_from_image( image=Image(array_2d=lensed_cube[i])) # dirty_cube = autolens_plot_utils.dirty_cube_from_visibilities( # visibilities=masked_dataset.data, # transformers=transformers, # shape=masked_dataset.grid_shape_3d # ) # # dirty_model_cube = autolens_plot_utils.dirty_cube_from_visibilities( # visibilities=model_data, # transformers=transformers, # shape=masked_dataset.grid_shape_3d # ) # # # velocities = np.linspace( # -n_channels * z_step_kms / 2.0, # +n_channels * z_step_kms / 2.0, # n_channels # ) # dirty_moment_0 = spectral_utils.moment_0( # cube=dirty_cube, # velocities=velocities # ) # dirty_model_moment_0 = spectral_utils.moment_0( # cube=dirty_model_cube, # velocities=velocities # ) # plt.figure() # plt.imshow(dirty_moment_0 - dirty_model_moment_0, cmap="jet") # plt.show() # exit() fit_plots.residual_map(fit=fit.DatasetFit( masked_dataset=masked_dataset, model_data=model_data), transformers=transformers)
data=np.add( cube, noise_map ), noise_map=noise_map, z_step_kms=z_step_kms ) # plot_utils.plot_cube( # cube=dataset.data, # ncols=8 # ) # exit() masked_dataset = MaskedDataset( dataset=dataset, mask=mask_3d ) # ================================================ # # NOTE: ... """ model_temp = profiles.Kinematical( centre=(0.0, 0.0), z_centre=16.0, intensity=1.0, effective_radius=0.5, inclination=30.0, phi=50.0, turnover_radius=0.05, maximum_velocity=200.0,