Esempio n. 1
0
    def test__constructor_inputs(self):

        psf_0 = im.PSF(np.ones((7, 7)), 1)
        ccd_0 = im.CCDData(np.ones((51, 51)),
                           pixel_scale=3.,
                           psf=psf_0,
                           noise_map=np.ones((51, 51)))
        mask_0 = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=(51, 51),
                                                             pixel_scale=1.0,
                                                             invert=True)
        mask_0[26, 26] = False

        psf_1 = im.PSF(np.ones((7, 7)), 1)
        ccd_1 = im.CCDData(np.ones((51, 51)),
                           pixel_scale=3.,
                           psf=psf_1,
                           noise_map=np.ones((51, 51)))
        mask_1 = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=(51, 51),
                                                             pixel_scale=1.0,
                                                             invert=True)
        mask_1[26, 26] = False

        lens_data_stack = lis.LensDataStack(ccd_datas=[ccd_0, ccd_1],
                                            masks=[mask_0, mask_1],
                                            sub_grid_size=8,
                                            image_psf_shape=(5, 5),
                                            mapping_matrix_psf_shape=(3, 3),
                                            positions=[np.array([[1.0, 1.0]])])

        assert lens_data_stack.sub_grid_size == 8
        assert lens_data_stack.convolvers_image[0].psf_shape == (5, 5)
        assert lens_data_stack.convolvers_mapping_matrix[0].psf_shape == (3, 3)
        assert lens_data_stack.convolvers_image[1].psf_shape == (5, 5)
        assert lens_data_stack.convolvers_mapping_matrix[1].psf_shape == (3, 3)
        assert (lens_data_stack.positions[0] == np.array([[1.0, 1.0]])).all()
Esempio n. 2
0
def make_li_blur_stack():

    image_0 = np.array([[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0],
                        [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]])
    psf_0 = ccd.PSF(array=(np.array([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0],
                                     [1.0, 1.0, 1.0]])),
                    pixel_scale=1.0,
                    renormalize=False)
    ccd_0 = ccd.CCDData(image_0,
                        pixel_scale=1.0,
                        psf=psf_0,
                        noise_map=np.ones((4, 4)))

    mask_0 = np.array([[True, True, True, True], [True, False, False, True],
                       [True, False, False, True], [True, True, True, True]])
    mask_0 = msk.Mask(array=mask_0, pixel_scale=1.0)

    image_1 = np.array([[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0],
                        [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]])
    psf_1 = ccd.PSF(array=(np.array([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0],
                                     [1.0, 1.0, 1.0]])),
                    pixel_scale=1.0,
                    renormalize=False)
    ccd_1 = ccd.CCDData(image_1,
                        pixel_scale=1.0,
                        psf=psf_1,
                        noise_map=np.ones((4, 4)))

    mask_1 = np.array([[True, True, True, True], [True, False, False, True],
                       [True, False, False, True], [True, True, True, True]])
    mask_1 = msk.Mask(array=mask_1, pixel_scale=1.0)

    return lds.LensDataStack(ccd_datas=[ccd_0, ccd_1],
                             masks=[mask_0, mask_1],
                             sub_grid_size=1)
Esempio n. 3
0
def make_image_1():

    image = scaled_array.ScaledSquarePixelArray(array=10.0 * np.ones((4, 4)),
                                                pixel_scale=6.0)
    psf = im.PSF(array=11.0 * np.ones((3, 3)),
                 pixel_scale=6.0,
                 renormalize=False)
    noise_map = im.NoiseMap(array=12.0 * np.ones((4, 4)), pixel_scale=6.0)
    background_noise_map = im.NoiseMap(array=13.0 * np.ones((4, 4)),
                                       pixel_scale=6.0)
    poisson_noise_map = im.PoissonNoiseMap(array=14.0 * np.ones((4, 4)),
                                           pixel_scale=6.0)
    exposure_time_map = im.ExposureTimeMap(array=15.0 * np.ones((4, 4)),
                                           pixel_scale=6.0)
    background_sky_map = scaled_array.ScaledSquarePixelArray(array=16.0 *
                                                             np.ones((4, 4)),
                                                             pixel_scale=6.0)

    return im.CCDData(image=image,
                      pixel_scale=6.0,
                      psf=psf,
                      noise_map=noise_map,
                      background_noise_map=background_noise_map,
                      poisson_noise_map=poisson_noise_map,
                      exposure_time_map=exposure_time_map,
                      background_sky_map=background_sky_map)
