def test_regression_on_extract_1d_spectra(ad, ref_ad_factory, change_working_dir): """ Regression test for the :func:`~geminidr.gmos.GMOSSpect.extract1DSpectra` primitive. Parameters ---------- ad : pytest.fixture (AstroData) Fixture that reads the filename and loads as an AstroData object. change_working_dir : pytest.fixture Fixture that changes the working directory (see :mod:`astrodata.testing`). reference_ad : pytest.fixture Fixture that contains a function used to load the reference AstroData object (see :mod:`recipe_system.testing`). """ with change_working_dir(): logutils.config( file_name='log_regression_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.viewer = geminidr.dormantViewer(p, None) p.extract1DSpectra(method="standard", width=None, grow=10) extracted_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(extracted_ad.filename) for ext, ref_ext in zip(extracted_ad, ref_ad): assert ext.data.ndim == 1 np.testing.assert_allclose(ext.data, ref_ext.data, atol=1e-3)
def test_regression_on_flux_calibration(ad, ref_ad_factory, change_working_dir): """ Regression test for the :func:`~geminidr.gmos.GMOSSpect.fluxCalibrate` primitive. Parameters ---------- ad : pytest.fixture (AstroData) Fixture that reads the filename and loads as an AstroData object. change_working_dir : pytest.fixture Fixture that changes the working directory (see :mod:`astrodata.testing`). reference_ad : pytest.fixture Fixture that contains a function used to load the reference AstroData object (see :mod:`recipe_system.testing`). """ with change_working_dir(): logutils.config( file_name='log_regression_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.fluxCalibrate(standard=ad) flux_calibrated_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(flux_calibrated_ad.filename) for flux_cal_ext, ref_ext in zip(flux_calibrated_ad, ref_ad): np.testing.assert_allclose(flux_cal_ext.data, ref_ext.data, atol=1e-4)
def test_regression_for_determine_distortion_using_models_coefficients( ad, change_working_dir, ref_ad_factory, request): """ Runs the `determineDistortion` primitive on a preprocessed data and compare its model with the one in the reference file. Parameters ---------- ad : pytest.fixture (AstroData) Fixture that reads the filename and loads as an AstroData object. change_working_dir : pytest.fixture Fixture that changes the working directory (see :mod:`astrodata.testing`). reference_ad : pytest.fixture Fixture that contains a function used to load the reference AstroData object (see :mod:`recipe_system.testing`). request : pytest.fixture PyTest built-in containing command line options. """ with change_working_dir(): logutils.config(file_name='log_model_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.viewer = geminidr.dormantViewer(p, None) p.determineDistortion(**fixed_parameters_for_determine_distortion) distortion_determined_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(distortion_determined_ad.filename) for ext, ext_ref in zip(distortion_determined_ad, ref_ad): c = np.ma.masked_invalid(ext.FITCOORD["coefficients"]) c_ref = np.ma.masked_invalid(ext_ref.FITCOORD["coefficients"]) np.testing.assert_allclose(c, c_ref, atol=2) if request.config.getoption("--do-plots"): do_plots(distortion_determined_ad, ref_ad)
def test_regression_for_determine_distortion_using_wcs(ad, change_working_dir, ref_ad_factory): """ Runs the `determineDistortion` primitive on a preprocessed data and compare its model with the one in the reference file. The distortion model needs to be reconstructed because different coefficients might return same results. Parameters ---------- ad : pytest.fixture (AstroData) Fixture that reads the filename and loads as an AstroData object. change_working_dir : pytest.fixture Fixture that changes the working directory (see :mod:`astrodata.testing`). reference_ad : pytest.fixture Fixture that contains a function used to load the reference AstroData object (see :mod:`recipe_system.testing`). """ with change_working_dir(): logutils.config( file_name='log_fitcoord_{:s}.txt'.format(ad.data_label())) p = GMOSLongslit([ad]) p.viewer = geminidr.dormantViewer(p, None) p.determineDistortion(**fixed_parameters_for_determine_distortion) distortion_determined_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(distortion_determined_ad.filename) model = distortion_determined_ad[0].wcs.get_transform( "pixels", "distortion_corrected")[1] ref_model = ref_ad[0].wcs.get_transform("pixels", "distortion_corrected")[1] X, Y = np.mgrid[:ad[0].shape[0], :ad[0].shape[1]] np.testing.assert_allclose(model(X, Y), ref_model(X, Y), atol=1)
def test_make_processed_slit_illum(processed_slit_illum, ref_ad_factory): assert "_slitIllum" in processed_slit_illum.filename ref_ad = ref_ad_factory(processed_slit_illum.filename) for ext, ext_ref in zip(processed_slit_illum, ref_ad): np.testing.assert_allclose(ext.data, ext_ref.data, atol=1)
def test_regression_determine_wavelength_solution(ad, fwidth, order, min_snr, caplog, change_working_dir, ref_ad_factory): """ Make sure that the wavelength solution gives same results on different runs. """ caplog.set_level(logging.INFO, logger="geminidr") with change_working_dir(): logutils.config( file_name='log_regress_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.viewer = geminidr.dormantViewer(p, None) p.determineWavelengthSolution( order=order, min_snr=min_snr, fwidth=fwidth, **determine_wavelength_solution_parameters) wcalibrated_ad = p.writeOutputs().pop() for record in caplog.records: if record.levelname == "WARNING": assert "No acceptable wavelength solution found" not in record.message ref_ad = ref_ad_factory(wcalibrated_ad.filename) table = wcalibrated_ad[0].WAVECAL table_ref = ref_ad[0].WAVECAL model = astromodels.dict_to_chebyshev( dict(zip(table["name"], table["coefficients"]))) ref_model = astromodels.dict_to_chebyshev( dict(zip(table_ref["name"], table_ref["coefficients"]))) x = np.arange(wcalibrated_ad[0].shape[1]) wavelength = model(x) ref_wavelength = ref_model(x) pixel_scale = wcalibrated_ad[0].pixel_scale() # arcsec / px slit_size_in_arcsec = float(wcalibrated_ad[0].focal_plane_mask().replace( 'arcsec', '')) slit_size_in_px = slit_size_in_arcsec / pixel_scale dispersion = abs( wcalibrated_ad[0].dispersion(asNanometers=True)) # nm / px tolerance = 0.5 * (slit_size_in_px * dispersion) np.testing.assert_allclose(wavelength, ref_wavelength, rtol=tolerance)
def test_regression_on_calculate_sensitivity(ad, change_working_dir, ref_ad_factory): with change_working_dir(): logutils.config(file_name='log_regression_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.calculateSensitivity(bandpass=5, order=6) calc_sens_ad = p.writeOutputs().pop() assert hasattr(calc_sens_ad[0], 'SENSFUNC') ref_ad = ref_ad_factory(ad.filename) for calc_sens_ext, ref_ext in zip(ad, ref_ad): np.testing.assert_allclose( calc_sens_ext.data, ref_ext.data, atol=1e-4)
def test_regression_determine_wavelength_solution(ad, fwidth, order, min_snr, caplog, change_working_dir, ref_ad_factory, request): """ Make sure that the wavelength solution gives same results on different runs. """ caplog.set_level(logging.INFO, logger="geminidr") with change_working_dir(): logutils.config( file_name='log_regress_{:s}.txt'.format(ad.data_label())) p = GMOSLongslit([ad]) p.viewer = geminidr.dormantViewer(p, None) p.determineWavelengthSolution( order=order, min_snr=min_snr, fwidth=fwidth, **determine_wavelength_solution_parameters) wcalibrated_ad = p.writeOutputs().pop() for record in caplog.records: if record.levelname == "WARNING": assert "No acceptable wavelength solution found" not in record.message ref_ad = ref_ad_factory(wcalibrated_ad.filename) model = am.get_named_submodel(wcalibrated_ad[0].wcs.forward_transform, "WAVE") ref_model = am.get_named_submodel(ref_ad[0].wcs.forward_transform, "WAVE") x = np.arange(wcalibrated_ad[0].shape[1]) wavelength = model(x) ref_wavelength = ref_model(x) pixel_scale = wcalibrated_ad[0].pixel_scale() # arcsec / px slit_size_in_arcsec = float(wcalibrated_ad[0].focal_plane_mask().replace( 'arcsec', '')) slit_size_in_px = slit_size_in_arcsec / pixel_scale dispersion = abs( wcalibrated_ad[0].dispersion(asNanometers=True)) # nm / px tolerance = 0.5 * (slit_size_in_px * dispersion) np.testing.assert_allclose(wavelength, ref_wavelength, rtol=tolerance) if request.config.getoption("--do-plots"): do_plots(wcalibrated_ad)
def test_regression_processed_flat(processed_flat, ref_ad_factory): """ Tests if the processed flat contains values around one. Parameters ---------- processed_flat : pytest.fixture Fixture containing an instance of the processed flat. ref_ad_factory : pytest.fixture Fixture containing a function that will receive the input file an return the path to the reference data. """ ref_flat = ref_ad_factory(processed_flat.filename) for ext, ext_ref in zip(processed_flat, ref_flat): astrodata.testing.assert_most_equal(ext.mask, ext_ref.mask, 10) astrodata.testing.assert_most_close(ext.data, ext_ref.data, 10, atol=0.05)
def test_regression_extract_1d_spectra(ad, change_working_dir, ref_ad_factory): with change_working_dir(): logutils.config( file_name='log_regression_{}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.viewer = geminidr.dormantViewer(p, None) p.skyCorrectFromSlit(order=5, grow=0) sky_subtracted_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(sky_subtracted_ad.filename) for ext, ref_ext in zip(sky_subtracted_ad, ref_ad): np.testing.assert_allclose(ext.data, ref_ext.data, atol=0.01)
def test_regression_on_qe_correct(ad, arc_ad, change_working_dir, ref_ad_factory): with change_working_dir(): logutils.config( file_name='log_test_regression{}.txt'.format(ad.data_label())) p = primitives_gmos_longslit.GMOSLongslit([ad]) p.QECorrect(arc=arc_ad) qe_corrected_ad = p.writeOutputs().pop() assert 'QECORR' in qe_corrected_ad.phu.keys() ref_ad = ref_ad_factory(qe_corrected_ad.filename) for qe_corrected_ext, ref_ext in zip(qe_corrected_ad, ref_ad): np.testing.assert_allclose(np.ma.masked_array( qe_corrected_ext.data, mask=qe_corrected_ext.mask), np.ma.masked_array(ref_ext.data, mask=ref_ext.mask), atol=0.05)
def test_regression_in_distortion_correct(ad, change_working_dir, ref_ad_factory): """ Runs the `distortionCorrect` primitive on a preprocessed data and compare its model with the one in the reference file. """ with change_working_dir(): logutils.config( file_name='log_regression_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_longslit.GMOSLongslit([deepcopy(ad)]) p.viewer = geminidr.dormantViewer(p, None) p.distortionCorrect(arc=deepcopy(ad), order=3, subsample=1) dist_corrected_ad = p.writeOutputs()[0] ref_ad = ref_ad_factory(dist_corrected_ad.filename) for ext, ext_ref in zip(dist_corrected_ad, ref_ad): data = np.ma.masked_invalid(ext.data) ref_data = np.ma.masked_invalid(ext_ref.data) np.testing.assert_allclose(data, ref_data, atol=1)
def test_regression_trace_apertures(ad, change_working_dir, ref_ad_factory): with change_working_dir(): logutils.config(file_name="log_regression_{}.txt".format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.viewer = geminidr.dormantViewer(p, None) p.traceApertures() aperture_traced_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(aperture_traced_ad.filename) for ext, ref_ext in zip(aperture_traced_ad, ref_ad): input_table = ext.APERTURE reference_table = ref_ext.APERTURE assert input_table['aper_lower'][0] <= 0 assert input_table['aper_upper'][0] >= 0 keys = ext.APERTURE.colnames actual = np.array([input_table[k] for k in keys]) desired = np.array([reference_table[k] for k in keys]) np.testing.assert_allclose(desired, actual, atol=0.05)
def test_regression_for_determine_distortion_using_fitcoord_table( ad, change_working_dir, ref_ad_factory): """ Runs the `determineDistortion` primitive on a preprocessed data and compare its model with the one in the reference file. The distortion model needs to be reconstructed because different coefficients might return same results. Parameters ---------- ad : pytest.fixture (AstroData) Fixture that reads the filename and loads as an AstroData object. change_working_dir : pytest.fixture Fixture that changes the working directory (see :mod:`astrodata.testing`). reference_ad : pytest.fixture Fixture that contains a function used to load the reference AstroData object (see :mod:`recipe_system.testing`). """ with change_working_dir(): logutils.config(file_name='log_fitcoord_{:s}.txt'.format(ad.data_label())) p = primitives_gmos_spect.GMOSSpect([ad]) p.viewer = geminidr.dormantViewer(p, None) p.determineDistortion(**fixed_parameters_for_determine_distortion) distortion_determined_ad = p.writeOutputs().pop() ref_ad = ref_ad_factory(distortion_determined_ad.filename) table = ad[0].FITCOORD model_dict = dict(zip(table['name'], table['coefficients'])) model = astromodels.dict_to_chebyshev(model_dict) ref_table = ref_ad[0].FITCOORD ref_model_dict = dict(zip(ref_table['name'], ref_table['coefficients'])) ref_model = astromodels.dict_to_chebyshev(ref_model_dict) X, Y = np.mgrid[:ad[0].shape[0], :ad[0].shape[1]] np.testing.assert_allclose(model(X, Y), ref_model(X, Y), atol=1)
def test_regression_on_qe_correct(ad, arc_ad, change_working_dir, ref_ad_factory): # The GMOS-N tests need to be run with `use_iraf=False` because the # reference files for those use the DRAGONS spline models. is_gmos_s = ad.instrument() == 'GMOS-S' with change_working_dir(): logutils.config( file_name='log_test_regression{}.txt'.format(ad.data_label())) p = primitives_gmos_longslit.GMOSLongslit([ad]) p.QECorrect(arc=arc_ad, use_iraf=is_gmos_s) qe_corrected_ad = p.writeOutputs().pop() assert 'QECORR' in qe_corrected_ad.phu.keys() ref_ad = ref_ad_factory(qe_corrected_ad.filename) for qe_corrected_ext, ref_ext in zip(qe_corrected_ad, ref_ad): np.testing.assert_allclose(np.ma.masked_array( qe_corrected_ext.data, mask=qe_corrected_ext.mask), np.ma.masked_array(ref_ext.data, mask=ref_ext.mask), atol=0.05)