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

ACID_code/data.py

@@ -581,6 +581,10 @@ class Data:
         # Make any values < 0 or infinite equal to nan, which are gracefully later handled.
         input_wavelengths, input_flux, input_errors = utils.mask_invalid(input_wavelengths, input_flux, input_errors, verbose=self.config.verbose)
 
+        # Check that none of the inputs are all nan
+        if np.all(np.isnan(input_wavelengths)) or np.all(np.isnan(input_flux)) or np.all(np.isnan(input_errors)):
+            raise ValueError("Any of the input wavelengths, spectra, and errors cannot be all NaN.")
+
         # Guess sn if input_sn not provided
         if input_sn is None:
             input_sn = utils.guess_SNR(input_wavelengths, input_flux, input_errors)
@@ -767,8 +771,10 @@ class DataList:
             data_list = [data_list]
 
         if verbose is not None:
-            self.data[0].config.verbose = verbose # verbose in config is a property and has good validation
-            self.verbose = self.data[0].config.verbose
+            old_verbose = np.copy(data_list[0].config.verbose)
+            data_list[0].config.verbose = verbose # verbose in config is a property and has good validation
+            self.verbose = np.copy(data_list[0].config.verbose)
+            data_list[0].config.verbose = old_verbose # reset to old verbose
         else:
             self.verbose = np.max([data.config.verbose for data in data_list])
 
@@ -838,6 +844,82 @@ class DataList:
         if len(np.unique(self.orders)) != len(self.orders):
             raise ValueError("All Data instances within the inputted list must have unique order numbers.")
 
+    def run_ACID(
+        self,
+        orders        : Array1D|int|str|None = None,
+        store_sampler : bool                 = True
+        ) -> None:
+        from .acid import Acid
+
+        if isinstance(orders, int):
+            orders = [orders]
+        elif isinstance(orders, str):
+            if orders == "all":
+                orders = self.orders
+            else:
+                raise ValueError("If orders is a string, it must be 'all' to run ACID on all orders. Got: {orders!r}")
+        elif orders is None:
+            orders = self.orders
+        elif isinstance(orders, list):
+            if not all(isinstance(o, int) for o in orders):
+                raise ValueError("If orders is a list, all elements must be integers. Got: {orders!r}")
+            if not all(o in self.orders for o in orders):
+                raise ValueError("All orders in the input list must be in the DataList. Got: {orders!r}, but available orders are: {self.orders!r}")
+        else:
+            raise ValueError("orders must be an int, a list of ints, 'all', or None. Got: {orders!r}")
+
+        for order in orders:
+            result = Acid(data=self.data_list[self.o2i[order]]).ACID()
+            if self.save_dir is not None:
+                results_dir = os.path.join(self.save_dir, "results")
+                os.makedirs(results_dir, exist_ok=True)
+                save_path = os.path.join(results_dir, f"order_{order}.pkl")
+                result.save(save_path, store_sampler=store_sampler)
+        return
+
+    @classmethod
+    def create(
+        cls,
+        wavelengths : Array2D                        = None,
+        flux        : Array2D                        = None,
+        errors      : Array2D                        = None,
+        sn          : Array1D                        = None,
+        order_range : Array1D|None                   = None,
+        load                                         = None,
+        config      : Config|None                    = None,
+        linelist    : Array2D|None|str|LineList|dict = None,
+        velocities  : Array1D|None                   = None,
+        save_dir    : str|None                       = None,
+        verbose     : IntLike|bool|None              = None,
+        ) -> DataList:
+
+        if load is not None:
+            from .load import Load
+            if not isinstance(load, Load):
+                raise ValueError("load must be an instance of the Load class. Got: {load!r}")
+            wavelengths, flux, errors, sn = load.get_data()
+            order_range = load.order_range
+
+        if order_range is None:
+            order_range = np.arange(len(wavelengths))
+
+        if len(order_range) != len(wavelengths):
+            raise ValueError("The length of the order_range must match the number of frames in the input data.")
+
+        config_dict = config.to_dict() if config is not None else {}
+
+        datalist = []
+        for order in order_range:
+            data = Data()
+            data.set_inputs(wavelengths[order], flux[order], errors[order], sn[order])
+            data.set_linelist(linelist=linelist)
+            data.velocities = velocities
+            config_dict["order"] = order
+            data.config = Config(**config_dict)
+            datalist.append(data)
+
+        return cls(datalist, save_dir=save_dir, verbose=verbose)
+
     def save(self, save_dir:str|None=None):
         d = {}
         self.save_dir = save_dir
