def test_raise(self):
     with self.assertRaises(ValueError):
         analysis = LensAnalysis(kwargs_model={'lens_model_list': ['SIS']})
         analysis.multi_gaussian_lens(kwargs_lens=[{'theta_E'}])
     with self.assertRaises(ValueError):
         analysis = LensAnalysis(
             kwargs_model={'lens_light_model_list': ['GAUSSIAN']})
         analysis.flux_components(kwargs_light=[{}],
                                  n_grid=400,
                                  delta_grid=0.01,
                                  deltaPix=1.,
                                  type="wrong")
示例#2
0
    def test_flux_components(self):
        phi, q = -0.37221683730659516, 0.70799587973181288
        e1, e2 = param_util.phi_q2_ellipticity(phi, q)

        phi2, q2 = 0.14944144075912402, 0.4105628122365978
        e12, e22 = param_util.phi_q2_ellipticity(phi2, q2)

        kwargs_profile = [{
            'Rs': 0.16350224766074103,
            'e1': e12,
            'e2': e22,
            'center_x': -0.019983826426838536,
            'center_y': 0.90000011282957304,
            'amp': 1.3168943578511678
        }, {
            'Rs': 0.29187068596715743,
            'e1': e1,
            'e2': e2,
            'center_x': 0.020568531548241405,
            'center_y': 0.036038490364800925,
            'Ra': 0.020000382843298824,
            'amp': 85.948773973262391
        }]
        kwargs_options = {
            'lens_model_list': ['SPEP'],
            'lens_model_internal_bool': [True],
            'lens_light_model_internal_bool': [True, True],
            'lens_light_model_list': ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE']
        }
        lensAnalysis = LensAnalysis(kwargs_options)
        flux_list, R_h_list = lensAnalysis.flux_components(kwargs_profile,
                                                           n_grid=400,
                                                           delta_grid=0.01,
                                                           deltaPix=1.,
                                                           type="lens")
        assert len(flux_list) == 2
        npt.assert_almost_equal(flux_list[0], 0.23898248741810812, decimal=8)
        npt.assert_almost_equal(flux_list[1], 3.0565768930826662, decimal=8)

        kwargs_profile = [{'amp': 1.}]
        kwargs_options = {
            'source_light_model_list': ['UNIFORM'],
            'lens_model_list': []
        }
        lensAnalysis = LensAnalysis(kwargs_options)
        flux_list, R_h_list = lensAnalysis.flux_components(kwargs_profile,
                                                           n_grid=400,
                                                           delta_grid=0.01,
                                                           deltaPix=1.,
                                                           type="source")
        assert len(flux_list) == 1
        npt.assert_almost_equal(flux_list[0], 16, decimal=8)
示例#3
0
    def test_flux_components(self):
        kwargs_profile = [{
            'Rs': 0.16350224766074103,
            'q': 0.4105628122365978,
            'center_x': -0.019983826426838536,
            'center_y': 0.90000011282957304,
            'phi_G': 0.14944144075912402,
            'sigma0': 1.3168943578511678
        }, {
            'Rs': 0.29187068596715743,
            'q': 0.70799587973181288,
            'center_x': -0.01,
            'center_y': 0.9,
            'Ra': 0.020000382843298824,
            'phi_G': -0.37221683730659516,
            'sigma0': 85.948773973262391
        }]
        kwargs_options = {
            'lens_model_list': ['SPEP'],
            'lens_model_internal_bool': [True],
            'lens_light_model_internal_bool': [True, True],
            'lens_light_model_list': ['HERNQUIST_ELLIPSE', 'PJAFFE_ELLIPSE']
        }
        lensAnalysis = LensAnalysis(kwargs_options)
        flux_list, R_h_list = lensAnalysis.flux_components(kwargs_profile,
                                                           n_grid=400,
                                                           delta_grid=0.01,
                                                           deltaPix=1.,
                                                           type="lens")
        assert len(flux_list) == 2
        npt.assert_almost_equal(flux_list[0], 0.23898248741810812, decimal=8)
        npt.assert_almost_equal(flux_list[1], 3.0565768930826662, decimal=8)

        kwargs_profile = [{'mean': 1.}]
        kwargs_options = {
            'lens_light_model_list': ['UNIFORM'],
            'lens_model_list': ['NONE']
        }
        lensAnalysis = LensAnalysis(kwargs_options)
        flux_list, R_h_list = lensAnalysis.flux_components(kwargs_profile,
                                                           n_grid=400,
                                                           delta_grid=0.01,
                                                           deltaPix=1.,
                                                           type="lens")
        assert len(flux_list) == 1
        npt.assert_almost_equal(flux_list[0], 16, decimal=8)