From ecb208c4c9f7f6fe73d3444e8121b319258bfcec Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Tue, 20 Jun 2023 19:44:50 -0500 Subject: [PATCH 01/43] Added resample_gollum to EchelleSpectrum and EchelleSpectrumList to allow resampling of synthetic model spectra from gollum to the same wavelength grid as muler spectra. --- src/muler/echelle.py | 82 +++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 81 insertions(+), 1 deletion(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index db8ba2f..4d63917 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -27,7 +27,7 @@ from astropy.constants import R_jup, R_sun, G, M_jup, R_earth, c from astropy.modeling.physical_models import BlackBody import specutils -from muler.utilities import apply_numpy_mask, is_list +from muler.utilities import apply_numpy_mask, is_list, resample_list # from barycorrpy import get_BC_vel from astropy.coordinates import SkyCoord, EarthLocation @@ -699,6 +699,46 @@ def apply_boolean_mask(self, mask): ) return spec + + def resample_gollum(self, model_a, model_b=None, fraction_a=1.0) + """Reads in a synthetic spectrum (or two) from gollum generated from model stellar atmospheres + and returns an EchelleSpectrum object with the same wavelength array and naned pixels as this object. + Applications include flux calibration or fitting models to science targets. + + Before running resample_gollum, you want to prepare your gollum precomputed spectra by reading them from + your model grid with the desired parameters (Teff, logg, Z, etc.), rv shifting them, rotationally broadening + them, and then instrumentally broadening them. + + Parameters + ------- + model_a : PrecomputedSpectrum from gollum + PrecomputedSpectrum object (e.g. PHOENIXSpectrum) read in using gollum representing a synthetic + spectrum computed from a stellar atmosphere model. + + model_b : PrecomputedSpectrum from gollum (default=None) + You can optionally specify a second PrecomputedSpectrum object from gollum such that model_a and model_b + will be linearly interpolated together as set by fraction_a. + fraction_a: + If model_b is provided, this is the fraction the combined spectrum of model_a and model_b is from model_a, + while model_b will have (1-fraction_a) contribution to the final model. + + Returns + ------- + spec_gollum: + EchelleSpectrum object derived from the synthetic spectrum from the model(s) from gollum with the same + wavelengths and naned pixels as this (self) EchelleSpectrum object. You can then use this outputted object for + flux calibration. + """ + if model_b is None: + spec_gollum = LinInterpResampler(model_a, self.spectral_axis) + else: + spec_gollum = LinInterpResampler(model_a, model_a.spectral_axis)*(fraction_a) + LinInterpResampler(model_b, model_a.spectral_axis)*(1.0 - fraction_a) + spec_gollum = LinInterpResampler(spec_gollum, self.spectral_axis) + + spec_gollum.flux[np.isnan(self.flux)] = np.nan #Copy over nans from self to avoid weird errors later on + + return spec_gollum + def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. Uuseful for airmass correction. Uncertainity is propogated by keeping the @@ -986,3 +1026,43 @@ def flatten(self, **kwargs): if "x_values" not in spec_out[i].meta: spec_out[i].meta["x_values"] = self[i].meta["x_values"] return spec_out + + def resample_gollum(self, model_a, model_b=None, fraction_a=1.0) + """Reads in a synthetic spectrum (or two) from gollum generated from model stellar atmospheres + and returns an EchelleSpectrumList object with the same wavelength array and naned pixels as this object. + Applications include flux calibration or fitting models to science targets. + + Before running resample_gollum, you want to prepare your gollum precomputed spectra by reading them from + your model grid with the desired parameters (Teff, logg, Z, etc.), rv shifting them, rotationally broadening + them, and then instrumentally broadening them. + + Parameters + ------- + model_a : PrecomputedSpectrum from gollum + PrecomputedSpectrum object (e.g. PHOENIXSpectrum) read in using gollum representing a synthetic + spectrum computed from a stellar atmosphere model. + + model_b : PrecomputedSpectrum from gollum (default=None) + You can optionally specify a second PrecomputedSpectrum object from gollum such that model_a and model_b + will be linearly interpolated together as set by fraction_a. + fraction_a: + If model_b is provided, this is the fraction the combined spectrum of model_a and model_b is from model_a, + while model_b will have (1-fraction_a) contribution to the final model. + + Returns + ------- + spec_gollum: + EchelleSpectrumList object derived from the synthetic spectrum from the model(s) from gollum with the same + wavelengths and naned pixels as this (self) EchelleSpectrumList object. You can then use this outputted object for + flux calibration. + """ + if model_b is None: + spec_gollum = resample_list(model_a, input_spectrum) + else: + spec_gollum = resample_list(model_a, self)*fraction_a + resample_list(modek_b, self)*(1.0-fraction_a) + + for i in range(len(spec_gollum)): #Copy over nans from self to avoid weird errors later on + spec_gollum[i].flux[np.isnan(self[i].flux)] = np.nan + + return spec_gollum + From 6895c973aca0949a6af40b61a8f23136b4cfe153 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 16:44:44 -0500 Subject: [PATCH 02/43] Bug fixes for gollum_resample. --- src/muler/echelle.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 4d63917..e83a1f8 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -28,6 +28,8 @@ from astropy.modeling.physical_models import BlackBody import specutils from muler.utilities import apply_numpy_mask, is_list, resample_list +from specutils.manipulation import LinearInterpolatedResampler +LinInterpResampler = LinearInterpolatedResampler() # from barycorrpy import get_BC_vel from astropy.coordinates import SkyCoord, EarthLocation @@ -700,7 +702,7 @@ def apply_boolean_mask(self, mask): return spec - def resample_gollum(self, model_a, model_b=None, fraction_a=1.0) + def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): """Reads in a synthetic spectrum (or two) from gollum generated from model stellar atmospheres and returns an EchelleSpectrum object with the same wavelength array and naned pixels as this object. Applications include flux calibration or fitting models to science targets. @@ -1027,7 +1029,7 @@ def flatten(self, **kwargs): spec_out[i].meta["x_values"] = self[i].meta["x_values"] return spec_out - def resample_gollum(self, model_a, model_b=None, fraction_a=1.0) + def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): """Reads in a synthetic spectrum (or two) from gollum generated from model stellar atmospheres and returns an EchelleSpectrumList object with the same wavelength array and naned pixels as this object. Applications include flux calibration or fitting models to science targets. @@ -1059,7 +1061,7 @@ def resample_gollum(self, model_a, model_b=None, fraction_a=1.0) if model_b is None: spec_gollum = resample_list(model_a, input_spectrum) else: - spec_gollum = resample_list(model_a, self)*fraction_a + resample_list(modek_b, self)*(1.0-fraction_a) + spec_gollum = resample_list(model_a, self)*fraction_a + resample_list(model_b, self)*(1.0-fraction_a) for i in range(len(spec_gollum)): #Copy over nans from self to avoid weird errors later on spec_gollum[i].flux[np.isnan(self[i].flux)] = np.nan From b40ea61f93b6536786800119942a583cd30c29ea Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 16:56:44 -0500 Subject: [PATCH 03/43] Added transfer of meta data to a resampled list so that x_values gets properly propogated. --- src/muler/utilities.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index 9587082..15715ab 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -195,7 +195,10 @@ def resample_list(spec_to_resample, specList, **kwargs): """ spec_out = copy.deepcopy(specList) for i in range(len(specList)): + meta_out = specList[i].meta spec_out[i] = spec_to_resample.resample(specList[i], **kwargs) + spec_out[i].meta = meta_out + breakpoint() return spec_out From d042164ade2e249fc717fef595cc379b9aadb7f3 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 17:03:48 -0500 Subject: [PATCH 04/43] Added a default available_ancillary_spectra variable to EchelleSpectrum to be empty [] to avoid errors when some definitions try to loop over available_ancillary_spectra. --- src/muler/echelle.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index e83a1f8..4e6ef9b 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -74,6 +74,7 @@ def __init__(self, *args, **kwargs): # self.ancillary_spectra = None super().__init__(*args, **kwargs) + self.available_ancillary_spectra = [] @property def snr(self): From fde893052950ed09af3e22dd71e0099afcf56c9d Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 17:17:06 -0500 Subject: [PATCH 05/43] Reverse previous change since it didn't work. --- src/muler/echelle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 4e6ef9b..5c0ee5a 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -74,7 +74,7 @@ def __init__(self, *args, **kwargs): # self.ancillary_spectra = None super().__init__(*args, **kwargs) - self.available_ancillary_spectra = [] + @property def snr(self): From e7c00599de4228eb439b72d42ac9f15ef5ad021f Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 17:47:37 -0500 Subject: [PATCH 06/43] Set resampled lists and single gollum spectra to output as EchelleSpectrum objects. --- src/muler/echelle.py | 5 ++--- src/muler/utilities.py | 10 +++++++--- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 5c0ee5a..b0cf646 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -109,7 +109,6 @@ def available_ancillary_spectra(self): if hasattr(self, "ancillary_spectra"): if self.ancillary_spectra is not None: output = [ - ancillary_spectrum for ancillary_spectrum in self.ancillary_spectra if ancillary_spectrum in self.meta.keys() ] @@ -727,7 +726,6 @@ def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): Returns ------- - spec_gollum: EchelleSpectrum object derived from the synthetic spectrum from the model(s) from gollum with the same wavelengths and naned pixels as this (self) EchelleSpectrum object. You can then use this outputted object for flux calibration. @@ -740,7 +738,8 @@ def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): spec_gollum.flux[np.isnan(self.flux)] = np.nan #Copy over nans from self to avoid weird errors later on - return spec_gollum + return self.__class__( + spectral_axis=spec_gollum.spectral_axis, flux=spec_gollum.flux, meta=self.meta, wcs=None) def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. diff --git a/src/muler/utilities.py b/src/muler/utilities.py index 15715ab..dd70c64 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -196,9 +196,13 @@ def resample_list(spec_to_resample, specList, **kwargs): spec_out = copy.deepcopy(specList) for i in range(len(specList)): meta_out = specList[i].meta - spec_out[i] = spec_to_resample.resample(specList[i], **kwargs) - spec_out[i].meta = meta_out - breakpoint() + resampled_spec = spec_to_resample.resample(specList[i], **kwargs) + if hasattr(resampled_spec, "unc"): + spec_out[i] = specList[i].__class__( + spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, uncertainty=resampled_spec.unc, meta=meta_out, wcs=None) + else: + spec_out[i] = specList[i].__class__( + spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=meta_out, wcs=None) return spec_out From 38c23e6b655ae0f476c473c673ee532252ecf09b Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 18:03:48 -0500 Subject: [PATCH 07/43] Re add in line of code that was accidently deleted. --- src/muler/echelle.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index b0cf646..5f3247f 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -109,6 +109,7 @@ def available_ancillary_spectra(self): if hasattr(self, "ancillary_spectra"): if self.ancillary_spectra is not None: output = [ + ancillary_spectrum for ancillary_spectrum in self.ancillary_spectra if ancillary_spectrum in self.meta.keys() ] From 708c319d792bf5803e6e9c08dd1093011e618325 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Wed, 21 Jun 2023 18:09:54 -0500 Subject: [PATCH 08/43] Minor variable name error fix. --- src/muler/echelle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 5f3247f..d22155d 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -1060,7 +1060,7 @@ def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): flux calibration. """ if model_b is None: - spec_gollum = resample_list(model_a, input_spectrum) + spec_gollum = resample_list(model_a, self) else: spec_gollum = resample_list(model_a, self)*fraction_a + resample_list(model_b, self)*(1.0-fraction_a) From 2e09282999c5caf7ec21b6edf1a358dd44def621 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 22 Jun 2023 14:03:40 -0500 Subject: [PATCH 09/43] Generalize resample_gollum() to LinResample(). --- src/muler/echelle.py | 105 ++++++++++++++++++++----------------------- 1 file changed, 49 insertions(+), 56 deletions(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index d22155d..11c6ad5 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -703,44 +703,41 @@ def apply_boolean_mask(self, mask): return spec - def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): - """Reads in a synthetic spectrum (or two) from gollum generated from model stellar atmospheres - and returns an EchelleSpectrum object with the same wavelength array and naned pixels as this object. - Applications include flux calibration or fitting models to science targets. - - Before running resample_gollum, you want to prepare your gollum precomputed spectra by reading them from - your model grid with the desired parameters (Teff, logg, Z, etc.), rv shifting them, rotationally broadening - them, and then instrumentally broadening them. + def LinResample(self, input_spec, fractions=1.0): + """Linearly resample in a spectrum, or a list of spectra, to match this spectrum return an EchelleSpectrum + object with the same wavelength array and naned pixels. Applications include resampling + synthetic spectra generated from stellar atmosphere models to match a real spectrum. Parameters ------- - model_a : PrecomputedSpectrum from gollum - PrecomputedSpectrum object (e.g. PHOENIXSpectrum) read in using gollum representing a synthetic - spectrum computed from a stellar atmosphere model. - - model_b : PrecomputedSpectrum from gollum (default=None) - You can optionally specify a second PrecomputedSpectrum object from gollum such that model_a and model_b - will be linearly interpolated together as set by fraction_a. - fraction_a: - If model_b is provided, this is the fraction the combined spectrum of model_a and model_b is from model_a, - while model_b will have (1-fraction_a) contribution to the final model. + input_spec : + A muler spectrum or similar specutils object, or list of such objects to be resampled to match this spectrum. + fractions : + If a list of input spectra are provided, the user must provide a list of floats denoting what + fraction each of the input spectra make up the final resampled spectrum. The total must equal 1. + For example, if I am stacking 3 input spectra and the first two spectra make up 40% of my resampled + spectrum and the last spectrum makes up 20%, fractions=[0.4, 0.4, 0.2]. Returns ------- - EchelleSpectrum object derived from the synthetic spectrum from the model(s) from gollum with the same - wavelengths and naned pixels as this (self) EchelleSpectrum object. You can then use this outputted object for - flux calibration. + An EchelleSpectrum object with the same wavelength array and naned pixels as this (self) object. """ - if model_b is None: - spec_gollum = LinInterpResampler(model_a, self.spectral_axis) + if is_list(input_spec): + fractions = np.array(fractions) #Check that fractions are a list and their sum equals 1 + sum_fractions = np.sum(fractions) + assert len(fractions) > 1, "You need to provide a fraction for each input spectrum. This is inputted as a list of floats." + assert sum_fractions == 1, "Total fractions in fraction list is "+str(sum_fractions)+" but total must equal to 1." + resampled_spec = LinInterpResampler(input_spec[0], input_spec[0].spectral_axis)*(fractions[0]) #Resample spectra + for i in range(1, len(input_spec)): + resampled_spec = resampled_spec + LinInterpResampler(input_spec[i], input_spec[0].spectral_axis)*(fractions[i]) + resampled_spec = LinInterpResampler(resampled_spec, self.spectral_axis) #Resample spectrum else: - spec_gollum = LinInterpResampler(model_a, model_a.spectral_axis)*(fraction_a) + LinInterpResampler(model_b, model_a.spectral_axis)*(1.0 - fraction_a) - spec_gollum = LinInterpResampler(spec_gollum, self.spectral_axis) + resampled_spec = LinInterpResampler(models, self.spectral_axis) - spec_gollum.flux[np.isnan(self.flux)] = np.nan #Copy over nans from self to avoid weird errors later on + resampled_spec.flux[np.isnan(self.flux)] = np.nan #Copy over nans from self to avoid weird errors later on return self.__class__( - spectral_axis=spec_gollum.spectral_axis, flux=spec_gollum.flux, meta=self.meta, wcs=None) + spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=self.meta, wcs=None) def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. @@ -1030,42 +1027,38 @@ def flatten(self, **kwargs): spec_out[i].meta["x_values"] = self[i].meta["x_values"] return spec_out - def resample_gollum(self, model_a, model_b=None, fraction_a=1.0): - """Reads in a synthetic spectrum (or two) from gollum generated from model stellar atmospheres - and returns an EchelleSpectrumList object with the same wavelength array and naned pixels as this object. - Applications include flux calibration or fitting models to science targets. - - Before running resample_gollum, you want to prepare your gollum precomputed spectra by reading them from - your model grid with the desired parameters (Teff, logg, Z, etc.), rv shifting them, rotationally broadening - them, and then instrumentally broadening them. + def LinResample(self, input_spec, fractions=1.0): + """Linearly resample in a spectrum, or a list of spectra, to match this spectrum return an EchelleSpectrumList + object with the same wavelength arrays and naned pixels. Applications include resampling + synthetic spectra generated from stellar atmosphere models to match a real spectrum. Parameters ------- - model_a : PrecomputedSpectrum from gollum - PrecomputedSpectrum object (e.g. PHOENIXSpectrum) read in using gollum representing a synthetic - spectrum computed from a stellar atmosphere model. - - model_b : PrecomputedSpectrum from gollum (default=None) - You can optionally specify a second PrecomputedSpectrum object from gollum such that model_a and model_b - will be linearly interpolated together as set by fraction_a. - fraction_a: - If model_b is provided, this is the fraction the combined spectrum of model_a and model_b is from model_a, - while model_b will have (1-fraction_a) contribution to the final model. + input_spec : + A muler spectrum or similar specutils object, or list of such objects to be resampled to match this spectrum. + fractions : + If a list of input spectra are provided, the user must provide a list of floats denoting what + fraction each of the input spectra make up the final resampled spectrum. The total must equal 1. + For example, if I am stacking 3 input spectra and the first two spectra make up 40% of my resampled + spectrum and the last spectrum makes up 20%, fractions=[0.4, 0.4, 0.2]. Returns ------- - spec_gollum: - EchelleSpectrumList object derived from the synthetic spectrum from the model(s) from gollum with the same - wavelengths and naned pixels as this (self) EchelleSpectrumList object. You can then use this outputted object for - flux calibration. + An EchelleSpectrumList object with the same wavelength arrays and naned pixels as this (self) object. """ - if model_b is None: - spec_gollum = resample_list(model_a, self) + if is_list(input_spec): # + fractions = np.array(fractions) #Check that fractions are a list and their sum equals 1 + sum_fractions = np.sum(fractions) + assert len(fractions) > 1, "You need to provide a fraction for each input spectrum. This is inputted as a list of floats." + assert sum_fractions == 1, "Total fractions in fraction list is "+str(sum_fractions)+" but total must equal to 1." + resampled_spec = resample_list(input_spec[0], self)*(fractions[0]) #Resample spectra + for i in range(1, len(input_spec)): + resampled_spec = resampled_spec + resample_list(input_spec[i], self)*(fractions[i]) else: - spec_gollum = resample_list(model_a, self)*fraction_a + resample_list(model_b, self)*(1.0-fraction_a) - - for i in range(len(spec_gollum)): #Copy over nans from self to avoid weird errors later on - spec_gollum[i].flux[np.isnan(self[i].flux)] = np.nan + resampled_spec = resample_list(input_spec, self) #Resample spectrum + + for i in range(len(resampled_spec)): #Copy over nans from self to avoid weird errors later on + resampled_spec[i].flux[np.isnan(self[i].flux)] = np.nan - return spec_gollum + return resampled_spec From 7f908371335ed6f1af27884397c66372dc9c7b5b Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 22 Jun 2023 14:09:16 -0500 Subject: [PATCH 10/43] Minor bug fix. --- src/muler/echelle.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 11c6ad5..896a10b 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -732,7 +732,7 @@ def LinResample(self, input_spec, fractions=1.0): resampled_spec = resampled_spec + LinInterpResampler(input_spec[i], input_spec[0].spectral_axis)*(fractions[i]) resampled_spec = LinInterpResampler(resampled_spec, self.spectral_axis) #Resample spectrum else: - resampled_spec = LinInterpResampler(models, self.spectral_axis) + resampled_spec = LinInterpResampler(resampled_spec, self.spectral_axis) resampled_spec.flux[np.isnan(self.flux)] = np.nan #Copy over nans from self to avoid weird errors later on From 5ae12abe98b4ebe5d9c474bb1da4a033723e0e9e Mon Sep 17 00:00:00 2001 From: gully Date: Thu, 22 Jun 2023 15:55:25 -0500 Subject: [PATCH 11/43] Add a tutorial to explore use cases around flux calibration --- docs/tutorials/flux_calibration.ipynb | 246 ++++++++++++++++++++++++++ 1 file changed, 246 insertions(+) create mode 100644 docs/tutorials/flux_calibration.ipynb diff --git a/docs/tutorials/flux_calibration.ipynb b/docs/tutorials/flux_calibration.ipynb new file mode 100644 index 0000000..b91caab --- /dev/null +++ b/docs/tutorials/flux_calibration.ipynb @@ -0,0 +1,246 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory flux calibration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from muler.hpf import HPFSpectrum, HPFSpectrumList\n", + "import numpy as np\n", + "import glob\n", + "\n", + "%config InlineBackend.figure_format='retina'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we have Goldilocks spectra:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "path = 'https://github.com/OttoStruve/muler_example_data/raw/main/HPF/01_A0V_standards/'\n", + "filename = 'Goldilocks_20210212T072837_v1.0_0037.spectra.fits'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can easily read in HPF data for a specific spectral order:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "original_spectrum = HPFSpectrum(file=path+filename, order=4)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "spectrum = original_spectrum.sky_subtract(method='vector').trim_edges().remove_nans().deblaze().normalize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can normalize and overplot plot the observed spectrum, sky subtracted spectrum, and the sky emission itself:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 395, + "width": 846 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "spectrum.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from gollum.phoenix import PHOENIXGrid" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Processing Teff=10200K|log(g)=4.00|Z=+0.0: 100%|██| 2/2 [00:00<00:00, 28.38it/s]\n" + ] + } + ], + "source": [ + "grid = PHOENIXGrid(teff_range=(10_000, 10_200), logg_range=(4,4), Z_range=(0,0))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "2" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(grid)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "raw_model1, raw_model2 = grid[0], grid[1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finding: we should allow the `grid` object to accept all of these arguments:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#grid.rotationally_broaden(130.0)\n", + "#grid.instrumental_broaden(55_000)\n", + "#grid.resample(spectrum)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "model1 = raw_model1.rotationally_broaden(130.0).instrumental_broaden(55_000).resample(spectrum)\n", + "model2 = raw_model2.rotationally_broaden(130.0).instrumental_broaden(55_000).resample(spectrum)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "factor = 0.2" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "mixture_model = factor * model1 + (1-factor) * model2" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 395, + "width": 846 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "ax = spectrum.plot()\n", + "mixture_model.normalize().plot(ax=ax);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.17" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From eff9c33f1dcce9b5c518d8c25169f963787f1971 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 22 Jun 2023 20:47:45 -0500 Subject: [PATCH 12/43] Add slit throughput estimates (mostly for IGRINS for now). --- src/muler/igrins.py | 156 ++++++++++++++++++++++++++++++++++++++++- src/muler/utilities.py | 90 ++++++++++++++++++++++++ 2 files changed, 244 insertions(+), 2 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index bc461ce..cf1ea1e 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -10,7 +10,9 @@ """ import logging import warnings +import json from muler.echelle import EchelleSpectrum, EchelleSpectrumList +from muler.utilities import estimate_slit_throughput_ABBA from astropy.time import Time import numpy as np import astropy @@ -18,6 +20,8 @@ from astropy import units as u from astropy.wcs import WCS, FITSFixedWarning from astropy.nddata import StdDevUncertainty +from specutils.manipulation import LinearInterpolatedResampler +LinInterpResampler = LinearInterpolatedResampler() import copy import os @@ -44,7 +48,7 @@ def getUncertainityFilepath(filepath): """Returns path for uncertainity file (.variance.fits or .sn.fits) Will first search for a .variance.fits file but if that does not exist - will serach for a .sn.fits file. + will search for a .sn.fits file. Parameters ---------- @@ -71,6 +75,87 @@ def getUncertainityFilepath(filepath): "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." ) +def getSlitProfileFilepath(filepath, band): + """Returns the path for the slit profile file (.slit_profile.json). + + Parameters + ---------- + filepath: Filepath to fits file storing the data. Can be .spec.fits or .spec_a0v.fits. + + Returns + ------- + slitProfileFilepath: string + Returns the file path to .slit_profile.json file. + """ + if ".spec_a0v.fits" in filepath: #Grab base file name for the uncertainity file + path_base = filepath[:-14] + elif ".spec_flattened.fits" in filepath: + path_base = filepath[:-20] + elif ".spec.fits" in filepath: + path_base = filepath[:-10] + path_base = path_base.replace('SDCH', 'SDC'+band).replace('SDCK', 'SDC'+band) #Make sure we are using the correct band + return path_base + '.slit_profile.json' + + + +def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True): + """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit and return the + coefficients of a linear fit. + + Parameters + ---------- + file: + Path to fits file (e.g. spec.fits) from which the slit_profile.json file is also in the same directory. + These should all be in the same IGRINS PLP output directory. + slit_length: float + Length of the slit on the sky in arcsec. + PA: float + Position angle of the slit on the sky in degrees. Measured counterclockwise from North to East. + guilding_error: float + Estimate of the guiding error in arcsec. This smears out the PSF fits in the East-West direction. + This should be used carefully and only for telescopes on equitorial mounts. + print_info: bool + Print information about the fit. + + Returns + ------- + m, b: + Coefficients for a fit of a linear trend of m*(1/wavelength)+b to the fractional slit throughput with the + wavelength units in microns. + + """ + h_band_filepath = getSlitProfileFilepath(file, 'H') #Get paths to .slit_profile.json files + k_band_filepath = getSlitProfileFilepath(file, 'K') + + assert os.path.exists(h_band_filepath) and os.path.exists(k_band_filepath) + + + slit_width = slit_length * (1.0/14.8) #Calculate slit width from slit length since IGRINS always uses the same slit no matter the telescope + #Get throughput for H band + json_file = open(h_band_filepath) + json_obj = json.load(json_file) + x = np.array(json_obj['profile_x']) * slit_length + y = np.array(json_obj['profile_y']) + f_through_slit_H = estimate_slit_throughput_ABBA(y, x=x, slit_length=slit_length, slit_width=slit_width, PA=PA, print_info=print_info) + #Get throughput for K band + json_file = open(k_band_filepath) + json_obj = json.load(json_file) + x = np.array(json_obj['profile_x']) * slit_length + y = np.array(json_obj['profile_y']) + f_through_slit_K = estimate_slit_throughput_ABBA(y, x=x, slit_length=slit_length, slit_width=slit_width, PA=PA, print_info=print_info) + #Fit linear trend through slit throughput as function of wavelength and using fitting a line through two points + m = (f_through_slit_K - f_through_slit_H) / ((1/2.2) - (1/1.65)) + b = f_through_slit_H - m*(1/1.65) + if print_info: + print('H-band slit throughput: ', f_through_slit_H) + print('K-band slit throughput:', f_through_slit_K) + print('m: ', m) + print('b: ', b) + + return m, b + + + class IGRINSSpectrum(EchelleSpectrum): r""" A container for IGRINS spectra @@ -95,9 +180,11 @@ def __init__( # self.ancillary_spectra = None self.noisy_edges = (450, 1950) self.instrumental_resolution = 45_000.0 + #False if variance.fits file used for uncertainity, true if sn.fits file used for uncertainity if file is not None: + assert (".spec_a0v.fits" in file) or (".spec.fits" in file) or (".spec_flattened.fits") # Determine the band if "SDCH" in file: @@ -231,6 +318,39 @@ def astropy_time(self): mjd = self.meta["header"]["MJD-OBS"] return Time(mjd, format="mjd", scale="utc") + def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True): + """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit. + + Parameters + ---------- + h_band_slitprofile_filepath: + Filepath to *.slit_profile.json file outputted by the IGRINS PLP storing the spatial + profile of the target along the slit for the H band. + k_band_slitprofile_filepath: + Filepath to *.slit_profile.json file outputted by the IGRINS PLP storing the spatial + profile of the target along the slit for the K band. + slit_length: float + Length of the slit on the sky in arcsec. + PA: float + Position angle of the slit on the sky in degrees. Measured counterclockwise from North to East. + guilding_error: float + Estimate of the guiding error in arcsec. This smears out the PSF fits in the East-West direction. + This should be used carefully and only for telescopes on equitorial mounts. + print_info: bool + Print information about the fit. + + Returns + ------- + Returns array of fractional slit throughput as a function of wavelength + """ + + m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info) + return m*(1/self.wavelength.um) + b + + + + + class IGRINSSpectrumList(EchelleSpectrumList): r""" @@ -255,6 +375,7 @@ def read(file, precache_hdus=True, wavefile=None): """ # still works assert (".spec_a0v.fits" in file) or (".spec.fits" in file) or (".spec_flattened.fits" in file) + sn_used = False #Default hdus = fits.open(file, memmap=False) if "rtell" not in file: #Default, if no rtell file is used @@ -283,5 +404,36 @@ def read(file, precache_hdus=True, wavefile=None): file=file, wavefile=wavefile, order=i, sn_used=sn_used, cached_hdus=cached_hdus ) list_out.append(spec) - return IGRINSSpectrumList(list_out) + specList = IGRINSSpectrumList(list_out) + return IGRINSSpectrumList(specList) + def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True): + """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit. + + Parameters + ---------- + h_band_slitprofile_filepath: + Filepath to *.slit_profile.json file outputted by the IGRINS PLP storing the spatial + profile of the target along the slit for the H band. + k_band_slitprofile_filepath: + Filepath to *.slit_profile.json file outputted by the IGRINS PLP storing the spatial + profile of the target along the slit for the K band. + slit_length: float + Length of the slit on the sky in arcsec. + PA: float + Position angle of the slit on the sky in degrees. Measured counterclockwise from North to East. + guilding_error: float + Estimate of the guiding error in arcsec. This smears out the PSF fits in the East-West direction. + This should be used carefully and only for telescopes on equitorial mounts. + print_info: bool + Print information about the fit. + + Returns + ------- + Returns list of arrays of fractional slit throughput as a function of wavelength + """ + m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info) + f_throughput = [] + for i in range(len(self)): + f_throughput.append(m*(1/self[i].wavelength.um) + b) + return f_throughput diff --git a/src/muler/utilities.py b/src/muler/utilities.py index dd70c64..ea167ca 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -2,6 +2,7 @@ import copy from specutils.spectra import Spectrum1D from astropy.nddata.nduncertainty import StdDevUncertainty +from astropy.modeling import models, fitting #import the astropy model fitting package from scipy.stats import binned_statistic @@ -240,3 +241,92 @@ def is_list(check_this): else: return False +def estimate_slit_throughput_ABBA(y, x=None, slit_length=14.8, slit_width=1.0, PA=90.0, guiding_error=1.5, print_info=True): + """ + Given a collapsed spatial profile long slit for a point (stellar) source nodded + ABBA along the slit, returns a numerical estimate of the fraction of light through the slit. + The A and B nods are fit with Moffat functions which are then projected from 1D to 2D and then + a mask is applied representing the slit and the the fraction of light in the PSFs inside the mask + are integrated to estimate the fraction of light that passes through the slit. + + Parameters + ---------- + y: numpy array of floats + Array representing the spatial profile of the source on the slit. It should be the PSF for + a point source nodded ABBA on the slit. + x: numpy array of floats (optional) + Array representing the spatial position along the slit in pixel space corrisponding to y. + slit_length: float + Length of the slit on the sky in arcsec. + slit_width: float + Width of the slit on the sky in arcsec. + PA: float + Position angle of the slit on the sky in degrees. Measured counterclockwise from North to East. + guilding_error: float + Estimate of the guiding error in arcsec. This smears out the PSF fits in the East-West direction. + This should be used carefully and only for telescopes on equitorial mounts. + print_info: bool + Print information about the fit. + + Returns: + ---------- + Float: The fraction of light from the source estimated to pass through the slit. + """ + + + slit_width_to_length_ratio = slit_width / slit_length + if x is None: #Generate equally spaced x array if it is not provided + ny = len(y) + x = (np.arange(ny) / ny) * slit_length + #Find maximum and minimum + i_max = np.where(y == np.nanmax(y))[0][0] + i_min = np.where(y == np.nanmin(y))[0][0] + if np.size(i_max) > 1: #Error catch for the rare event when two or more pixels match the max or min y values + i_max = i_max[0] + if np.size(i_min) > 1: + i_min = i_min[0] + #Fit 2 Moffat distributions to the psfs from A and B positions (see https://docs.astropy.org/en/stable/modeling/compound-models.html) + g1 = models.Moffat1D(amplitude=y[i_max], x_0=x[i_max], alpha=1.0, gamma=1.0) + g2 = models.Moffat1D(amplitude=y[i_min], x_0=x[i_min], alpha=1.0, gamma=1.0) + gg_init = g1 + g2 + fitter = fitting.TRFLSQFitter() + gg_fit = fitter(gg_init, x, y) + if print_info: + print('FWHM A beam:', gg_fit[0].fwhm) + print('FWHM B beam:', gg_fit[1].fwhm) + #Numerically estimate light through slit + g1_fit = models.Moffat2D(amplitude=np.abs(gg_fit[0].amplitude), x_0=gg_fit[0].x_0 - 0.5*slit_length, alpha=gg_fit[0].alpha, gamma=gg_fit[0].gamma) + g2_fit = models.Moffat2D(amplitude=np.abs(gg_fit[1].amplitude), x_0=gg_fit[1].x_0 - 0.5*slit_length, alpha=gg_fit[1].alpha, gamma=gg_fit[1].gamma) + #Generate a 2D grid in x and y for numerically calculating slit loss + n_axis = 5000 + half_n_axis = n_axis / 2 + max_x = np.nanmax(x) + dx = 1.2 * (max_x / n_axis) + dy = 1.2 * (max_x / n_axis) + y2d, x2d = np.meshgrid(np.arange(n_axis), np.arange(n_axis)) + x2d = (x2d - half_n_axis) * dx + y2d = (y2d - half_n_axis) * dy + #simulate guiding error by "smearing out" PSF + position_angle_in_radians = PA * (np.pi)/180.0 #PA in radians + fraction_guiding_error = np.cos(position_angle_in_radians)*guiding_error #arcsec, estimated by doubling average fwhm of moffet functions + diff_x0 = fraction_guiding_error * np.cos(position_angle_in_radians) + diff_y0 = fraction_guiding_error * np.sin(position_angle_in_radians) + g1_fit.x_0 += 0.5*diff_x0 + g2_fit.x_0 += 0.5*diff_x0 + g1_fit.y_0 += 0.5*diff_y0 + g2_fit.y_0 += 0.5*diff_y0 + profiles_2d = np.zeros(np.shape(x2d)) + n = 5 + for i in range(n): + profiles_2d += (1/n)*(g1_fit(x2d, y2d) + g2_fit(x2d, y2d)) + g1_fit.x_0 -= (1/(n-1))*diff_x0 + g2_fit.x_0 -= (1/(n-1))*diff_x0 + g1_fit.y_0 -= (1/(n-1))*diff_y0 + g2_fit.y_0 -= (1/(n-1))*diff_y0 + #Mask esitmated 2D PSFs to estimate fraction of light through the slit + profiles_2d = profiles_2d / np.nansum(profiles_2d) #Normalize each pixel by fraction of starlight + outside_slit = (y2d <= -0.5*slit_width) | (y2d >= 0.5*slit_width) | (x2d <= -0.5*slit_length) | (x2d >= 0.5*slit_length) #Apply mask + profiles_2d[outside_slit] = np.nan + fraction_through_slit = np.nansum(profiles_2d) + + return fraction_through_slit From a7237cd525a98d8c9932cf33381492f2a0eaa555 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 26 Jun 2023 12:30:27 -0500 Subject: [PATCH 13/43] Add ability to read in 2D IGRINS spectra. --- src/muler/igrins.py | 38 +++++++++++++++++++++++++++----------- 1 file changed, 27 insertions(+), 11 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index cf1ea1e..21a4d21 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -66,14 +66,24 @@ def getUncertainityFilepath(filepath): path_base = filepath[:-20] elif ".spec.fits" in filepath: path_base = filepath[:-10] - if os.path.exists(path_base + '.variance.fits'): #Prefer .variance.fits file - return path_base + '.variance.fits' - elif os.path.exists(path_base + '.sn.fits'): #If no .variance.fits file found, try using the .sn.fits file - return path_base + '.sn.fits' + elif ".spec2d.fits" in filepath: + path_base = filepath[:-12] + if ".spec2d.fits" in filepath: + if os.path.exists(path_base + '.var2d.fits'): + return path_base + '.var2d.fits' + else: + raise Exception( + "The file .var2d.fits does not exist in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." + ) else: - raise Exception( - "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." - ) + if os.path.exists(path_base + '.variance.fits'): #Prefer .variance.fits file + return path_base + '.variance.fits' + elif os.path.exists(path_base + '.sn.fits'): #If no .variance.fits file found, try using the .sn.fits file + return path_base + '.sn.fits' + else: + raise Exception( + "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." + ) def getSlitProfileFilepath(filepath, band): """Returns the path for the slit profile file (.slit_profile.json). @@ -93,6 +103,8 @@ def getSlitProfileFilepath(filepath, band): path_base = filepath[:-20] elif ".spec.fits" in filepath: path_base = filepath[:-10] + elif ".spec2d.fits" in filepath: + path_base = filepath[:-12] path_base = path_base.replace('SDCH', 'SDC'+band).replace('SDCK', 'SDC'+band) #Make sure we are using the correct band return path_base + '.slit_profile.json' @@ -185,7 +197,7 @@ def __init__( if file is not None: - assert (".spec_a0v.fits" in file) or (".spec.fits" in file) or (".spec_flattened.fits") + assert (".spec_a0v.fits" in file) or (".spec.fits" in file) or (".spec_flattened.fits" in file) or ('.spec2d.fits' in file) # Determine the band if "SDCH" in file: band = "H" @@ -232,7 +244,7 @@ def __init__( elif ".spec_a0v.fits" in file: lamb = hdus["WAVELENGTH"].data[order].astype(float) * u.micron flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(float) * u.ct - elif (("spec.fits" in file) or ("spec_flattened.fits" in file)) and (wavefile is not None): + elif (("spec.fits" in file) or ("spec_flattened.fits" in file) or ('.spec2d.fits' in file)) and (wavefile is not None): lamb = ( wave_hdus[0].data[order].astype(float) * 1e-3 * u.micron ) # Note .wave.fits and .wavesol_v1.fts files store their wavelenghts in nm so they need to be converted to microns @@ -374,7 +386,7 @@ def read(file, precache_hdus=True, wavefile=None): """ # still works - assert (".spec_a0v.fits" in file) or (".spec.fits" in file) or (".spec_flattened.fits" in file) + assert (".spec_a0v.fits" in file) or (".spec.fits" in file) or (".spec_flattened.fits" in file) or (".spec2d.fits" in file) sn_used = False #Default hdus = fits.open(file, memmap=False) @@ -396,7 +408,11 @@ def read(file, precache_hdus=True, wavefile=None): wave_hdus = fits.open(full_path, memmap=False) cached_hdus.append(wave_hdus) - n_orders, n_pix = hdus[0].data.shape + hdus0_shape = hdus[0].data.shape + if len(hdus0_shape) == 2: #1D spectrum + n_orders, n_pix = hdus[0].data.shape + elif len(hdus0_shape) == 3: #3D spectrum + n_orders, n_height, n_pix = hdus[0].data.shape list_out = [] for i in range(n_orders - 1, -1, -1): From ba62c02b2e643a3ee44566f54d2993fce23bfa81 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 26 Jun 2023 14:11:27 -0500 Subject: [PATCH 14/43] Add function to create a slit profile from a 2D spectrum order. --- src/muler/echelle.py | 41 +++++++++++++++++++++++++++++++++++++++++ src/muler/igrins.py | 2 +- 2 files changed, 42 insertions(+), 1 deletion(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 896a10b..04928b6 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -739,6 +739,47 @@ def LinResample(self, input_spec, fractions=1.0): return self.__class__( spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=self.meta, wcs=None) + def get_slit_profile(self, lower=None, upper=None, slit_length=1.0): + """"For a 2D spectrum, returns the slit profile + + Parameters + ---------- + lower : AstroPy Quantity or float + The short wavelength limit at which to define the slit profile. + If the value is a float, it assume Angstrom units. + upper : AstroPy Quantity or float + The long wavelength limit at which to define the slit profiled. + If the value is a float, it assume Angstrom units. + + Returns + ------- + Array with the same height as the 2D spectrum of the median estimated slit profile + """ + #Get the upper and lower wavelength limits in the correct units + + assert len(np.shape(self.flux)) == 2, "Spectrum must be 2D to estimate slit profile." #Test to make sure this is a 2D spectrum + + if lower is None: + lower = self.wavelength.min().value + if upper is None: + upper = self.wavelength.max().value + + if type(lower) is not u.Quantity: + # Assume it's Angstroms + lower = lower * u.Angstrom + if type(upper) is not u.Quantity: + upper = upper * u.Angstrom + + mask = (self.wavelength >= lower) & (self.wavelength <= upper) + + flux = self.flux[:, mask].value + normalized_flux = flux / np.nansum(flux, axis=0) + median_slit_profile = np.nanmedian(normalized_flux, axis=1) + + return median_slit_profile + + + def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. Uuseful for airmass correction. Uncertainity is propogated by keeping the diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 21a4d21..7c1b10a 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -411,7 +411,7 @@ def read(file, precache_hdus=True, wavefile=None): hdus0_shape = hdus[0].data.shape if len(hdus0_shape) == 2: #1D spectrum n_orders, n_pix = hdus[0].data.shape - elif len(hdus0_shape) == 3: #3D spectrum + elif len(hdus0_shape) == 3: #2D spectrum n_orders, n_height, n_pix = hdus[0].data.shape list_out = [] From 4b2102059b2477b5a72a332aa6f3adeb20229a5d Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 29 Jun 2023 17:01:49 -0500 Subject: [PATCH 15/43] Moved LinResample from being a method to be a function in utilities.py and renamed it resample_combine_spectra. --- src/muler/echelle.py | 73 ------------------------------------------ src/muler/utilities.py | 61 +++++++++++++++++++++++++++++++++++ 2 files changed, 61 insertions(+), 73 deletions(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 04928b6..85f577e 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -28,8 +28,6 @@ from astropy.modeling.physical_models import BlackBody import specutils from muler.utilities import apply_numpy_mask, is_list, resample_list -from specutils.manipulation import LinearInterpolatedResampler -LinInterpResampler = LinearInterpolatedResampler() # from barycorrpy import get_BC_vel from astropy.coordinates import SkyCoord, EarthLocation @@ -703,42 +701,6 @@ def apply_boolean_mask(self, mask): return spec - def LinResample(self, input_spec, fractions=1.0): - """Linearly resample in a spectrum, or a list of spectra, to match this spectrum return an EchelleSpectrum - object with the same wavelength array and naned pixels. Applications include resampling - synthetic spectra generated from stellar atmosphere models to match a real spectrum. - - Parameters - ------- - input_spec : - A muler spectrum or similar specutils object, or list of such objects to be resampled to match this spectrum. - fractions : - If a list of input spectra are provided, the user must provide a list of floats denoting what - fraction each of the input spectra make up the final resampled spectrum. The total must equal 1. - For example, if I am stacking 3 input spectra and the first two spectra make up 40% of my resampled - spectrum and the last spectrum makes up 20%, fractions=[0.4, 0.4, 0.2]. - - Returns - ------- - An EchelleSpectrum object with the same wavelength array and naned pixels as this (self) object. - """ - if is_list(input_spec): - fractions = np.array(fractions) #Check that fractions are a list and their sum equals 1 - sum_fractions = np.sum(fractions) - assert len(fractions) > 1, "You need to provide a fraction for each input spectrum. This is inputted as a list of floats." - assert sum_fractions == 1, "Total fractions in fraction list is "+str(sum_fractions)+" but total must equal to 1." - resampled_spec = LinInterpResampler(input_spec[0], input_spec[0].spectral_axis)*(fractions[0]) #Resample spectra - for i in range(1, len(input_spec)): - resampled_spec = resampled_spec + LinInterpResampler(input_spec[i], input_spec[0].spectral_axis)*(fractions[i]) - resampled_spec = LinInterpResampler(resampled_spec, self.spectral_axis) #Resample spectrum - else: - resampled_spec = LinInterpResampler(resampled_spec, self.spectral_axis) - - resampled_spec.flux[np.isnan(self.flux)] = np.nan #Copy over nans from self to avoid weird errors later on - - return self.__class__( - spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=self.meta, wcs=None) - def get_slit_profile(self, lower=None, upper=None, slit_length=1.0): """"For a 2D spectrum, returns the slit profile @@ -1068,38 +1030,3 @@ def flatten(self, **kwargs): spec_out[i].meta["x_values"] = self[i].meta["x_values"] return spec_out - def LinResample(self, input_spec, fractions=1.0): - """Linearly resample in a spectrum, or a list of spectra, to match this spectrum return an EchelleSpectrumList - object with the same wavelength arrays and naned pixels. Applications include resampling - synthetic spectra generated from stellar atmosphere models to match a real spectrum. - - Parameters - ------- - input_spec : - A muler spectrum or similar specutils object, or list of such objects to be resampled to match this spectrum. - fractions : - If a list of input spectra are provided, the user must provide a list of floats denoting what - fraction each of the input spectra make up the final resampled spectrum. The total must equal 1. - For example, if I am stacking 3 input spectra and the first two spectra make up 40% of my resampled - spectrum and the last spectrum makes up 20%, fractions=[0.4, 0.4, 0.2]. - - Returns - ------- - An EchelleSpectrumList object with the same wavelength arrays and naned pixels as this (self) object. - """ - if is_list(input_spec): # - fractions = np.array(fractions) #Check that fractions are a list and their sum equals 1 - sum_fractions = np.sum(fractions) - assert len(fractions) > 1, "You need to provide a fraction for each input spectrum. This is inputted as a list of floats." - assert sum_fractions == 1, "Total fractions in fraction list is "+str(sum_fractions)+" but total must equal to 1." - resampled_spec = resample_list(input_spec[0], self)*(fractions[0]) #Resample spectra - for i in range(1, len(input_spec)): - resampled_spec = resampled_spec + resample_list(input_spec[i], self)*(fractions[i]) - else: - resampled_spec = resample_list(input_spec, self) #Resample spectrum - - for i in range(len(resampled_spec)): #Copy over nans from self to avoid weird errors later on - resampled_spec[i].flux[np.isnan(self[i].flux)] = np.nan - - return resampled_spec - diff --git a/src/muler/utilities.py b/src/muler/utilities.py index ea167ca..f921510 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -4,6 +4,67 @@ from astropy.nddata.nduncertainty import StdDevUncertainty from astropy.modeling import models, fitting #import the astropy model fitting package from scipy.stats import binned_statistic +from specutils.manipulation import LinearInterpolatedResampler +LinInterpResampler = LinearInterpolatedResampler() + + +def resample_combine_spectra(input_spec, spec_to_match, weights=1.0): + """Linearly resample input_spectra, which can be a list of spectra, to match specrum_to_match and return an EchelleSpectrum + or EchelleSpectrumList object with the same spectral axis and naned pixels as specrum_to_match. One main applications + for this is to match multiple synthetic spectra generated from stellar atmosphere models to a real spectrum. + + Parameters + ------- + input_spec : + A EchelleSpectrumm EchelleSpectrumList, or similar specutils object (or list of objects) to be resampled to match spec_to_match. + specrum_to_match : + A EchelleSpectrum or EchelleSpectrumLis spectrum which the input_spec will be resampled to match in both wavelength and naned pixels + weights : + A list or array giving the fraction of each spectrum in input_spec that makes up the final resampled spectrum. + Useful for grid interpolation for stellar atmosphere models or just stacking spectra from multiple objects + into one spectrum. + + Returns + ------- + An EchelleSpectrum or EchelleSpectrumList object with the same wavelength arrays and naned pixels as spec_to_match. + """ + + if is_list(input_spec): # + weights = np.array(weights) #Check that weights are a list and their sum equals 1 + sum_weights = np.sum(weights) + assert (len(weights)==1 and weights[0] == 1) or (len(weights) > 1), "If providing weights, You need to provide a weight for each input spectrum.." + assert sum_weights == 1, "Total weights in weights list is "+str(sum_weights)+" but total must equal to 1." + + if is_list(spec_to_match): + resampled_spec = resample_list(input_spec[0], spec_to_match)*(weights[0]) #Resample spectra + for i in range(1, len(input_spec)): + if len(weights)==1 and weights[0] == 1: + resampled_spec = resampled_spec + resample_list(input_spec[i], spec_to_match)*(weights[i]) + else: + resampled_spec = resampled_spec + resample_list(input_spec[i], spec_to_match) + else: + resampled_spec = LinInterpResampler(input_spec[0], spec_to_match.spectral_axis)*(weights[0]) #Resample spectra + for i in range(1, len(input_spec)): + if len(weights)==1 and weights[0] == 1: + resampled_spec = resampled_spec + LinInterpResampler(input_spec[i], spec_to_match.spectral_axis)*(weights[i]) + else: + resampled_spec = resampled_spec + LinInterpResampler(input_spec[i], spec_to_match.spectral_axis) + else: + if is_list(spec_to_match): + resampled_spec = resample_list(input_spec, specrum_to_match) #Resample spectrum + else: + resampled_spec = LinInterpResampler(input_spec, spec_to_match.spectral_axis) + resampled_spec = spec_to_match.__class__( #Ensure resampled_spec is the same object as spec_to_match + spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=self.meta, wcs=None) + + if is_list(spec_to_match): #Propogate nans from spec_to_match to avoid wierd errors + for i in range(len(spec_to_match)): + resampled_spec[i].flux[np.isnan(spec_to_match[i].flux.value)] = np.nan + else: + resampled_spec.flux[np.isnan(spec_to_match.flux.value)] = np.nan + + return resampled_spec + def combine_spectra(spec_list): From d1e134d8be3aea03b6ebedc93fdf2ba5130fc0ad Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Tue, 11 Jul 2023 13:46:58 -0500 Subject: [PATCH 16/43] Building up the Slit class in utilities.py. Lots of cleaning up and debugging of the code. --- src/muler/igrins.py | 35 +++++-- src/muler/utilities.py | 232 +++++++++++++++++++++++++---------------- 2 files changed, 172 insertions(+), 95 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 7c1b10a..559a287 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -12,7 +12,7 @@ import warnings import json from muler.echelle import EchelleSpectrum, EchelleSpectrumList -from muler.utilities import estimate_slit_throughput_ABBA +from muler.utilities import Slit from astropy.time import Time import numpy as np import astropy @@ -110,7 +110,7 @@ def getSlitProfileFilepath(filepath, band): -def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True): +def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit and return the coefficients of a linear fit. @@ -128,6 +128,8 @@ def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guidi This should be used carefully and only for telescopes on equitorial mounts. print_info: bool Print information about the fit. + plot: bool + Visualize slit throughput calculations. Returns ------- @@ -143,22 +145,39 @@ def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guidi slit_width = slit_length * (1.0/14.8) #Calculate slit width from slit length since IGRINS always uses the same slit no matter the telescope + igrins_slit = Slit(length=slit_length, width=slit_width, PA=PA) #Get throughput for H band json_file = open(h_band_filepath) json_obj = json.load(json_file) x = np.array(json_obj['profile_x']) * slit_length y = np.array(json_obj['profile_y']) - f_through_slit_H = estimate_slit_throughput_ABBA(y, x=x, slit_length=slit_length, slit_width=slit_width, PA=PA, print_info=print_info) + igrins_slit.clear() + igrins_slit.ABBA(y, x=x, print_info=print_info, plot=plot) + if plot: + print('2D plot of H-band') + igrins_slit.plot2d() + #breakpoint() + f_through_slit_H = igrins_slit.estimate_slit_throughput() #Get throughput for K band json_file = open(k_band_filepath) json_obj = json.load(json_file) x = np.array(json_obj['profile_x']) * slit_length y = np.array(json_obj['profile_y']) - f_through_slit_K = estimate_slit_throughput_ABBA(y, x=x, slit_length=slit_length, slit_width=slit_width, PA=PA, print_info=print_info) + igrins_slit.clear() + igrins_slit.ABBA(y, x=x, print_info=print_info, plot=plot) + if plot: + print('2D plot of K-band') + igrins_slit.plot2d() + breakpoint() + f_through_slit_K = igrins_slit.estimate_slit_throughput() #Fit linear trend through slit throughput as function of wavelength and using fitting a line through two points m = (f_through_slit_K - f_through_slit_H) / ((1/2.2) - (1/1.65)) b = f_through_slit_H - m*(1/1.65) if print_info: + # log.info('H-band slit throughput: ', f_through_slit_H) + # log.info('K-band slit throughput:', f_through_slit_K) + # log.info('m: ', m) + # log.info('b: ', b) print('H-band slit throughput: ', f_through_slit_H) print('K-band slit throughput:', f_through_slit_K) print('m: ', m) @@ -330,7 +349,7 @@ def astropy_time(self): mjd = self.meta["header"]["MJD-OBS"] return Time(mjd, format="mjd", scale="utc") - def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True): + def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit. Parameters @@ -356,7 +375,7 @@ def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5 Returns array of fractional slit throughput as a function of wavelength """ - m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info) + m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info, plot=plot) return m*(1/self.wavelength.um) + b @@ -422,7 +441,7 @@ def read(file, precache_hdus=True, wavefile=None): list_out.append(spec) specList = IGRINSSpectrumList(list_out) return IGRINSSpectrumList(specList) - def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True): + def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit. Parameters @@ -448,7 +467,7 @@ def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5 Returns list of arrays of fractional slit throughput as a function of wavelength """ - m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info) + m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info, plot=plot) f_throughput = [] for i in range(len(self)): f_throughput.append(m*(1/self[i].wavelength.um) + b) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index f921510..682cf78 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -1,3 +1,5 @@ +import logging + import numpy as np import copy from specutils.spectra import Spectrum1D @@ -5,8 +7,11 @@ from astropy.modeling import models, fitting #import the astropy model fitting package from scipy.stats import binned_statistic from specutils.manipulation import LinearInterpolatedResampler +from matplotlib import pyplot as plt LinInterpResampler = LinearInterpolatedResampler() +log = logging.getLogger(__name__) + def resample_combine_spectra(input_spec, spec_to_match, weights=1.0): """Linearly resample input_spectra, which can be a list of spectra, to match specrum_to_match and return an EchelleSpectrum @@ -302,92 +307,145 @@ def is_list(check_this): else: return False -def estimate_slit_throughput_ABBA(y, x=None, slit_length=14.8, slit_width=1.0, PA=90.0, guiding_error=1.5, print_info=True): - """ - Given a collapsed spatial profile long slit for a point (stellar) source nodded - ABBA along the slit, returns a numerical estimate of the fraction of light through the slit. - The A and B nods are fit with Moffat functions which are then projected from 1D to 2D and then - a mask is applied representing the slit and the the fraction of light in the PSFs inside the mask - are integrated to estimate the fraction of light that passes through the slit. - - Parameters - ---------- - y: numpy array of floats - Array representing the spatial profile of the source on the slit. It should be the PSF for - a point source nodded ABBA on the slit. - x: numpy array of floats (optional) - Array representing the spatial position along the slit in pixel space corrisponding to y. - slit_length: float - Length of the slit on the sky in arcsec. - slit_width: float - Width of the slit on the sky in arcsec. - PA: float - Position angle of the slit on the sky in degrees. Measured counterclockwise from North to East. - guilding_error: float - Estimate of the guiding error in arcsec. This smears out the PSF fits in the East-West direction. - This should be used carefully and only for telescopes on equitorial mounts. - print_info: bool - Print information about the fit. - - Returns: - ---------- - Float: The fraction of light from the source estimated to pass through the slit. - """ +class Slit: + def __init__(self, length=14.8, width=1.0, PA=90.0, guiding_error=1.5, n_axis=5000): + """ + A class to handle information about a spectrometer's slit, used for calculating things like slit losses + + Parameters + ---------- + length: float + Length of the slit on the sky in arcsec. + width: float + Width of the slit on the sky in arcsec. + PA: float + Position angle of the slit on the sky in degrees. Measured counterclockwise from North to East. + guilding_error: float + Estimate of the guiding error in arcsec. This smears out the PSF fits in the East-West direction. + This should be used carefully and only for telescopes on equitorial mounts. + n_axis: float + Size of axis for a 2D square array storing estimated profiles along the slit in 2D for later masking - slit_width_to_length_ratio = slit_width / slit_length - if x is None: #Generate equally spaced x array if it is not provided - ny = len(y) - x = (np.arange(ny) / ny) * slit_length - #Find maximum and minimum - i_max = np.where(y == np.nanmax(y))[0][0] - i_min = np.where(y == np.nanmin(y))[0][0] - if np.size(i_max) > 1: #Error catch for the rare event when two or more pixels match the max or min y values - i_max = i_max[0] - if np.size(i_min) > 1: - i_min = i_min[0] - #Fit 2 Moffat distributions to the psfs from A and B positions (see https://docs.astropy.org/en/stable/modeling/compound-models.html) - g1 = models.Moffat1D(amplitude=y[i_max], x_0=x[i_max], alpha=1.0, gamma=1.0) - g2 = models.Moffat1D(amplitude=y[i_min], x_0=x[i_min], alpha=1.0, gamma=1.0) - gg_init = g1 + g2 - fitter = fitting.TRFLSQFitter() - gg_fit = fitter(gg_init, x, y) - if print_info: - print('FWHM A beam:', gg_fit[0].fwhm) - print('FWHM B beam:', gg_fit[1].fwhm) - #Numerically estimate light through slit - g1_fit = models.Moffat2D(amplitude=np.abs(gg_fit[0].amplitude), x_0=gg_fit[0].x_0 - 0.5*slit_length, alpha=gg_fit[0].alpha, gamma=gg_fit[0].gamma) - g2_fit = models.Moffat2D(amplitude=np.abs(gg_fit[1].amplitude), x_0=gg_fit[1].x_0 - 0.5*slit_length, alpha=gg_fit[1].alpha, gamma=gg_fit[1].gamma) - #Generate a 2D grid in x and y for numerically calculating slit loss - n_axis = 5000 - half_n_axis = n_axis / 2 - max_x = np.nanmax(x) - dx = 1.2 * (max_x / n_axis) - dy = 1.2 * (max_x / n_axis) - y2d, x2d = np.meshgrid(np.arange(n_axis), np.arange(n_axis)) - x2d = (x2d - half_n_axis) * dx - y2d = (y2d - half_n_axis) * dy - #simulate guiding error by "smearing out" PSF - position_angle_in_radians = PA * (np.pi)/180.0 #PA in radians - fraction_guiding_error = np.cos(position_angle_in_radians)*guiding_error #arcsec, estimated by doubling average fwhm of moffet functions - diff_x0 = fraction_guiding_error * np.cos(position_angle_in_radians) - diff_y0 = fraction_guiding_error * np.sin(position_angle_in_radians) - g1_fit.x_0 += 0.5*diff_x0 - g2_fit.x_0 += 0.5*diff_x0 - g1_fit.y_0 += 0.5*diff_y0 - g2_fit.y_0 += 0.5*diff_y0 - profiles_2d = np.zeros(np.shape(x2d)) - n = 5 - for i in range(n): - profiles_2d += (1/n)*(g1_fit(x2d, y2d) + g2_fit(x2d, y2d)) - g1_fit.x_0 -= (1/(n-1))*diff_x0 - g2_fit.x_0 -= (1/(n-1))*diff_x0 - g1_fit.y_0 -= (1/(n-1))*diff_y0 - g2_fit.y_0 -= (1/(n-1))*diff_y0 - #Mask esitmated 2D PSFs to estimate fraction of light through the slit - profiles_2d = profiles_2d / np.nansum(profiles_2d) #Normalize each pixel by fraction of starlight - outside_slit = (y2d <= -0.5*slit_width) | (y2d >= 0.5*slit_width) | (x2d <= -0.5*slit_length) | (x2d >= 0.5*slit_length) #Apply mask - profiles_2d[outside_slit] = np.nan - fraction_through_slit = np.nansum(profiles_2d) - - return fraction_through_slit + """ + self.length = length + self.width = width + self.PA = PA + self.guiding_error = guiding_error + + half_n_axis = n_axis / 2 + dx = 1.2 * (length / n_axis) + dy = 1.2 * (length / n_axis) + x2d, y2d = np.meshgrid(np.arange(n_axis), np.arange(n_axis)) + x2d = (x2d - half_n_axis) * dx + y2d = (y2d - half_n_axis) * dy + self.x2d = x2d #Store x coordinates of 2D grid + self.y2d = y2d #Store y coordinates on 2D grid + self.f2d = np.zeros(np.shape(y2d)) #Store 2D grid of estimated fluxes' + half_length = 0.5 * self.length + half_width = 0.5 * self.width + self.mask = (x2d <= -half_width) | (x2d >= half_width) | (y2d <= -half_length) | (y2d >= half_length) #Create mask where every pixel inside slit is True and outside is False + def ABBA(self, y, x=None, print_info=True, plot=False): + """ + Given a collapsed spatial profile long slit for a point (stellar) source nodded + ABBA along the slit, generate an estimate of A and B nods' 2D PSFs. + The A and B nods are fit with Moffat functions which are then projected from 1D to 2D and then + a mask is applied representing the slit and the the fraction of light in the PSFs inside the mask + are integrated to estimate the fraction of light that passes through the slit. + + Parameters + ---------- + y: numpy array of floats + Array representing the spatial profile of the source on the slit. It should be the PSF for + a point source nodded ABBA on the slit. + x: numpy array of floats (optional) + Array representing the spatial position along the slit in pixel space corrisponding to y. + print_info: bool + Print information about the fit. + plot: bool + Set to True to plot the 1D profile along the slit, Moffat fits, and residuals + """ + slit_width_to_length_ratio = self.width / self.length + if x is None: #Generate equally spaced x array if it is not provided + ny = len(y) + x = (np.arange(ny) / ny) * slit_length + #Find maximum and minimum + i_max = np.where(y == np.nanmax(y))[0][0] + i_min = np.where(y == np.nanmin(y))[0][0] + if np.size(i_max) > 1: #Error catch for the rare event when two or more pixels match the max or min y values + i_max = i_max[0] + if np.size(i_min) > 1: + i_min = i_min[0] + #Fit 2 Moffat distributions to the psfs from A and B positions (see https://docs.astropy.org/en/stable/modeling/compound-models.html) + g1 = models.Moffat1D(amplitude=y[i_max], x_0=x[i_max], alpha=1.0, gamma=1.0) + g2 = models.Moffat1D(amplitude=y[i_min], x_0=x[i_min], alpha=1.0, gamma=1.0) + gg_init = g1 + g2 + fitter = fitting.TRFLSQFitter() + gg_fit = fitter(gg_init, x, y) + if plot: + plt.figure() + plt.plot(x, y, '.', label='Std Star Data') + plt.plot(x, gg_fit(x), label='Moffat Distribution Fit') + plt.plot(x, y-gg_fit(x), label='Residuals') + plt.xlabel('Distance along slit (arcsec)') + plt.ylabel('Flux') + plt.legend() + plt.show() + if print_info: + #log.info('FWHM A beam:', gg_fit[0].fwhm) + #log.info('FWHM B beam:', gg_fit[1].fwhm) + print('FWHM A beam:', gg_fit[0].fwhm) + print('FWHM B beam:', gg_fit[1].fwhm) + #Numerically estimate light through slit + g1_fit = models.Moffat2D(amplitude=np.abs(gg_fit[0].amplitude), x_0=gg_fit[0].x_0 - 0.5*self.length, alpha=gg_fit[0].alpha, gamma=gg_fit[0].gamma) + g2_fit = models.Moffat2D(amplitude=np.abs(gg_fit[1].amplitude), x_0=gg_fit[1].x_0 - 0.5*self.length, alpha=gg_fit[1].alpha, gamma=gg_fit[1].gamma) + #simulate guiding error by "smearing out" PSF + position_angle_in_radians = self.PA * (np.pi)/180.0 #PA in radians + fraction_guiding_error = np.cos(position_angle_in_radians)*self.guiding_error #arcsec, estimated by doubling average fwhm of moffet functions + diff_x0 = fraction_guiding_error * np.cos(position_angle_in_radians) + diff_y0 = fraction_guiding_error * np.sin(position_angle_in_radians) + g1_fit.x_0 += 0.5*diff_x0 + g2_fit.x_0 += 0.5*diff_x0 + g1_fit.y_0 += 0.5*diff_y0 + g2_fit.y_0 += 0.5*diff_y0 + n = 5 + for i in range(n): + self.f2d += (1/n)*(g1_fit(self.y2d, self.x2d) + g2_fit(self.y2d, self.x2d)) + g1_fit.x_0 -= (1/(n-1))*diff_x0 + g2_fit.x_0 -= (1/(n-1))*diff_x0 + g1_fit.y_0 -= (1/(n-1))*diff_y0 + g2_fit.y_0 -= (1/(n-1))*diff_y0 + def estimate_slit_throughput(self, normalize=True): + """ + a mask is applied representing the slit and the the fraction of light in the PSFs inside the mask + are integrated to estimate the fraction of light that passes through the slit. + """ + if normalize: #You almost alwyas want to normalize + self.normalize() + fraction_through_slit = np.nansum(self.f2d[~self.mask]) #Get fraction of light inside the slit mask + return fraction_through_slit + def clear(self): + """ + Clear 2D flux array + """ + self.f2d[:] = 0.0 + def normalize(self): + """ + #Normalize each pixel by fraction of starlight + """ + self.f2d = self.f2d / np.nansum(self.f2d) + def plot2d(self, **kwarg): + """ + Visualize the 2D distribution with slit overplotted + """ + plt.figure() + plt.imshow(self.f2d, origin='lower', aspect='auto', **kwarg) + plt.colorbar() + half_width = 0.5*self.width #Pkit slit outline + half_length = 0.5*self.length + # slit_ouline_x = np.array([-half_width, half_width, half_width, -half_width, -half_width]) + # slit_ouline_y = np.array([-half_length, -half_length, half_length, half_length, -half_length]) + # plt.plot(slit_ouline_x, slit_ouline_y, color='White', linewidth=3.0) + numerical_mask = np.ones(np.shape(self.mask)) + plt.contour(self.mask, levels=[0.0,0.5, 1.0], colors='white', linewidths=2) + plt.show() \ No newline at end of file From dde8a751062c746dbbc00af632126a1569eb4a35 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Tue, 11 Jul 2023 13:49:54 -0500 Subject: [PATCH 17/43] Minor bug fix. --- src/muler/utilities.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index 682cf78..a8c6b65 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -368,7 +368,7 @@ def ABBA(self, y, x=None, print_info=True, plot=False): slit_width_to_length_ratio = self.width / self.length if x is None: #Generate equally spaced x array if it is not provided ny = len(y) - x = (np.arange(ny) / ny) * slit_length + x = (np.arange(ny) / ny) * self.length #Find maximum and minimum i_max = np.where(y == np.nanmax(y))[0][0] i_min = np.where(y == np.nanmin(y))[0][0] From 85a32993b80974b5ffe4ecc561eae40af029eb80 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Tue, 11 Jul 2023 14:07:07 -0500 Subject: [PATCH 18/43] More bug fixes. --- src/muler/utilities.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index a8c6b65..d5667ec 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -56,11 +56,11 @@ def resample_combine_spectra(input_spec, spec_to_match, weights=1.0): resampled_spec = resampled_spec + LinInterpResampler(input_spec[i], spec_to_match.spectral_axis) else: if is_list(spec_to_match): - resampled_spec = resample_list(input_spec, specrum_to_match) #Resample spectrum + resampled_spec = resample_list(input_spec, spec_to_match) #Resample spectrum else: resampled_spec = LinInterpResampler(input_spec, spec_to_match.spectral_axis) resampled_spec = spec_to_match.__class__( #Ensure resampled_spec is the same object as spec_to_match - spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=self.meta, wcs=None) + spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=resampled_spec.meta, wcs=None) if is_list(spec_to_match): #Propogate nans from spec_to_match to avoid wierd errors for i in range(len(spec_to_match)): From 7be1a677e3fc36175713338b1b73633ed0618c59 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 17 Aug 2023 18:32:10 -0500 Subject: [PATCH 19/43] Modified apply_numpy_mask in utilities.py to be compatible with 2D spectra. Should allow multiple other defs dependent on apply_numpy_mask to also handle 2D spectra. --- src/muler/utilities.py | 59 ++++++++++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 19 deletions(-) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index d5667ec..5f24d3c 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -217,16 +217,6 @@ def apply_numpy_mask(spec, mask): " The boolean mask should have the same shape as the spectrum." ) - if spec.uncertainty is not None: - masked_unc = spec.uncertainty[mask] - else: - masked_unc = None - - if spec.mask is not None: - mask_out = spec.mask[mask] - else: - mask_out = None - if spec.meta is not None: meta_out = copy.deepcopy(spec.meta) if "x_values" in spec.meta.keys(): @@ -234,14 +224,45 @@ def apply_numpy_mask(spec, mask): else: meta_out = None - return spec.__class__( - spectral_axis=spec.wavelength.value[mask] * spec.wavelength.unit, - flux=spec.flux[mask], - mask=mask_out, - uncertainty=masked_unc, - wcs=None, - meta=meta_out, - ) + ndim = spec.flux.ndim #Grab dimensionality of spec, can be 1D or 2D + if ndim == 1: #For 1D spectra + if spec.uncertainty is not None: + masked_unc = spec.uncertainty[mask] + else: + masked_unc = None + + if spec.mask is not None: + mask_out = spec.mask[mask] + else: + mask_out = None + + return spec.__class__( + spectral_axis=spec.wavelength.value[mask] * spec.wavelength.unit, + flux=spec.flux[mask], + mask=mask_out, + uncertainty=masked_unc, + wcs=None, + meta=meta_out, + ) + elif ndim == 2: #For 2D (e.g. slit) spectra + if spec.uncertainty is not None: + masked_unc = spec.uncertainty[:, mask] + else: + masked_unc = None + + if spec.mask is not None: + mask_out = spec.mask[:, mask] + else: + mask_out = None + + return spec.__class__( + spectral_axis=spec.wavelength.value[mask] * spec.wavelength.unit, + flux=spec.flux[:, mask], + mask=mask_out, + uncertainty=masked_unc, + wcs=None, + meta=meta_out, + ) def resample_list(spec_to_resample, specList, **kwargs): @@ -420,7 +441,7 @@ def estimate_slit_throughput(self, normalize=True): a mask is applied representing the slit and the the fraction of light in the PSFs inside the mask are integrated to estimate the fraction of light that passes through the slit. """ - if normalize: #You almost alwyas want to normalize + if normalize: #You almost always want to normalize self.normalize() fraction_through_slit = np.nansum(self.f2d[~self.mask]) #Get fraction of light inside the slit mask return fraction_through_slit From 9a417378e7b2d1faf0333f9993ab6ba5c4f36e30 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 24 Aug 2023 18:44:32 -0500 Subject: [PATCH 20/43] Major updates for IGRINS slit throughput measuring. --- src/muler/igrins.py | 82 ++++++++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 30 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 559a287..9e3146b 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -85,17 +85,26 @@ def getUncertainityFilepath(filepath): "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." ) -def getSlitProfileFilepath(filepath, band): - """Returns the path for the slit profile file (.slit_profile.json). +def getSlitProfile(filepath, band, slit_length): + """Returns the path for the slit profile. Will first look for a 2D + spectrum .spec2d.fits file to calculate the profile from. If a spec2d.fits + file does not exist, will look for a .slit_profile.json. Parameters ---------- - filepath: Filepath to fits file storing the data. Can be .spec.fits or .spec_a0v.fits. + filepath: string + Filepath to fits file storing the data. Can be .spec.fits or .spec_a0v.fits. + band: string + 'H' or 'K' specifying which band + slit_length: float + Length of the slit on the sky in arcsec. Returns ------- - slitProfileFilepath: string - Returns the file path to .slit_profile.json file. + x: float + Distance in arcsec along the slit + y: float + Flux of beam profile across the slit """ if ".spec_a0v.fits" in filepath: #Grab base file name for the uncertainity file path_base = filepath[:-14] @@ -105,8 +114,29 @@ def getSlitProfileFilepath(filepath, band): path_base = filepath[:-10] elif ".spec2d.fits" in filepath: path_base = filepath[:-12] - path_base = path_base.replace('SDCH', 'SDC'+band).replace('SDCK', 'SDC'+band) #Make sure we are using the correct band - return path_base + '.slit_profile.json' + path_base = path_base.replace('SDCH', 'SDC'+band).replace('SDCK', 'SDC'+band) + spec2d_filepath = path_base + '.spec2d.fits' + json_filepath = path_base + '.slit_profile.json' + if os.path.exists(filepath): #First try to use the 2D spectrum in a .spec2d.fits file to estimate the slit proflie + spec2d = fits.getdata(spec2d_filepath) + long_spec2d = spec2d[0,:,800:1200] #Chop off order edges at columns 800 and 1200 + for i in range(1, len(spec2d)): + long_spec2d = np.concatenate([long_spec2d, spec2d[i,:,800:1200]], axis=1) + y = np.nanmedian(long_spec2d, axis=1) + x = np.arange(len(y)) * (slit_length / len(y)) + elif os.path.exists(json_filepath): #If no 2D spectrum exists, try using the PLP estimate in .slit_profile.json + json_file = open(filepath) + json_obj = json.load(json_file) + x = np.array(json_obj['profile_x']) * slit_length + y = np.array(json_obj['profile_y']) + json_file.close() + else: + raise Exception( + "Need either .spec2d.fits or .slit_profile.json file in the same directory as " + + filepath + + " in order to get an estimate of the slit profile. .spec2d.fits or .slit_profile.json are missing." + ) + return x, y @@ -138,19 +168,9 @@ def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guidi wavelength units in microns. """ - h_band_filepath = getSlitProfileFilepath(file, 'H') #Get paths to .slit_profile.json files - k_band_filepath = getSlitProfileFilepath(file, 'K') - - assert os.path.exists(h_band_filepath) and os.path.exists(k_band_filepath) - - - slit_width = slit_length * (1.0/14.8) #Calculate slit width from slit length since IGRINS always uses the same slit no matter the telescope - igrins_slit = Slit(length=slit_length, width=slit_width, PA=PA) + igrins_slit = Slit(length=slit_length, width=slit_length*(1/14.8), PA=PA, guiding_error=guiding_error) #Get throughput for H band - json_file = open(h_band_filepath) - json_obj = json.load(json_file) - x = np.array(json_obj['profile_x']) * slit_length - y = np.array(json_obj['profile_y']) + x, y = getSlitProfile(file, band='H', slit_length=slit_length) #Get slit profile igrins_slit.clear() igrins_slit.ABBA(y, x=x, print_info=print_info, plot=plot) if plot: @@ -159,10 +179,7 @@ def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guidi #breakpoint() f_through_slit_H = igrins_slit.estimate_slit_throughput() #Get throughput for K band - json_file = open(k_band_filepath) - json_obj = json.load(json_file) - x = np.array(json_obj['profile_x']) * slit_length - y = np.array(json_obj['profile_y']) + x, y = getSlitProfile(file, band='K', slit_length=slit_length) #Get slit profile igrins_slit.clear() igrins_slit.ABBA(y, x=x, print_info=print_info, plot=plot) if plot: @@ -182,7 +199,6 @@ def getIGRINSSlitThroughputABBACoefficients(file, slit_length=14.8, PA=90, guidi print('K-band slit throughput:', f_through_slit_K) print('m: ', m) print('b: ', b) - return m, b @@ -211,6 +227,7 @@ def __init__( # self.ancillary_spectra = None self.noisy_edges = (450, 1950) self.instrumental_resolution = 45_000.0 + self.file = file #False if variance.fits file used for uncertainity, true if sn.fits file used for uncertainity @@ -349,7 +366,7 @@ def astropy_time(self): mjd = self.meta["header"]["MJD-OBS"] return Time(mjd, format="mjd", scale="utc") - def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): + def getSlitThroughput(self, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit. Parameters @@ -375,7 +392,7 @@ def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5 Returns array of fractional slit throughput as a function of wavelength """ - m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info, plot=plot) + m, b = getIGRINSSlitThroughputABBACoefficients(self.file, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info, plot=plot) return m*(1/self.wavelength.um) + b @@ -390,6 +407,7 @@ class IGRINSSpectrumList(EchelleSpectrumList): """ def __init__(self, *args, **kwargs): + self.file = None self.normalization_order_index = 14 super().__init__(*args, **kwargs) @@ -400,8 +418,11 @@ def read(file, precache_hdus=True, wavefile=None): Parameters ---------- file : (str) - A path to a reduced IGRINS spectrum from plp + A path to a reduced IGRINS spectrum from plp. wavefile : (str) + Path to a file storing a wavelength soultion for a night from the plp. + Wave files are found in the IGRINS PLP callib/primary/DATE/ directory with + the extension wvlsol_v1.fits. """ # still works @@ -440,8 +461,9 @@ def read(file, precache_hdus=True, wavefile=None): ) list_out.append(spec) specList = IGRINSSpectrumList(list_out) - return IGRINSSpectrumList(specList) - def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): + specList.file = file + return specList + def getSlitThroughput(self, slit_length=14.8, PA=90, guiding_error=1.5, print_info=True, plot=False): """Estimate the wavelength dependent fractional slit throughput for a point source nodded ABBA on the IGRINS slit. Parameters @@ -467,7 +489,7 @@ def getSlitThroughput(self, filepath, slit_length=14.8, PA=90, guiding_error=1.5 Returns list of arrays of fractional slit throughput as a function of wavelength """ - m, b = getIGRINSSlitThroughputABBACoefficients(filepath, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info, plot=plot) + m, b = getIGRINSSlitThroughputABBACoefficients(self.file, slit_length=slit_length, PA=PA, guiding_error=guiding_error, print_info=print_info, plot=plot) f_throughput = [] for i in range(len(self)): f_throughput.append(m*(1/self[i].wavelength.um) + b) From 61402998f606980b257e2b090ad1df6add4a5e75 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 24 Aug 2023 18:59:28 -0500 Subject: [PATCH 21/43] Fix IGRINS wavelengths. --- src/muler/igrins.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 9e3146b..4bc7636 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -282,7 +282,7 @@ def __init__( flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(float) * u.ct elif (("spec.fits" in file) or ("spec_flattened.fits" in file) or ('.spec2d.fits' in file)) and (wavefile is not None): lamb = ( - wave_hdus[0].data[order].astype(float) * 1e-3 * u.micron + wave_hdus[0].data[order].astype(float) * u.micron ) # Note .wave.fits and .wavesol_v1.fts files store their wavelenghts in nm so they need to be converted to microns flux = hdus[0].data[order].astype(float) * u.ct elif (("spec.fits" in file) or ("spec_flattened.fits" in file)) and (wavefile is None): From f88c080c4a65c7448acd652d436b3869256ed3ff Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Fri, 25 Aug 2023 18:33:15 -0500 Subject: [PATCH 22/43] Added trim_overlap() to EchelleSpectrumList. This is desgined to simply trim overlapping areas of different orders in a spectrum list so that they can easily be combined by stitch(). --- src/muler/echelle.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 85f577e..5e84e8f 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -821,6 +821,34 @@ def trim_edges(self, limits=None): return spec_out + def trim_overlap(self): + """Trim all the edges that overlap with adjacent spectra (e.g. orders) + in the list. Useful for running before stitch().""" + spec_out = copy.deepcopy(self) + n = len(spec_out) + + for i in range(n): #Loop through each spectrum/order in list + print('starting i ', i) + if i == 0: #Figure out where to trim the left side + left_limit = 0 + elif self[i].spectral_axis[0] > self[i-1].spectral_axis[-1]: + left_limit = 0 + else: + mid_wave = 0.5*(self[i].spectral_axis[0] + self[i-1].spectral_axis[-1]) + left_limit = np.where(self[i].spectral_axis > mid_wave)[-1][0] + 1 + if i == n-1: #Figure out where to trim the right side + right_limit = len(self[i].spectral_axis) + elif self[i].spectral_axis[-1] < self[i+1].spectral_axis[0]: + right_limit = len(self[i].spectral_axis) + else: + mid_wave = 0.5*(self[i].spectral_axis[-1] + self[i+1].spectral_axis[0]) + right_limit = np.where(self[i].spectral_axis > mid_wave)[0][0] - 1 + + if left_limit > 0 or right_limit < len(self[i].spectral_axis): + spec_out[i] = spec_out[i].trim_edges((left_limit, right_limit)) + + return spec_out + def deblaze(self, method="spline"): """Remove blaze function from all orders by interpolating a spline function From e7bba34e536008c6f96e9c40f703a139253d5f6a Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Fri, 25 Aug 2023 18:39:12 -0500 Subject: [PATCH 23/43] Refined range of columns to determine IGRINS slit profile FWHM for point sources. Should be more accurate now when using .spec2d.fits files instead of the estimates of the slit profiles from the pipeline, due to avoiding the sides of an order where the focus isn't as good. --- src/muler/igrins.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 4bc7636..959beb2 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -119,9 +119,9 @@ def getSlitProfile(filepath, band, slit_length): json_filepath = path_base + '.slit_profile.json' if os.path.exists(filepath): #First try to use the 2D spectrum in a .spec2d.fits file to estimate the slit proflie spec2d = fits.getdata(spec2d_filepath) - long_spec2d = spec2d[0,:,800:1200] #Chop off order edges at columns 800 and 1200 - for i in range(1, len(spec2d)): - long_spec2d = np.concatenate([long_spec2d, spec2d[i,:,800:1200]], axis=1) + long_spec2d = spec2d[2,:,1000:1300] #Chop off order edges at columns 800 and 1200 + for i in range(3, len(spec2d)-2): + long_spec2d = np.concatenate([long_spec2d, spec2d[i,:,1000:1300]], axis=1) y = np.nanmedian(long_spec2d, axis=1) x = np.arange(len(y)) * (slit_length / len(y)) elif os.path.exists(json_filepath): #If no 2D spectrum exists, try using the PLP estimate in .slit_profile.json From 8e1f2d993b590745e26619f13ebbc33ccf4ddb80 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 28 Aug 2023 14:16:48 -0500 Subject: [PATCH 24/43] Add tynt and dust_extinction dependencies to the environment files. --- environment.yml | 3 +++ environment_M1.yml | 2 ++ 2 files changed, 5 insertions(+) diff --git a/environment.yml b/environment.yml index ecfb4b4..15a34fc 100644 --- a/environment.yml +++ b/environment.yml @@ -30,8 +30,11 @@ dependencies: - coverage - coveralls - twine + - dust_extinction - pip - pip: - sphinx-material - celerite2 - specutils==1.9.1 + - tynt + diff --git a/environment_M1.yml b/environment_M1.yml index 36df598..d15c9ec 100644 --- a/environment_M1.yml +++ b/environment_M1.yml @@ -30,7 +30,9 @@ dependencies: - coverage - coveralls - twine + - dust_extinction - pip - pip: - sphinx-material - celerite2 + - tynt From 3b6651d84edf7f284d9c128dd28fac119ccc0dc7 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 7 Sep 2023 15:40:48 -0500 Subject: [PATCH 25/43] More additions and fixes for flux calibration. More convenience functions. --- src/muler/echelle.py | 140 +++++++++++++++++++++++++++++++++++++++-- src/muler/igrins.py | 48 +++++++++++++- src/muler/utilities.py | 104 ++++++++++++++++++++++++++++-- 3 files changed, 281 insertions(+), 11 deletions(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 5e84e8f..92a6b02 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -26,9 +26,11 @@ from scipy.signal import savgol_filter from astropy.constants import R_jup, R_sun, G, M_jup, R_earth, c from astropy.modeling.physical_models import BlackBody +from scipy.ndimage import median_filter, gaussian_filter1d import specutils from muler.utilities import apply_numpy_mask, is_list, resample_list + # from barycorrpy import get_BC_vel from astropy.coordinates import SkyCoord, EarthLocation from astropy.time import Time @@ -39,6 +41,9 @@ import os import copy +from specutils.manipulation import LinearInterpolatedResampler + + from specutils.spectra.spectral_region import SpectralRegion from specutils.analysis import equivalent_width @@ -741,6 +746,97 @@ def get_slit_profile(self, lower=None, upper=None, slit_length=1.0): return median_slit_profile + def resample(self, target_spectrum): + """Resample spectrum onto a new spectral_axis. + Copied from gollum. + + Parameters + ---------- + target_spectrum : Spectrum1D + Spectrum whose wavelength grid you seek to match + + Returns + ------- + resampled_spec : PrecomputedSpectrum + Resampled spectrum + """ + output = LinearInterpolatedResampler()(self, target_spectrum.wavelength) + + return self._copy( + spectral_axis=output.wavelength.value * output.wavelength.unit, + flux=output.flux, uncertainty=output.uncertainty, meta=self.meta, + wcs=None, + ) + + def instrumental_broaden(self, resolving_power=55000): + r"""Instrumentally broaden the spectrum for a given instrumental resolution + Copied verbatim from gollum. + + Known limitation: If the wavelength sampling changes with wavelength, + the convolution becomes inaccurate. It may be better to FFT, + following Starfish. + + Parameters + ---------- + resolving_power : int + Instrumental resolving power :math:`R = \frac{\lambda}{\delta \lambda}` + + Returns + ------- + broadened_spec : PrecomputedSpectrum + Instrumentally broadened spectrum + """ + # In detail the spectral resolution is wavelength dependent... + # For now we assume a constant resolving power + angstroms_per_pixel = np.median(np.diff(self.wavelength.angstrom)) + lam0 = np.median(self.wavelength.value) + delta_lam = lam0 / resolving_power + + scale_factor = 2.355 + sigma = delta_lam / scale_factor / angstroms_per_pixel + + convolved_flux = gaussian_filter1d(self.flux.value, sigma) * self.flux.unit + return self._copy(flux=convolved_flux) + def fill_nans(self, method=median_filter, **kwargs): + """Fill nans with the median of surrounding pixels using + scipy.ndimage.median_filter + + Parameters + ---------- + method: def + def to apply to smooth surrounding pixels (e.g. scipy.ndimage.median_filter) + **kwargs: + Gets passed to method (e.g. size for scipy.ndimage.median_filter) + """ + flux = self.flux + unc = self.uncertainty.array + filtered_flux = Quantity(method(flux.value, **kwargs), unit=self.flux.unit) + filtered_variance = method(unc**2, **kwargs) + filtered_unc = (filtered_variance**0.5) + found_nans = np.isnan(flux.value) + flux[found_nans] = filtered_flux[found_nans] + unc[found_nans] = filtered_unc[found_nans] + + return self.__class__( + spectral_axis=self.spectral_axis, flux=flux, uncertainty=StdDevUncertainty(unc), meta=self.meta, wcs=None) + def apply(self, method=np.nansum, **kwargs): + """ + Apply any method to the spectrum. This is very general and can be used for many + things. Uncertainity is propogated. + + Parameters + ---------- + method: def + def to apply to spectrum (e.g. np.nansum to collapse a multidimensional spectrum) + **kwargs: + Gets passed to method (e.g. axis for np.nansum) + """ + flux = self.flux + unc = self.uncertainty.array + flux = Quantity(method(self.flux.value, **kwargs), unit=self.flux.unit) + unc = method(self.uncertainty.array**2, **kwargs)**0.5 + return self.__class__( + spectral_axis=self.spectral_axis, flux=flux, uncertainty=StdDevUncertainty(unc), meta=self.meta, wcs=None) def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. @@ -821,27 +917,27 @@ def trim_edges(self, limits=None): return spec_out - def trim_overlap(self): + def trim_overlap(self, pivot=0.5): """Trim all the edges that overlap with adjacent spectra (e.g. orders) in the list. Useful for running before stitch().""" spec_out = copy.deepcopy(self) n = len(spec_out) for i in range(n): #Loop through each spectrum/order in list - print('starting i ', i) + #print('starting i ', i) if i == 0: #Figure out where to trim the left side left_limit = 0 elif self[i].spectral_axis[0] > self[i-1].spectral_axis[-1]: left_limit = 0 else: - mid_wave = 0.5*(self[i].spectral_axis[0] + self[i-1].spectral_axis[-1]) + mid_wave = self[i].spectral_axis[0]*(1-pivot) + self[i-1].spectral_axis[-1]*(pivot) left_limit = np.where(self[i].spectral_axis > mid_wave)[-1][0] + 1 if i == n-1: #Figure out where to trim the right side right_limit = len(self[i].spectral_axis) elif self[i].spectral_axis[-1] < self[i+1].spectral_axis[0]: right_limit = len(self[i].spectral_axis) else: - mid_wave = 0.5*(self[i].spectral_axis[-1] + self[i+1].spectral_axis[0]) + mid_wave = self[i].spectral_axis[-1]*(pivot) + self[i+1].spectral_axis[0]*(1-pivot) right_limit = np.where(self[i].spectral_axis > mid_wave)[0][0] - 1 if left_limit > 0 or right_limit < len(self[i].spectral_axis): @@ -1058,3 +1154,39 @@ def flatten(self, **kwargs): spec_out[i].meta["x_values"] = self[i].meta["x_values"] return spec_out + def fill_nans(self, method=median_filter, **kwargs): + """Fill nans with the median of surrounding pixels using + scipy.ndimage.median_filter + + Parameters + ---------- + method: def + def to apply to smooth surrounding pixels (e.g. scipy.ndimage.median_filter) + **kwargs: + Gets passed to method (e.g. size for scipy.ndimage.median_filter) + """ + spec_out = copy.deepcopy(self) + for i in range(len(self)): + spec_out[i] = self[i].fill_nans(method=method, **kwargs) + if "x_values" not in spec_out[i].meta: + spec_out[i].meta["x_values"] = self[i].meta["x_values"] + return spec_out + + def apply(self, method=np.nansum, **kwargs): + """ + Apply any method to the spectral list. This is very general and can be used for many + things. Uncertainity is propogated. + + Parameters + ---------- + method: def + def to apply to spectrum (e.g. np.nansum to collapse a multidimensional spectrum) + **kwargs: + Gets passed to method (e.g. axis for np.nansum) + """ + spec_out = copy.deepcopy(self) + for i in range(len(self)): + spec_out[i] = self[i].apply(method=method, **kwargs) + if "x_values" not in spec_out[i].meta: + spec_out[i].meta["x_values"] = self[i].meta["x_values"] + return spec_out \ No newline at end of file diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 959beb2..08c3b12 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -12,7 +12,7 @@ import warnings import json from muler.echelle import EchelleSpectrum, EchelleSpectrumList -from muler.utilities import Slit +from muler.utilities import Slit, concatenate_orders from astropy.time import Time import numpy as np import astropy @@ -43,6 +43,52 @@ grating_order_offsets = {"H": 98, "K": 71} +def readPLP(plppath, date, frameno, waveframeno, dim='1D'): + """Convience function for easily reading in the full IGRINS Spectrum (both H and K bands) + from the IGRINS PLP output + + Parameters + ---------- + plppath: string + Path to the IGRINS PLP (e.g. "/Users/Username/Desktop/plp/") + date: int or string + Date for night of IGIRNS observation in format of YYYYMMDD (e.g. "201401023") + frameno: int or string + Number of frame denoting target as specified as the first frame in the + recipes file for the night (e.g. 54 or "0054") + waveframeno: int or string + Number of frame denoting target as specified as the first frame in the + recipes file for the wavelength solution (e.g. 54 or "0054") from a wvlsol_v1 file. + This is usually the first frame number for the sky. + dim: string + Set to "1D" to read in the 1D extracted spectrum from the .spec.fits files + or "2D" to read in the rectified 2D spectrum from the .spec2d.fits files + + Returns + ------- + IGRINSSpectrumList containing all the orders for the H and K bands for the specified target + """ + if type(date) is not str: #Converhet dates and frame numbers to the proper string format + date = '%.8d' % int(date) + if type(frameno) is not str: + frameno = '%.4d' % int(frameno) + if type(waveframeno) is not str: + waveframeno = '%.4d' % int(waveframeno) + if dim.upper() == '1D': #Use proper filename for 1D or 2D extractions + suffix = '.spec.fits' + elif dim.upper() == '2D': + suffix = '.spec2d.fits' + else: + raise Exception( + "Argument 'dim' must be '1D' for .spec.fits files or '2D' for .spec2d.fits files." + ) + spec_H = IGRINSSpectrumList.read(plppath+'outdata/'+date +'/'+'SDCH_'+date+'_'+frameno+suffix, #Read in H band + wavefile=plppath+'calib/primary/'+date +'/SKY_SDCH_'+date+'_'+waveframeno+'.wvlsol_v1.fits') + spec_K = IGRINSSpectrumList.read(plppath+'outdata/'+date +'/'+'SDCK_'+date+'_'+frameno+suffix, #Read in K band + wavefile=plppath+'calib/primary/'+date +'/SKY_SDCK_'+date+'_'+waveframeno+'.wvlsol_v1.fits') + spec_all = concatenate_orders(spec_H, spec_K) #Combine H and K bands + return spec_all + def getUncertainityFilepath(filepath): """Returns path for uncertainity file (.variance.fits or .sn.fits) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index 5f24d3c..9c206ec 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -5,10 +5,13 @@ from specutils.spectra import Spectrum1D from astropy.nddata.nduncertainty import StdDevUncertainty from astropy.modeling import models, fitting #import the astropy model fitting package +from astropy import units as u from scipy.stats import binned_statistic +from scipy.interpolate import interp1d from specutils.manipulation import LinearInterpolatedResampler from matplotlib import pyplot as plt LinInterpResampler = LinearInterpolatedResampler() +from tynt import FilterGenerator log = logging.getLogger(__name__) @@ -323,11 +326,7 @@ def is_list(check_this): True: Object has more than one element (e.g. is a list or array) False: Object has a single element (e.g. a single variable like 10.0) """ - if np.size(check_this) > 1: - return True - else: - return False - + return isinstance(check_this, list) class Slit: def __init__(self, length=14.8, width=1.0, PA=90.0, guiding_error=1.5, n_axis=5000): @@ -469,4 +468,97 @@ def plot2d(self, **kwarg): # plt.plot(slit_ouline_x, slit_ouline_y, color='White', linewidth=3.0) numerical_mask = np.ones(np.shape(self.mask)) plt.contour(self.mask, levels=[0.0,0.5, 1.0], colors='white', linewidths=2) - plt.show() \ No newline at end of file + plt.show() + + +class absoluteFluxCalibration: + def __init__(self, std_spec, synth_spec): + """ + A class to handle absolute flux calibration using a standard star spectrum and synthetic spectrum of the + standard star. + + Parameters + ---------- + std_spec: EchelleSpectrum, EchelleSpectrumList, Spectrum1D, or SpectrumList like object + Actual spectrum of the standard star + synth_spec: Spectrum1D, or SpectrumList like object from gollum + Synethic spectrum of the standard star from a stellar atmosphere model read in with gollum, or something similar + """ + self.std_spec = std_spec + self.synth_spec = synth_spec + + +class photometry: + def __init__(self): + f = FilterGenerator() + johnson_bands = np.array(['U', 'B','V','R','I']) #2MASS + twoMass_bands = np.array(['J', 'H', 'Ks']) #Johnson filters + self.bands = np.concatenate((johnson_bands, twoMass_bands)) + self.f0_lambda = np.array([3.96526e-9*1e4, 6.13268e-9*1e4, 3.62708e-9*1e4, 2.17037e-9*1e4, 1.12588e-9*1e4, #Source: http://svo2.cab.inta-csic.es/theory/fps3/index.php?mode=browse&gname=Generic&gname2=Bessell&asttype=, with units converted from erg cm^-2 s^-1 ang^-1 to erg cm^-2 s^-1 um^-1 by multiplying by 1e-4 + 3.129e-13*1e7, 1.133e-13*1e7, 4.283e-14*1e7]) #2MASS: Convert units to from W cm^-2 um^-1 to erg s^-1 cm^-2 um^-1 + self.x = np.arange(0.0, 10.0, 1e-6) + self.delta_lambda = np.abs(self.x[1]-self.x[0]) + n = len(self.bands) + tcurve_interp = [] + tcurve_resampled = [] + for i in range(n): + if self.bands[i] in twoMass_bands: + filt = f.reconstruct('2MASS/2MASS.'+self.bands[i]) + elif self.bands[i] in johnson_bands: + filt = f.reconstruct('Generic/Johnson.'+self.bands[i]) + interp_obj = interp1d(filt.wavelength.to('um'), filt.transmittance, kind='cubic', fill_value=0.0, bounds_error=False) + tcurve_interp.append(interp_obj) + tcurve_resampled.append(interp_obj(self.x)) + self.tcurve_interp = tcurve_interp + self.tcurve_resampled = tcurve_resampled + + # if band == 'K': + # band = 'Ks' #Catch to set K band band name to 'Ks' + # twoMass_bands = np.array(['J', 'H', 'Ks']) + # johnson_bands = np.array(['U', 'B','V','R','I']) + # if band in twoMass_bands: #2MASS NIR filters + # f0_lambda = (np.array([3.129e-13, 1.133e-13, 4.283e-14]) * 1e7) [band == twoMass_bands][0] #Convert units to from W cm^-2 um^-1 to erg s^-1 cm^-2 um^-1 + # filt = f.reconstruct('2MASS/2MASS.'+band) + # elif band in johnson_bands: #Johnson filters + # f0_lambda = (np.array([417.5e-11, 632e-11, 363.1e-11, 217.7e-11, 112.6e-11]) * 1e4 )[band == johnson_bands][0] #Source: Table A2 from Bessel (1998), with units converted from erg cm^-2 s^-1 ang^-1 to erg cm^-2 s^-1 um^-1 by multiplying by 1e-4 + # filt = f.reconstruct('Generic/Johnson.'+band) + # else: + # raise Exception( + # "Band"+band+" not recognized. Must be U, B, V, R, I, J, H, or Ks." + # ) + #self.f0_lambda = f0_lambda + + # self.tcurve_interp = interp1d(filt.wavelength.to('um'), filt.transmittance, kind='cubic', fill_value=0.0, bounds_error=False) #Create interp obj for the transmission curve + # self.tcurve_resampled = self.tcurve_interp(self.x) + #self.vega_V_flambdla_zero_point = 363.1e-7 #Vega flux zero point for V band from Bessell et al. (1998) in erg cm^2 s^-1 um^-1 + def scale(self, synth_spec, band='V', mag=0.0): + i = self.grab_band_index(band) + resampled_synthetic_spectrum = LinInterpResampler(synth_spec , self.x*u.um).flux.value + f_lambda = np.nansum(resampled_synthetic_spectrum * self.tcurve_resampled[i] * self.x * self.delta_lambda) / np.nansum(self.tcurve_resampled[i] * self.x * self.delta_lambda) + magnitude_scale = 10**(0.4*(-mag)) + # print('self.f0_lambda', self.f0_lambda[i]) + # print('f_lambda', f_lambda) + # print('magnitude_scale', magnitude_scale) + return synth_spec * (self.f0_lambda[i] / f_lambda) * magnitude_scale + def get(self, synth_spec, band='V', resample=True): + i = self.grab_band_index(band) + if resample: + resampled_synthetic_spectrum = LinInterpResampler(synth_spec , self.x*u.um).flux.value + f_lambda = np.nansum(resampled_synthetic_spectrum * self.tcurve_resampled[i] * self.x * self.delta_lambda) / np.nansum(self.tcurve_resampled[i] * self.x * self.delta_lambda) + else: + x = synth_spec.wavelength.to('um').value + delta_lambda = np.concatenate([[x[1]-x[0]], x[1:] - x[:-1]]) + interp_obj = interp1d(self.x, self.tcurve_resampled[i], kind='linear', fill_value=0.0, bounds_error=False) + resampled_tcurve = interp_obj(x) + goodpix = (synth_spec.flux.value > 1e-20) & (synth_spec.flux.value < 1e10) + f_lambda = np.nansum(synth_spec.flux.value[goodpix] * resampled_tcurve[goodpix] * x[goodpix] * delta_lambda[goodpix]) / np.nansum(resampled_tcurve[goodpix] * x[goodpix] * delta_lambda[goodpix]) + print(np.sum(np.isfinite(synth_spec.flux.value))) + #print(np.nansum(synth_spec.flux.value * resampled_tcurve * x * delta_lambda)) + print(np.nansum(resampled_tcurve * x * delta_lambda)) + magnitude = -2.5 * np.log10(f_lambda / self.f0_lambda[i]) + return magnitude + def grab_band_index(self, band): + if band == 'K': + band = 'Ks' #Catch to set K band band name to 'Ks' + i = np.where(band == self.bands)[0][0] + return i From c35905dec4ac541bf8d7941d74945fe0c5fa493b Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 7 Sep 2023 16:16:49 -0500 Subject: [PATCH 26/43] Try changing how tynt is installed. --- environment.yml | 2 +- environment_M1.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/environment.yml b/environment.yml index 15a34fc..c994b43 100644 --- a/environment.yml +++ b/environment.yml @@ -31,10 +31,10 @@ dependencies: - coveralls - twine - dust_extinction + - tynt - pip - pip: - sphinx-material - celerite2 - specutils==1.9.1 - - tynt diff --git a/environment_M1.yml b/environment_M1.yml index d15c9ec..ff9e9ed 100644 --- a/environment_M1.yml +++ b/environment_M1.yml @@ -31,8 +31,8 @@ dependencies: - coveralls - twine - dust_extinction + - tynt - pip - pip: - sphinx-material - celerite2 - - tynt From f8513529b58cad860961c2048be4fec45f385e73 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 7 Sep 2023 16:21:46 -0500 Subject: [PATCH 27/43] Put tynt back under plp. Not sure why it isn't installing correctly for the tests. --- environment.yml | 2 +- environment_M1.yml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/environment.yml b/environment.yml index c994b43..15a34fc 100644 --- a/environment.yml +++ b/environment.yml @@ -31,10 +31,10 @@ dependencies: - coveralls - twine - dust_extinction - - tynt - pip - pip: - sphinx-material - celerite2 - specutils==1.9.1 + - tynt diff --git a/environment_M1.yml b/environment_M1.yml index ff9e9ed..d15c9ec 100644 --- a/environment_M1.yml +++ b/environment_M1.yml @@ -31,8 +31,8 @@ dependencies: - coveralls - twine - dust_extinction - - tynt - pip - pip: - sphinx-material - celerite2 + - tynt From 499ed25f31e5620cb3e36ce534b97bb1836a07ba Mon Sep 17 00:00:00 2001 From: gully Date: Thu, 7 Sep 2023 17:11:55 -0500 Subject: [PATCH 28/43] add tynt to actions to get it to work... --- docs/requirements_actions.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/requirements_actions.txt b/docs/requirements_actions.txt index b06dca0..88b748b 100644 --- a/docs/requirements_actions.txt +++ b/docs/requirements_actions.txt @@ -16,3 +16,4 @@ bokeh # needed for gollum to install on RTD gollum==0.2.1 numpydoc sphinx-gallery +tynt From 30fa0969729cbe1ac537aaa77703d2a1d1b68633 Mon Sep 17 00:00:00 2001 From: gully Date: Thu, 7 Sep 2023 17:12:56 -0500 Subject: [PATCH 29/43] turn off numpy build matrix in GitHub actions-- it wasnt doing anything anyways --- .github/workflows/muler-tests.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/muler-tests.yml b/.github/workflows/muler-tests.yml index 342802f..4a830a6 100644 --- a/.github/workflows/muler-tests.yml +++ b/.github/workflows/muler-tests.yml @@ -11,8 +11,8 @@ jobs: python-version: [3.9] specutils-version: [1.5, 1.9.1] astropy-version: [5.2] - numpy-version: [1.18, 1.24] - + #numpy-version: [1.18, 1.24] + steps: - uses: actions/checkout@v2 - uses: actions/checkout@v2 From 9419d579ba271f124b08879dc8bef0705c4c6637 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Fri, 22 Sep 2023 23:46:14 -0500 Subject: [PATCH 30/43] Added method for HPF spectra to allow resampling of the sky fiber spectrum to the sci fiber wavelength solution. This produced better sky subtractions. --- src/muler/hpf.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/src/muler/hpf.py b/src/muler/hpf.py index fd4160b..9e114bc 100644 --- a/src/muler/hpf.py +++ b/src/muler/hpf.py @@ -304,6 +304,20 @@ def deblaze(self, method="template"): log.error("This method is deprecated! Please use the new deblaze method") raise NotImplementedError + def sky_resample(self): + """ + Resample's sky spectrum from the sky fiber to match the spectrum from the science fiber + + Returns + ------- + Spectrum with sky fiber spectrum resampled to match the wavelength solution of the science fiber + + """ + spec = copy.deepcopy(self) + spec.meta["sky"] = spec.sky.resample(spec) + #spec.sky = spec.sky.resample(spec) + return spec + def sky_subtract(self, method="scalar"): """Subtract sky spectrum from science spectrum, with refinements for sky throughput @@ -434,6 +448,22 @@ def deblaze(self): return spec_out + def sky_resample(self): + """ + Resample's sky spectrum from the sky fiber to match the spectrum from the science fiber + + Returns + ------- + Spectrum with sky fiber spectrum resampled to match the wavelength solution of the science fiber + + """ + spec_out = copy.copy(self) + for i in range(len(spec_out)): + spec_out[i] = spec_out[i].sky_resample() + + return spec_out + + def sky_subtract(self, method="vector"): """Sky subtract the entire spectrum""" spec_out = copy.copy(self) From b3b1581ec6ac2da4c69ba08476a61f92d1bb47a4 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Sat, 23 Sep 2023 00:59:56 -0500 Subject: [PATCH 31/43] Allow user to scale HPF sky subtraction when using the scalar method. --- src/muler/hpf.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/src/muler/hpf.py b/src/muler/hpf.py index 9e114bc..71f52d3 100644 --- a/src/muler/hpf.py +++ b/src/muler/hpf.py @@ -318,7 +318,7 @@ def sky_resample(self): #spec.sky = spec.sky.resample(spec) return spec - def sky_subtract(self, method="scalar"): + def sky_subtract(self, method="scalar", scale=0.93): """Subtract sky spectrum from science spectrum, with refinements for sky throughput Note: This operation does not wavelength shift or scale the sky spectrum @@ -329,6 +329,9 @@ def sky_subtract(self, method="scalar"): The method for sky subtraction: "naive", "scalar", or "vector", as described in Gully-Santiago et al. in prep. Default is scalar. + scale : (float) + When using the "scalar" method, sets the scale. Default is 0.93. + Returns ------- sky_subtractedSpec : (HPFSpectrum) @@ -341,7 +344,7 @@ def sky_subtract(self, method="scalar"): ) beta = 1.0 * u.dimensionless_unscaled elif method == "scalar": - beta = 0.93 * u.dimensionless_unscaled + beta = scale * u.dimensionless_unscaled elif method == "vector": beta_native_spectrum = spec.get_static_sky_ratio_template() resampler = LinearInterpolatedResampler(extrapolation_treatment="zero_fill") @@ -464,11 +467,11 @@ def sky_resample(self): return spec_out - def sky_subtract(self, method="vector"): + def sky_subtract(self, method="vector", scale=0.93): """Sky subtract the entire spectrum""" spec_out = copy.copy(self) for i in range(len(spec_out)): - spec_out[i] = spec_out[i].sky_subtract(method=method) + spec_out[i] = spec_out[i].sky_subtract(method=method, scale=scale) return spec_out From 4499827955d6c21b9ba53dfd9c4224fb103b8042 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Sat, 23 Sep 2023 01:08:08 -0500 Subject: [PATCH 32/43] Build the sky resampling right into the sky subtraction so nobody ever forgets to do it. The sky fiber should always be interpolated onto the science fiber's wavelength solution before sky subtraction, according to the HPF folks. --- src/muler/hpf.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/muler/hpf.py b/src/muler/hpf.py index 71f52d3..e54cf66 100644 --- a/src/muler/hpf.py +++ b/src/muler/hpf.py @@ -354,7 +354,7 @@ def sky_subtract(self, method="scalar", scale=0.93): raise NotImplementedError # These steps should propagate uncertainty? - sky_estimator = spec.sky.multiply(beta, handle_meta="first_found") + sky_estimator = spec.sky_resample().sky.multiply(beta, handle_meta="first_found") return spec.subtract(sky_estimator, handle_meta="first_found") def mask_tellurics(self, method="TelFit", threshold=0.999, dilation=5): From d49f9c4b0a6a2748bd6a143dc1724409d3aab838 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Fri, 12 Jan 2024 12:59:09 -0600 Subject: [PATCH 33/43] Fix compatibility issue between old and new versions of the IGRINS PLP for spec_a0v.fits files. --- src/muler/hpf.py | 24 ++++++++++++++++++++++++ src/muler/igrins.py | 9 ++++++--- 2 files changed, 30 insertions(+), 3 deletions(-) diff --git a/src/muler/hpf.py b/src/muler/hpf.py index e54cf66..05cb951 100644 --- a/src/muler/hpf.py +++ b/src/muler/hpf.py @@ -12,12 +12,14 @@ import warnings import logging from muler.echelle import EchelleSpectrum, EchelleSpectrumList +from muler.utilities import resample_list import numpy as np import astropy from astropy.io import fits from astropy import units as u from astropy.wcs import WCS, FITSFixedWarning from astropy.nddata import StdDevUncertainty +from scipy.ndimage import median_filter from scipy.interpolate import InterpolatedUnivariateSpline from astropy.constants import R_jup, R_sun, G, M_jup, R_earth, c from astropy.time import Time @@ -28,6 +30,7 @@ from . import templates import pandas as pd + log = logging.getLogger(__name__) for category in [ @@ -349,6 +352,9 @@ def sky_subtract(self, method="scalar", scale=0.93): beta_native_spectrum = spec.get_static_sky_ratio_template() resampler = LinearInterpolatedResampler(extrapolation_treatment="zero_fill") beta = resampler(beta_native_spectrum, spec.spectral_axis) + # elif method == 'median': #Attempt to measure the scale of the sky lines between the fibers using a median of the pixels + # resampled_sky = spec.sky.resample(spec) + # good_sci_pixels = self.flux.value - else: log.error("Method must be one of 'naive', 'scalar' or 'vector'. ") raise NotImplementedError @@ -475,6 +481,24 @@ def sky_subtract(self, method="vector", scale=0.93): return spec_out + def test_print_sky_scale(self): + #reampled_sky = resample_list(self.sky, self) #Resample sky to match sci wavelengths + all_sky = np.zeros([2048, len(self)]) #Put all science and sky fiber flux into 2D arrays for easy manipulation + all_sci = np.zeros([2048, len(self)]) + for i in range(len(self)): + all_sky[:, i] = (self[i].sky).resample(self[i]).flux.value + all_sci[:, i] = self[i].flux.value + all_sky -= median_filter(all_sky, [25, 1]) #Subtract continuum/background using a running median filter + all_sci -= median_filter(all_sci, [25, 1]) + #all_sky[all_sky ] + max_sky_flux = np.nanmax(all_sky) + bad_pix = (all_sky < 0.1 * max_sky_flux) & (all_sci < 0.1 * max_sky_flux) + all_sky[bad_pix] = np.nan + all_sci[bad_pix] = np.nan + print(np.nanmedian(all_sci / all_sky)) + + + # def sky_subtract(self): # """Sky subtract all orders # """ diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 08c3b12..3bd741e 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -494,11 +494,14 @@ def read(file, precache_hdus=True, wavefile=None): wave_hdus = fits.open(full_path, memmap=False) cached_hdus.append(wave_hdus) - hdus0_shape = hdus[0].data.shape + if hdus[0].data is not None: + hdus0_shape = hdus[0].data.shape #Normally we read from the 0th extension + else: + hdus0_shape = hdus[1].data.shape #To insure compatibility with new version of the PLP for spec_a0v.fits files if len(hdus0_shape) == 2: #1D spectrum - n_orders, n_pix = hdus[0].data.shape + n_orders, n_pix = hdus0_shape elif len(hdus0_shape) == 3: #2D spectrum - n_orders, n_height, n_pix = hdus[0].data.shape + n_orders, n_height, n_pix = hdus0_shape list_out = [] for i in range(n_orders - 1, -1, -1): From 979270e18668fedc15fedbe84150cf4a090976ea Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 5 Feb 2024 19:46:41 -0600 Subject: [PATCH 34/43] Fix resample_combine_spectra. --- src/muler/utilities.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/muler/utilities.py b/src/muler/utilities.py index 9c206ec..c548038 100644 --- a/src/muler/utilities.py +++ b/src/muler/utilities.py @@ -62,8 +62,8 @@ def resample_combine_spectra(input_spec, spec_to_match, weights=1.0): resampled_spec = resample_list(input_spec, spec_to_match) #Resample spectrum else: resampled_spec = LinInterpResampler(input_spec, spec_to_match.spectral_axis) - resampled_spec = spec_to_match.__class__( #Ensure resampled_spec is the same object as spec_to_match - spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=resampled_spec.meta, wcs=None) + resampled_spec = spec_to_match.__class__( #Ensure resampled_spec is the same object as spec_to_match + spectral_axis=resampled_spec.spectral_axis, flux=resampled_spec.flux, meta=resampled_spec.meta, wcs=None) if is_list(spec_to_match): #Propogate nans from spec_to_match to avoid wierd errors for i in range(len(spec_to_match)): From b189208e968fea1df1f4435e8566d8c3b614a6a2 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 26 Feb 2024 11:55:21 -0600 Subject: [PATCH 35/43] Update muler to read variance from .spec_a0v.fits files for outputs from the new IGRINS PLP. It is still compatible with the old version as well. --- src/muler/igrins.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 3bd741e..b4b31dc 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -323,6 +323,11 @@ def __init__( ) lamb = hdus["WAVELENGTH"].data[order].astype(np.float64) * u.micron flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(np.float64) * u.ct + try: + uncertainity_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] + sn_used = false + except: + print("Warning: Using older PLP versions of .spec_a0v.fits files which have no variance saved. Will grab .variance.fits file.") elif ".spec_a0v.fits" in file: lamb = hdus["WAVELENGTH"].data[order].astype(float) * u.micron flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(float) * u.ct @@ -350,7 +355,7 @@ def __init__( if not sn_used: #If .variance.fits used variance = uncertainity_hdus[0].data[order].astype(np.float64) stddev = np.sqrt(variance) - if ("rtell" in file) or ("spec_a0v" in file): #If using a rtell or spec_a0v file with a variance file, scale the stddev to preserve signal-to-noise + if ("rtell" in file): #If using a rtell or spec_a0v file with a variance file, scale the stddev to preserve signal-to-noise unprocessed_flux = hdus["TGT_SPEC"].data[order].astype(np.float64) stddev *= (flux.value / unprocessed_flux) else: #Else if .sn.fits (or SNR HDU in rtell file) used From 346a8da1486d21287b1bc3eacd285ff708b469f3 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 26 Feb 2024 12:19:05 -0600 Subject: [PATCH 36/43] Revert to previous commit. --- src/muler/igrins.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index b4b31dc..6c503ed 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -294,6 +294,8 @@ def __init__( if "rtell" in file: sn = hdus["SNR"].data[order] uncertainity_hdus = None + elif "spec_a0v" in file: + uncertainity_hdus = hdus["SPEC_DIVIDE_A0V_VARIANCE"] else: uncertainity_hdus = cached_hdus[1] if wavefile is not None: @@ -359,6 +361,8 @@ def __init__( unprocessed_flux = hdus["TGT_SPEC"].data[order].astype(np.float64) stddev *= (flux.value / unprocessed_flux) else: #Else if .sn.fits (or SNR HDU in rtell file) used + if "spec_a0v" in file: + sn = uncertainity_hdus[0].data[order].astype(np.float64)**0.5 / flux.value if not "rtell" in file: sn = uncertainity_hdus[0].data[order].astype(np.float64) dw = np.gradient(lamb) #Divide out stuff the IGRINS PLP did to calculate the uncertainity per resolution element to get the uncertainity per pixel @@ -481,7 +485,7 @@ def read(file, precache_hdus=True, wavefile=None): sn_used = False #Default hdus = fits.open(file, memmap=False) - if "rtell" not in file: #Default, if no rtell file is used + if "rtell" not in file and "spec_a0v" not in file: #Default, if no rtell file is used uncertainty_filepath = getUncertainityFilepath(file) uncertainity_hdus = fits.open(uncertainty_filepath, memmap=False) cached_hdus = [hdus, uncertainity_hdus] From b19a0c549c61d1c1306311450252116644b7dc2d Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Mon, 26 Feb 2024 12:19:12 -0600 Subject: [PATCH 37/43] : :q This reverts commit 346a8da1486d21287b1bc3eacd285ff708b469f3. --- src/muler/igrins.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 6c503ed..b4b31dc 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -294,8 +294,6 @@ def __init__( if "rtell" in file: sn = hdus["SNR"].data[order] uncertainity_hdus = None - elif "spec_a0v" in file: - uncertainity_hdus = hdus["SPEC_DIVIDE_A0V_VARIANCE"] else: uncertainity_hdus = cached_hdus[1] if wavefile is not None: @@ -361,8 +359,6 @@ def __init__( unprocessed_flux = hdus["TGT_SPEC"].data[order].astype(np.float64) stddev *= (flux.value / unprocessed_flux) else: #Else if .sn.fits (or SNR HDU in rtell file) used - if "spec_a0v" in file: - sn = uncertainity_hdus[0].data[order].astype(np.float64)**0.5 / flux.value if not "rtell" in file: sn = uncertainity_hdus[0].data[order].astype(np.float64) dw = np.gradient(lamb) #Divide out stuff the IGRINS PLP did to calculate the uncertainity per resolution element to get the uncertainity per pixel @@ -485,7 +481,7 @@ def read(file, precache_hdus=True, wavefile=None): sn_used = False #Default hdus = fits.open(file, memmap=False) - if "rtell" not in file and "spec_a0v" not in file: #Default, if no rtell file is used + if "rtell" not in file: #Default, if no rtell file is used uncertainty_filepath = getUncertainityFilepath(file) uncertainity_hdus = fits.open(uncertainty_filepath, memmap=False) cached_hdus = [hdus, uncertainity_hdus] From 18a05f58ea8c35e6af28259a2cbcff5e94df3718 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 7 Mar 2024 16:27:55 -0600 Subject: [PATCH 38/43] Add compatibility with plp v3 spec_a0v.fits files. --- src/muler/igrins.py | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index b4b31dc..2433c7d 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -307,12 +307,12 @@ def __init__( base_path = os.path.dirname(file) full_path = base_path + '/' + os.path.basename(wavefile) wave_hdus = fits.open(full_path) - if "rtell" not in file: + if "rtell" not in file and "spec_a0v" not in file: uncertainty_filepath = getUncertainityFilepath(file) uncertainity_hdus = fits.open(uncertainty_filepath, memmap=False) if '.sn.fits' in uncertainty_filepath: sn_used = True - else: #If rtell file is used, grab SNR stored in extension + elif "rtell" in file: #If rtell file is used, grab SNR stored in extension sn = hdus["SNR"].data[order] sn_used = True uncertainity_hdus = None @@ -325,12 +325,17 @@ def __init__( flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(np.float64) * u.ct try: uncertainity_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] - sn_used = false + sn_used = False except: print("Warning: Using older PLP versions of .spec_a0v.fits files which have no variance saved. Will grab .variance.fits file.") elif ".spec_a0v.fits" in file: lamb = hdus["WAVELENGTH"].data[order].astype(float) * u.micron flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(float) * u.ct + try: + uncertainity_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] + sn_used = False + except: + print("Warning: Using older PLP versions of .spec_a0v.fits files which have no variance saved. Will grab .variance.fits file.") elif (("spec.fits" in file) or ("spec_flattened.fits" in file) or ('.spec2d.fits' in file)) and (wavefile is not None): lamb = ( wave_hdus[0].data[order].astype(float) * u.micron @@ -481,7 +486,11 @@ def read(file, precache_hdus=True, wavefile=None): sn_used = False #Default hdus = fits.open(file, memmap=False) - if "rtell" not in file: #Default, if no rtell file is used + + #hdus["SPEC_DIVIDE_A0V_VARIANCE"] + if "SPEC_DIVIDE_A0V_VARIANCE" in hdus: + cached_hdus = [hdus, [hdus["SPEC_DIVIDE_A0V_VARIANCE"]]] + elif "rtell" not in file: #Default, if no rtell file is used uncertainty_filepath = getUncertainityFilepath(file) uncertainity_hdus = fits.open(uncertainty_filepath, memmap=False) cached_hdus = [hdus, uncertainity_hdus] From 96bf9d3d7ddae11b46a11abc7d22dbdafe2cfbe2 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 18 Jul 2024 16:24:15 -0500 Subject: [PATCH 39/43] Add new dependencies. --- docs/tutorials/IGRINS_SpecList_demo.ipynb | 51 +++++++++++++---------- 1 file changed, 30 insertions(+), 21 deletions(-) diff --git a/docs/tutorials/IGRINS_SpecList_demo.ipynb b/docs/tutorials/IGRINS_SpecList_demo.ipynb index 2b7d5db..b446c18 100644 --- a/docs/tutorials/IGRINS_SpecList_demo.ipynb +++ b/docs/tutorials/IGRINS_SpecList_demo.ipynb @@ -20,14 +20,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from muler.igrins import IGRINSSpectrum, IGRINSSpectrumList\n", "from specutils import Spectrum1D, SpectrumList\n", "import numpy as np\n", - "import matplotlib.pyplot as plt\n", + "import matplotlib.pyplot as pltf\n", "import astropy.units as u\n", "%matplotlib inline\n", "%config InlineBackend.figure_format='retina'" @@ -42,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -53,33 +53,42 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "Exception", + "evalue": "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mException\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[3], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m spec_list \u001b[38;5;241m=\u001b[39m \u001b[43mIGRINSSpectrumList\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfull_path\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mnormalize()\n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/muler/igrins.py:434\u001b[0m, in \u001b[0;36mIGRINSSpectrumList.read\u001b[0;34m(file, precache_hdus, wavefile)\u001b[0m\n\u001b[1;32m 432\u001b[0m hdus \u001b[38;5;241m=\u001b[39m fits\u001b[38;5;241m.\u001b[39mopen(file, memmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[1;32m 433\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mrtell\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m file: \u001b[38;5;66;03m#Default, if no rtell file is used\u001b[39;00m\n\u001b[0;32m--> 434\u001b[0m uncertainty_filepath \u001b[38;5;241m=\u001b[39m \u001b[43mgetUncertainityFilepath\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 435\u001b[0m uncertainity_hdus \u001b[38;5;241m=\u001b[39m fits\u001b[38;5;241m.\u001b[39mopen(uncertainty_filepath, memmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m) \n\u001b[1;32m 436\u001b[0m cached_hdus \u001b[38;5;241m=\u001b[39m [hdus, uncertainity_hdus] \n", + "File \u001b[0;32m~/anaconda3/lib/python3.10/muler/igrins.py:84\u001b[0m, in \u001b[0;36mgetUncertainityFilepath\u001b[0;34m(filepath)\u001b[0m\n\u001b[1;32m 82\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m path_base \u001b[38;5;241m+\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m.sn.fits\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 83\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 84\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m(\n\u001b[1;32m 85\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNeither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 86\u001b[0m )\n", + "\u001b[0;31mException\u001b[0m: Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." + ] + } + ], "source": [ "spec_list = IGRINSSpectrumList.read(full_path).normalize()" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [ { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "image/png": { - "height": 264, - "width": 1445 - }, - "needs_background": "light" - }, - "output_type": "display_data" + "ename": "NameError", + "evalue": "name 'spec_list' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[4], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mspec_list\u001b[49m\u001b[38;5;241m.\u001b[39mremove_nans()\u001b[38;5;241m.\u001b[39mtrim_edges()\u001b[38;5;241m.\u001b[39mnormalize(order_index\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m15\u001b[39m)\u001b[38;5;241m.\u001b[39mplot(color\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, ylo\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m, yhi\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.5\u001b[39m);\n", + "\u001b[0;31mNameError\u001b[0m: name 'spec_list' is not defined" + ] } ], "source": [ @@ -468,7 +477,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.12" + "version": "3.10.8" } }, "nbformat": 4, From 79874993bfc215bab7a83d34ee722d006efb2d97 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 18 Jul 2024 16:54:31 -0500 Subject: [PATCH 40/43] Fix issue where uncertainity_hdus were not always there. Default is None. --- src/muler/igrins.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 2433c7d..66b2a20 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -289,11 +289,11 @@ def __init__( raise NameError("Cannot identify file as an IGRINS spectrum") grating_order = grating_order_offsets[band] + order + uncertainity_hdus = None #Default value if cached_hdus is not None: hdus = cached_hdus[0] if "rtell" in file: sn = hdus["SNR"].data[order] - uncertainity_hdus = None else: uncertainity_hdus = cached_hdus[1] if wavefile is not None: @@ -315,7 +315,6 @@ def __init__( elif "rtell" in file: #If rtell file is used, grab SNR stored in extension sn = hdus["SNR"].data[order] sn_used = True - uncertainity_hdus = None hdr = hdus[0].header if ("spec_a0v.fits" in file) and (wavefile is not None): log.warn( From a420e4af1452459966fbf60cf2754beddad8e345 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 18 Jul 2024 16:57:50 -0500 Subject: [PATCH 41/43] Fix issue where uncertainity were not always there. Default is None. --- src/muler/igrins.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 66b2a20..88d896a 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -289,7 +289,8 @@ def __init__( raise NameError("Cannot identify file as an IGRINS spectrum") grating_order = grating_order_offsets[band] + order - uncertainity_hdus = None #Default value + uncertainity_hdus = None #Default values + uncertainity = None if cached_hdus is not None: hdus = cached_hdus[0] if "rtell" in file: @@ -372,7 +373,6 @@ def __init__( uncertainty = StdDevUncertainty(np.abs(stddev)) mask = np.isnan(flux) | np.isnan(uncertainty.array) else: - uncertainity = None mask = np.isnan(flux) super().__init__( From 2e000a872915cc0db37773d6e03bb725c4dd0eca Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Thu, 18 Jul 2024 17:05:24 -0500 Subject: [PATCH 42/43] Fix typo for the word uncertainty --- src/muler/echelle.py | 8 ++++---- src/muler/igrins.py | 44 ++++++++++++++++++++++---------------------- 2 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/muler/echelle.py b/src/muler/echelle.py index 67f5f5a..aa66259 100644 --- a/src/muler/echelle.py +++ b/src/muler/echelle.py @@ -822,7 +822,7 @@ def to apply to smooth surrounding pixels (e.g. scipy.ndimage.median_filter) def apply(self, method=np.nansum, **kwargs): """ Apply any method to the spectrum. This is very general and can be used for many - things. Uncertainity is propogated. + things. Uncertainty is propogated. Parameters ---------- @@ -840,7 +840,7 @@ def to apply to spectrum (e.g. np.nansum to collapse a multidimensional spectrum def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. - Uuseful for airmass correction. Uncertainity is propogated by keeping the + Uuseful for airmass correction. Uncertainty is propogated by keeping the singal-to-noise constant. Parameters @@ -1116,7 +1116,7 @@ def __truediv__(self, other): def __pow__(self, power): """Take flux to a power while preserving the exiting flux units. - Uuseful for airmass correction. Uncertainity is propagated by keeping the + Uuseful for airmass correction. Uncertainty is propagated by keeping the singal-to-noise constant. Parameters @@ -1175,7 +1175,7 @@ def to apply to smooth surrounding pixels (e.g. scipy.ndimage.median_filter) def apply(self, method=np.nansum, **kwargs): """ Apply any method to the spectral list. This is very general and can be used for many - things. Uncertainity is propogated. + things. Uncertainty is propogated. Parameters ---------- diff --git a/src/muler/igrins.py b/src/muler/igrins.py index 88d896a..dc418e0 100644 --- a/src/muler/igrins.py +++ b/src/muler/igrins.py @@ -90,8 +90,8 @@ def readPLP(plppath, date, frameno, waveframeno, dim='1D'): return spec_all -def getUncertainityFilepath(filepath): - """Returns path for uncertainity file (.variance.fits or .sn.fits) +def getUncertaintyFilepath(filepath): + """Returns path for uncertainty file (.variance.fits or .sn.fits) Will first search for a .variance.fits file but if that does not exist will search for a .sn.fits file. @@ -102,11 +102,11 @@ def getUncertainityFilepath(filepath): Returns ------- - uncertainityFilepath: string + uncertaintyFilepath: string Returns the file path to the uncertianity (.variance.fits or .sn.fits) file. """ - if ".spec_a0v.fits" in filepath: #Grab base file name for the uncertainity file + if ".spec_a0v.fits" in filepath: #Grab base file name for the uncertainty file path_base = filepath[:-14] elif ".spec_flattened.fits" in filepath: path_base = filepath[:-20] @@ -119,7 +119,7 @@ def getUncertainityFilepath(filepath): return path_base + '.var2d.fits' else: raise Exception( - "The file .var2d.fits does not exist in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." + "The file .var2d.fits does not exist in the same path as the spectrum file to get the uncertainty. Please provide one of these files in the same directory as your spectrum file." ) else: if os.path.exists(path_base + '.variance.fits'): #Prefer .variance.fits file @@ -128,7 +128,7 @@ def getUncertainityFilepath(filepath): return path_base + '.sn.fits' else: raise Exception( - "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainity. Please provide one of these files in the same directory as your spectrum file." + "Neither .variance.fits or .sn.fits exists in the same path as the spectrum file to get the uncertainty. Please provide one of these files in the same directory as your spectrum file." ) def getSlitProfile(filepath, band, slit_length): @@ -152,7 +152,7 @@ def getSlitProfile(filepath, band, slit_length): y: float Flux of beam profile across the slit """ - if ".spec_a0v.fits" in filepath: #Grab base file name for the uncertainity file + if ".spec_a0v.fits" in filepath: #Grab base file name for the uncertainty file path_base = filepath[:-14] elif ".spec_flattened.fits" in filepath: path_base = filepath[:-20] @@ -275,7 +275,7 @@ def __init__( self.instrumental_resolution = 45_000.0 self.file = file - #False if variance.fits file used for uncertainity, true if sn.fits file used for uncertainity + #False if variance.fits file used for uncertainty, true if sn.fits file used for uncertainty if file is not None: @@ -289,14 +289,14 @@ def __init__( raise NameError("Cannot identify file as an IGRINS spectrum") grating_order = grating_order_offsets[band] + order - uncertainity_hdus = None #Default values - uncertainity = None + uncertainty_hdus = None #Default values + uncertainty = None if cached_hdus is not None: hdus = cached_hdus[0] if "rtell" in file: sn = hdus["SNR"].data[order] else: - uncertainity_hdus = cached_hdus[1] + uncertainty_hdus = cached_hdus[1] if wavefile is not None: wave_hdus = cached_hdus[2] else: #Read in files if cached_hdus are not provided @@ -309,8 +309,8 @@ def __init__( full_path = base_path + '/' + os.path.basename(wavefile) wave_hdus = fits.open(full_path) if "rtell" not in file and "spec_a0v" not in file: - uncertainty_filepath = getUncertainityFilepath(file) - uncertainity_hdus = fits.open(uncertainty_filepath, memmap=False) + uncertainty_filepath = getUncertaintyFilepath(file) + uncertainty_hdus = fits.open(uncertainty_filepath, memmap=False) if '.sn.fits' in uncertainty_filepath: sn_used = True elif "rtell" in file: #If rtell file is used, grab SNR stored in extension @@ -324,7 +324,7 @@ def __init__( lamb = hdus["WAVELENGTH"].data[order].astype(np.float64) * u.micron flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(np.float64) * u.ct try: - uncertainity_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] + uncertainty_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] sn_used = False except: print("Warning: Using older PLP versions of .spec_a0v.fits files which have no variance saved. Will grab .variance.fits file.") @@ -332,7 +332,7 @@ def __init__( lamb = hdus["WAVELENGTH"].data[order].astype(float) * u.micron flux = hdus["SPEC_DIVIDE_A0V"].data[order].astype(float) * u.ct try: - uncertainity_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] + uncertainty_hdus = [hdus["SPEC_DIVIDE_A0V_VARIANCE"]] sn_used = False except: print("Warning: Using older PLP versions of .spec_a0v.fits files which have no variance saved. Will grab .variance.fits file.") @@ -356,17 +356,17 @@ def __init__( "m": grating_order, "header": hdr, } - if uncertainity_hdus is not None or ("rtell" in file): + if uncertainty_hdus is not None or ("rtell" in file): if not sn_used: #If .variance.fits used - variance = uncertainity_hdus[0].data[order].astype(np.float64) + variance = uncertainty_hdus[0].data[order].astype(np.float64) stddev = np.sqrt(variance) if ("rtell" in file): #If using a rtell or spec_a0v file with a variance file, scale the stddev to preserve signal-to-noise unprocessed_flux = hdus["TGT_SPEC"].data[order].astype(np.float64) stddev *= (flux.value / unprocessed_flux) else: #Else if .sn.fits (or SNR HDU in rtell file) used if not "rtell" in file: - sn = uncertainity_hdus[0].data[order].astype(np.float64) - dw = np.gradient(lamb) #Divide out stuff the IGRINS PLP did to calculate the uncertainity per resolution element to get the uncertainity per pixel + sn = uncertainty_hdus[0].data[order].astype(np.float64) + dw = np.gradient(lamb) #Divide out stuff the IGRINS PLP did to calculate the uncertainty per resolution element to get the uncertainty per pixel pixel_per_res_element = (lamb/40000.)/dw sn_per_pixel = sn / np.sqrt(pixel_per_res_element) stddev = flux.value / sn_per_pixel.value @@ -490,9 +490,9 @@ def read(file, precache_hdus=True, wavefile=None): if "SPEC_DIVIDE_A0V_VARIANCE" in hdus: cached_hdus = [hdus, [hdus["SPEC_DIVIDE_A0V_VARIANCE"]]] elif "rtell" not in file: #Default, if no rtell file is used - uncertainty_filepath = getUncertainityFilepath(file) - uncertainity_hdus = fits.open(uncertainty_filepath, memmap=False) - cached_hdus = [hdus, uncertainity_hdus] + uncertainty_filepath = getUncertaintyFilepath(file) + uncertainty_hdus = fits.open(uncertainty_filepath, memmap=False) + cached_hdus = [hdus, uncertainty_hdus] if '.sn.fits' in uncertainty_filepath: sn_used = True else: #If rtell file is used From 0c0cb9142513ae299eba309bf84313862bac0cb1 Mon Sep 17 00:00:00 2001 From: Kyle Kaplan Date: Fri, 19 Jul 2024 15:10:06 -0500 Subject: [PATCH 43/43] Update hardcoded wavelength file in IGRINS unit tests. --- tests/test_igrins.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_igrins.py b/tests/test_igrins.py index 278e6ea..de5fd94 100644 --- a/tests/test_igrins.py +++ b/tests/test_igrins.py @@ -231,7 +231,7 @@ def test_deblaze(): def test_bandmath(): """Does band math work?""" spec1 = IGRINSSpectrumList.read(file=file) - spec2 = IGRINSSpectrumList.read(file=file_2, wavefile="SDCH_20201202_0063.wave.fits") + spec2 = IGRINSSpectrumList.read(file=file_2, wavefile="SKY_SDCH_20201202_0033.wvlsol_v1.fits") #Test band math for orders new_order = spec1[10] + spec2[10]