def test__plane_generator_from_aggregator(masked_imaging_7x7, samples, model):
path_prefix = "aggregator_plane_gen"
database_file = path.join(conf.instance.output_path, "plane.sqlite")
result_path = path.join(conf.instance.output_path, path_prefix)
clean(database_file=database_file, result_path=result_path)
search = mock.MockSearch(samples=samples)
search.paths = af.DirectoryPaths(path_prefix=path_prefix)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7)
search.fit(model=model, analysis=analysis)
agg = af.Aggregator.from_database(filename=database_file)
agg.add_directory(directory=result_path)
plane_gen = ag.agg.Plane(aggregator=agg)
for plane in plane_gen:
assert plane.galaxies[0].redshift == 0.5
assert plane.galaxies[0].light.centre == (0.0, 1.0)
assert plane.galaxies[1].redshift == 1.0
clean(database_file=database_file, result_path=result_path)
def test__figure_of_merit__includes_hyper_image_and_noise__matches_fit(
self, masked_imaging_7x7
):
hyper_image_sky = ag.hyper_data.HyperImageSky(sky_scale=1.0)
hyper_background_noise = ag.hyper_data.HyperBackgroundNoise(noise_scale=1.0)
galaxy = ag.Galaxy(redshift=0.5, light=ag.lp.EllSersic(intensity=0.1))
model = af.Collection(
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
galaxies=af.Collection(galaxy=galaxy),
)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7)
instance = model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(instance=instance)
plane = analysis.plane_for_instance(instance=instance)
fit = ag.FitImaging(
imaging=masked_imaging_7x7,
plane=plane,
hyper_image_sky=hyper_image_sky,
hyper_background_noise=hyper_background_noise,
)
assert fit.log_likelihood == fit_figure_of_merit
def test__fit_imaging_generator_from_aggregator(masked_imaging_7x7, samples,
model):
path_prefix = "aggregator_fit_imaging_gen"
database_file = path.join(conf.instance.output_path, "fit_imaging.sqlite")
result_path = path.join(conf.instance.output_path, path_prefix)
clean(database_file=database_file, result_path=result_path)
search = mock.MockSearch(samples=samples)
search.paths = af.DirectoryPaths(path_prefix=path_prefix)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7)
search.fit(model=model, analysis=analysis)
agg = af.Aggregator.from_database(filename=database_file)
agg.add_directory(directory=result_path)
fit_imaging_gen = ag.agg.FitImaging(aggregator=agg)
for fit_imaging in fit_imaging_gen:
assert (fit_imaging.image == masked_imaging_7x7.image).all()
clean(database_file=database_file, result_path=result_path)
def test__uses_hyper_fit_correctly(self, masked_imaging_7x7):
galaxies = af.ModelInstance()
galaxies.galaxy = ag.Galaxy(redshift=0.5,
light=ag.lp.EllSersic(intensity=1.0),
mass=ag.mp.SphIsothermal)
galaxies.source = ag.Galaxy(redshift=1.0, light=ag.lp.EllSersic())
instance = af.ModelInstance()
instance.galaxies = galaxies
galaxy_hyper_image = ag.Array2D.ones(shape_native=(3, 3),
pixel_scales=0.1)
galaxy_hyper_image[4] = 10.0
hyper_model_image = ag.Array2D.full(fill_value=0.5,
shape_native=(3, 3),
pixel_scales=0.1)
hyper_galaxy_image_path_dict = {
("galaxies", "galaxy"): galaxy_hyper_image
}
result = mock.MockResult(
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=hyper_model_image,
)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7,
hyper_dataset_result=result)
hyper_galaxy = ag.HyperGalaxy(contribution_factor=1.0,
noise_factor=1.0,
noise_power=1.0)
instance.galaxies.galaxy.hyper_galaxy = hyper_galaxy
fit_likelihood = analysis.log_likelihood_function(instance=instance)
g0 = ag.Galaxy(
redshift=0.5,
light_profile=instance.galaxies.galaxy.light,
mass_profile=instance.galaxies.galaxy.mass,
hyper_galaxy=hyper_galaxy,
hyper_model_image=hyper_model_image,
hyper_galaxy_image=galaxy_hyper_image,
hyper_minimum_value=0.0,
)
g1 = ag.Galaxy(redshift=1.0,
light_profile=instance.galaxies.source.light)
plane = ag.Plane(galaxies=[g0, g1])
fit = ag.FitImaging(dataset=masked_imaging_7x7, plane=plane)
assert (fit.plane.galaxies[0].hyper_galaxy_image == galaxy_hyper_image
).all()
assert fit_likelihood == fit.log_likelihood
def test__make_result__result_imaging_is_returned(self, masked_imaging_7x7):
model = af.Collection(galaxies=af.Collection(galaxy_0=ag.Galaxy(redshift=0.5)))
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7)
search = mock.MockSearch(name="test_search")
result = search.fit(model=model, analysis=analysis)
assert isinstance(result, res.ResultImaging)
def test__figure_of_merit__matches_correct_fit_given_galaxy_profiles(
self, masked_imaging_7x7
):
galaxy = ag.Galaxy(redshift=0.5, light=ag.lp.EllSersic(intensity=0.1))
model = af.Collection(galaxies=af.Collection(galaxy=galaxy))
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7)
instance = model.instance_from_unit_vector([])
fit_figure_of_merit = analysis.log_likelihood_function(instance=instance)
plane = analysis.plane_for_instance(instance=instance)
fit = ag.FitImaging(imaging=masked_imaging_7x7, plane=plane)
assert fit.log_likelihood == fit_figure_of_merit
def test__associate_hyper_images(self, masked_imaging_7x7):
galaxies = af.ModelInstance()
galaxies.galaxy = ag.Galaxy(redshift=0.5)
galaxies.source = ag.Galaxy(redshift=1.0)
instance = af.ModelInstance()
instance.galaxies = galaxies
hyper_galaxy_image_path_dict = {
("galaxies", "galaxy"): ag.Array2D.ones(
shape_native=(3, 3), pixel_scales=1.0
),
("galaxies", "source"): ag.Array2D.full(
fill_value=2.0, shape_native=(3, 3), pixel_scales=1.0
),
}
result = mock.MockResult(
instance=instance,
hyper_galaxy_image_path_dict=hyper_galaxy_image_path_dict,
hyper_model_image=ag.Array2D.full(
fill_value=3.0, shape_native=(3, 3), pixel_scales=1.0
),
)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7, hyper_result=result)
instance = analysis.associate_hyper_images(instance=instance)
assert instance.galaxies.galaxy.hyper_galaxy_image.native == pytest.approx(
np.ones((3, 3)), 1.0e-4
)
assert instance.galaxies.source.hyper_galaxy_image.native == pytest.approx(
2.0 * np.ones((3, 3)), 1.0e-4
)
assert instance.galaxies.galaxy.hyper_model_image.native == pytest.approx(
3.0 * np.ones((3, 3)), 1.0e-4
)
assert instance.galaxies.source.hyper_model_image.native == pytest.approx(
3.0 * np.ones((3, 3)), 1.0e-4
)
def test__imaging_generator_from_aggregator(imaging_7x7, mask_2d_7x7, samples, model):
path_prefix = "aggregator_imaging_gen"
database_file = path.join(conf.instance.output_path, "imaging.sqlite")
result_path = path.join(conf.instance.output_path, path_prefix)
clean(database_file=database_file, result_path=result_path)
masked_imaging_7x7 = imaging_7x7.apply_mask(mask=mask_2d_7x7)
masked_imaging_7x7 = masked_imaging_7x7.apply_settings(
settings=ag.SettingsImaging(
grid_class=ag.Grid2DIterate,
grid_inversion_class=ag.Grid2DIterate,
fractional_accuracy=0.5,
sub_steps=[2],
)
)
search = mock.MockSearch(samples=samples)
search.paths = af.DirectoryPaths(path_prefix=path_prefix)
analysis = ag.AnalysisImaging(dataset=masked_imaging_7x7)
search.fit(model=model, analysis=analysis)
agg = af.Aggregator.from_database(filename=database_file)
agg.add_directory(directory=result_path)
imaging_agg = ag.agg.ImagingAgg(aggregator=agg)
imaging_gen = imaging_agg.imaging_gen()
for imaging in imaging_gen:
assert (imaging.image == masked_imaging_7x7.image).all()
assert isinstance(imaging.grid, ag.Grid2DIterate)
assert isinstance(imaging.grid_inversion, ag.Grid2DIterate)
assert imaging.grid.sub_steps == [2]
assert imaging.grid.fractional_accuracy == 0.5
clean(database_file=database_file, result_path=result_path)
def make_analysis_imaging_7x7():
return ag.AnalysisImaging(dataset=make_masked_imaging_7x7())
def make_analysis_imaging_7x7():
return ag.AnalysisImaging(
dataset=make_masked_imaging_7x7(),
settings_inversion=aa.SettingsInversion(use_w_tilde=False),
)