@@ -864,9 +946,8 @@ class DataList:
     @save_dir.setter
     def save_dir(self, dir):
         if dir is None:
-            return # do not change save_dir
-        if not os.path.isdir(dir):
-            raise ValueError(f"save_dir must be a valid path to a directory to save the DataList, or None to not save to disk. Got: {dir}")
+            return None
+        os.mkdir(dir, exist_ok=True)
         self._save_dir = dir
 
 class LineList:

ACID_code/load.py

@@ -4,7 +4,8 @@ Each function will load a data object that can be directly input into the ACID i
 """
 from __future__ import annotations
 from beartype import beartype
-from .data import Data
+import numpy as np
+from .data import Data, DataList
 from . import utils
 from .utils import Array2D
 from astropy.io import fits
@@ -33,9 +34,8 @@ class Load:
         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
-        
-        
         """
+        raise NotImplementedError("This class is still in development and not yet ready for use. Please check back later.")
 
         self.file = file
         self.blaze_file = blaze_file
@@ -86,18 +86,46 @@ class Load:
         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 to_datalist(self, **kwargs) -> DataList:
+        datalist = DataList.create(
+            wavelengths = self.wavelengths,
+            flux        = self.flux,
+            errors      = self.errors,
+            sn          = self.sn,
+            order_range = self.order_range,
+            **kwargs,
+        )
+        return datalist
+
     def HARPS(self):
         # La Silla HARPS spectra
         try:
             hdr = self.hdul[0].header
             data = self.hdul[0].data
+            wavelengths = self.hdul[1].data
         except Exception as e:
             raise ValueError(self.load_exception + str(e))
-            
-        pass
+
+
+        if self.blaze_profile is not None:
+            try:
+                blaze_hdu = fits.open(self.blaze_file)
+                blaze_profiles = np.array(blaze_hdu[0].data)
+                self.flux = data / blaze_profiles
+            except:
+                print("Error loading blaze profile. No blaze correction applied.")
+
+        return
 
     def HARPS_N(self):
-        # La Palma HARPS-N spectra
+        hdul = fits.open(self.file)
+        hdr = hdul[0].header
+        flux = hdul[1].data
+        errors = hdul[2].data
+        dq = hdul[3].data
+        wavelengths = hdul[5].data
+        sn = np.array([hdr[f"HIERARCH TNG QC ORDER{i+1} SNR"] for i in range(len(flux))])
+
         pass
 
     def GEMINI_GHOST(self):

ACID_code/lsd.py

@@ -89,9 +89,9 @@ class LSD:
         # Clip linelist to wavelength range of spectrum
         wavelengths_linelist, depths_linelist = utils.clip_wavelengths(wavelengths, wavelengths_linelist, depths_linelist)
         if len(wavelengths_linelist) == 0:
-            raise ValueError(f"No lines in linelist are within the wavelength range of the observed spectrum. "\
-                             f"Please check your linelist and input spectrum. You may have mismatched wavelengths "\
-                             f"units between linelist and spectrum or an empty linelist.")
+            raise ValueError(f"No lines in linelist are within the wavelength range of the observed spectrum. \n"\
+                             f"You may have mismatched wavelengths units between linelist and spectrum or an empty linelist.\n"\
+                             f"Please check your linelist and input spectrum.")
 
         # Apply S/N cut (of 1/(3*SN)) to linelist
         wavelengths_linelist, depths_linelist = self.sn_clip(wavelengths_linelist, depths_linelist, sn)

ACID_code/profiles.py

@@ -16,7 +16,7 @@ class Profiles:
             velocities : Array1D = None,
             flux       : Array1D = None,
             flux_err   : Array1D = None,
-            data       : Data    = None
+            data       : Data    = None,
         ) -> None:
         """Initializes the Profiles class with velocity, flux, and optional flux error data.
 
@@ -34,7 +34,7 @@ class Profiles:
         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.
+            Must be provided if all three of the above inputs were not passed, by default None. 
         """
 
         if data is not None:

ACID_code/result.py

@@ -162,13 +162,11 @@ class Result:
         # Obtain flattened samples
         flat_samples = self.sampler.get_chain(discard=self.burnin, thin=self.thin, flat=True)
 
-        # Getting the final profile and continuum values - median of last 1000 steps
+        # Getting the final profile and continuum values
         nvel = len(self.data.velocities) if self.config.deterministic_profile is False else 0
         quartiles = np.percentile(flat_samples, [16, 50, 84], axis=0)
         errors = np.diff(quartiles, axis=0)
         errors = np.max(errors, axis=0) # why?
