def test_user_supplied_poly_coeff_twodspec(): # Load the image lhs6328_fits = fits.open( os.path.join(HERE, "test_data", "v_e_20180810_12_1_0_0.fits.gz") )[0] spatial_mask = np.arange(50, 200) spec_mask = np.arange(50, 1024) # # Loading two pre-saved spectral traces from a single FITS file. # lhs6328 = spectral_reduction.TwoDSpec( lhs6328_fits, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, readnoise=2.34, log_file_name=None, ) # Trace the spectra lhs6328.ap_trace(nspec=2, display=False) # Extract the spectra lhs6328.ap_extract(apwidth=10, optimal=True, skywidth=10, display=False) # Calibrate the 1D spectra lhs6328_onedspec = spectral_reduction.OneDSpec(log_file_name=None) lhs6328_onedspec.from_twodspec(lhs6328) fit_coeff = np.array( [ 3.09833375e03, 5.98842823e00, -2.83963934e-03, 2.84842392e-06, -1.03725267e-09, ] ) fit_type = "poly" # Note that there are two science traces, so two polyfit coefficients # have to be supplied by in a list lhs6328_onedspec.add_fit_coeff(fit_coeff, fit_type) lhs6328_onedspec.apply_wavelength_calibration() # Inspect reduced spectrum lhs6328_onedspec.inspect_reduced_spectrum(display=False) # Save as a FITS file lhs6328_onedspec.save_fits( output="wavecal+count", filename=os.path.join( HERE, "test_output", "user_supplied_wavelength_polyfit_coefficients", ), stype="science", overwrite=True, )
def test_forced_extraction_tophat(): lhs6328_twodspec = spectral_reduction.TwoDSpec( lhs6328_frame, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, readnoise=5.7, gain=2.45, log_level="INFO", log_file_folder=os.path.join(HERE, "test_output"), ) lhs6328_twodspec.add_trace(trace, trace_sigma) # Force extraction lhs6328_twodspec.ap_extract( apwidth=15, skywidth=10, skydeg=1, optimal=False, forced=True, display=False, save_fig=True, filename=os.path.join(HERE, "test_output", "test_force_extraxtion4"), fig_type="iframe+png", ) # Store the forced extracted count count_forced = copy.copy(lhs6328_twodspec.spectrum_list[0].count) assert (np.nansum(tophat_count) >= np.nansum(count_forced) * 0.999) & ( np.nansum(tophat_count) <= np.nansum(count_forced) * 1.001)
def test_saturated_data(): # Science frame lhs6328_frame = image_reduction.ImageReduction( log_level="DEBUG", log_file_folder=os.path.join(HERE, "test_output") ) lhs6328_frame.add_filelist( os.path.join( HERE, "test_data", "sprat_LHS6328_fake_saturated_data.list" ) ) lhs6328_frame.load_data() lhs6328_frame.reduce() lhs6328_frame.save_masks( os.path.join( HERE, "test_output", "fake_saturated_reduced_image_mask.fits" ), overwrite=True, ) assert (lhs6328_frame.bad_mask == lhs6328_frame.saturation_mask).all() lhs6328_twodspec = spectral_reduction.TwoDSpec( lhs6328_frame, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, readnoise=5.7, log_level="DEBUG", log_file_folder=os.path.join(HERE, "test_output"), ) lhs6328_twodspec.ap_trace(nspec=1) lhs6328_twodspec.ap_extract(model="lowess", lowess_frac=0.8)
def test_add_arc_path_with_hdu_number(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_arc( os.path.join(HERE, "test_data", "v_a_20180810_13_1_0_1.fits.gz[0]") ) assert (twodspec.arc == arc_fits.data).all() assert twodspec.arc_header == arc_fits.header
def test_add_data_numpy_array(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data( img_with_fits.image_fits.data, img_with_fits.image_fits.header ) assert (twodspec.img == img_with_fits.image_fits.data).all() assert twodspec.header == img_with_fits.image_fits.header
def test_forced_extraction_horne86_lowess(): lhs6328_twodspec = spectral_reduction.TwoDSpec( lhs6328_frame, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, readnoise=5.7, gain=2.45, log_level="INFO", log_file_folder=os.path.join(HERE, "test_output"), ) lhs6328_twodspec.add_trace(trace, trace_sigma) # Force extraction lhs6328_twodspec.ap_extract( apwidth=15, skywidth=10, skydeg=1, optimal=True, model="lowess", forced=True, variances=horne86_var, display=False, ) # Store the forced extracted count count_forced = copy.copy(lhs6328_twodspec.spectrum_list[0].count) assert (np.nansum(horne86_count) >= np.nansum(count_forced) * 0.999) & ( np.nansum(horne86_count) <= np.nansum(count_forced) * 1.001)
def test_spectral_extraction(): # masking spec_mask = np.arange(10, 900) spatial_mask = np.arange(15, 85) # initialise the two spectral_reduction.TwoDSpec() dummy_twodspec = spectral_reduction.TwoDSpec( dummy_data, spatial_mask=spatial_mask, spec_mask=spec_mask, log_file_name=None, log_level="DEBUG", saxis=1, flip=False, cosmicray_sigma=5.0, readnoise=0.1, gain=1.0, seeing=1.0, exptime=1.0, ) # Trace the spectrum, note that the first 15 rows were trimmed from the # spatial_mask dummy_twodspec.ap_trace( rescale=True, ap_faint=0, save_fig=True, fig_type="iframe+png", filename=os.path.join(HERE, "test_output", "test_full_run_aptrace"), return_jsonstring=True, ) trace = np.round(np.mean(dummy_twodspec.spectrum_list[0].trace)) assert trace == 35, ("Trace is at row " + str(trace) + ", but it is expected to be at row 35.") # Optimal extracting spectrum by summing over the aperture along the trace dummy_twodspec.ap_extract( apwidth=5, optimal=False, filename=os.path.join(HERE, "test_output", "test_full_run_apextract"), save_fig=True, fig_type="iframe+png", return_jsonstring=True, ) count = np.mean(dummy_twodspec.spectrum_list[0].count) assert np.round(count).astype("int") == 54, ("Extracted count is " + str(count) + " but it should be 54.") dummy_twodspec.inspect_extracted_spectrum( display=False, filename=os.path.join(HERE, "test_output", "test_full_run_extracted_spectrum"), save_fig=True, fig_type="iframe+png", return_jsonstring=True, )
def test_add_data_path(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data( os.path.join(HERE, "test_data", "v_e_20180810_12_1_0_0.fits.gz")) data_array = fits.open( os.path.join(HERE, "test_data", "v_e_20180810_12_1_0_0.fits.gz"))[0] assert (twodspec.img == data_array.data).all() assert twodspec.header == data_array.header
def test_gauss_vs_lowess_ap_extract(): twodspec_gauss = spectral_reduction.TwoDSpec(log_file_name=None) twodspec_gauss.add_data(img) twodspec_gauss.ap_trace() twodspec_lowess = copy.copy(twodspec_gauss) twodspec_gauss.ap_extract(model="gauss") twodspec_lowess.ap_extract(model="lowess") count_g = np.nansum(twodspec_gauss.spectrum_list[0].count) count_l = np.nansum(twodspec_lowess.spectrum_list[0].count) assert (count_l > count_g * 0.95) & (count_l < count_g * 1.05)
def test_user_supplied_wavelength_twodspec(mock_show): # Load the image lhs6328_fits = fits.open( os.path.join(HERE, "test_data", "v_e_20180810_12_1_0_0.fits.gz") )[0] spatial_mask = np.arange(50, 200) spec_mask = np.arange(50, 1024) # # Loading two pre-saved spectral traces from a single FITS file. # lhs6328 = spectral_reduction.TwoDSpec( lhs6328_fits, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, readnoise=2.34, log_file_name=None, ) # Trace the spectra lhs6328.ap_trace(nspec=2, display=True) # Extract the spectra lhs6328.ap_extract(apwidth=10, optimal=True, skywidth=10, display=True) # Calibrate the 1D spectra lhs6328_onedspec = spectral_reduction.OneDSpec(log_file_name=None) lhs6328_onedspec.from_twodspec(lhs6328) wavelength = np.genfromtxt( os.path.join( HERE, "test_data", "test_full_run_standard_wavelength.csv" ) ) # Manually supply wavelengths lhs6328_onedspec.add_wavelength([wavelength, wavelength]) # Inspect reduced spectrum lhs6328_onedspec.inspect_reduced_spectrum(display=False) # Save as a FITS file lhs6328_onedspec.save_fits( output="count", filename=os.path.join(HERE, "test_output", "user_supplied_wavelength"), stype="science", overwrite=True, )
def test_lowess_ap_extract(mock_show): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(img) twodspec.ap_trace() twodspec.ap_extract(model="lowess") twodspec.inspect_extracted_spectrum( display=True, save_fig=True, return_jsonstring=True, filename="test/test_output/extracted_spectrum", ) twodspec.inspect_residual( display=False, save_fig=True, return_jsonstring=True, filename=os.path.join(HERE, "test_output", "residual_image"), )
def test_user_supplied_trace(): spatial_mask = np.arange(50, 200) spec_mask = np.arange(50, 1024) # Loading a single pre-saved spectral trace. lhs6328_extracted = fits.open( os.path.join(HERE, "test_data", "test_full_run_science_0.fits")) lhs6328_trace = lhs6328_extracted[1].data lhs6328_trace_sigma = lhs6328_extracted[2].data lhs6328_twodspec = spectral_reduction.TwoDSpec( os.path.join(HERE, "test_data", "v_e_20180810_12_1_0_0.fits.gz"), spatial_mask=spatial_mask, spec_mask=spec_mask, readnoise=2.34, log_file_name=None, ) lhs6328_twodspec.add_trace(trace=lhs6328_trace, trace_sigma=lhs6328_trace_sigma) lhs6328_twodspec.ap_extract(apwidth=15, optimal=True, skywidth=10, skydeg=1, display=False) lhs6328_twodspec.save_fits( output="count", filename=os.path.join(HERE, "test_output", "user_supplied_trace_for_extraction"), overwrite=True, ) lhs6328_twodspec.remove_trace()
def test_set_all_properties(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(img) twodspec.set_properties( saxis=1, variance=10.0, spatial_mask=(1, ), spec_mask=(1, ), flip=True, cosmicray=True, sigclip=3.0, readnoise=10.0, gain=2.6, seeing=1.7, exptime=300.0, airmass=1.5, verbose=True, ) assert twodspec.saxis == 1 assert twodspec.waxis == 0 assert (twodspec.variance == 10.0).all() assert twodspec.spatial_mask == (1, ) assert twodspec.spec_mask == (1, ) assert twodspec.flip assert twodspec.cosmicray assert twodspec.readnoise == 10.0 assert twodspec.gain == 2.6 assert twodspec.seeing == 1.7 assert twodspec.exptime == 300.0 assert twodspec.airmass == 1.5 assert twodspec.verbose # Assert the cosmic ray cleaning is a different copy of the data assert twodspec.img is not img.image_fits.data # Changing the saxis, and everything else should still be the same twodspec.set_properties( saxis=0, gain=None, seeing=None, exptime=None, airmass=None, variance=None, ) assert twodspec.saxis == 0 assert twodspec.waxis == 1 assert twodspec.spatial_mask == (1, ) assert twodspec.spec_mask == (1, ) assert twodspec.flip assert twodspec.cosmicray assert twodspec.readnoise == 10.0 # The gain is now read from the header, so it's 2.45 assert twodspec.gain == 2.45 # The seeing is now read from the header, so it's 0.712134 assert twodspec.seeing == 0.712134 # The *total* exposure time is now read from the header, so it's 240. assert twodspec.exptime == 240.0 # The airmass is now read from the header, so it's 1.250338 assert twodspec.airmass == 1.250338 assert twodspec.verbose # Resetting all values to the header values twodspec.set_properties(saxis=0, cosmicray=False, variance=None) # The readnoise is now set twodspec.set_readnoise(20.0) # The gain is now set twodspec.set_gain(np.pi) # The seeing is now set twodspec.set_seeing(123.4) # The seeing is now set twodspec.set_exptime(0.1234) # The airmass is now set twodspec.set_airmass(1.2345) # Asset all the changes assert twodspec.readnoise == 20.0 assert twodspec.gain == np.pi assert twodspec.seeing == 123.4 assert twodspec.exptime == 0.1234 assert twodspec.airmass == 1.2345 # Now without resetting, setting all the values based on the given # FITS header keyword. twodspec.set_readnoise("CRDNOISE") # The gain is now read from the header, so it's 2.45 twodspec.set_gain("GAIN") # The seeing is now read from the header, so it's 0.712134 twodspec.set_seeing("ESTSEE") # The exptime is now read from the header, so it's 120. twodspec.set_exptime("EXPTIME") # The airmass is now read from the header, so it's 1.250338 twodspec.set_airmass("AIRMASS") # Asset all the changes assert twodspec.readnoise == 0.0 assert twodspec.gain == 2.45 assert twodspec.seeing == 0.712134 assert twodspec.exptime == 120.0 assert twodspec.airmass == 1.250338 twodspec.add_data(img_with_fits) # Now set all of them to zeros twodspec.set_readnoise(0) twodspec.set_gain(0) twodspec.set_seeing(0) twodspec.set_exptime(0) twodspec.set_airmass(0) # Now add the header keywords without updating twodspec.set_readnoise_keyword("CRDNOISE", append=True, update=False) twodspec.set_gain_keyword("GAIN", append=True, update=False) twodspec.set_seeing_keyword("ESTSEE", append=True, update=False) twodspec.set_exptime_keyword("EXPTIME", append=True, update=False) twodspec.set_airmass_keyword("AIRMASS", append=True, update=False) # Asset nothing is changed assert twodspec.readnoise == 0 assert twodspec.gain == 0 assert twodspec.seeing == 0 assert twodspec.exptime == 0 assert twodspec.airmass == 0 # Now update twodspec.set_readnoise_keyword("CRDNOISE") twodspec.set_gain_keyword("GAIN") twodspec.set_seeing_keyword("ESTSEE") twodspec.set_exptime_keyword("EXPTIME") twodspec.set_airmass_keyword("AIRMASS") # Asset all the changes assert twodspec.readnoise == 0.0 assert twodspec.gain == 2.45 assert twodspec.seeing == 0.712134 assert twodspec.exptime == 120.0 assert twodspec.airmass == 1.250338 # Again, supplying with list instead twodspec.set_readnoise_keyword(["CRDNOISE"]) twodspec.set_gain_keyword(["GAIN"]) twodspec.set_seeing_keyword(["ESTSEE"]) twodspec.set_exptime_keyword(["EXPTIME"]) twodspec.set_airmass_keyword(["AIRMASS"]) # Asset assert twodspec.readnoise == 0.0 assert twodspec.gain == 2.45 assert twodspec.seeing == 0.712134 assert twodspec.exptime == 120.0 assert twodspec.airmass == 1.250338 # Again, supplying with numpy.ndarray instead twodspec.set_readnoise_keyword(np.array(["CRDNOISE"])) twodspec.set_gain_keyword(np.array(["GAIN"])) twodspec.set_seeing_keyword(np.array(["ESTSEE"])) twodspec.set_exptime_keyword(np.array(["EXPTIME"])) twodspec.set_airmass_keyword(np.array(["AIRMASS"])) # Asset assert twodspec.readnoise == 0.0 assert twodspec.gain == 2.45 assert twodspec.seeing == 0.712134 assert twodspec.exptime == 120.0 assert twodspec.airmass == 1.250338 # Again, supplying None twodspec.set_readnoise_keyword(None) twodspec.set_gain_keyword(None) twodspec.set_seeing_keyword(None) twodspec.set_exptime_keyword(None) twodspec.set_airmass_keyword(None) # Asset assert twodspec.readnoise == 0 assert twodspec.gain == 1 assert twodspec.seeing == 1 assert twodspec.exptime == 1 assert twodspec.airmass == 1
def test_add_bad_pixel_mask_expect_fail(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_bad_mask(np.polyval)
def test_add_bad_pixel_mask_hdu_list(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_bad_mask(fits.HDUList(fits.ImageHDU(bad_mask.astype("int"))))
def test_add_bad_pixel_mask_numpy_array(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_bad_mask(bad_mask)
def test_add_arc_path_wrong_hdu_number_expect_fail(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_arc( os.path.join(HERE, "test_data", "v_a_20180810_13_1_0_1.fits.gz[10]"))
def test_add_arc_hdulist(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_arc(arc_in_CCDData) assert (twodspec.arc == arc_fits.data).all() assert twodspec.arc_header == arc_fits.header
def test_add_arc_primaryhdu(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_arc(arc_fits) assert (twodspec.arc == arc_fits.data).all() assert twodspec.arc_header == arc_fits.header
spec_mask = np.arange(50, 1024) # Science frame lhs6328_frame = image_reduction.ImageReduction(log_level="DEBUG", log_file_folder=os.path.join( HERE, "test_output")) lhs6328_frame.add_filelist( os.path.join(HERE, "test_data", "sprat_LHS6328.list")) lhs6328_frame.load_data() lhs6328_frame.reduce() lhs6328_twodspec = spectral_reduction.TwoDSpec( lhs6328_frame, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, sigclip=1.0, readnoise=5.7, log_level="DEBUG", log_file_folder=os.path.join(HERE, "test_output"), ) lhs6328_twodspec.ap_trace(nspec=2, display=False) # assert the resampled image has the total photon count within 0.1% of the # input def test_rectify(): twodspec = copy.copy(lhs6328_twodspec) twodspec.get_rectification( bin_size=6, n_bin=[2, 4],
def test_lowess_ap_extract_upper_detector_edge(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(missing_upper_half_spectrum_image_fits) twodspec.ap_trace() twodspec.ap_extract(model="lowess")
def test_add_random_data_expect_fail(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(np.polyfit)
def test_add_no_data(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(None)
def test_add_data_hdulist(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(img_in_hdulist) assert (twodspec.img == img_with_fits.image_fits.data).all() assert twodspec.header == img_with_fits.image_fits.header
spatial_mask = np.arange(30, 200) spec_mask = np.arange(50, 1024) # Science frame lhs6328_frame = image_reduction.ImageReduction(log_level="INFO", log_file_name=None) lhs6328_frame.add_filelist( os.path.join(HERE, "test_data", "sprat_LHS6328.list")) lhs6328_frame.load_data() lhs6328_frame.reduce() lhs6328_twodspec = spectral_reduction.TwoDSpec( lhs6328_frame, spatial_mask=spatial_mask, spec_mask=spec_mask, cosmicray=True, readnoise=5.7, log_level="DEBUG", log_file_name=None, ) lhs6328_twodspec.ap_trace(nspec=1, display=False) def test_tophat_extraction(): lhs6328_twodspec.ap_extract(optimal=False, display=False) lhs6328_twodspec.ap_extract(optimal=False, display=False, spec_id=0) lhs6328_twodspec.ap_extract(optimal=False, display=False, spec_id=[0]) lhs6328_twodspec.ap_extract( optimal=False, apwidth=[4, 5],
def test_add_arc_image_reduction(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_data(img) assert (twodspec.arc == arc_fits.data).all() assert twodspec.arc_header == arc_fits.header
def test_gausian_spectral_extraction_10000s_exptime_2x_gain(): # masking spec_mask = np.arange(10, 900) spatial_mask = np.arange(15, 85) # initialise the two spectral_reduction.TwoDSpec() dummy_twodspec = spectral_reduction.TwoDSpec( dummy_gaussian_data, spatial_mask=spatial_mask, spec_mask=spec_mask, log_file_name=None, log_level="CRITICAL", saxis=1, flip=False, cosmicray_sigma=5.0, readnoise=0.1, gain=2.0, seeing=1.0, exptime=10000.0, ) # Trace the spectrum, note that the first 15 rows were trimmed from the # spatial_mask dummy_twodspec.ap_trace( rescale=True, fit_deg=0, ) trace = np.round(np.mean(dummy_twodspec.spectrum_list[0].trace)) assert np.isclose(trace, 35), ("Trace is at row " + str(trace) + ", but it is expected to be at row 35.") # Direct extraction by summing over the aperture along the trace dummy_twodspec.ap_extract( apwidth=5, optimal=False, ) count = np.mean(dummy_twodspec.spectrum_list[0].count) count_err = np.mean(dummy_twodspec.spectrum_list[0].count_err) snr_tophat = count / count_err assert np.isclose(count, 10000.0, rtol=0.01, atol=count_err), ("Extracted count is " + str(count) + " but it should be ~10000.") # Optimal extraction (Horne86 gauss) dummy_twodspec.ap_extract(apwidth=5, optimal=True, model="gauss") count = np.mean(dummy_twodspec.spectrum_list[0].count) count_err = np.mean(dummy_twodspec.spectrum_list[0].count_err) snr_horne = count / count_err assert np.isclose(count, 10000.0, rtol=0.01, atol=count_err), ("Extracted count is " + str(count) + " but it should be ~10000.") # Optimal extraction (Horne86 lowess) dummy_twodspec.ap_extract( apwidth=5, optimal=True, model="lowess", lowess_frac=0.05, ) count = np.mean(dummy_twodspec.spectrum_list[0].count) count_err = np.mean(dummy_twodspec.spectrum_list[0].count_err) snr_horne = count / count_err assert np.isclose(count, 10000.0, rtol=0.01, atol=count_err), ("Extracted count is " + str(count) + " but it should be ~10000.") # Optimal extraction (Marsh89) dummy_twodspec.ap_extract(apwidth=5, optimal=True, model="marsh89") count = np.mean(dummy_twodspec.spectrum_list[0].count) count_err = np.mean(dummy_twodspec.spectrum_list[0].count_err) snr_marsh = count / count_err assert np.isclose(count, 10000.0, rtol=0.01, atol=count_err), ("Extracted count is " + str(count) + " but it should be ~10000.")
def test_add_arc_numpy_array_and_header_in_list(): twodspec = spectral_reduction.TwoDSpec(log_file_name=None) twodspec.add_arc(arc_fits.data, [arc_fits.header]) assert (twodspec.arc == arc_fits.data).all() assert twodspec.arc_header == arc_fits.header
def extract_floyds(light_fits, flat_fits, arc_fits, coeff_red=None, coeff_blue=None): light_data = light_fits.data light_header = fits.Header(light_fits.header) red = spectral_reduction.TwoDSpec(light_data, header=light_header, spatial_mask=red_spatial_mask, spec_mask=red_spec_mask, cosmicray=True, sigclip=2., readnoise=3.5, gain=2.3, log_level='INFO', log_file_name=None) blue = spectral_reduction.TwoDSpec(light_data, header=light_header, spatial_mask=blue_spatial_mask, spec_mask=blue_spec_mask, cosmicray=True, sigclip=2., readnoise=3.5, gain=2.3, log_level='INFO', log_file_name=None) # Add the arcs before rectifying the image, which will apply the # rectification to the arc frames too blue.add_arc(arc_fits.data, fits.Header(arc_fits.header)) blue.apply_mask_to_arc() red.add_arc(arc_fits.data, fits.Header(arc_fits.header)) red.apply_mask_to_arc() # Get the trace to rectify the image red.ap_trace(nspec=1, ap_faint=20, percentile=10, trace_width=50, shift_tol=35, fit_deg=5, display=False) red.get_rectification(upsample_factor=5, coeff=coeff_red, display=True) red.apply_rectification() # Need to store the traces for fringe correction before overwriting them # with the new traces trace_red = copy.deepcopy(red.spectrum_list[0].trace) trace_sigma_red = copy.deepcopy(red.spectrum_list[0].trace_sigma) # Get the trace again for the rectified image and then extract red.ap_trace(nspec=1, ap_faint=20, percentile=10, trace_width=20, fit_deg=3, display=False) red.ap_extract(apwidth=10, spec_id=0, display=False) # Do the same with the blue blue.ap_trace(nspec=1, ap_faint=10, percentile=10, trace_width=20, shift_tol=50, fit_deg=5, display=False) blue.get_rectification(upsample_factor=5, coeff=coeff_blue, display=True) blue.apply_rectification() blue.ap_trace(nspec=1, percentile=10, trace_width=20, fit_deg=3, display=False) blue.ap_extract(apwidth=10, display=False) red.extract_arc_spec(spec_width=15, display=False) blue.extract_arc_spec(spec_width=15, display=False) # Get the blue and red traces for fringe removal trace_red_rectified = red.spectrum_list[0].trace trace_sigma_red_rectified = red.spectrum_list[0].trace_sigma # Extract the red flat flat_data = flat_fits.data flat_header = fits.Header(flat_fits.header) flat = spectral_reduction.TwoDSpec(flat_data, header=flat_header, spatial_mask=red_spatial_mask, spec_mask=red_spec_mask, cosmicray=True, readnoise=3.5, gain=2.3, log_level='INFO', log_file_name=None) # Force extraction from the flat for fringe correction flat.add_trace(trace_red, trace_sigma_red) flat.get_rectification(coeff=red.rec_coeff) flat.apply_rectification() flat.add_trace(trace_red_rectified, trace_sigma_red_rectified) flat.ap_extract(apwidth=10, skywidth=0, display=False) return red, blue, flat
def test_logger(): twodspec_debug = spectral_reduction.TwoDSpec( log_level="DEBUG", logger_name="twodspec_debug", log_file_name="twodspec_debug.log", log_file_folder=os.path.join(HERE, "test_output"), ) twodspec_info = spectral_reduction.TwoDSpec( log_level="INFO", logger_name="twodspec_info", log_file_name="twodspec_info.log", log_file_folder=os.path.join(HERE, "test_output"), ) twodspec_warning = spectral_reduction.TwoDSpec( log_level="WARNING", logger_name="twodspec_warning", log_file_name="twodspec_warning.log", log_file_folder=os.path.join(HERE, "test_output"), ) twodspec_error = spectral_reduction.TwoDSpec( log_level="ERROR", logger_name="twodspec_error", log_file_name="twodspec_error.log", log_file_folder=os.path.join(HERE, "test_output"), ) twodspec_critical = spectral_reduction.TwoDSpec( log_level="CRITICAL", logger_name="twodspec_critical", log_file_name="twodspec_critical.log", log_file_folder=os.path.join(HERE, "test_output"), ) twodspec_debug.logger.debug("debug: debug mode") twodspec_debug.logger.info("debug: info mode") twodspec_debug.logger.warning("debug: warning mode") twodspec_debug.logger.error("debug: error mode") twodspec_debug.logger.critical("debug: critical mode") twodspec_info.logger.debug("info: debug mode") twodspec_info.logger.info("info: info mode") twodspec_info.logger.warning("info: warning mode") twodspec_info.logger.error("info: error mode") twodspec_info.logger.critical("info: critical mode") twodspec_warning.logger.debug("warning: debug mode") twodspec_warning.logger.info("warning: info mode") twodspec_warning.logger.warning("warning: warning mode") twodspec_warning.logger.error("warning: error mode") twodspec_warning.logger.critical("warning: critical mode") twodspec_error.logger.debug("error: debug mode") twodspec_error.logger.info("error: info mode") twodspec_error.logger.warning("error: warning mode") twodspec_error.logger.error("error: error mode") twodspec_error.logger.critical("error: critical mode") twodspec_critical.logger.debug("critical: debug mode") twodspec_critical.logger.info("critical: info mode") twodspec_critical.logger.warning("critical: warning mode") twodspec_critical.logger.error("critical: error mode") twodspec_critical.logger.critical("critical: critical mode") debug_debug_length = file_len( os.path.join(HERE, "test_output", "twodspec_debug.log")) debug_info_length = file_len( os.path.join(HERE, "test_output", "twodspec_info.log")) debug_warning_length = file_len( os.path.join(HERE, "test_output", "twodspec_warning.log")) debug_error_length = file_len( os.path.join(HERE, "test_output", "twodspec_error.log")) debug_critical_length = file_len( os.path.join(HERE, "test_output", "twodspec_critical.log")) assert (debug_debug_length == 5 ), "Expecting 5 lines in the log file, " + "{} is logged.".format( debug_debug_length) assert (debug_info_length == 4 ), "Expecting 4 lines in the log file, " + "{} is logged.".format( debug_info_length) assert (debug_warning_length == 3 ), "Expecting 3 lines in the log file, " + "{} is logged.".format( debug_warning_length) assert (debug_error_length == 2 ), "Expecting 2 lines in the log file, " + "{} is logged.".format( debug_error_length) assert (debug_critical_length == 1 ), "Expecting 1 lines in the log file, " + "{} is logged.".format( debug_critical_length)