def test_psf_subtraction_ref_mask(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 3),
                                         name_in='pca_ref_mask',
                                         images_in_tag='science_prep',
                                         reference_in_tag='reference_prep',
                                         res_mean_tag='res_mean_ref_mask',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_ref_mask',
                                         extra_rot=0.,
                                         subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref_mask')

        data = self.pipeline.get_data('res_mean_ref_mask')
        assert np.sum(data) == pytest.approx(9.400558926815758e-06,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('basis_ref_mask')
        assert np.sum(data) == pytest.approx(0.08411251293842326,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)
Beispiel #2
0
    def test_psf_subtraction_len_parang(self) -> None:

        database = h5py.File(self.test_dir + 'PynPoint_database.hdf5', 'a')
        database['config'].attrs['CPU'] = 1

        parang = self.pipeline.get_data('header_science/PARANG')
        self.pipeline.set_attribute('science_prep',
                                    'PARANG',
                                    np.append(parang, 0.),
                                    static=False)

        module = PcaPsfSubtractionModule(pca_numbers=[
            5,
        ],
                                         name_in='pca_len_parang',
                                         images_in_tag='science_prep',
                                         reference_in_tag='science_prep',
                                         res_mean_tag='res_mean_len_parang',
                                         extra_rot=0.)

        self.pipeline.add_module(module)

        with pytest.raises(ValueError) as error:
            self.pipeline.run_module('pca_len_parang')

        assert str(error.value) == 'The number of images (80) is not equal to the number of ' \
                                   'parallactic angles (81).'
Beispiel #3
0
    def test_psf_subtraction(self):

        module = PcaPsfSubtractionModule(pca_numbers=(2, ),
                                         name_in='pca',
                                         images_in_tag='fake',
                                         reference_in_tag='fake',
                                         res_mean_tag='res_mean',
                                         res_median_tag=None,
                                         res_arr_out_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         extra_rot=0.)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca')

        data = self.pipeline.get_data('res_mean')
        assert np.allclose(data[0, 49, 31],
                           4.8963214463463886e-05,
                           rtol=limit,
                           atol=0.)
        assert np.allclose(np.mean(data),
                           1.8409659677297164e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (1, 101, 101)
    def test_psf_subtraction_ref_no_mean_mask(self) -> None:

        module = PcaPsfSubtractionModule(
            pca_numbers=range(1, 3),
            name_in='pca_ref_no_mean_mask',
            images_in_tag='science_prep',
            reference_in_tag='reference_prep',
            res_mean_tag='res_mean_ref_no_mean_mask',
            res_median_tag=None,
            res_weighted_tag=None,
            res_rot_mean_clip_tag=None,
            res_arr_out_tag=None,
            basis_out_tag='basis_ref_no_mean_mask',
            extra_rot=0.,
            subtract_mean=False)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref_no_mean_mask')

        data = self.pipeline.get_data('res_mean_ref_no_mean_mask')
        assert np.sum(data) == pytest.approx(2.354235994950671e-05,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('basis_ref_no_mean_mask')
        assert np.sum(data) == pytest.approx(5.655460951633233,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)
Beispiel #5
0
    def test_psf_subtraction(self):

        pca = PcaPsfSubtractionModule(pca_numbers=(5, ),
                                      name_in="psf_subtraction",
                                      images_in_tag="im_arr_stacked",
                                      reference_in_tag="im_arr_stacked",
                                      res_mean_tag="res_mean",
                                      res_median_tag=None,
                                      res_arr_out_tag=None,
                                      res_rot_mean_clip_tag=None,
                                      extra_rot=0.)

        self.pipeline.add_module(pca)
        self.pipeline.run_module("psf_subtraction")

        data = self.pipeline.get_data("res_mean")
        assert np.allclose(data[0, 38, 22],
                           2.073746596517549e-05,
                           rtol=limit,
                           atol=0.)
        assert np.allclose(np.mean(data),
                           -1.5133345435496935e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (1, 46, 46)
Beispiel #6
0
    def test_psf_subtraction_ref_no_mean(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 21),
                                         name_in='pca_ref_no_mean',
                                         images_in_tag='science',
                                         reference_in_tag='reference',
                                         res_mean_tag='res_mean_ref_no_mean',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_ref_no_mean',
                                         extra_rot=0.,
                                         subtract_mean=False)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref_no_mean')

        data = self.pipeline.get_data('res_mean_ref_no_mean')
        assert np.allclose(np.mean(data),
                           3.7029738044199534e-07,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('basis_ref_no_mean')
        assert np.allclose(np.mean(data),
                           2.3755682312090375e-05,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
Beispiel #7
0
    def test_psf_subtraction_pca_single_mask(self) -> None:

        pca = PcaPsfSubtractionModule(
            pca_numbers=range(1, 21),
            name_in='pca_single_mask',
            images_in_tag='science_prep',
            reference_in_tag='science_prep',
            res_mean_tag='res_mean_single_mask',
            res_median_tag='res_median_single_mask',
            res_weighted_tag='res_weighted_single_mask',
            res_rot_mean_clip_tag='res_clip_single_mask',
            res_arr_out_tag='res_arr_single_mask',
            basis_out_tag='basis_single_mask',
            extra_rot=-15.,
            subtract_mean=True)

        self.pipeline.add_module(pca)
        self.pipeline.run_module('pca_single_mask')

        data = self.pipeline.get_data('res_mean_single_mask')
        assert np.allclose(np.mean(data),
                           -1.6536519510012155e-09,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_median_single_mask')
        assert np.allclose(np.mean(data),
                           5.6094356668078245e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_weighted_single_mask')
        assert np.allclose(np.mean(data),
                           4.7079857263662695e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_clip_single_mask')
        assert np.allclose(np.mean(data),
                           -4.875856901892831e-10,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_arr_single_mask5')
        assert np.allclose(np.mean(data),
                           -1.700674890172441e-09,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (80, 100, 100)

        data = self.pipeline.get_data('basis_single_mask')
        assert np.allclose(np.mean(data),
                           5.584100479595007e-06,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
Beispiel #8
0
    def test_psf_subtraction_no_mean(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 21),
                                         name_in='pca_no_mean',
                                         images_in_tag='science',
                                         reference_in_tag='science',
                                         res_mean_tag='res_mean_no_mean',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_no_mean',
                                         extra_rot=0.,
                                         subtract_mean=False)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_no_mean')

        data = self.pipeline.get_data('res_mean_no_mean')
        assert np.allclose(np.mean(data),
                           2.413203757426239e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('basis_no_mean')
        assert np.allclose(np.mean(data),
                           7.4728664805632875e-06,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
Beispiel #9
0
    def test_psf_subtraction_ref(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 21),
                                         name_in='pca_ref',
                                         images_in_tag='science',
                                         reference_in_tag='reference',
                                         res_mean_tag='res_mean_ref',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_ref',
                                         extra_rot=0.,
                                         subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref')

        data = self.pipeline.get_data('res_mean_ref')
        assert np.allclose(np.mean(data),
                           1.1662201512335965e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('basis_ref')
        assert np.allclose(np.mean(data),
                           -1.6780507257603104e-05,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
Beispiel #10
0
    def test_psf_subtraction_no_mean_mask(self):

        pca = PcaPsfSubtractionModule(pca_numbers=range(1, 21),
                                      name_in='pca_no_mean_mask',
                                      images_in_tag='science_prep',
                                      reference_in_tag='science_prep',
                                      res_mean_tag='res_mean_no_mean_mask',
                                      res_median_tag=None,
                                      res_weighted_tag=None,
                                      res_rot_mean_clip_tag=None,
                                      res_arr_out_tag=None,
                                      basis_out_tag='basis_no_mean_mask',
                                      extra_rot=0.,
                                      subtract_mean=False)

        self.pipeline.add_module(pca)
        self.pipeline.run_module('pca_no_mean_mask')

        data = self.pipeline.get_data('res_mean_no_mean_mask')
        assert np.allclose(np.mean(data),
                           -1.0905008724474168e-09,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('basis_no_mean_mask')
        assert np.allclose(np.sum(np.abs(data)),
                           1025.2018448288406,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
Beispiel #11
0
    def test_psf_subtraction_pca_single(self) -> None:

        module = PcaPsfSubtractionModule(
            pca_numbers=range(1, 21),
            name_in='pca_single',
            images_in_tag='science',
            reference_in_tag='science',
            res_mean_tag='res_mean_single',
            res_median_tag='res_median_single',
            res_weighted_tag='res_weighted_single',
            res_rot_mean_clip_tag='res_clip_single',
            res_arr_out_tag='res_arr_single',
            basis_out_tag='basis_single',
            extra_rot=-15.,
            subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_single')

        data = self.pipeline.get_data('res_mean_single')
        assert np.allclose(np.mean(data),
                           2.6959819771522928e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_median_single')
        assert np.allclose(np.mean(data),
                           -2.4142571236920345e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_weighted_single')
        assert np.allclose(np.mean(data),
                           -5.293559651636843e-09,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_clip_single')
        assert np.allclose(np.mean(data),
                           2.6199554737979536e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('res_arr_single5')
        assert np.allclose(np.mean(data),
                           3.184676024912723e-08,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (80, 100, 100)

        data = self.pipeline.get_data('basis_single')
        assert np.allclose(np.mean(data),
                           -1.593245396350998e-05,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
Beispiel #12
0
    def test_psf_subtraction_ref_no_mean_mask(self) -> None:

        module = PcaPsfSubtractionModule(
            pca_numbers=range(1, 21),
            name_in='pca_ref_no_mean_mask',
            images_in_tag='science_prep',
            reference_in_tag='reference_prep',
            res_mean_tag='res_mean_ref_no_mean_mask',
            res_median_tag=None,
            res_weighted_tag=None,
            res_rot_mean_clip_tag=None,
            res_arr_out_tag=None,
            basis_out_tag='basis_ref_no_mean_mask',
            extra_rot=0.,
            subtract_mean=False)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref_no_mean_mask')

        data = self.pipeline.get_data('res_mean_ref_no_mean_mask')
        assert np.allclose(np.mean(data),
                           3.848255803450399e-07,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('basis_ref_no_mean_mask')
        assert np.allclose(np.sum(np.abs(data)),
                           1026.3329224435665,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
    def test_psf_subtraction_ref_no_mean(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 3),
                                         name_in='pca_ref_no_mean',
                                         images_in_tag='science',
                                         reference_in_tag='reference',
                                         res_mean_tag='res_mean_ref_no_mean',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_ref_no_mean',
                                         extra_rot=0.,
                                         subtract_mean=False)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref_no_mean')

        data = self.pipeline.get_data('res_mean_ref_no_mean')
        assert np.sum(data) == pytest.approx(0.0006081272007585764,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('basis_ref_no_mean')
        assert np.sum(data) == pytest.approx(5.118005177367774,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)
    def test_psf_subtraction_ref(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 3),
                                         name_in='pca_ref',
                                         images_in_tag='science',
                                         reference_in_tag='reference',
                                         res_mean_tag='res_mean_ref',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_ref',
                                         extra_rot=0.,
                                         subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref')

        data = self.pipeline.get_data('res_mean_ref')
        assert np.sum(data) == pytest.approx(0.0006330226118859073,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('basis_ref')
        assert np.sum(data) == pytest.approx(0.0943869773132221,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)
Beispiel #15
0
    def test_psf_subtraction_ref_mask(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=range(1, 21),
                                         name_in='pca_ref_mask',
                                         images_in_tag='science_prep',
                                         reference_in_tag='reference_prep',
                                         res_mean_tag='res_mean_ref_mask',
                                         res_median_tag=None,
                                         res_weighted_tag=None,
                                         res_rot_mean_clip_tag=None,
                                         res_arr_out_tag=None,
                                         basis_out_tag='basis_ref_mask',
                                         extra_rot=0.,
                                         subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_ref_mask')

        data = self.pipeline.get_data('res_mean_ref_mask')
        assert np.allclose(np.mean(data),
                           -9.962692629500833e-10,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)

        data = self.pipeline.get_data('basis_ref_mask')
        assert np.allclose(np.mean(data),
                           -2.3165670099810983e-05,
                           rtol=limit,
                           atol=0.)
        assert data.shape == (20, 100, 100)
    def test_psf_subtraction_pca_single_mask(self) -> None:

        pca = PcaPsfSubtractionModule(
            pca_numbers=range(1, 3),
            name_in='pca_single_mask',
            images_in_tag='science_prep',
            reference_in_tag='science_prep',
            res_mean_tag='res_mean_single_mask',
            res_median_tag='res_median_single_mask',
            res_weighted_tag='res_weighted_single_mask',
            res_rot_mean_clip_tag='res_clip_single_mask',
            res_arr_out_tag='res_arr_single_mask',
            basis_out_tag='basis_single_mask',
            extra_rot=45.,
            subtract_mean=True)

        self.pipeline.add_module(pca)
        self.pipeline.run_module('pca_single_mask')

        data = self.pipeline.get_data('res_mean_single_mask')
        assert np.sum(data) == pytest.approx(0.00010696166038626307,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_median_single_mask')
        assert np.sum(data) == pytest.approx(-0.0021005307611346156,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_weighted_single_mask')
        assert np.sum(data) == pytest.approx(0.06014309988789256,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_clip_single_mask')
        # assert np.sum(data) == pytest.approx(9.35120662148806e-05, rel=self.limit, abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_arr_single_mask1')
        assert np.sum(data) == pytest.approx(0.0006170872862547557,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (10, 21, 21)

        data = self.pipeline.get_data('basis_single_mask')
        assert np.sum(data) == pytest.approx(0.08411251293842359,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)
    def test_psf_subtraction_pca_single(self) -> None:

        module = PcaPsfSubtractionModule(
            pca_numbers=range(1, 3),
            name_in='pca_single',
            images_in_tag='science',
            reference_in_tag='science',
            res_mean_tag='res_mean_single',
            res_median_tag='res_median_single',
            res_weighted_tag='res_weighted_single',
            res_rot_mean_clip_tag='res_clip_single',
            res_arr_out_tag='res_arr_single',
            basis_out_tag='basis_single',
            extra_rot=45.,
            subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_single')

        data = self.pipeline.get_data('res_mean_single')
        assert np.sum(data) == pytest.approx(-0.00011857022709778602,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_median_single')
        assert np.sum(data) == pytest.approx(-0.002184868916566093,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_weighted_single')
        assert np.sum(data) == pytest.approx(0.08102176735226937,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)

        # data = self.pipeline.get_data('res_clip_single')
        # assert np.sum(data) == pytest.approx(7.09495495339349e-05, rel=self.limit, abs=0.)
        # assert data.shape == (2, 21, 21)

        data = self.pipeline.get_data('res_arr_single1')
        assert np.sum(data) == pytest.approx(-0.0002751385418691618,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (10, 21, 21)

        data = self.pipeline.get_data('basis_single')
        assert np.sum(data) == pytest.approx(0.09438697731322143,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (2, 21, 21)
Beispiel #18
0
    def test_psf_subtraction_pca_multi_mask(self) -> None:

        database = h5py.File(self.test_dir + 'PynPoint_database.hdf5', 'a')
        database['config'].attrs['CPU'] = 4

        module = PcaPsfSubtractionModule(
            pca_numbers=range(1, 21),
            name_in='pca_multi_mask',
            images_in_tag='science_prep',
            reference_in_tag='science_prep',
            res_mean_tag='res_mean_multi_mask',
            res_median_tag='res_median_multi_mask',
            res_weighted_tag='res_weighted_multi_mask',
            res_rot_mean_clip_tag='res_clip_multi_mask',
            res_arr_out_tag=None,
            basis_out_tag='basis_multi_mask',
            extra_rot=-15.,
            subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_multi_mask')

        data_single = self.pipeline.get_data('res_mean_single_mask')
        data_multi = self.pipeline.get_data('res_mean_multi_mask')
        assert np.allclose(data_single[data_single > 1e-12],
                           data_multi[data_multi > 1e-12],
                           rtol=1e-6,
                           atol=0.)
        assert data_single.shape == data_multi.shape

        data_single = self.pipeline.get_data('res_median_single_mask')
        data_multi = self.pipeline.get_data('res_median_multi_mask')
        assert np.allclose(data_single[data_single > 1e-12],
                           data_multi[data_multi > 1e-12],
                           rtol=1e-6,
                           atol=0.)
        assert data_single.shape == data_multi.shape

        data_single = self.pipeline.get_data('res_weighted_single_mask')
        data_multi = self.pipeline.get_data('res_weighted_multi_mask')
        assert np.allclose(data_single[data_single > 1e-12],
                           data_multi[data_multi > 1e-12],
                           rtol=1e-6,
                           atol=0.)
        assert data_single.shape == data_multi.shape

        data_single = self.pipeline.get_data('basis_single_mask')
        data_multi = self.pipeline.get_data('basis_multi_mask')
        assert np.allclose(data_single, data_multi, rtol=1e-5, atol=0.)
        assert data_single.shape == data_multi.shape
    def test_psf_subtraction_pca_multi(self) -> None:

        with h5py.File(self.test_dir + 'PynPoint_database.hdf5',
                       'a') as hdf_file:
            hdf_file['config'].attrs['CPU'] = 4

        module = PcaPsfSubtractionModule(
            pca_numbers=range(1, 3),
            name_in='pca_multi',
            images_in_tag='science',
            reference_in_tag='science',
            res_mean_tag='res_mean_multi',
            res_median_tag='res_median_multi',
            res_weighted_tag='res_weighted_multi',
            res_rot_mean_clip_tag='res_clip_multi',
            res_arr_out_tag=None,
            basis_out_tag='basis_multi',
            extra_rot=45.,
            subtract_mean=True)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca_multi')

        data_single = self.pipeline.get_data('res_mean_single')
        data_multi = self.pipeline.get_data('res_mean_multi')
        assert data_single.shape == data_multi.shape

        assert data_single[data_single > 1e-12] == \
            pytest.approx(data_multi[data_multi > 1e-12], rel=self.limit, abs=0.)

        data_single = self.pipeline.get_data('res_median_single')
        data_multi = self.pipeline.get_data('res_median_multi')
        assert data_single.shape == data_multi.shape

        assert data_single[data_single > 1e-12] == \
            pytest.approx(data_multi[data_multi > 1e-12], rel=self.limit, abs=0.)

        data_single = self.pipeline.get_data('res_weighted_single')
        data_multi = self.pipeline.get_data('res_weighted_multi')
        assert data_single.shape == data_multi.shape

        assert data_single[data_single > 1e-12] == \
            pytest.approx(data_multi[data_multi > 1e-12], rel=self.limit, abs=0.)

        data_single = self.pipeline.get_data('basis_single')
        data_multi = self.pipeline.get_data('basis_multi')
        assert data_single.shape == data_multi.shape

        assert data_single[data_single > 1e-12] == \
            pytest.approx(data_multi[data_multi > 1e-12], rel=self.limit, abs=0.)
Beispiel #20
0
    def test_psf_subtraction_sdi_multi(self) -> None:

        with h5py.File(self.test_dir+'PynPoint_database.hdf5', 'a') as hdf_file:
            hdf_file['config'].attrs['CPU'] = 4

        processing_types = ['SDI', 'ADI+SDI']

        pca_numbers = [range(1, 3), (range(1, 3), range(1, 3))]

        expected = [[-0.0044942456603888695, 0.02613693149969979, -0.15045543311096457, -0.008432530081399985],
                    [-0.0094093643053501, -0.08171546066331437, 0.560810054788774, -0.014527353460544753]]

        shape_expc = [(2, 3, 21, 21), (2, 2, 3, 21, 21)]

        for i, p_type in enumerate(processing_types):

            module = PcaPsfSubtractionModule(pca_numbers=pca_numbers[i],
                                             name_in='pca_multi_sdi_'+p_type,
                                             images_in_tag='science',
                                             reference_in_tag='science',
                                             res_mean_tag='res_mean_multi_sdi_'+p_type,
                                             res_median_tag='res_median_multi_sdi_'+p_type,
                                             res_weighted_tag='res_weighted_multi_sdi_'+p_type,
                                             res_rot_mean_clip_tag='res_clip_multi_sdi_'+p_type,
                                             res_arr_out_tag=None,
                                             basis_out_tag=None,
                                             extra_rot=0.,
                                             subtract_mean=True,
                                             processing_type=p_type)

            self.pipeline.add_module(module)
            self.pipeline.run_module('pca_multi_sdi_'+p_type)

            data = self.pipeline.get_data('res_mean_multi_sdi_'+p_type)
            assert np.sum(data) == pytest.approx(expected[i][0], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_median_multi_sdi_'+p_type)
            assert np.sum(data) == pytest.approx(expected[i][1], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_weighted_multi_sdi_'+p_type)
            assert np.sum(data) == pytest.approx(expected[i][2], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_clip_multi_sdi_'+p_type)
#            assert np.sum(data) == pytest.approx(expected[i][3], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]
Beispiel #21
0
    def test_psf_subtraction_sdi(self) -> None:

        processing_types = ['ADI', 'SDI+ADI', 'ADI+SDI']

        expected = [[-0.176152493909826, -0.7938155399702668, 19.552033067005578, -0.21617058715490922],
                    [-0.004568154679096975, -0.08621264803633322, 2.2901225325010888, -0.010269745733878437],
                    [0.008630501634061892, -0.05776205365084376, -0.4285370289350482, 0.0058856438951644455]]

        shape_expc = [(2, 3, 21, 21), (2, 2, 3, 21, 21), (1, 1, 3, 21, 21)]

        pca_numbers = [range(1, 3), (range(1, 3), range(1, 3)), ([1], [1])]
        
        res_arr_tags = [None, None, 'res_arr_single_sdi_ADI+SDI']

        for i, p_type in enumerate(processing_types):

            module = PcaPsfSubtractionModule(pca_numbers=pca_numbers[i],
                                             name_in='pca_single_sdi_'+p_type,
                                             images_in_tag='science',
                                             reference_in_tag='science',
                                             res_mean_tag='res_mean_single_sdi_'+p_type,
                                             res_median_tag='res_median_single_sdi_'+p_type,
                                             res_weighted_tag='res_weighted_single_sdi_'+p_type,
                                             res_rot_mean_clip_tag='res_clip_single_sdi_'+p_type,
                                             res_arr_out_tag=res_arr_tags[i],
                                             basis_out_tag='basis_single_sdi_'+p_type,
                                             extra_rot=0.,
                                             subtract_mean=True,
                                             processing_type=p_type)

            self.pipeline.add_module(module)
            self.pipeline.run_module('pca_single_sdi_'+p_type)

            data = self.pipeline.get_data('res_mean_single_sdi_'+p_type)
            assert np.sum(data) == pytest.approx(expected[i][0], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_median_single_sdi_'+p_type)
            assert np.sum(data) == pytest.approx(expected[i][1], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_weighted_single_sdi_'+p_type)
            assert np.sum(data) == pytest.approx(expected[i][2], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_clip_single_sdi_'+p_type)
#            assert np.sum(data) == pytest.approx(expected[i][3], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]
Beispiel #22
0
    def test_psf_subtraction(self) -> None:

        module = PcaPsfSubtractionModule(pca_numbers=[
            1,
        ],
                                         name_in='pca',
                                         images_in_tag='fake',
                                         reference_in_tag='fake',
                                         res_mean_tag='res_mean',
                                         extra_rot=0.)

        self.pipeline.add_module(module)
        self.pipeline.run_module('pca')

        data = self.pipeline.get_data('res_mean')
        assert np.sum(data) == pytest.approx(0.014757351752469366,
                                             rel=self.limit,
                                             abs=0.)
        assert data.shape == (1, 21, 21)
    def test_psf_subtraction_pca_multi(self):

        database = h5py.File(self.test_dir + 'PynPoint_database.hdf5', 'a')
        database['config'].attrs['CPU'] = 4

        pca = PcaPsfSubtractionModule(pca_numbers=np.arange(1, 21, 1),
                                      name_in="pca_multi",
                                      images_in_tag="science",
                                      reference_in_tag="science",
                                      res_mean_tag="res_mean_multi",
                                      res_median_tag="res_median_multi",
                                      res_weighted_tag="res_weighted_multi",
                                      res_rot_mean_clip_tag="res_clip_multi",
                                      res_arr_out_tag=None,
                                      basis_out_tag="basis_multi",
                                      extra_rot=-15.,
                                      subtract_mean=True)

        self.pipeline.add_module(pca)
        self.pipeline.run_module("pca_multi")

        data_single = self.pipeline.get_data("res_mean_single")
        data_multi = self.pipeline.get_data("res_mean_multi")
        assert np.allclose(data_single, data_multi, rtol=1e-6, atol=0.)
        assert data_single.shape == data_multi.shape

        data_single = self.pipeline.get_data("res_median_single")
        data_multi = self.pipeline.get_data("res_median_multi")
        assert np.allclose(data_single, data_multi, rtol=1e-6, atol=0.)
        assert data_single.shape == data_multi.shape

        data_single = self.pipeline.get_data("res_weighted_single")
        data_multi = self.pipeline.get_data("res_weighted_multi")
        assert np.allclose(data_single, data_multi, rtol=1e-6, atol=0.)
        assert data_single.shape == data_multi.shape

        data_single = self.pipeline.get_data("basis_single")
        data_multi = self.pipeline.get_data("basis_multi")
        assert np.allclose(data_single, data_multi, rtol=1e-5, atol=0.)
        assert data_single.shape == data_multi.shape
    def test_psf_subtraction_sdi(self) -> None:

        processing_types = ['ADI', 'SDI+ADI', 'ADI+SDI', 'CODI']

        expected = [[
            -0.16718942968552664, -0.790697125718532, 19.507979777136892,
            -0.21617058715490922
        ],
                    [
                        -0.001347198747121658, -0.08621264803633322,
                        2.3073192270025333, -0.010269745733878437
                    ],
                    [
                        0.009450917836998779, -0.05776205365084376,
                        -0.43506678222476264, 0.0058856438951644455
                    ],
                    [
                        -0.2428739554898396, -0.5069023645693083,
                        9.326414176548905, 0.00
                    ]]

        shape_expc = [(2, 3, 21, 21), (2, 2, 3, 21, 21), (1, 1, 3, 21, 21),
                      (2, 3, 21, 21)]

        pca_numbers = [
            range(1, 3), (range(1, 3), range(1, 3)), ([1], [1]),
            range(1, 3)
        ]

        res_arr_tags = [None, None, 'res_arr_single_sdi_ADI+SDI', None]

        for i, p_type in enumerate(processing_types):

            module = PcaPsfSubtractionModule(
                pca_numbers=pca_numbers[i],
                name_in='pca_single_sdi_' + p_type,
                images_in_tag='science',
                reference_in_tag='science',
                res_mean_tag='res_mean_single_sdi_' + p_type,
                res_median_tag='res_median_single_sdi_' + p_type,
                res_weighted_tag='res_weighted_single_sdi_' + p_type,
                res_rot_mean_clip_tag='res_clip_single_sdi_' + p_type,
                res_arr_out_tag=res_arr_tags[i],
                basis_out_tag='basis_single_sdi_' + p_type,
                extra_rot=0.,
                subtract_mean=True,
                processing_type=p_type)

            self.pipeline.add_module(module)
            self.pipeline.run_module('pca_single_sdi_' + p_type)

            data = self.pipeline.get_data('res_mean_single_sdi_' + p_type)
            assert np.sum(data) == pytest.approx(expected[i][0],
                                                 rel=self.limit,
                                                 abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_median_single_sdi_' + p_type)
            assert np.sum(data) == pytest.approx(expected[i][1],
                                                 rel=self.limit,
                                                 abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_weighted_single_sdi_' + p_type)
            assert np.sum(data) == pytest.approx(expected[i][2],
                                                 rel=self.limit,
                                                 abs=0.)
            assert data.shape == shape_expc[i]

            data = self.pipeline.get_data('res_clip_single_sdi_' + p_type)
            #            assert np.sum(data) == pytest.approx(expected[i][3], rel=self.limit, abs=0.)
            assert data.shape == shape_expc[i]