arvi 0.1.18__py3-none-any.whl → 0.1.20__py3-none-any.whl

arvi/timeseries.py

@@ -1,17 +1,15 @@
 import os
 from dataclasses import dataclass, field
 from typing import Union
-from functools import partial
+from functools import partial, partialmethod
 from glob import glob
 import warnings
 from copy import deepcopy
 from datetime import datetime, timezone
 import numpy as np
 
-from astropy import units
-
 from .setup_logger import logger
-from . import config
+from .config import config
 from .translations import translate
 from .dace_wrapper import do_download_filetype, do_symlink_filetype, get_observations, get_arrays
 from .simbad_wrapper import simbad
@@ -20,8 +18,11 @@ from .extra_data import get_extra_data
 from .stats import wmean, wrms
 from .binning import bin_ccf_mask, binRV
 from .HZ import getHZ_period
-from .utils import strtobool, there_is_internet, timer
+from .utils import strtobool, there_is_internet, timer, chdir
+from .utils import lazy_import
 
+units = lazy_import('astropy.units')
+# from astropy import units
 
 class ExtraFields:
     pass
@@ -54,12 +55,19 @@ class RV:
     do_adjust_means: bool = field(init=True, repr=False, default=True)
     only_latest_pipeline: bool = field(init=True, repr=False, default=True)
     load_extra_data: Union[bool, str] = field(init=True, repr=False, default=False)
+    check_drs_qc: bool = field(init=True, repr=False, default=True)
     #
+    units = 'm/s'
     _child: bool = field(init=True, repr=False, default=False)
     _did_secular_acceleration: bool = field(init=False, repr=False, default=False)
     _did_sigma_clip: bool = field(init=False, repr=False, default=False)
     _did_adjust_means: bool = field(init=False, repr=False, default=False)
+    _did_simbad_query: bool = field(init=False, repr=False, default=False)
+    _did_gaia_query: bool = field(init=False, repr=False, default=False)
     _raise_on_error: bool = field(init=True, repr=False, default=True)
+    # 
+    _simbad = None
+    _gaia = None
 
     def __repr__(self):
         if self.N == 0:
@@ -70,60 +78,126 @@ class RV:
             nmasked = self.N - self.mtime.size
             return f"RV(star='{self.star}', N={self.N}, masked={nmasked})"
 
+    @property
+    def simbad(self):
+        if self._simbad is not None:
+            return self._simbad
+
+        if self._child:
+            return None
+    
+        if self._did_simbad_query:
+            return None
+
+        if self.verbose:
+            logger.info('querying Simbad...')
+
+        # complicated way to query Simbad with self.__star__ or, if that
+        # fails, try after removing a trailing 'A'
+        for target in set([self.__star__, self.__star__.replace('A', '')]):
+            try:
+                self._simbad = simbad(target)
+                break
+            except ValueError:
+                continue
+        else:
+            if self.verbose:
+                logger.error(f'simbad query for {self.__star__} failed')
+
+        self._did_simbad_query = True
+        return self._simbad
+
+    @property
+    def gaia(self):
+        if self._gaia is not None:
+            return self._gaia
+
+        if self._child:
+            return None
+
+        if self._did_gaia_query:
+            return None
+
+        if self.verbose:
+            logger.info('querying Gaia...')
+
+        # complicated way to query Gaia with self.__star__ or, if that fails,
+        # try after removing a trailing 'A'
+        for target in set([self.__star__, self.__star__.replace('A', '')]):
+            try:
+                self._gaia = gaia(target)
+                break
+            except ValueError:
+                continue
+        else:
+            if self.verbose:
+                logger.error(f'Gaia query for {self.__star__} failed')
+
+        self._did_gaia_query = True
+        return self._gaia
+
+    def __post_init_special_sun(self):
+        import pickle
+        from .extra_data import get_sun_data
+        path = get_sun_data(download=not self._child)
+        self.dace_result = pickle.load(open(path, 'rb'))
+
+
     def __post_init__(self):
         self.__star__ = translate(self.star)
 