Esempio n. 4
0
        def test__1x2_image__tracing_fits_data_with_chi_sq_5_and_chi_sq_4(
                self):

            psf_0 = ccd.PSF(array=(np.array([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0],
                                             [0.0, 0.0, 0.0]])),
                            pixel_scale=1.0)
            ccd_0 = ccd.CCDData(5.0 * np.ones((3, 4)),
                                pixel_scale=1.0,
                                psf=psf_0,
                                noise_map=np.ones((3, 4)))
            ccd_0.image[1, 2] = 4.0
            mask_0 = msk.Mask(array=np.array([[True, True, True, True],
                                              [True, False, False, True],
                                              [True, True, True, True]]),
                              pixel_scale=1.0)

            psf_1 = ccd.PSF(array=(np.array([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0],
                                             [0.0, 0.0, 0.0]])),
                            pixel_scale=1.0)
            ccd_1 = ccd.CCDData(5.0 * np.ones((3, 4)),
                                pixel_scale=1.0,
                                psf=psf_1,
                                noise_map=np.ones((3, 4)))
            mask_1 = msk.Mask(array=np.array([[True, True, True, True],
                                              [True, False, False, True],
                                              [True, True, True, True]]),
                              pixel_scale=1.0)

            li_stack = lds.LensDataStack(ccd_datas=[ccd_0, ccd_1],
                                         masks=[mask_0, mask_1],
                                         sub_grid_size=1)

            # Setup as a ray trace instance, using a light profile for the lens

            g0 = g.Galaxy(light_profile=MockLightProfile(value=1.0, size=2))
            tracer = ray_tracing_stack.TracerImagePlaneStack(
                lens_galaxies=[g0],
                image_plane_grid_stacks=li_stack.grid_stacks)

            fit = lens_fit_stack.LensProfileFitStack(lens_data_stack=li_stack,
                                                     tracer=tracer)

            assert fit.chi_squared == 25.0 + 32.0
            assert fit.reduced_chi_squared == (25.0 + 32.0) / 2.0
            assert fit.likelihood == -0.5 * (
                (25.0 + 2.0 * np.log(2 * np.pi * 1.0)) +
                (32.0 + 2.0 * np.log(2 * np.pi * 1.0)))
Esempio n. 5
0
def make_lens_image():
    ccd_data = ccd.CCDData(np.array(np.zeros(shape)),
                           pixel_scale=1.0,
                           psf=ccd.PSF(np.ones((3, 3)), pixel_scale=1.0),
                           noise_map=ccd.NoiseMap(np.ones(shape),
                                                  pixel_scale=1.0))
    mask = msk.Mask.circular(shape=shape, pixel_scale=1, radius_arcsec=3.0)
    return li.LensData(ccd_data=ccd_data, mask=mask)
def make_image():
    image = scaled_array.ScaledSquarePixelArray(array=np.ones((3, 3)),
                                                pixel_scale=1.0)
    noise_map = im.NoiseMap(array=2.0 * np.ones((3, 3)), pixel_scale=1.0)
    psf = im.PSF(array=3.0 * np.ones((1, 1)), pixel_scale=1.0)

    return im.CCDData(image=image,
                      pixel_scale=1.0,
                      noise_map=noise_map,
                      psf=psf)
Esempio n. 7
0
def make_ccd():
    image = scaled_array.ScaledSquarePixelArray(array=np.ones((3, 3)),
                                                pixel_scale=1.0)
    noise_map = im.NoiseMap(array=2.0 * np.ones((3, 3)), pixel_scale=1.0)
    psf = im.PSF(array=3.0 * np.ones((1, 1)), pixel_scale=1.0)

    return im.CCDData(image=image,
                      pixel_scale=1.0,
                      noise_map=noise_map,
                      psf=psf,
                      exposure_time_map=2.0 * np.ones((3, 3)),
                      background_sky_map=3.0 * np.ones((3, 3)))
