ACID-code 1.5.0a2__py3-none-any.whl → 1.5.0a3__py3-none-any.whl

ACID_code/acid.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import contextlib
 import warnings
 warnings.filterwarnings("ignore")
 import sys, emcee, os, time, inspect, inspect
@@ -169,7 +170,7 @@ class Acid:
             if linelist is not None or linelist_wl is not None or linelist_depths is not None:
                 raise ValueError("Use either 'linelist', or legacy 'linelist_path', not both. See the API for more details.")
             linelist = kwargs.pop("linelist_path")
-            if self.verbose > 0:
+            if self.config.verbose > 0:
                 print("Warning: 'linelist_path' is a legacy argument for inputting a linelist, " \
                 f"please use 'linelist' instead.\n The 'linelist_path' argument does not support full input validation.")
         # Anything left in kwargs is invalid
@@ -957,8 +958,11 @@ class Acid:
                     step_number += self.config.check_interval
 
                     try:
-                        # We want to keep the time for get_autocorr_time to run constant, so thin accordingly 
-                        tau = self.sampler.get_autocorr_time(tol=0, thin=step_number//self.config.check_interval)
+                        # We want to keep the time for get_autocorr_time to run constant, so thin accordingly
+                        with open(os.devnull, "w") as devnull, \
+                            contextlib.redirect_stdout(devnull), \
+                            contextlib.redirect_stderr(devnull):
+                            tau = self.sampler.get_autocorr_time(tol=0, thin=step_number//self.config.check_interval)
                     except emcee.autocorr.AutocorrError:
                         continue
 
@@ -983,7 +987,11 @@ class Acid:
                 step_number += self.config.check_interval
 
                 try:
-                    tau = self.sampler.get_autocorr_time(tol=0)
+                    # We want to keep the time for get_autocorr_time to run constant, so thin accordingly
+                    with open(os.devnull, "w") as devnull, \
+                        contextlib.redirect_stdout(devnull), \
+                        contextlib.redirect_stderr(devnull):
+                        tau = self.sampler.get_autocorr_time(tol=0, thin=step_number//self.config.check_interval)
                 except emcee.autocorr.AutocorrError:
                     continue
 

ACID_code/data.py

@@ -328,9 +328,10 @@ class Data:
     ndim     : Optional[int]        = None
 
     # Data required/calculated in results/after MCMC sampling
-    profiles : Optional[np.ndarray] = None  # the array to store all frames of the MCMC sampling
-    nsteps     : Optional[int]        = 0
-    max_steps  : Optional[int]        = None
+    profiles          : Optional[np.ndarray] = None  # the array to store all frames of the MCMC sampling
+    combined_profiles : Optional[np.ndarray] = None
+    nsteps            : Optional[int]        = 0
+    max_steps         : Optional[int]        = None
 
     # Other useful data and figures:
     initialisation_time : Optional[float] = None  # time taken for initialization
@@ -606,6 +607,12 @@ class Data:
         if input_sn.shape[0] != input_flux.shape[0]:
             raise ValueError("The number of frames for the SN must match the number of frames in wavelengths, flux, and errors.")
 
+        # Ensure data is sorted by wavelength
+        sort_idx = np.argsort(input_wavelengths, axis=-1)
+        input_wavelengths = np.take_along_axis(input_wavelengths, sort_idx, axis=-1)
+        input_flux = np.take_along_axis(input_flux, sort_idx, axis=-1)
+        input_errors = np.take_along_axis(input_errors, sort_idx, axis=-1)
+
         # Apply skips
         input_wavelengths = input_wavelengths[:, ::skips]
         input_flux       = input_flux[:, ::skips]
@@ -632,7 +639,7 @@ class Data:
             self.errors         = {"input": input_errors}
             self.sn             = {"input": input_sn}
 
-        # Apply skips and set inputs to class variables
+        # Set inputs to class variables
         self.wavelengths["input"] = input_wavelengths
         self.flux["input"]        = input_flux
         self.errors["input"]      = input_errors

ACID_code/load.py

@@ -6,15 +6,18 @@ from __future__ import annotations
 from beartype import beartype
 from .data import Data
 from . import utils
+from .utils import Array2D
 from astropy.io import fits
 
 @beartype
 class Load:
+
     def __init__(
             self,
-            instrument: str,
-            file      : str,
-            blaze_file: str|None = None,
+            instrument    : str,
+            file          : str,
+            blaze_file    : str|None     = None,
+            blaze_profile : Array2D|None = None
             ):
         """
         Parameters
@@ -22,6 +25,16 @@ class Load:
         instrument : str
             The name of the instrument the data was taken with. This will determine how the data is loaded and configured.
             Current options are "HARPS", "HARPS-N", "GEMINI-GHOST", "GEMINI-GRACES"
+        file : str
+            The path to the fits file containing the data to be loaded.
+        blaze_file : str, optional
+            The path to the fits file containing the blaze profile for the data to be loaded.
+            If not provided, no blaze correction is applied. By default, None
+        blaze_profile : Array2D, optional
+            Instead load the blaze profile yourself and input it here. This will override the blaze_file input if 
+            both are provided. By default, None
+        
+        
         """
 
         self.file = file
@@ -67,6 +80,12 @@ class Load:
         self.hdul = fits.open(file) # standard astropy error catching will catch if this fails
         self.loader(self.hdul)
 
+        # If blaze profile is provided, load it
+        if blaze_profile is not None:
+            self.data.blaze = blaze_profile
+        elif blaze_file is not None:
+            pass # TODO: load blaze file and save to self.data.blaze or tailor blaze files to each instrument
+
     def HARPS(self):
         # La Silla HARPS spectra
         try:

ACID_code/profiles.py

@@ -4,25 +4,50 @@ from scipy.optimize import curve_fit
 import matplotlib.pyplot as plt
 from beartype import beartype
 from scipy.special import wofz
+from .utils import Array1D
+from .data import Data
 
 @beartype
 class Profiles:
     """A class for fitting spectral line profiles such as Voigt and Gaussian profiles.
     """
-    def __init__(self, velocities, flux, flux_err=None):
+    def __init__(
+            self,
+            velocities : Array1D = None,
+            flux       : Array1D = None,
+            flux_err   : Array1D = None,
+            data       : Data    = None
+        ) -> None:
         """Initializes the Profiles class with velocity, flux, and optional flux error data.
 
         Parameters
         ----------
-        velocities : array_like
+        velocities : Array1D
             The velocity values corresponding to the spectral line profile.
-        flux : array_like
-            The flux values of the spectral line profile.
-        flux_err : array_like, optional
-            The errors associated with the flux values, by default None.
+            Must be provided if no data instance is passed, by default None.
+        flux : Array1D
+            The flux values of the spectral line profile
+            Must be provided if no data instance is passed, by default None.
+        flux_err : Array1D, optional
+            The errors associated with the flux values, by default None. If not
+            input, they won't be used in the fitting process.
+        data : Data, optional
+            A data instance to draw velocities, flux and flux errors. Will raise an
+            exception if they do not exist within the class.
+            Must be provided if all three of the above inputs were not passed, by default None.
         """
 
-        flux -= 1
+        if data is not None:
+            if not getattr(data, 'velocities', None) or not getattr(data, 'profiles', None):
+                raise ValueError("Data instance must have attributes 'velocities' and 'profiles'. Try running ACID first.")
+            velocities = data.velocities
+            flux = data.profiles[0,0] # Subtract 1 to convert from normalized flux to absorption depth
+            flux_err = data.profiles[0,1]
+        else:
+            if velocities is None or flux is None:
+                raise ValueError("If no data instance is provided, then at least velocities and flux must be provided.")
+
+        flux -= 1 # Subtract 1 to convert from normalized flux to absorption depth
 
         self.velocities = velocities
         self.flux = flux
@@ -35,35 +60,38 @@ class Profiles:
         self.fitted_x = np.linspace(np.min(velocities), np.max(velocities), 1000)
         pass
 
-    def plot_fit(self, model:str|None='all', **kwargs):
+    def plot_fit(self, model:str|None='voigt', return_fig=False, **kwargs):
         """Plots the original data and the fitted profile if available.
         
         Parameters
         ----------
         model : str | None, optional
             The type of model to plot. String options are 'voigt', 'gaussian', 
-            'lorentzian', or 'all'. Choosing None will plot whichever models have 
+            'lorentzian', 'none', or 'all'. Choosing 'none' or None will plot whichever models have 
             already been fitted for, by default 'all'.
+        return_fig : bool, optional
+            Whether to return the (fig, ax) tuple and not call plt.show(). If False, calls
+            plt.show() and returns None. By default False.
         **kwargs : dict
             Additional keyword arguments to pass to the fitting functions if the models
             have not been fitted yet.
         Returns
         -------
-        None
+        tuple | None
         """
-        models = ["voigt", "gaussian", "lorentzian"]
+        models = ["voigt", "gaussian", "lorentzian", "none"]
         if model is not None:
             model = model.lower()
             if model not in models + ['all']:
                 raise ValueError("Model must be 'voigt', 'gaussian', 'lorentzian' or 'all'.")
-        
+
         if model == 'all':
-            model_list = models
-        elif model is None:
+            model_list = models[:-1] # Exclude 'none'
+        elif model is None or model == "none":
             model_list = list(self.fitted_y.keys())
         else:
             model_list = [model]
-        
+
         for m in model_list:
             if m not in self.fitted_y:
                 fit_func = getattr(self, f"fit_{m}")

ACID_code/result.py

@@ -206,50 +206,58 @@ class Result:
 
         self.profiles = np.zeros((len(self.data.flux["input"]), 2, len(self.data.velocities)))
 
-        for counter in range(len(self.data.flux["input"])):
-            flux = np.copy(self.data.flux["input"][counter])
-            error = np.copy(self.data.errors["input"][counter])
-            wavelengths = np.copy(self.data.wavelengths["input"][counter])
-            sn = np.copy(self.data.sn["input"][counter])
+        # First get the combined profile, and then calculate each frame's profile if there are multiple frames.
+        # If there is one frame, then the combined_profile is the same as the single frame profile.
+
+        for counter in range(len(self.data.flux["input"])+1):
+            if counter == 0:
+                flux = np.copy(self.data.flux["combined"])
+                error = np.copy(self.data.errors["combined"])
+                wavelengths = np.copy(self.data.wavelengths["combined"])
+                sn = np.copy(self.data.sn["combined"])
+                error[self.data.residual_masks] = 1e12
+            else:
+                flux = np.copy(self.data.flux["input"][counter-1])[self.data.nanmask]
+                error = np.copy(self.data.errors["input"][counter-1])[self.data.nanmask]
+                wavelengths = np.copy(self.data.wavelengths["input"][counter-1])[self.data.nanmask]
+                sn = np.copy(self.data.sn["input"][counter-1])
+
+                # Masking based off residuals interpolated onto new wavelength grid
+                reference_wave = self.data.wavelengths["input"][np.nanargmax(self.data.sn["input"])]
+                reference_wave = reference_wave[self.data.nanmask]
 
-            flux = flux[self.data.nanmask]
-            error = error[self.data.nanmask]
-            wavelengths = wavelengths[self.data.nanmask]
+                reference_mask = np.zeros_like(reference_wave, dtype=bool)
+                reference_mask[self.data.residual_masks] = True
+                reference_interp1d = interp1d(reference_wave, reference_mask.astype(float), kind="nearest", bounds_error=False, fill_value=0.0)
+                interpolated_mask = reference_interp1d(wavelengths) > 0.5
+                error[interpolated_mask] = 1e12
 
             # Build continuum model
             a, b = utils.get_normalisation_coeffs(wavelengths)
             norm_wavelengths = (a*wavelengths)+b
-            mdl1 = P.polyval(norm_wavelengths, self.poly_cos)
-
-            # Masking based off residuals interpolated onto new wavelength grid
-            reference_wave = self.data.wavelengths["input"][np.nanargmax(self.data.sn["input"])]
-            reference_wave = reference_wave[self.data.nanmask]
-            mask_pos = np.ones(reference_wave.shape)
-            mask_pos[self.data.residual_masks]=1e12
-            f2 = interp1d(reference_wave, mask_pos, bounds_error = False, fill_value = np.nan)
-            interp_mask_pos = f2(wavelengths)
-            interp_mask_idx = tuple([interp_mask_pos>=1e12])
-
-            error[interp_mask_idx]=1e12
+            mdl = P.polyval(norm_wavelengths, self.poly_cos)
 
             # correcting continuum
-            error = np.sqrt((error/mdl1)**2 + (continuum_error/mdl1)**2)
-            flux /= mdl1
+            error = np.sqrt((error/mdl)**2 + (continuum_error/mdl)**2)
+            flux /= mdl
 
-            remove = tuple([flux<0])
-            flux[remove] = 1.
-            error[remove] = 1e12
+            # Check whether we can skip alpha by reusing the same alpha, only true if the wavelength grid is identical
+            condition = np.all(wavelengths==self.data.wavelengths["combined"])
+            alpha = self.data.alpha if condition is True else None
 
             LSD_profiles = LSD(self.data)
-            LSD_profiles.run_LSD(wavelengths, flux, error, sn=sn)
+            LSD_profiles.run_LSD(wavelengths, flux, error, sn=sn, alpha=alpha)
 
             profile_f = LSD_profiles.profile_F
             profile_errors_f = LSD_profiles.profile_errors_F
-            # profile_f = profile_f-1
 
-            self.profiles[counter]=[profile_f, profile_errors_f]
+            if counter == 0:
+                self.combined_profile = [profile_f, profile_errors_f]
+            else:
+                self.profiles[counter-1] = [profile_f, profile_errors_f]
 
         self.data.profiles = self.profiles # point Data.profiles to Result.profiles to keep them in sync
+        self.data.combined_profiles = self.combined_profile
         self.data.get_profiles_time = time() - t0
         self.data.full_run_time = self.data.initialisation_time + self.data.mcmc_time + self.data.get_profiles_time
 
@@ -259,6 +267,22 @@ class Result:
     def __getitem__(self, item) -> np.ndarray:
         """Allows indexing into the profiles array directly from the Result object.
         """
+        if isinstance(item, tuple):
+            if len(item) == 3:
+                # Legacy support for indexing style
+                _order, frame, velocity = item
+                item = (frame, velocity)
+            elif len(item) == 2:
+                item = item
+            elif len(item) == 1:
+                return self.combined_profile[item[0]]
+        elif isinstance(item, int):
+            return self.combined_profile[item]
+        elif isinstance(item, str):
+            if "combined" in item.lower():
+                return self.combined_profile
+            elif "profile" in item.lower():
+                return self.profiles
         return self.profiles[item]
 
     @_require_profiles
@@ -473,18 +497,15 @@ class Result:
     @_require_profiles
     def plot_forward_model(
         self,
-        input_version   :str       = "masked",
         grid            :bool      = True,
         labels          :dict|None = None,
         return_fig      :bool      = False,
         subplot_kwargs  :dict|None = None,
         ) -> None | tuple:
-        """Plots the forward model fit to the observed spectrum.
+        """Plots the forward model calculated from the final profiles to the combined input spectrum.
 
         Parameters
         ----------
-        input_version : str, optional
-            Which input spectrum to use: 'combined', 'input', 'masked', by default 'masked'
         grid : bool, optional
             Show or hide grid, by default True
         labels : dict | None, optional
@@ -499,11 +520,6 @@ class Result:
         If return_fig is True, returns a tuple (fig, ax) of the figure and axes objects containing the plot.
         Otherwise, displays the plot and returns None.
         """
-
-        # Validate all inputs and set defaults
-        input_version = input_version.lower()
-        if input_version not in self.data.wavelengths.keys():
-            raise ValueError(f"input_version must be one of {list(self.data.wavelengths.keys())}")
         
         # Set default labels
         default_labels = {
@@ -523,20 +539,26 @@ class Result:
         subplot_kwargs = utils.set_dict_defaults(subplot_kwargs, {"figsize": (10, 8)})
 
         # Get input data
-        input_wavelengths = self.data.wavelengths[input_version]
-        input_flux = self.data.flux[input_version]
-        input_errors = self.data.errors[input_version]
+        wavelengths = self.data.wavelengths["combined"]
+        flux = self.data.flux["combined"]
 
-        # Get model flux
-        samples = self.sampler.get_chain(discard=self.burnin, thin=self.thin, flat=True)
-        theta_median = np.median(samples, axis=0)
-        model_flux, _ = self.model(theta_median)
+        a, b = utils.get_normalisation_coeffs(wavelengths)
+        profile = utils.flux_to_od(self.combined_profile[0])[0]
+
+        # Get flat_samples which are the same samples used to calculate the final profile
+        flat_samples = self.sampler.get_chain(discard=self.burnin, thin=self.thin, flat=True)
+        nvel = len(self.data.velocities) if self.config.deterministic_profile is False else 0
+        poly_samples = flat_samples[:, nvel:] # continuum polynomial samples
+        continuum_model = P.polyval(wavelengths*a+b, np.median(poly_samples, axis=0))
+        model_flux = np.exp(- (self.data.alpha @ profile)) * continuum_model
 
         # Plotting
         fig, ax = plt.subplots(2, 1, **subplot_kwargs)
-        ax[0].plot(input_wavelengths, input_flux, color='black', linewidth=1, label='Observed Spectrum')
-        ax[0].plot(input_wavelengths, model_flux, color='C0', linewidth=1, label='Forward Model Fit')
-        ax[1].plot(input_wavelengths, input_flux - model_flux, color='C0', linewidth=1, label='Residuals')
+        ax[0].plot(wavelengths, flux, color='black', linewidth=1, label='Observed Spectrum')
+        ax[0].plot(wavelengths, model_flux, color='C0', linewidth=1, label='Forward Model Fit')
+        ax[0].plot(wavelengths, continuum_model, color='C1', linewidth=1, label='Fitted Continuum', linestyle='--')
+        ax[1].plot(wavelengths, flux - model_flux, color='C0', linewidth=1, label='Residuals')
+        ax[1].axhline(0, color='black', linestyle='--', linewidth=1)
         ax[0].set_title(labels["title"])
         ax[1].set_xlabel(labels["xlabel"])
         ax[0].set_ylabel(labels["ylabel"])
@@ -739,7 +761,7 @@ class Result:
         try:
             self.thin = int(np.min(self.tau)/5)
             if self.converged:
-                self.burnin = int(2 * np.max(self.tau))
+                self.burnin = int(3 * np.max(self.tau))
             else:
                 self.burnin = self.nsteps - 1000 # just the last 1000 steps
         except:

{acid_code-1.5.0a2.dist-info → acid_code-1.5.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ACID_code
-Version: 1.5.0a2
+Version: 1.5.0a3
 Summary: Returns line profiles from input spectra by fitting the stellar continuum and performing LSD
 Author: Lucy Dolan
 Author-email: Benjamin Cadell <bcadell01@qub.ac.uk>

acid_code-1.5.0a3.dist-info/RECORD

@@ -0,0 +1,14 @@
+ACID_code/__init__.py,sha256=5ocFY2Pyeo4VclLFRlph8LM8tdIoPtwUmrQwgUnbVIk,463
+ACID_code/acid.py,sha256=7BslKV9iGt6CXAdGTp2wrxes7cw592WHmff_ArweGt0,69763
+ACID_code/data.py,sha256=AKLEhB5b3E__pgBmdLtQjzvKqDnYBIKmbeUsrnvk-Co,47133
+ACID_code/load.py,sha256=a-9mFRsT8UDU-A5m-fPwDtPOS9ibPz8GnDdZaoiBGbo,4372
+ACID_code/lsd.py,sha256=XBv3PuT5of5QW5EKon7wK_wuy0b8byjLbyXh_xvH2qM,30492
+ACID_code/mcmc.py,sha256=tsWZrEy8IZt-Hh3GJka3sIU8SkM4GivSgKyo8lWoycA,10564
+ACID_code/profiles.py,sha256=Z2Ttnk49-Aq5oR--qdmbv3R4EM7TjtUJ9YXGy8S1024,13453
+ACID_code/result.py,sha256=_MY8Brr5z8eXhzcR46wMmE8BHHAIi0ErpmAvyy0U9lE,40424
+ACID_code/utils.py,sha256=Y3RdQR-rrTsaUpABDV0eRhwMvubcLD1w18ubGziKt0g,16292
+acid_code-1.5.0a3.dist-info/licenses/LICENSE,sha256=L6dUgqjvHmRoobrBCPSHKC4UtRM5Ldp1DJBC4bnLk3w,1070
+acid_code-1.5.0a3.dist-info/METADATA,sha256=w5ukCW5ClgyTYXSumEs65_9p85rY1mw3pL5L4ydgQaA,2979
+acid_code-1.5.0a3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+acid_code-1.5.0a3.dist-info/top_level.txt,sha256=O4OaSabv1ebFYQmHgftr1PGAv6BvC2l81Y3HjgNehQI,10
+acid_code-1.5.0a3.dist-info/RECORD,,

acid_code-1.5.0a2.dist-info/RECORD

@@ -1,14 +0,0 @@
-ACID_code/__init__.py,sha256=5ocFY2Pyeo4VclLFRlph8LM8tdIoPtwUmrQwgUnbVIk,463
-ACID_code/acid.py,sha256=mL3_BZmlOvcYS8IqWsyU4RZ6v5DIgpKEPrljSaXU2eA,69197
-ACID_code/data.py,sha256=Ab2EHDQi85-ziN-eF5MpNSBaPPf4GJ06IJYiLR7SptQ,46738
-ACID_code/load.py,sha256=EdQxHf_tVC4ekfm1LDoO5NhCwo7EYk5FlqlpcEzLjF0,3481
-ACID_code/lsd.py,sha256=XBv3PuT5of5QW5EKon7wK_wuy0b8byjLbyXh_xvH2qM,30492
-ACID_code/mcmc.py,sha256=tsWZrEy8IZt-Hh3GJka3sIU8SkM4GivSgKyo8lWoycA,10564
-ACID_code/profiles.py,sha256=NH_bK7eZYmPk4hCv1a5eXLqxjdny8i0BBBiwfNxnsB8,11809
-ACID_code/result.py,sha256=Q0YZUlM_gt3_NW2ntXh-daj6B0nqrGSsgu6g3oNOK4Y,38773
-ACID_code/utils.py,sha256=Y3RdQR-rrTsaUpABDV0eRhwMvubcLD1w18ubGziKt0g,16292
-acid_code-1.5.0a2.dist-info/licenses/LICENSE,sha256=L6dUgqjvHmRoobrBCPSHKC4UtRM5Ldp1DJBC4bnLk3w,1070
-acid_code-1.5.0a2.dist-info/METADATA,sha256=rZA4IHcjdX3prbyh9pEw5sDBxJhrcBefmcF0xoZLqDE,2979
-acid_code-1.5.0a2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-acid_code-1.5.0a2.dist-info/top_level.txt,sha256=O4OaSabv1ebFYQmHgftr1PGAv6BvC2l81Y3HjgNehQI,10
-acid_code-1.5.0a2.dist-info/RECORD,,