-        if not self._child:
-            if config.check_internet and not there_is_internet():
-                raise ConnectionError('There is no internet connection?')
+        if self.star.lower() == 'sun':
+            self.__post_init_special_sun()
+            self.do_secular_acceleration = False
+            self.units = 'km/s'
 
-            # complicated way to query Simbad with self.__star__ or, if that
-            # fails, try after removing a trailing 'A'
-            for target in (self.__star__, self.__star__.replace('A', '')):
-                try:
-                    self.simbad = simbad(target)
-                    break
-                except ValueError:
-                    continue
-            else:
+        else:
+            if not self._child:
+                if config.check_internet and not there_is_internet():
+                    raise ConnectionError('There is no internet connection?')
+
+                # make Simbad and Gaia queries in parallel
+                import concurrent.futures
+                with timer('simbad and gaia queries'):
+                    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+                        executor.map(self.__getattribute__, ('simbad', 'gaia'))
+
+                # with timer('simbad query'):
+                #     self.simbad
+                # with timer('gaia query'):
+                #     self.gaia
+
+                # query DACE
                 if self.verbose:
-                    logger.error(f'simbad query for {self.__star__} failed')
-
-            # complicated way to query Gaia with self.__star__ or, if that
-            # fails, try after removing a trailing 'A'
-            for target in (self.__star__, self.__star__.replace('A', '')):
+                    logger.info(f'querying DACE for {self.__star__}...')
                 try:
-                    self.gaia = gaia(target)
-                    break
-                except ValueError:
-                    continue
-            else:
-                if self.verbose:
-                    logger.error(f'Gaia query for {self.__star__} failed')
-
-            # query DACE
-            if self.verbose:
-                logger.info(f'querying DACE for {self.__star__}...')
-            try:
-                with timer():
-                    mid = self.simbad.main_id if hasattr(self, 'simbad') else None
-                    self.dace_result = get_observations(self.__star__, self.instrument,
-                                                        main_id=mid, verbose=self.verbose)
-            except ValueError as e:
-                # querying DACE failed, should we raise an error?
-                if self._raise_on_error:
-                    raise e
-                else:
-                    self.time = np.array([])
-                    self.instruments = []
-                    self.units = ''
-                    return
+                    if hasattr(self, 'simbad') and self.simbad is not None:
+                        mid = self.simbad.main_id
+                    else:
+                        mid = None
+
+                    with timer():
+                        self.dace_result = get_observations(self.__star__, self.instrument,
+                                                            main_id=mid, verbose=self.verbose)
+                except ValueError as e:
+                    # querying DACE failed, should we raise an error?
+                    if self._raise_on_error:
+                        raise e
+                    else:
+                        self.time = np.array([])
+                        self.instruments = []
+                        self.units = ''
+                        return
 
-            # store the date of the last DACE query
-            time_stamp = datetime.now(timezone.utc)  #.isoformat().split('.')[0]
-            self._last_dace_query = time_stamp
+                # store the date of the last DACE query
+                time_stamp = datetime.now(timezone.utc)  #.isoformat().split('.')[0]
+                self._last_dace_query = time_stamp
 
-        self.units = 'm/s'
+        _replacements = (('-', '_'), ('.', '_'), ('__', '_'))
+        def do_replacements(s):
+            for a, b in _replacements:
+                s = s.replace(a, b)
+            return s
 
         # build children
         if not self._child:
@@ -133,9 +207,9 @@ class RV:
 
             for (inst, pipe, mode), data in arrays:
                 child = RV.from_dace_data(self.star, inst, pipe, mode, data, _child=True,
-                                          verbose=self.verbose)
-                inst = inst.replace('-', '_')
-                pipe = pipe.replace('.', '_').replace('__', '_')
+                                          check_drs_qc=self.check_drs_qc, verbose=self.verbose)
+                inst = do_replacements(inst)
+                pipe = do_replacements(pipe)
                 if self.only_latest_pipeline:
                     # save as self.INST
                     setattr(self, inst, child)
