Exemple #1
0
    def test_duplication(self):
        phase = ph.LensSourcePlanePhase(lens_galaxies=[gm.GalaxyModel()],
                                        source_galaxies=[gm.GalaxyModel()],
                                        phase_name='test_phase')

        ph.LensSourcePlanePhase(phase_name='test_phase')

        assert phase.lens_galaxies is not None
        assert phase.source_galaxies is not None
Exemple #2
0
def make_pipeline(test_name):

    phase1 = ph.LensSourcePlanePhase(lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
                                     source_galaxies=dict(source_0=gm.GalaxyModel(sersic=lp.EllipticalSersic)),
                                     optimizer_class=nl.MultiNest, phase_name="{}/phase1".format(test_name))

    phase1.optimizer.const_efficiency_mode = True
    phase1.optimizer.n_live_points = 60
    phase1.optimizer.sampling_efficiency = 0.7

    class AddSourceGalaxyPhase(ph.LensSourcePlanePhase):

        def pass_priors(self, previous_results):

            self.lens_galaxies_lens = previous_results[0].variable.lens
            self.source_galaxies_source_0 = previous_results[0].variable.source_0

    phase2 = AddSourceGalaxyPhase(lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
                                  source_galaxies=dict(source_0=gm.GalaxyModel(sersic=lp.EllipticalSersic),
                                                       source_1=gm.GalaxyModel(sersic=lp.EllipticalSersic)),
                                  optimizer_class=nl.MultiNest, phase_name="{}/phase2".format(test_name))

    phase2.optimizer.const_efficiency_mode = True
    phase2.optimizer.n_live_points = 60
    phase2.optimizer.sampling_efficiency = 0.7

    return pl.PipelineImaging(test_name, phase1, phase2)
Exemple #3
0
    def test_fit(self, ccd_data):
        clean_images()

        phase = ph.LensSourcePlanePhase(
            optimizer_class=NLO,
            lens_galaxies=[gm.GalaxyModel(light=lp.EllipticalSersic)],
            source_galaxies=[gm.GalaxyModel(light=lp.EllipticalSersic)],
            phase_name='test_phase')
        result = phase.run(data=ccd_data)
        assert isinstance(result.constant.lens_galaxies[0], g.Galaxy)
        assert isinstance(result.constant.source_galaxies[0], g.Galaxy)
Exemple #4
0
    def test__tracer_for_instance__includes_cosmology(self, ccd_data):
        lens_galaxy = g.Galaxy()
        source_galaxy = g.Galaxy()

        phase = ph.LensPlanePhase(lens_galaxies=[lens_galaxy],
                                  cosmology=cosmo.FLRW,
                                  phase_name='test_phase')
        analysis = phase.make_analysis(ccd_data)
        instance = phase.constant
        tracer = analysis.tracer_for_instance(instance)
        padded_tracer = analysis.padded_tracer_for_instance(instance)

        assert tracer.image_plane.galaxies[0] == lens_galaxy
        assert tracer.cosmology == cosmo.FLRW
        assert padded_tracer.image_plane.galaxies[0] == lens_galaxy
        assert padded_tracer.cosmology == cosmo.FLRW

        phase = ph.LensSourcePlanePhase(lens_galaxies=[lens_galaxy],
                                        source_galaxies=[source_galaxy],
                                        cosmology=cosmo.FLRW,
                                        phase_name='test_phase')
        analysis = phase.make_analysis(ccd_data)
        instance = phase.constant
        tracer = analysis.tracer_for_instance(instance)
        padded_tracer = analysis.padded_tracer_for_instance(instance)

        assert tracer.image_plane.galaxies[0] == lens_galaxy
        assert tracer.source_plane.galaxies[0] == source_galaxy
        assert tracer.cosmology == cosmo.FLRW
        assert padded_tracer.image_plane.galaxies[0] == lens_galaxy
        assert padded_tracer.source_plane.galaxies[0] == source_galaxy
        assert padded_tracer.cosmology == cosmo.FLRW

        galaxy_0 = g.Galaxy(redshift=0.1)
        galaxy_1 = g.Galaxy(redshift=0.2)
        galaxy_2 = g.Galaxy(redshift=0.3)

        phase = ph.MultiPlanePhase(galaxies=[galaxy_0, galaxy_1, galaxy_2],
                                   cosmology=cosmo.WMAP7,
                                   phase_name='test_phase')
        analysis = phase.make_analysis(ccd_data)
        instance = phase.constant
        tracer = analysis.tracer_for_instance(instance)
        padded_tracer = analysis.padded_tracer_for_instance(instance)

        assert tracer.planes[0].galaxies[0] == galaxy_0
        assert tracer.planes[1].galaxies[0] == galaxy_1
        assert tracer.planes[2].galaxies[0] == galaxy_2
        assert tracer.cosmology == cosmo.WMAP7
        assert padded_tracer.planes[0].galaxies[0] == galaxy_0
        assert padded_tracer.planes[1].galaxies[0] == galaxy_1
        assert padded_tracer.planes[2].galaxies[0] == galaxy_2
        assert padded_tracer.cosmology == cosmo.WMAP7
