def test_model_instance_sum_priority(self):
instance_1 = mm.ModelInstance()
galaxy_1 = g.Galaxy()
instance_1.galaxy = galaxy_1
instance_2 = mm.ModelInstance()
galaxy_2 = g.Galaxy()
instance_2.galaxy = galaxy_2
assert (instance_1 + instance_2).galaxy == galaxy_2
def test_match_galaxy_models_by_name(self, phase, galaxy_model, galaxy):
phase.lens_galaxies = dict(galaxy_one=galaxy_model)
instance = mm.ModelInstance()
instance.galaxy_one = galaxy
assert phase.match_instance_to_models(instance) == [
("galaxy_one", galaxy, galaxy_model)
]
def test_fit_priors_with_results(self, phase):
argument_tuples = []
galaxy_model_one = gm.GalaxyModel()
galaxy_model_two = gm.GalaxyModel()
new_galaxy_model_one = gm.GalaxyModel()
new_galaxy_model_two = gm.GalaxyModel()
new_galaxy_models = {
galaxy_model_one: new_galaxy_model_one,
galaxy_model_two: new_galaxy_model_two
}
def fitting_function(best_fit_galaxy, initial_galaxy_model):
argument_tuples.append((best_fit_galaxy, initial_galaxy_model))
return new_galaxy_models[initial_galaxy_model]
phase.lens_galaxies = dict(galaxy_one=galaxy_model_one,
galaxy_two=galaxy_model_two)
instance_one = mm.ModelInstance()
galaxy_one = g.Galaxy()
instance_one.galaxy_one = galaxy_one
instance_one.galaxy_two = g.Galaxy()
results_one = MockResults(constant=instance_one)
instance_two = mm.ModelInstance()
galaxy_two = g.Galaxy()
instance_two.galaxy_two = galaxy_two
results_two = MockResults(constant=instance_two)
assert phase.lens_galaxies.galaxy_one == galaxy_model_one
assert phase.lens_galaxies.galaxy_two == galaxy_model_two
phase.fit_priors_with_results([results_one, results_two],
fitting_function)
assert phase.lens_galaxies.galaxy_one == new_galaxy_model_one
assert phase.lens_galaxies.galaxy_two == new_galaxy_model_two
assert argument_tuples == [(galaxy_one, galaxy_model_one),
(galaxy_two, galaxy_model_two)]
def __init__(self,
model_image=None,
galaxy_images=(),
constant=None,
analysis=None,
optimizer=None):
self.model_image = model_image
self.galaxy_images = galaxy_images
self.constant = constant or mm.ModelInstance()
self.variable = mm.ModelMapper()
self.analysis = analysis
self.optimizer = optimizer
def test_fit_priors(self, phase, galaxy_model, galaxy):
argument_tuples = []
new_galaxy_model = gm.GalaxyModel()
def fitting_function(best_fit_galaxy, initial_galaxy_model):
argument_tuples.append((best_fit_galaxy, initial_galaxy_model))
return new_galaxy_model
phase.lens_galaxies = dict(galaxy_one=galaxy_model)
assert phase.lens_galaxies.galaxy_one is not None
instance = mm.ModelInstance()
instance.galaxy_one = galaxy
phase.fit_priors(instance, fitting_function)
assert phase.lens_galaxies.galaxy_one == new_galaxy_model
assert argument_tuples == [(galaxy, galaxy_model)]
def run(self, positions, pixel_scale, previous_results):
self.positions = positions
self.pixel_scale = pixel_scale
self.previous_results = previous_results
return non_linear.Result(model_mapper.ModelInstance(), 1)
def run(self, data, previous_results, mask=None, positions=None):
self.data = data
self.previous_results = previous_results
self.mask = mask
self.positions = positions
return non_linear.Result(model_mapper.ModelInstance(), 1)