@@ -148,16 +222,14 @@ class RV:
             #! sorted?
             if self.only_latest_pipeline:
                 self.instruments = [
-                    inst.replace('-', '_')
+                    do_replacements(inst)
                     for (inst, _, _), _ in arrays
                 ]
             else:
                 self.instruments = [
-                    inst.replace('-', '_') + '_' + pipe.replace('.', '_').replace('__', '_')
+                    do_replacements(inst) + '_' + do_replacements(pipe)
                     for (inst, pipe, _), _ in arrays
                 ]
-            # self.pipelines =
-
             # all other quantities
             self._build_arrays()
 
@@ -190,6 +262,8 @@ class RV:
 
             if self.do_adjust_means:
                 self.adjust_means()
+        
+        self._download_directory = f'{self.star.replace(" ", "")}_downloads'
 
     def __add__(self, other, inplace=False):
         # if not isinstance(other, self.__class__):
@@ -232,7 +306,7 @@ class RV:
         file = f'{star_name}_{ts}.pkl'
         pickle.dump(self, open(file, 'wb'), protocol=0)
         if self.verbose:
-            logger.info(f'Saved snapshot to {file}')
+            logger.info(f'saved snapshot to {file}')
 
     @property
     def N(self) -> int:
@@ -312,6 +386,10 @@ class RV:
     def _mtime_sorter(self):
         return np.argsort(self.mtime)
 
+    def _index_from_instrument_index(self, index, instrument):
+        ind = np.where(self.instrument_array == instrument)[0]
+        return ind[getattr(self, instrument).mask][index]
+
     @property
     def _tt(self) -> np.ndarray:
         return np.linspace(self.mtime.min(), self.mtime.max(), 20*self.N)
@@ -319,6 +397,7 @@ class RV:
     @classmethod
     def from_dace_data(cls, star, inst, pipe, mode, data, **kwargs):
         verbose = kwargs.pop('verbose', False)
+        check_drs_qc = kwargs.pop('check_drs_qc', True)
         s = cls(star, **kwargs)
         #
         ind = np.argsort(data['rjd'])
@@ -344,9 +423,9 @@ class RV:
                     s._quantities.append('ccf_mask')
                 else:
                     # be careful with bogus values in rhk and rhk_err
-                    if arr in ('rhk', 'rhk_err'):
-                        mask99999 = (data[arr] == -99999) | (data[arr] == -99)
-                        data[arr][mask99999] = np.nan
+                    # --> not just in rhk and rhk_err...
+                    if data[arr].dtype == float and (bad := data[arr] == -99999).any():
+                        data[arr][bad] = np.nan
 
                     setattr(s, arr, data[arr][ind])
                     s._quantities.append(arr)
@@ -354,7 +433,7 @@ class RV:
         s._quantities = np.array(s._quantities)
 
         # mask out drs_qc = False
-        if not s.drs_qc.all():
+        if check_drs_qc and not s.drs_qc.all():
             n = (~s.drs_qc).sum()
             if verbose:
                 logger.warning(f'masking {n} points where DRS QC failed for {inst}')
@@ -406,8 +485,11 @@ class RV:
 
         dt = datetime.fromtimestamp(float(timestamp))
         if verbose:
-            logger.info(f'Reading snapshot of {star} from {dt}')
-        return pickle.load(open(file, 'rb'))
+            logger.info(f'reading snapshot of {star} from {dt}')
+        
+        s = pickle.load(open(file, 'rb'))
+        s._snapshot = file
+        return s
 
     @classmethod
     def from_rdb(cls, files, star=None, instrument=None, units='ms', **kwargs):
@@ -474,12 +556,16 @@ class RV:
                     names = header.split()
 
             if len(names) > 3:
