예제 #1
0
    def visualize_fit(self, fit, during_analysis):
        pass

        # fit_plots.data(
        #     fit=fit,
        #     output_filename="fit_data",
        #     output_path=self.image_path,
        #     output_format="png",
        # )
        # fit_plots.noise_map(
        #     fit=fit,
        #     output_filename="fit_noise_map",
        #     output_path=self.image_path,
        #     output_format="png",
        # )
        # fit_plots.model_data(
        #     fit=fit,
        #     output_filename="fit_model_data",
        #     output_path=self.image_path,
        #     output_format="png",
        # )

        fit_plots.residual_map(
            fit=fit,
            output_filename="fit_residual_map",
            output_path=self.image_path,
            output_format="png",
        )
예제 #2
0
파일: runner.py 프로젝트: Sketos/tutorials
    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")
예제 #3
0
    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)