Esempio n. 8
0
def make_ccd():

    image = scaled_array.ScaledSquarePixelArray(array=np.ones((4, 4)), pixel_scale=3.0)
    psf = ccd.PSF(array=np.ones((3, 3)), pixel_scale=3.0, renormalize=False)
    noise_map = ccd.NoiseMap(array=2.0 * np.ones((4, 4)), pixel_scale=3.0)
    background_noise_map = ccd.NoiseMap(array=3.0 * np.ones((4, 4)), pixel_scale=3.0)
    poisson_noise_map = ccd.PoissonNoiseMap(array=4.0 * np.ones((4, 4)), pixel_scale=3.0)
    exposure_time_map = ccd.ExposureTimeMap(array=5.0 * np.ones((4, 4)), pixel_scale=3.0)
    background_sky_map = scaled_array.ScaledSquarePixelArray(array=6.0 * np.ones((4, 4)), pixel_scale=3.0)

    return ccd.CCDData(image=image, pixel_scale=3.0, psf=psf, noise_map=noise_map,
                       background_noise_map=background_noise_map, poisson_noise_map=poisson_noise_map,
                       exposure_time_map=exposure_time_map, background_sky_map=background_sky_map)
Esempio n. 9
0
        def test__image__tracing_fits_data_perfectly__no_psf_blurring__lh_is_noise_normalization(
                self):

            psf_0 = ccd.PSF(array=(np.array([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0],
                                             [0.0, 0.0, 0.0]])),
                            pixel_scale=1.0)
            ccd_0 = ccd.CCDData(np.ones((3, 3)),
                                pixel_scale=1.0,
                                psf=psf_0,
                                noise_map=np.ones((3, 3)))
            mask_0 = msk.Mask(array=np.array([[True, True, True],
                                              [True, False, True],
                                              [True, True, True]]),
                              pixel_scale=1.0)

            psf_1 = ccd.PSF(array=(np.array([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0],
                                             [0.0, 0.0, 0.0]])),
                            pixel_scale=1.0)
            ccd_1 = ccd.CCDData(np.ones((3, 3)),
                                pixel_scale=1.0,
                                psf=psf_1,
                                noise_map=np.ones((3, 3)))
            mask_1 = msk.Mask(array=np.array([[True, True, True],
                                              [True, False, True],
                                              [True, True, True]]),
                              pixel_scale=1.0)

            li_stack = lds.LensDataStack(ccd_datas=[ccd_0, ccd_1],
                                         masks=[mask_0, mask_1],
                                         sub_grid_size=1)

            g0 = g.Galaxy(light_profile=MockLightProfile(value=1.0))
            tracer = ray_tracing_stack.TracerImagePlaneStack(
                lens_galaxies=[g0],
                image_plane_grid_stacks=li_stack.grid_stacks)

            fit = lens_fit_stack.LensProfileFitStack(lens_data_stack=li_stack,
                                                     tracer=tracer)
            assert fit.likelihood == 2.0 * -0.5 * np.log(2 * np.pi * 1.0)