-                kw = dict(skip_header=0, comments='--', names=True, dtype=None, encoding=None)
+                if f.endswith('.rdb'):
+                    kw = dict(skip_header=2, dtype=None, encoding=None)
+                else:
+                    kw = dict(skip_header=0, comments='--', names=True, dtype=None, encoding=None)
                 if '\t' in header:
                     data = np.genfromtxt(f, **kw, delimiter='\t')
                 else:
                     data = np.genfromtxt(f, **kw)
-                # data.dtype.names = names
+                if len(names) == len(data.dtype.names):
+                    data.dtype.names = names
             else:
                 data = np.array([], dtype=np.dtype([]))
 
@@ -591,13 +677,11 @@ class RV:
 
             _s.fwhm = np.array([i.FWHM*1e3 for i in CCFs])
             _s.fwhm_err = np.array([i.FWHMerror*1e3 for i in CCFs])
-
             _quantities.append('fwhm')
             _quantities.append('fwhm_err')
 
             _s.contrast = np.array([i.contrast for i in CCFs])
             _s.contrast_err = np.array([i.contrast_error for i in CCFs])
-
             _quantities.append('contrast')
             _quantities.append('contrast_err')
 
@@ -618,7 +702,6 @@ class RV:
                 if verbose:
                     logger.warning(f'masking {n} points where DRS QC failed for {instrument}')
                 _s.mask &= _s.drs_qc
-            print(_s.mask)
 
             _s._quantities = np.array(_quantities)
             setattr(s, instrument, _s)
@@ -714,8 +797,17 @@ class RV:
                 )
                 setattr(self, q, arr)
 
+    @property
+    def download_directory(self):
+        """ Directory where to download data """
+        return self._download_directory
+
+    @download_directory.setter
+    def download_directory(self, value):
+        self._download_directory = value
+
     def download_ccf(self, instrument=None, index=None, limit=None,
-                     directory=None, symlink=False, **kwargs):
+                     directory=None, symlink=False, load=True, **kwargs):
         """ Download CCFs from DACE
 
         Args:
@@ -724,17 +816,13 @@ class RV:
             limit (int): Maximum number of files to download.
             directory (str): Directory where to store data.
         """
-        if directory is None:
-            directory = f'{self.star}_downloads'
+        directory = directory or self.download_directory
 
-        if instrument is None:
-            files = [file for file in self.raw_file if file.endswith('.fits')]
-        else:
-            strict = kwargs.pop('strict', False)
-            instrument = self._check_instrument(instrument, strict=strict)
-            files = []
-            for inst in instrument:
-                files += list(getattr(self, inst).raw_file)
+        strict = kwargs.pop('strict', False)
+        instrument = self._check_instrument(instrument, strict=strict)
+        files = []
+        for inst in instrument:
+            files += list(getattr(self, inst).raw_file)
 
         if index is not None:
             index = np.atleast_1d(index)
@@ -750,6 +838,23 @@ class RV:
         else:
             do_download_filetype('CCF', files[:limit], directory, verbose=self.verbose, **kwargs)
 
+        if load:
+            try:
+                from os.path import basename, join
+                from .utils import sanitize_path
+                import iCCF
+                downloaded = [
+                    sanitize_path(join(directory, basename(f).replace('.fits', '_CCF_A.fits')))
+                    for f in files[:limit]
+                ]
+                if self.verbose:
+                    logger.info('loading the CCF(s) into `.CCF` attribute')
+
+                self.CCF = iCCF.from_file(downloaded)
+
+            except (ImportError, ValueError):
+                pass
+
     def download_s1d(self, instrument=None, index=None, limit=None,
                      directory=None, symlink=False, **kwargs):
         """ Download S1Ds from DACE
@@ -760,17 +865,13 @@ class RV:
             limit (int): Maximum number of files to download.
             directory (str): Directory where to store data.
         """