Exemple #5
0
def make_pipeline(test_name):

    phase1 = ph.LensSourcePlanePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source=gm.GalaxyModel(light=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase1".format(test_name))

    phase1.optimizer.const_efficiency_mode = True
    phase1.optimizer.n_live_points = 60
    phase1.optimizer.sampling_efficiency = 0.8

    return pl.PipelineImaging(test_name, phase1)
Exemple #6
0
def make_pipeline(pipeline_name):

    # This is the same phase 1 as the complex source pipeline, which we saw gave a good fit to the overall
    # structure of the lensed source and provided an accurate lens mass model.

    phase1 = ph.LensSourcePlanePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source=gm.GalaxyModel(light=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name=pipeline_name + '/phase_1_initialize')

    phase1.optimizer.sampling_efficiency = 0.3
    phase1.optimizer.const_efficiency_mode = True

    # Now, in phase 2, lets use the lens mass model to fit the source with an inversion.

    class InversionPhase(ph.LensSourcePlanePhase):
        def pass_priors(self, previous_results):

            # We can customize the inversion's priors like we do our light and mass profiles.

            self.lens_galaxies.lens = previous_results[0].variable.lens
            self.source_galaxies.source.pixelization.shape_0 = mm.UniformPrior(
                lower_limit=20.0, upper_limit=40.0)
            self.source_galaxies.source.pixelization.shape_1 = mm.UniformPrior(
                lower_limit=20.0, upper_limit=40.0)

            # The expected value of the regularization coefficient depends on the details of the data reduction and
            # source galaxy. A broad log-uniform prior is thus an appropriate way to sample the large range of
            # possible values.
            self.source_galaxies.source.regularization.coefficients_0 = mm.LogUniformPrior(
                lower_limit=1.0e-6, upper_limit=10000.0)

    phase2 = InversionPhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source=gm.GalaxyModel(
            pixelization=pix.Rectangular, regularization=reg.Constant)),
        optimizer_class=nl.MultiNest,
        phase_name=pipeline_name + '/phase_2_inversion')

    phase2.optimizer.sampling_efficiency = 0.3
    phase2.optimizer.const_efficiency_mode = True

    return pipeline.PipelineImaging(pipeline_name, phase1, phase2)
Exemple #7
0
    def test__fit_figure_of_merit__matches_correct_fit_given_galaxy_profiles(
            self, ccd_data):

        lens_galaxy = g.Galaxy(light=lp.EllipticalSersic(intensity=0.1))
        source_galaxy = g.Galaxy(
            pixelization=pix.Rectangular(shape=(4, 4)),
            regularization=reg.Constant(coefficients=(1.0, )))

        phase = ph.LensPlanePhase(lens_galaxies=[lens_galaxy],
                                  mask_function=ph.default_mask_function,
                                  cosmology=cosmo.FLRW,
                                  phase_name='test_phase')
        analysis = phase.make_analysis(data=ccd_data)
        instance = phase.constant
        fit_figure_of_merit = analysis.fit(instance=instance)

        mask = phase.mask_function(image=ccd_data.image)
        lens_data = li.LensData(ccd_data=ccd_data, mask=mask)
        tracer = analysis.tracer_for_instance(instance=instance)
        fit = lens_fit.LensProfileFit(lens_data=lens_data, tracer=tracer)

        assert fit.likelihood == fit_figure_of_merit

        phase = ph.LensSourcePlanePhase(lens_galaxies=[lens_galaxy],
                                        source_galaxies=[source_galaxy],
                                        mask_function=ph.default_mask_function,
                                        cosmology=cosmo.FLRW,
                                        phase_name='test_phase')
        analysis = phase.make_analysis(data=ccd_data)
        instance = phase.constant
        fit_figure_of_merit = analysis.fit(instance=instance)

        mask = phase.mask_function(image=ccd_data.image)
        lens_data = li.LensData(ccd_data=ccd_data, mask=mask)
        tracer = analysis.tracer_for_instance(instance=instance)
        fit = lens_fit.LensProfileInversionFit(lens_data=lens_data,
                                               tracer=tracer)

        assert fit.evidence == fit_figure_of_merit