Esempio n. 10
0
def make_li_manual_stack():

    image_0 = np.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 2.0, 3.0, 0.0],
                        [0.0, 4.0, 5.0, 6.0, 0.0], [0.0, 7.0, 8.0, 9.0, 0.0],
                        [0.0, 0.0, 0.0, 0.0, 0.0]])
    psf_0 = ccd.PSF(array=(np.array([[1.0, 5.0, 9.0], [2.0, 5.0, 1.0],
                                     [3.0, 4.0, 0.0]])),
                    pixel_scale=1.0)
    ccd_0 = ccd.CCDData(image_0,
                        pixel_scale=1.0,
                        psf=psf_0,
                        noise_map=np.ones((5, 5)))
    mask_0 = msk.Mask(array=np.array([[True, True, True, True, True],
                                      [True, False, False, False, True],
                                      [True, False, False, False, True],
                                      [True, False, False, False, True],
                                      [True, True, True, True, True]]),
                      pixel_scale=1.0)

    image_1 = np.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 2.0, 3.0, 0.0],
                        [0.0, 4.0, 6.0, 6.0, 0.0], [0.0, 7.0, 8.0, 9.0, 0.0],
                        [0.0, 0.0, 0.0, 0.0, 0.0]])
    psf_1 = ccd.PSF(array=(np.array([[1.0, 1.0, 1.0], [2.0, 1.0, 1.0],
                                     [3.0, 1.0, 0.0]])),
                    pixel_scale=1.0)
    ccd_1 = ccd.CCDData(image_1,
                        pixel_scale=1.0,
                        psf=psf_1,
                        noise_map=np.ones((5, 5)))
    mask_1 = msk.Mask(array=np.array([[True, True, True, True, True],
                                      [True, False, False, False, True],
                                      [True, False, False, False, True],
                                      [True, False, False, True, True],
                                      [True, True, True, True, True]]),
                      pixel_scale=1.0)

    return lds.LensDataStack(ccd_datas=[ccd_0, ccd_1],
                             masks=[mask_0, mask_1],
                             sub_grid_size=1)
Esempio n. 11
0
def make_ccd_data():
    pixel_scale = 1.0

    image = scaled_array.ScaledSquarePixelArray(array=np.array(
        np.zeros(shape)),
                                                pixel_scale=pixel_scale)
    psf = ccd.PSF(array=np.ones((3, 3)), pixel_scale=pixel_scale)
    noise_map = ccd.NoiseMap(np.ones(shape), pixel_scale=1.0)

    return ccd.CCDData(image=image,
                       pixel_scale=pixel_scale,
                       psf=psf,
                       noise_map=noise_map)
Esempio n. 12
0
    def test__constructor_inputs(self):

        psf = ccd.PSF(np.ones((7, 7)), 1)
        image = ccd.CCDData(np.ones((51, 51)), pixel_scale=3., psf=psf, noise_map=np.ones((51, 51)))
        mask = msk.Mask.unmasked_for_shape_and_pixel_scale(shape=(51, 51), pixel_scale=1.0, invert=True)
        mask[26, 26] = False

        lens_data = ld.LensData(image, mask, sub_grid_size=8, image_psf_shape=(5, 5),
                                 mapping_matrix_psf_shape=(3, 3), positions=[np.array([[1.0, 1.0]])])

        assert lens_data.sub_grid_size == 8
        assert lens_data.convolver_image.psf_shape == (5, 5)
        assert lens_data.convolver_mapping_matrix.psf_shape == (3, 3)
        assert (lens_data.positions[0] == np.array([[1.0, 1.0]])).all()

        assert lens_data.image_psf_shape == (5,5)
        assert lens_data.mapping_matrix_psf_shape == (3,3)
Esempio n. 13
0
def make_lens_data_blur():

    psf = ccd.PSF(array=(np.array([[1.0, 1.0, 1.0], [1.0, 1.0, 1.0],
                                   [1.0, 1.0, 1.0]])),
                  pixel_scale=1.0,
                  renormalize=False)
    im = ccd.CCDData(image=5.0 * np.ones((6, 6)),
                     pixel_scale=1.0,
                     psf=psf,
                     noise_map=np.ones((6, 6)),
                     exposure_time_map=3.0 * np.ones((6, 6)),
                     background_sky_map=4.0 * np.ones((6, 6)))

    ma = np.array([[True, True, True, True, True, True],
                   [True, False, False, False, False, True],
                   [True, False, False, False, False, True],
                   [True, False, False, False, False, True],
                   [True, False, False, False, False, True],
                   [True, True, True, True, True, True]])
    ma = mask.Mask(array=ma, pixel_scale=1.0)

    return ld.LensData(ccd_data=im, mask=ma, sub_grid_size=2)