-        self.profile       = quartiles[1, :nvel]
-        self.profile_err   = errors[:nvel]
         self.poly_cos      = quartiles[1, nvel:]
         self.poly_cos_err  = errors[nvel:]  
 
@@ -191,7 +189,6 @@ class Result:
         n_samples, ncoeffs = coeffs.shape
         npix = powers.shape[0]
         matrix_size_gb = (2 * n_samples * npix + n_samples * ncoeffs + npix * ncoeffs) * 8 * 1e-9
-
         # If memory exceeded, fallback to using 1000 random samples
         if matrix_size_gb > m_available:
             if self.config.verbose > 0:
@@ -204,12 +201,11 @@ class Result:
         conts = (coeffs @ powers.T)
         continuum_error = np.std(conts, axis=0)
 
-        self.profiles = np.zeros((len(self.data.flux["input"]), 2, len(self.data.velocities)))
-
         # 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):
+        nframes = len(self.data.flux["input"])
+        self.profiles = np.zeros((nframes, 2, len(self.data.velocities)))
+        for counter in range(nframes+1):
             if counter == 0:
                 flux = np.copy(self.data.flux["combined"])
                 error = np.copy(self.data.errors["combined"])
@@ -242,8 +238,8 @@ class Result:
             flux /= mdl
 
             # 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
+            condition = np.array_equal(wavelengths, self.data.wavelengths["combined"])
+            alpha = self.data.alpha if condition else None
 
             LSD_profiles = LSD(self.data)
             LSD_profiles.run_LSD(wavelengths, flux, error, sn=sn, alpha=alpha)
@@ -543,7 +539,7 @@ class Result:
         flux = self.data.flux["combined"]
 
         a, b = utils.get_normalisation_coeffs(wavelengths)
-        profile = utils.flux_to_od(self.combined_profile[0])[0]
+        profile = utils.flux_to_od(self.combined_profile[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)
@@ -557,7 +553,7 @@ class Result:
         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].plot(wavelengths, model_flux - 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"])

ACID_code/utils.py

@@ -354,7 +354,7 @@ def flux_to_od(flux=None, errors=None, linelist=None):
     if linelist is not None:
         out.append(-np.log(1 - linelist))
 
-    return tuple(out)
+    return tuple(out) if len(out) > 1 else out[0]
 
 def od_to_flux(od=None, errors=None, linelist=None):
     """Converts optical depth to flux, errors, and linelist.
@@ -389,7 +389,7 @@ def od_to_flux(od=None, errors=None, linelist=None):
     if linelist is not None:
         out.append(1-np.exp(-linelist))
 
-    return tuple(out)
+    return tuple(out) if len(out) > 1 else out[0]
 
 def configure_mp_environ(os):
     """Configures the multiprocessing environment variables for optimal performance.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ACID_code
-Version: 1.5.0a3
+Version: 1.5.0a4
 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.0a4.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=5Oms-M5Jhi-0OT1mceBeVW9Pmrf0IWvBpMm-iZjV4po,50722
+ACID_code/load.py,sha256=3gzIZpAv7flgX5ekWdRDI95hkPTxvtp2F1liygpivOQ,5453
+ACID_code/lsd.py,sha256=YcShX62fqYCy2ZmFDOXEzKl-5nUM5QvYmCsk_KO8F9E,30495
+ACID_code/mcmc.py,sha256=tsWZrEy8IZt-Hh3GJka3sIU8SkM4GivSgKyo8lWoycA,10564
+ACID_code/profiles.py,sha256=Nm77ERkDByWKD5DeQv8VspV9eP98vqw-IyRYer-9qm8,13455
+ACID_code/result.py,sha256=XTkLjTO6Wmu5MZeAl-1z80jyAIiXVaXnPC0_MDRqNrA,40303
+ACID_code/utils.py,sha256=XF3Wi_t4bkBGYKrXeMipBNrs3Wp6R_YA3w9Qu-t1DCs,16348
+acid_code-1.5.0a4.dist-info/licenses/LICENSE,sha256=L6dUgqjvHmRoobrBCPSHKC4UtRM5Ldp1DJBC4bnLk3w,1070
+acid_code-1.5.0a4.dist-info/METADATA,sha256=hkq1Gwp55q4EciL0n5ugIkZkVB2fflEjOt8oNTenHrI,2979
+acid_code-1.5.0a4.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+acid_code-1.5.0a4.dist-info/top_level.txt,sha256=O4OaSabv1ebFYQmHgftr1PGAv6BvC2l81Y3HjgNehQI,10
+acid_code-1.5.0a4.dist-info/RECORD,,

acid_code-1.5.0a3.dist-info/RECORD

@@ -1,14 +0,0 @@
-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,,