Exemple #8
0
def make_pipeline(test_name):
    phase1 = ph.LensSourcePlanePhase(
        lens_galaxies=[gm.GalaxyModel(sie=mp.EllipticalIsothermal)],
        source_galaxies=[gm.GalaxyModel(sersic=lp.EllipticalSersic)],
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase1".format(test_name))

    phase1.optimizer.const_efficiency_mode = True
    phase1.optimizer.n_live_points = 60
    phase1.optimizer.sampling_efficiency = 0.8

    phase1h = ph.LensMassAndSourceProfileHyperOnlyPhase(
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase1h".format(test_name))

    class SourceHyperPhase(ph.LensSourcePlaneHyperPhase):
        def pass_priors(self, previous_results):
            phase1_results = previous_results[-1]
            phase1h_results = previous_results[-1].hyper
            #        self.lens_galaxies[0] = previous_results[-1].variable.lens_galaxies[0]
            self.source_galaxies = phase1_results.variable.source_galaxies
            self.source_galaxies[
                0].hyper_galaxy = phase1h_results.constant.source_galaxies[
                    0].hyper_galaxy

    phase2 = SourceHyperPhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source=gm.GalaxyModel(light=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase2".format(test_name))

    phase2.optimizer.const_efficiency_mode = True
    phase2.optimizer.n_live_points = 40
    phase2.optimizer.sampling_efficiency = 0.8

    return pl.PipelineImaging(test_name, phase1, phase1h, phase2)
Exemple #9
0
def make_pipeline(test_name):

    phase1 = ph.LensSourcePlanePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source_0=gm.GalaxyModel(
            sersic=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase1".format(test_name))

    phase1.optimizer.const_efficiency_mode = True
    phase1.optimizer.n_live_points = 60
    phase1.optimizer.sampling_efficiency = 0.7

    phase1h = ph.LensMassAndSourceProfileHyperOnlyPhase(
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase1h".format(test_name))

    class AddSourceGalaxyPhase(ph.LensSourcePlaneHyperPhase):
        def pass_priors(self, previous_results):
            phase1_results = previous_results[-1]
            phase1h_results = previous_results[-1].hyper
            self.lens_galaxies.lens = phase1_results.variable.lens
            self.source_galaxies.source_0 = phase1_results.variable.source_0
            self.source_galaxies.source_0.hyper_galaxy = phase1h_results.constant.source_0.hyper_galaxy

    phase2 = AddSourceGalaxyPhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(
            source_0=gm.GalaxyModel(sersic=lp.EllipticalSersic),
            source_1=gm.GalaxyModel(sersic=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase2".format(test_name))

    phase2.optimizer.const_efficiency_mode = True
    phase2.optimizer.n_live_points = 60
    phase2.optimizer.sampling_efficiency = 0.7

    phase2h = ph.LensMassAndSourceProfileHyperOnlyPhase(
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase1h".format(test_name))

    class BothSourceGalaxiesPhase(ph.LensSourcePlaneHyperPhase):
        def pass_priors(self, previous_results):

            phase2_results = previous_results[1]
            phase2h_results = previous_results[1].hyper
            self.lens_galaxies.lens = phase2_results.variable.lens
            self.source_galaxies.source_0 = phase2_results.variable.source_0
            self.source_galaxies.source_1 = phase2_results.variable.source_1
            self.source_galaxies.source_0.hyper_galaxy = phase2h_results.constant.source_0.hyper_galaxy
            self.source_galaxies.source_1.hyper_galaxy = phase2h_results.constant.source_1.hyper_galaxy

    phase3 = BothSourceGalaxiesPhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(
            source_0=gm.GalaxyModel(sersic=lp.EllipticalSersic),
            source_1=gm.GalaxyModel(sersic=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name="{}/phase3".format(test_name))

    return pl.PipelineImaging(test_name, phase1, phase1h, phase2, phase2h,
                              phase3)
                              extract_array_from_mask=True,
                              zoom_around_mask=True)


# When we run the phase, we don't pass it the mask as an array. Instead, we pass it the mask as a function. The reason
# for this will become clear in the next chapter, but for now I would say you just accept this syntax.
def mask_function():
    return msk.Mask.circular_annular(shape=ccd_data.shape,
                                     pixel_scale=ccd_data.pixel_scale,
                                     inner_radius_arcsec=0.6,
                                     outer_radius_arcsec=2.4)


phase_with_custom_mask = ph.LensSourcePlanePhase(
    lens_galaxies=dict(lens=gm.GalaxyModel()),
    source_galaxies=dict(source=gm.GalaxyModel()),
    mask_function=mask_function,  # <- We input the mask function here
    optimizer_class=nl.MultiNest,
    phase_name='phase')

# So, our mask encompasses the lensed source galaxy. However, is this really the right sized mask? Do we actually want
# a bigger mask? a smaller mask?

# When it comes to masking, we are essentially balancing run-speed and accuracy. If speed wasn't a consideration,
# bigger masks would *always* be better, for two reasons:

# 1) The lensed source galaxy may have very faint emission that when you look at the plot above you don't notice.
#    Overly aggressive masking risks you masking out some of that light - data which would better constrain your
#    lens model!

# 2) When you fit an image with a model image, the fit is performed only within the masked region. Outside of the
#    masked region it is possible that the model image produces some source-galaxy light in a region of the image
# When we plot it, the lens light's is clealy visible in the centre of the image
ccd_plotters.plot_ccd_subplot(ccd_data=ccd_data)

# Now lets fit it using a phase, noting that indeed the galaxy-model corresponds to the one above.

# Because we now have 18 non-linear parameters, the non-linear search takes a lot longer to run. On my laptop, this
# phase took around an hour, which is a bit too long for you to wait if you want to go through these tutorials quickly.
# Therefore, as discussed before, I've included the results of this non-linear search already, allowing you to
# go through the tutorial as if you had actually run them.

# Nevertheless, you could try running it yourself (maybe over your lunch break?). All you need to do is change the
# phase_name below, maybe to something like 'howtolens/3_realism_and_complexity_rerun'
phase = ph.LensSourcePlanePhase(
    lens_galaxies=dict(lens_galaxy=gm.GalaxyModel(
        light=lp.EllipticalSersic, mass=mp.EllipticalIsothermal)),
    source_galaxies=dict(source_galaxy=gm.GalaxyModel(
        light=lp.EllipticalExponential)),
    optimizer_class=nl.MultiNest,
    phase_name='3_realism_and_complexity')

# Lets run the phase.
print(
    'MultiNest has begun running - checkout the workspace/howtolens/chapter_2_lens_modeling/output/3_realism_and_complexity'
    'folder for live output of the results, images and lens model.'
    'This Jupyter notebook cell with progress once MultiNest has completed - this could take some time!'
)
results = phase.run(data=ccd_data)
print('MultiNest has finished run - you may now continue the notebook.')

# And lets look at the image.
lens_fit_plotters.plot_fit_subplot(fit=results.most_likely_fit,
Exemple #12
0
# We're going to model our lens galaxy using a light profile (an elliptical Sersic) and mass profile
# (a singular isothermal ellipsoid). We load these profiles from the 'light_profiles (lp)' and 'mass_profiles (mp)'.

# To setup our model galaxies, we use the 'galaxy_model' module and GalaxyModel class.
# A GalaxyModel represents a galaxy where the parameters of its associated profiles are
# variable and fitted for by the analysis.
lens_galaxy_model = gm.GalaxyModel(light=lp.EllipticalSersic,
                                   mass=mp.EllipticalIsothermal)
source_galaxy_model = gm.GalaxyModel(light=lp.EllipticalSersic)

# 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 = ph.LensSourcePlanePhase(
    lens_galaxies=dict(lens=gm.GalaxyModel(light=lp.EllipticalSersic,
                                           mass=mp.EllipticalIsothermal,
                                           shear=mp.ExternalShear)),
    source_galaxies=dict(source=gm.GalaxyModel(light=lp.EllipticalSersic)),
    optimizer_class=nl.MultiNest,
    phase_name='example/phase_non_pipeline')

# You'll see these lines throughout all of the example pipelines. They are used to make MultiNest sample the \
# non-linear parameter space faster (if you haven't already, checkout the tutorial '' in howtolens/chapter_2).

phase.optimizer.const_efficiency_mode = True
phase.optimizer.n_live_points = 50
phase.optimizer.sampling_efficiency = 0.5

# We run the phase on the image, print the results and plot the fit.
result = phase.run(data=ccd_data)
lens_fit_plotters.plot_fit_subplot(fit=result.most_likely_fit)
Exemple #13
0
# In approaches 1 and 2, we extended our non-linear search an olive branch and generously helped it find the highest
# likelihood regions of parameter space. In approach 3 ,we're going to be stern with our non-linear search, and tell it
# 'look harder'.

# Basically, every non-linear search algorithm has a set of parameters that govern how thoroughly it searches parameter
# space. The more thoroughly it looks, the more likely it is that it'll find the global maximum lens model. However,
# the search will also take longer - and we don't want it to take too long to get some results.

# Lets setup a phase, and overwrite some of the non-linear search's parameters from the defaults it assumes in the
# 'config/non_linear.ini' config file:

custom_non_linear_phase = ph.LensSourcePlanePhase(
    lens_galaxies=dict(lens=gm.GalaxyModel(light=lp.EllipticalSersic,
                                           mass=mp.EllipticalIsothermal)),
    source_galaxies=dict(source=gm.GalaxyModel(
        light=lp.EllipticalExponential)),
    optimizer_class=nl.MultiNest,
    phase_name='4_custom_non_linear')

# The 'optimizer' below is MultiNest, the non-linear search we're using.

# When MultiNest searches non-linear parameter space, it places down a set of 'live-points', each of which corresponds
# to a particular lens model (set of parameters) and each has an associted likelihood. If it guesses a new lens model with a
# higher likelihood than any of the currently active live points, this new lens model will become an active point. As a
# result, the active point with the lowest likelihood is discarded.

# The more live points MultiNest uses, the more thoroughly it will sample parameter space. Lets increase the number of
# points from the default value (50) to 100.
custom_non_linear_phase.optimizer.n_live_points = 100
# Lets model the source galaxy with a spherical exponential light profile (again, what it was simulated with).
source_galaxy_model = gm.GalaxyModel(light=lp.SphericalExponential)

# A phase takes our galaxy models and fits their parameters via a non-linear search (in this case, MultiNest). In this
# example, we have a lens-plane and source-plane, so we use a LensSourcePlanePhase.

# (Just like we could give profiles descriptive names, like 'light', 'bulge' and 'disk', we can do the exact same
# thing with galaxies. This is very good practise - as once we start using complex lens models, you could potentially
# have a lot of galaxies - and this is the best way to keep track of them!)

# (also, just ignore the 'dict' - its necessary syntax but not something you need to concern yourself with)

phase = ph.LensSourcePlanePhase(
    lens_galaxies=dict(lens_galaxy=lens_galaxy_model),
    source_galaxies=dict(source_galaxy=source_galaxy_model),
    optimizer_class=non_linear.MultiNest,
    phase_name='1_non_linear_search')

# To run the phase, we simply pass it the image data we want to fit, and the non-linear search begins! As the phase
# runs, a logger will show you the parameters of the best-fit model.
print(
    'MultiNest has begun running - checkout the workspace/howtolens/chapter_2_lens_modeling/output/1_non_linear_search'
    'folder for live output of the results, images and lens model.'
    'This Jupyter notebook cell with progress once MultiNest has completed - this could take some time!'
)
results = phase.run(data=ccd_data)
print('MultiNest has finished run - you may now continue the notebook.')

# Now this has run you should checkout the 'AutoLens/workspace/howtolens/chapter_2_lens_modeling/output' folder.
# This is where the results of the phase are written to your hard-disk (in the '1_non_linear_search' folder).
Exemple #15
0
def make_pipeline(pipeline_path=''):

    pipeline_name = 'pipeline_complex_source'
    pipeline_path = pipeline_path + pipeline_name

    # To begin, we need to initialize the lens's mass model. We should be able to do this by using a simple source
    # model. It won't fit the complicated structure of the source, but it'll give us a reasonable estimate of the
    # einstein radius and the other lens-mass parameters.

    # This should run fine without any prior-passes. In general, a thick, giant ring of source light is something we
    # can be confident MultiNest will fit without much issue, especially when the lens galaxy's light isn't included
    # such that the parameter space is just 12 parameters.

    phase1 = ph.LensSourcePlanePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source=gm.GalaxyModel(
            light_0=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name=pipeline_path + '/phase_1_simple_source')

    phase1.optimizer.const_efficiency_mode = True
    phase1.optimizer.n_live_points = 40
    phase1.optimizer.sampling_efficiency = 0.5

    # Now lets add another source component, using the previous model as the initialization on the lens / source
    # parameters. We'll vary the parameters of the lens mass model and first source galaxy component during the fit.

    class X2SourcePhase(ph.LensSourcePlanePhase):
        def pass_priors(self, previous_results):

            self.lens_galaxies.lens = previous_results[0].variable.lens
            self.source_galaxies.source.light_0 = previous_results[
                0].variable.source.light_0

    # You'll notice I've stop writing 'phase_1_results = previous_results[0]' - we know how
    # the previous results are structured now so lets not clutter our code!

    phase2 = X2SourcePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(source=gm.GalaxyModel(
            light_0=lp.EllipticalExponential, light_1=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name=pipeline_path + '/phase_2_x2_source')

    phase2.optimizer.const_efficiency_mode = True
    phase2.optimizer.n_live_points = 40
    phase2.optimizer.sampling_efficiency = 0.5

    # Now lets do the same again, but with 3 source galaxy components.

    class X3SourcePhase(ph.LensSourcePlanePhase):
        def pass_priors(self, previous_results):

            self.lens_galaxies.lens = previous_results[1].variable.lens
            self.source_galaxies.source.light_0 = previous_results[
                1].variable.source.light_0
            self.source_galaxies.source.light_1 = previous_results[
                1].variable.source.light_1

    phase3 = X3SourcePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(
            source=gm.GalaxyModel(light_0=lp.EllipticalExponential,
                                  light_1=lp.EllipticalSersic,
                                  light_2=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name=pipeline_path + '/phase_3_x3_source')

    phase3.optimizer.const_efficiency_mode = True
    phase3.optimizer.n_live_points = 50
    phase3.optimizer.sampling_efficiency = 0.5

    # And one more for luck!

    class X4SourcePhase(ph.LensSourcePlanePhase):
        def pass_priors(self, previous_results):

            self.lens_galaxies.lens = previous_results[2].variable.lens
            self.source_galaxies.source.light_0 = previous_results[
                2].variable.source.light_0
            self.source_galaxies.source.light_1 = previous_results[
                2].variable.source.light_1
            self.source_galaxies.source.light_2 = previous_results[
                2].variable.source.light_2

    phase4 = X4SourcePhase(
        lens_galaxies=dict(lens=gm.GalaxyModel(mass=mp.EllipticalIsothermal)),
        source_galaxies=dict(
            source=gm.GalaxyModel(light_0=lp.EllipticalExponential,
                                  light_1=lp.EllipticalSersic,
                                  light_2=lp.EllipticalSersic,
                                  light_3=lp.EllipticalSersic)),
        optimizer_class=nl.MultiNest,
        phase_name=pipeline_path + '/phase_4_x4_source')

    phase4.optimizer.const_efficiency_mode = True
    phase4.optimizer.n_live_points = 50
    phase4.optimizer.sampling_efficiency = 0.5

    return pipeline.PipelineImaging(pipeline_path, phase1, phase2, phase3,
                                    phase4)
    return ccd_simulated


# Simulate the image and set it up.
ccd_data = simulate()
ccd_plotters.plot_ccd_subplot(ccd_data=ccd_data)

# Lets first run the phase without black magic, which is performed using the standard lines of code we're used to.

# A word of warning, this phase takes >1 hour to run... so if you get bored, skip the run cell below continue to the
# phase with black magic (afterall, the whole point of this tutorial is how slow MultiNest can run, so theres no harm
# if the slow run speed bores you to tears :P).

phase_normal = ph.LensSourcePlanePhase(
    lens_galaxies=dict(lens=gm.GalaxyModel(light=lp.EllipticalSersic,
                                           mass=mp.EllipticalIsothermal)),
    source_galaxies=dict(source=gm.GalaxyModel(light=lp.EllipticalSersic)),
    optimizer_class=nl.MultiNest,
    phase_name='7_no_black_magic')

# We're going to use the time module to time how long each MultiNest run takes. However, if you resume the MultiNest
# run from a previous job, this time won't be accurate. Fortunately, if you look in the folder
# 'howtolens/chapter_2_lens_modeling/output/7_no_black_magic') you'll find a file 'run_time' which gives the overall
# run-time including any resumes.
start = time.time()

# Lets run the phase - the run-time will be output to the output/7_multinest_black_magic/

print(
    'MultiNest has begun running - checkout the workspace/howtolens/chapter_2_lens_modeling/output/7_multinest_black_magic'
    ' folder for live output of the results, images and lens model.'
    ' This Jupyter notebook cell with progress once MultiNest has completed - this could take some time!'
Exemple #17
0
def make_phase():
    return ph.LensSourcePlanePhase(optimizer_class=NLO,
                                   mask_function=ph.default_mask_function,
                                   phase_name='test_phase')