-        if directory is None:
-            directory = f'{self.star}_downloads'
+        directory = directory or self.download_directory
 
-        if instrument is None:
-            files = [file for file in self.raw_file if file.endswith('.fits')]
-        else:
-            strict = kwargs.pop('strict', False)
-            instrument = self._check_instrument(instrument, strict=strict)
-            files = []
-            for inst in instrument:
-                files += list(getattr(self, inst).raw_file)
+        strict = kwargs.pop('strict', False)
+        instrument = self._check_instrument(instrument, strict=strict)
+        files = []
+        for inst in instrument:
+            files += list(getattr(self, inst).raw_file)
 
         if index is not None:
             index = np.atleast_1d(index)
@@ -796,17 +897,13 @@ class RV:
             limit (int): Maximum number of files to download.
             directory (str): Directory where to store data.
         """
-        if directory is None:
-            directory = f'{self.star}_downloads'
+        directory = directory or self.download_directory
 
-        if instrument is None:
-            files = [file for file in self.raw_file if file.endswith('.fits')]
-        else:
-            strict = kwargs.pop('strict', False)
-            instrument = self._check_instrument(instrument, strict=strict)
-            files = []
-            for inst in instrument:
-                files += list(getattr(self, inst).raw_file)
+        strict = kwargs.pop('strict', False)
+        instrument = self._check_instrument(instrument, strict=strict)
+        files = []
+        for inst in instrument:
+            files += list(getattr(self, inst).raw_file)
 
         if index is not None:
             index = np.atleast_1d(index)
@@ -859,8 +956,9 @@ class RV:
         instruments = self._check_instrument(instrument, strict)
 
         if instruments is None:
-            logger.error(f"No data from instrument '{instrument}'")
-            logger.info(f'available: {self.instruments}')
+            if self.verbose:
+                logger.error(f"No data from instrument '{instrument}'")
+                logger.info(f'available: {self.instruments}')
             return
 
         for instrument in instruments:
@@ -922,7 +1020,11 @@ class RV:
             return
 
         if self.verbose:
-            logger.info(f'removing points {index}')
+            inst = np.unique(self.instrument_array[index])
+            if len(index) == 1:
+                logger.info(f'removing point {index[0]} from {inst[0]}')
+            else:
+                logger.info(f'removing points {index} from {inst}')
 
         self.mask[index] = False
         self._propagate_mask_changes()
@@ -932,6 +1034,31 @@ class RV:
         if config.return_self:
             return self
 
+    def restore_point(self, index):
+        """
+        Restore previously deleted individual observations at a given index (or
+        indices). NOTE: Like Python, the index is 0-based.
+
+        Args:
+            index (int, list, ndarray):
+                Single index, list, or array of indices to restore.
+        """
+        index = np.atleast_1d(index)
+        try:
+            instrument_index = self.obs[index]
+            np.array(self.instruments)[instrument_index - 1]
+        except IndexError:
+            logger.errors(f'index {index} is out of bounds for N={self.N}')
+            return
+
+        if self.verbose:
+            logger.info(f'restoring point{"s" if index.size > 1 else ""} {index}')
+
+        self.mask[index] = True
+        self._propagate_mask_changes()
+        if config.return_self:
+            return self
+
     def remove_non_public(self):
         """ Remove non-public observations """
         if self.verbose:
@@ -1040,6 +1167,11 @@ class RV:
             self.gaia
             self.gaia.plx
 
+            if self.gaia.plx < 0:
+                if self.verbose:
+                    logger.error('negative Gaia parallax, falling back to Simbad')
+                raise AttributeError
+
             if self.verbose:
                 logger.info('using Gaia information to remove secular acceleration')
 
@@ -1054,10 +1186,11 @@ class RV:
             μ = μα**2 + μδ**2
             sa = (μ * d).to(units.m / units.second / units.year,
                             equivalencies=units.dimensionless_angles())
-
         except AttributeError:
             try:
                 self.simbad
+                if self.simbad is None:
+                    raise AttributeError
             except AttributeError:
                 if self.verbose:
                     logger.error('no information from simbad, cannot remove secular acceleration')
@@ -1158,6 +1291,7 @@ class RV:
             return
 
         instruments = self._check_instrument(instrument, strict)
+        changed_instruments = []
 
         for inst in instruments:
             m = self.instrument_array == inst
@@ -1170,6 +1304,10 @@ class RV:
                 s = 's' if (n == 0 or n > 1) else ''
                 logger.warning(f'sigma-clip RVs will remove {n} point{s} for {inst}')
 
+            if n > 0:
+                self.mask[ind] = False
+                changed_instruments.append(inst)
+
             # # check if going to remove all observations from one instrument
             # if n in self.NN.values(): # all observations
             #     # insts = np.unique(self.instrument_array[~ind])
@@ -1180,13 +1318,11 @@ class RV:
             #         return self
             #     continue
 
-            self.mask[ind] = False
-
         self._propagate_mask_changes()
 
         if self._did_adjust_means:
             self._did_adjust_means = False
-            self.adjust_means()
+            self.adjust_means(instrument=changed_instruments)
 
         if config.return_self:
             return self
@@ -1308,11 +1444,16 @@ class RV:
         snew._build_arrays()
         return snew
 
-    def nth_day_mean(self, n=1.0):
+    def nth_day_mean(self, n=1.0, masked=True):
         """ Calculate the n-th day rolling mean of the radial velocities """
-        mask = np.abs(self.mtime[:, None] - self.mtime[None, :]) < n
-        z = np.full((self.mtime.size, self.mtime.size), np.nan)
-        z[mask] = np.repeat(self.mvrad[:, None], self.mtime.size, axis=1)[mask]
+        if masked:
+            mask = np.abs(self.mtime[:, None] - self.mtime[None, :]) < n
+            z = np.full((self.mtime.size, self.mtime.size), np.nan)
+            z[mask] = np.repeat(self.mvrad[:, None], self.mtime.size, axis=1)[mask]
+        else:
+            mask = np.abs(self.time[:, None] - self.time[None, :]) < n
+            z = np.full((self.time.size, self.time.size), np.nan)
+            z[mask] = np.repeat(self.vrad[:, None], self.time.size, axis=1)[mask]
         return np.nanmean(z, axis=0)
 
     def subtract_mean(self):
@@ -1334,13 +1475,26 @@ class RV:
             s.vrad += self._meanRV
         self._build_arrays()
 
-    def adjust_means(self, just_rv=False):
-        """ Subtract individual mean RVs from each instrument """
+    def adjust_means(self, just_rv=False, instrument=None, **kwargs):
+        """
+        Subtract individual mean RVs from each instrument or from specific
+        instruments
+        """
         if self._child or self._did_adjust_means:
             return
 
+        # if self.verbose:
+        #     print_as_table = len(self.instruments) > 2 and len(self.instruments) < 7
+        #     rows = [self.instruments]
+        #     row = []
+        #     if print_as_table:
+        #         logger.info('subtracted weighted average from each instrument:')
+    
         others = ('fwhm', 'bispan', )
-        for inst in self.instruments:
+
+        instruments = self._check_instrument(instrument, strict=kwargs.get('strict', False))
+
+        for inst in instruments:
             s = getattr(self, inst)
 
             if s.mtime.size == 0:
@@ -1361,33 +1515,105 @@ class RV:
             s.vrad -= s.rv_mean
 
             if self.verbose:
+                # if print_as_table:
+                #     row.append(f'{s.rv_mean:.3f}')
+                # else:
                 logger.info(f'subtracted weighted average from {inst:10s}: ({s.rv_mean:.3f} {self.units})')
 
             if just_rv:
                 continue
 
             for i, other in enumerate(others):
-                y, ye = getattr(s, other), getattr(s, other + '_err')
+                try:
+                    y, ye = getattr(s, other), getattr(s, other + '_err')
+                except AttributeError:
+                    continue
                 m = wmean(y[s.mask], ye[s.mask])
                 setattr(s, f'{other}_mean', m)
                 setattr(s, other, getattr(s, other) - m)
 
+        # if print_as_table:
+        #     from .utils import pretty_print_table
+        #     rows.append(row)
+        #     pretty_print_table(rows, logger=logger)
+
         self._build_arrays()
         self._did_adjust_means = True
         if config.return_self:
             return self
 
     def add_to_vrad(self, values):
-        """ Add an array of values to the RVs of all instruments """
+        """ Add a value of array of values to the RVs of all instruments """
+        values = np.atleast_1d(values)
+        if values.size == 1:
+            values = np.full_like(self.vrad, values)
+
+        masked = False
         if values.size != self.vrad.size:
-            raise ValueError(f"incompatible sizes: len(values) must equal self.N, got {values.size} != {self.vrad.size}")
+            if values.size == self.mvrad.size:
+                logger.warning('adding to masked RVs only')
+                masked = True
+            else:
+                raise ValueError(f"incompatible sizes: len(values) must equal self.N, got {values.size} != {self.vrad.size}")
+
+        for inst in self.instruments:
+            s = getattr(self, inst)
+            if masked:
+                mask = self.instrument_array[self.mask] == inst
+                s.vrad[s.mask] += values[mask]
+            else:
+                mask = self.instrument_array == inst
+                s.vrad += values[mask]
+        self._build_arrays()
+
+    def add_to_quantity(self, quantity, values):
+        """
+        Add a value of array of values to the given quantity of all instruments
+        """
+        if not hasattr(self, quantity):
+            logger.error(f"cannot find '{quantity}' attribute")
+            return
+        q = getattr(self, quantity)
+
+        values = np.atleast_1d(values)
+        if values.size == 1:
+            values = np.full_like(q, values)
+        if values.size != q.size:
+            raise ValueError(f"incompatible sizes: len(values) must equal self.N, got {values.size} != {q.size}")
 
         for inst in self.instruments:
             s = getattr(self, inst)
             mask = self.instrument_array == inst
-            s.vrad += values[mask]
+            setattr(s, quantity, getattr(s, quantity) + values[mask])
+        self._build_arrays()
+
+    def change_units(self, new_units):
+        possible = {'m/s': 'm/s', 'km/s': 'km/s', 'ms': 'm/s', 'kms': 'km/s'}
+        if new_units not in possible:
+            msg = f"new_units must be one of 'm/s', 'km/s', 'ms', 'kms', got '{new_units}'"
+            raise ValueError(msg)
+        
+        new_units = possible[new_units]
+        if new_units == self.units:
+            return
+
+        if self.verbose:
+            logger.info(f"changing units from {self.units} to {new_units}")
+
+        if new_units == 'm/s' and self.units == 'km/s':
+            factor = 1e3
+        elif new_units == 'km/s' and self.units == 'm/s':
+            factor = 1e-3
+        
+        for inst in self.instruments:
+            s = getattr(self, inst)
+            s.vrad *= factor
+            s.svrad *= factor
+            s.fwhm *= factor
+            s.fwhm_err *= factor
 
         self._build_arrays()
+        self.units = new_units
 
 
     def put_at_systemic_velocity(self):
@@ -1474,12 +1700,14 @@ class RV:
                         _s.time, _s.vrad, _s.svrad,
                         _s.fwhm, _s.fwhm_err,
                         _s.rhk, _s.rhk_err,
+                        _s.bispan, _s.bispan_err,
                     ]
                 else:
                     d = np.c_[
                         _s.mtime, _s.mvrad, _s.msvrad,
                         _s.fwhm[_s.mask], _s.fwhm_err[_s.mask],
                         _s.rhk[_s.mask], _s.rhk_err[_s.mask],
+                        _s.bispan[_s.mask], _s.bispan_err[_s.mask],
                     ]
                 if not save_nans:
                     if np.isnan(d).any():
@@ -1489,8 +1717,14 @@ class RV:
                         if self.verbose:
                             logger.warning(f'masking {nan_mask.sum()} observations with NaN in indicators')
 
-                header =  'bjd\tvrad\tsvrad\tfwhm\tsfwhm\trhk\tsrhk\n'
-                header += '---\t----\t-----\t----\t-----\t---\t----'
+                header = '\t'.join(['bjd', 'vrad', 'svrad', 
+                                    'fwhm', 'sfwhm',
+                                    'rhk', 'srhk',
+                                    'bispan', 'sbispan'
+                                    ]) 
+                header += '\n'
+                header += '\t'.join(['-' * len(c) for c in header.strip().split('\t')])
+
             else:
                 if save_masked:
                     d = np.c_[_s.time, _s.vrad, _s.svrad]
@@ -1678,3 +1912,62 @@ def fit_sine(t, y, yerr=None, period='gls', fix_period=False):
 
     xbest, _ = leastsq(f, p0, args=(t, y, yerr))
     return xbest, partial(sine, p=xbest)
+
+
+def fit_n_sines(t, y, yerr=None, n=1, period='gls', fix_period=False):
+    """ Fit N sine curves of the form y = ∑i Ai * sin(2π * t / Pi + φi) + c
+
+    Args:
+        t (ndarray):
+            Time array
+        y (ndarray):
+            Array of observed values
+        yerr (ndarray, optional):
+            Array of uncertainties. Defaults to None.
+        n (int, optional):
+            Number of sine curves to fit. Defaults to 1.
+        period (str or float, optional):
+            Initial guess for periods or 'gls' to get them from Lomb-Scargle
+            periodogram. Defaults to 'gls'.
+        fix_period (bool, optional):
+            Whether to fix the periods. Defaults to False.
+
+    Returns:
+        p (ndarray):
+            Best-fit parameters [A, P, φ, c] or [A, φ, c] for each sine curve
+        f (callable):
+            Function that returns the best-fit curve for input times
+    """
+    from scipy.optimize import leastsq
+    if period == 'gls':
+        from astropy.timeseries import LombScargle
+        # first period guess
+        gls = LombScargle(t, y, yerr)
+        freq, power = gls.autopower()
+        period = [1 / freq[power.argmax()]]
+        yc = y.copy()
+        for i in range(1, n):
+            p, f = fit_sine(t, y, yerr, period=period[i-1], fix_period=True)
+            yc -= f(t)
+            gls = LombScargle(t, yc, yerr)
+            freq, power = gls.autopower()
+            period.append(1 / freq[power.argmax()])
+    else:
+        assert len(period) == n, f'wrong number of periods, expected {n} but got {len(period)}'
+
+    if yerr is None:
+        yerr = np.ones_like(y)
+
+    if fix_period:
+        def sine(t, p):
+            return p[-1] + np.sum([p[2*i] * np.sin(2 * np.pi * t / period[i] + p[2*i+1]) for i in range(n)], axis=0)
+        f = lambda p, t, y, ye: (sine(t, p) - y) / ye
+        p0 = [y.std(), 0.0] * n + [y.mean()]
+    else:
+        def sine(t, p):
+            return p[-1] + np.sum([p[3*i] * np.sin(2 * np.pi * t / p[3*i+1] + p[3*i+2]) for i in range(n)], axis=0)
+        f = lambda p, t, y, ye: (sine(t, p) - y) / ye
+        p0 = np.r_[np.insert([y.std(), 0.0] * n, np.arange(1, 2*n, n), period), y.mean()]
+
+    xbest, _ = leastsq(f, p0, args=(t, y, yerr))
+    return xbest, partial(sine, p=xbest)