arvi 0.1.16__py3-none-any.whl → 0.1.19__py3-none-any.whl

arvi/__init__.py

@@ -1,7 +1,16 @@
 __all__ = ['RV']
 
+from importlib.metadata import version, PackageNotFoundError
+
+from .config import config
 from .timeseries import RV
 
+try:
+    __version__ = version("arvi")
+except PackageNotFoundError:
+    # package is not installed
+    pass
+
 ## OLD
 # # the __getattr__ function is always called twice, so we need this
 # # to only build and return the RV object on the second time

arvi/ariadne_wrapper.py

@@ -2,6 +2,9 @@ import os
 import sys
 from matplotlib import pyplot as plt
 
+from .utils import stdout_disabled, all_logging_disabled
+from .setup_logger import logger
+
 try:
     from astroARIADNE.star import Star
     from astroARIADNE.fitter import Fitter

arvi/berv.py

@@ -12,7 +12,7 @@ from astropy.timeseries import LombScargle
 from tqdm import tqdm
 
 from .setup_logger import logger
-from . import config
+from .config import config
 
 
 def correct_rvs(self, simple=False, H=None, save_files=False, plot=True):
@@ -349,7 +349,6 @@ def BERV(self, H=None, use_gaia_meassurements=False, plx=None,
         axs[1].plot(bjd, diff, 'k.', label=label)
         axs[1].axhline(np.mean(diff), ls='--', c='k', alpha=0.1)
 
-        from adjustText import adjust_text
         text = axs[1].text(bjd.max(), diff.min() + 0.1*diff.ptp(), 
                            f'ptp: {diff.ptp()*1e2:.2f} cm/s',
                            ha='right', va='bottom', color='g', alpha=0.8)

arvi/config.py

@@ -1,14 +1,36 @@
-# whether to return self from (some) RV methods
-return_self = False
 
-# whether to check internet connection before querying DACE
-check_internet = False
+def instancer(cls):
+    return cls()
 
-# make all DACE requests without using a .dacerc file
-request_as_public = False
+@instancer
+class config:
+    # configuration values
+    __conf = {
+        # whether to return self from (some) RV methods
+        'return_self': False,
+        # whether to adjust instrument means before gls by default
+        'adjust_means_gls': True,
+        # whether to check internet connection before querying DACE
+        'check_internet': False,
+        # make all DACE requests without using a .dacerc file
+        'request_as_public': False,
+        # username for DACE servers
+        'username': 'desousaj',
+        # debug
+        'debug': False,
+    }
+    # all, for now
+    __setters = list(__conf.keys())
 
-# whether to adjust instrument means before gls by default
-adjust_means_gls = True
+    def __getattr__(self, name):
+        if name in ('__custom_documentations__', ):
+            # return {'return_self': 'help!'}
+            return {}
 
-# debug
-debug = False
+        return self.__conf[name]
+
+    def __setattr__(self, name, value):
+        if name in config.__setters:
+            self.__conf[name] = value
+        else:
+            raise NameError(f"unknown configuration name '{name}'")

arvi/dace_wrapper.py

@@ -10,8 +10,8 @@ from .utils import create_directory, all_logging_disabled, stdout_disabled, tqdm
 
 
 def load_spectroscopy() -> SpectroscopyClass:
-    from .config import request_as_public
-    if request_as_public:
+    from .config import config
+    if config.request_as_public:
         with all_logging_disabled():
             dace = DaceClass(dace_rc_config_path='none')
         return SpectroscopyClass(dace_instance=dace)
@@ -41,14 +41,18 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
 
         # select ESPRESSO mode, which is defined at the level of the pipeline
         if 'ESPRESSO' in inst:
-            if any(ESPRESSO_mode in pipe for pipe in pipelines):
+
+            find_mode = [ESPRESSO_mode in pipe for pipe in pipelines]
+            # the mode was not found
+            if not any(find_mode):
+                if len(pipelines) > 1 and verbose:
+                    logger.warning(f'no observations for requested ESPRESSO mode ({ESPRESSO_mode})')
+            # the mode was found but do nothing if it's the only one
+            elif any(find_mode) and not all(find_mode):
                 if verbose:
                     logger.info(f'selecting mode {ESPRESSO_mode} for ESPRESSO')
                 i = [i for i, pipe in enumerate(pipelines) if ESPRESSO_mode in pipe][0]
                 pipelines = [pipelines[i]]
-            else:
-                if len(pipelines) > 1 and verbose:
-                    logger.warning(f'no observations for requested ESPRESSO mode ({ESPRESSO_mode})')
 
         if latest_pipeline:
             if verbose and len(pipelines) > 1:
@@ -59,6 +63,7 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
         for pipe in pipelines:
             modes = list(result[inst][pipe].keys())
 
+                
             # select NIRPS mode, which is defined at the level of the mode
             if 'NIRPS' in inst:
                 if NIRPS_mode in modes:
@@ -70,6 +75,19 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
                     if verbose:
                         logger.warning(f'no observations for requested NIRPS mode ({NIRPS_mode})')
 
+            # HARPS15 observations should not be separated by 'mode' if some are
+            # done together with NIRPS
+            if 'HARPS15' in inst and 'HARPS+NIRPS' in modes:
+                m0 = modes[0]
+                data = {
+                    k: np.concatenate([result[inst][pipe][m][k] for m in modes])
+                    for k in result[inst][pipe][m0].keys()
+                }
+                arrays.append(
+                    ((inst, pipe, m0), data)
+                )
+                continue
+
             for mode in modes:
                 if 'rjd' not in result[inst][pipe][mode]:
                     logger.error(f"No 'rjd' key for {inst} - {pipe}")
@@ -105,7 +123,7 @@ def get_observations_from_instrument(star, instrument, main_id=None):
 
     Spectroscopy = load_spectroscopy()
     filters = {
-        "ins_name": {"contains": [instrument]}, 
+        "ins_name": {"contains": [instrument]},
         "obj_id_daceid": {"contains": [dace_id]}
     }
     with stdout_disabled(), all_logging_disabled():
@@ -115,62 +133,70 @@ def get_observations_from_instrument(star, instrument, main_id=None):
         raise ValueError
 
     r = {}
+
     for inst in np.unique(result['ins_name']):
         mask1 = result['ins_name'] == inst
         r[inst] = {}
+
         for pipe in np.unique(result['ins_drs_version'][mask1]):
             mask2 = mask1 & (result['ins_drs_version'] == pipe)
-            ins_mode = np.unique(result['ins_mode'][mask2])[0]
-            _nan = np.full(mask2.sum(), np.nan)
-            r[inst][pipe] = {
-                ins_mode: {
-                    'texp': result['texp'][mask2],
-                    'bispan': result['spectro_ccf_bispan'][mask2],
-                    'bispan_err': result['spectro_ccf_bispan_err'][mask2],
-                    'drift_noise': result['spectro_cal_drift_noise'][mask2],
-                    'rjd': result['obj_date_bjd'][mask2],
+            r[inst][pipe] = {}
+
+            for ins_mode in np.unique(result['ins_mode'][mask2]):
+                mask3 = mask2 & (result['ins_mode'] == ins_mode)
+                _nan = np.full(mask3.sum(), np.nan)
+
+                r[inst][pipe][ins_mode] = {
+                    'texp': result['texp'][mask3],
+                    'bispan': result['spectro_ccf_bispan'][mask3],
+                    'bispan_err': result['spectro_ccf_bispan_err'][mask3],
+                    'drift_noise': result['spectro_cal_drift_noise'][mask3],
+                    'rjd': result['obj_date_bjd'][mask3],
                     'cal_therror': _nan,
-                    'fwhm': result['spectro_ccf_fwhm'][mask2],
-                    'fwhm_err': result['spectro_ccf_fwhm_err'][mask2],
-                    'rv': result['spectro_ccf_rv'][mask2],
-                    'rv_err': result['spectro_ccf_rv_err'][mask2],
-                    'berv': result['spectro_cal_berv'][mask2],
+                    'fwhm': result['spectro_ccf_fwhm'][mask3],
+                    'fwhm_err': result['spectro_ccf_fwhm_err'][mask3],
+                    'rv': result['spectro_ccf_rv'][mask3],
+                    'rv_err': result['spectro_ccf_rv_err'][mask3],
+                    'berv': result['spectro_cal_berv'][mask3],
                     'ccf_noise': _nan,
-                    'rhk': result['spectro_analysis_rhk'][mask2],
-                    'rhk_err': result['spectro_analysis_rhk_err'][mask2],
-                    'contrast': result['spectro_ccf_contrast'][mask2],
-                    'contrast_err': result['spectro_ccf_contrast_err'][mask2],
-                    'cal_thfile': result['spectro_cal_thfile'][mask2],
-                    'spectroFluxSn50': result['spectro_flux_sn50'][mask2],
-                    'protm08': result['spectro_analysis_protm08'][mask2],
-                    'protm08_err': result['spectro_analysis_protm08_err'][mask2],
-                    'caindex': result['spectro_analysis_ca'][mask2],
-                    'caindex_err': result['spectro_analysis_ca_err'][mask2],
-                    'pub_reference': result['pub_ref'][mask2],
-                    'drs_qc': result['spectro_drs_qc'][mask2],
-                    'haindex': result['spectro_analysis_halpha'][mask2],
-                    'haindex_err': result['spectro_analysis_halpha_err'][mask2],
-                    'protn84': result['spectro_analysis_protn84'][mask2],
-                    'protn84_err': result['spectro_analysis_protn84_err'][mask2],
-                    'naindex': result['spectro_analysis_na'][mask2],
-                    'naindex_err': result['spectro_analysis_na_err'][mask2],
+                    'rhk': result['spectro_analysis_rhk'][mask3],
+                    'rhk_err': result['spectro_analysis_rhk_err'][mask3],
+                    'contrast': result['spectro_ccf_contrast'][mask3],
+                    'contrast_err': result['spectro_ccf_contrast_err'][mask3],
+                    'cal_thfile': result['spectro_cal_thfile'][mask3],
+                    'spectroFluxSn50': result['spectro_flux_sn50'][mask3],
+                    'protm08': result['spectro_analysis_protm08'][mask3],
+                    'protm08_err': result['spectro_analysis_protm08_err'][mask3],
+                    'caindex': result['spectro_analysis_ca'][mask3],
+                    'caindex_err': result['spectro_analysis_ca_err'][mask3],
+                    'pub_reference': result['pub_ref'][mask3],
+                    'drs_qc': result['spectro_drs_qc'][mask3],
+                    'haindex': result['spectro_analysis_halpha'][mask3],
+                    'haindex_err': result['spectro_analysis_halpha_err'][mask3],
+                    'protn84': result['spectro_analysis_protn84'][mask3],
+                    'protn84_err': result['spectro_analysis_protn84_err'][mask3],
+                    'naindex': result['spectro_analysis_na'][mask3],
+                    'naindex_err': result['spectro_analysis_na_err'][mask3],
                     'snca2': _nan,
-                    'mask': result['spectro_ccf_mask'][mask2],
-                    'public': result['public'][mask2],
-                    'spectroFluxSn20': result['spectro_flux_sn20'][mask2],
-                    'sindex': result['spectro_analysis_smw'][mask2],
-                    'sindex_err': result['spectro_analysis_smw_err'][mask2],
+                    'mask': result['spectro_ccf_mask'][mask3],
+                    'public': result['public'][mask3],
+                    'spectroFluxSn20': result['spectro_flux_sn20'][mask3],
+                    'sindex': result['spectro_analysis_smw'][mask3],
+                    'sindex_err': result['spectro_analysis_smw_err'][mask3],
                     'drift_used': _nan,
-                    'ccf_asym': result['spectro_ccf_asym'][mask2],
-                    'ccf_asym_err': result['spectro_ccf_asym_err'][mask2],
-                    'date_night': result['date_night'][mask2],
-                    'raw_file': result['file_rootpath'][mask2],
-                    'prog_id': result['prog_id'][mask2],
-                    'th_ar': result['th_ar'][mask2],
-                    'th_ar1': result['th_ar1'][mask2],
-                    'th_ar2': result['th_ar2'][mask2],
+                    'ccf_asym': result['spectro_ccf_asym'][mask3],
+                    'ccf_asym_err': result['spectro_ccf_asym_err'][mask3],
+                    'date_night': result['date_night'][mask3],
+                    'raw_file': result['file_rootpath'][mask3],
+                    'prog_id': result['prog_id'][mask3],
+                    'th_ar': result['th_ar'][mask3],
+                    'th_ar1': result['th_ar1'][mask3],
+                    'th_ar2': result['th_ar2'][mask3],
                 }
-            }
+    
+    # print(r.keys())    
+    # print([r[k].keys() for k in r.keys()])
+    # print([r[k1][k2].keys() for k1 in r.keys() for k2 in r[k1].keys()])
     return r
 
 def get_observations(star, instrument=None, main_id=None, verbose=True):
@@ -225,9 +251,9 @@ def get_observations(star, instrument=None, main_id=None, verbose=True):
     # (i.e. ensure that 3.x.x > 3.5)
     from re import match
     def cmp(a, b):
-        if a[0] in ('3.5', '3.5 EGGS') and match(r'3.\d.\d', b[0]):
+        if a[0] in ('3.5', '3.5 EGGS') or 'EGGS' in a[0] and match(r'3.\d.\d', b[0]):
             return -1
-        if b[0] in ('3.5', '3.5 EGGS') and match(r'3.\d.\d', a[0]):
+        if b[0] in ('3.5', '3.5 EGGS') or 'EGGS' in b[0] and match(r'3.\d.\d', a[0]):
             return 1
 
         if a[0] == b[0]:
@@ -248,16 +274,20 @@ def get_observations(star, instrument=None, main_id=None, verbose=True):
             _inst = ''
             for inst in instruments:
                 pipelines = list(new_result[inst].keys())
+                max_len = max([len(pipe) for pipe in pipelines])
                 for pipe in pipelines:
+                    last_pipe = pipe == pipelines[-1]
                     modes = list(new_result[inst][pipe].keys())
                     for mode in modes:
                         N = len(new_result[inst][pipe][mode]['rjd'])
                         # LOG
-                        if inst == _inst:
-                            logger.info(f'{" ":>12s} └ {pipe} - {mode} ({N} observations)')
+                        if inst == _inst and last_pipe:
+                            logger.info(f'{" ":>12s} └ {pipe:{max_len}s} - {mode} ({N} observations)')
+                        elif inst == _inst:
+                            logger.info(f'{" ":>12s} ├ {pipe:{max_len}s} - {mode} ({N} observations)')
                         else:
-                            logger.info(f'{inst:>12s} ├ {pipe} - {mode} ({N} observations)')
-                        _inst = inst
+                            logger.info(f'{inst:>12s} ├ {pipe:{max_len}s} - {mode} ({N} observations)')
+                            _inst = inst
 
     return new_result
 
@@ -381,12 +411,12 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
 
     if verbose:
         if chunk_size < n:
-            msg = f"Downloading {n} {type}s "
+            msg = f"downloading {n} {type}s "
             msg += f"(in chunks of {chunk_size}) "
             msg += f"into '{output_directory}'..."
             logger.info(msg)
         else:
-            msg = f"Downloading {n} {type}s into '{output_directory}'..."
+            msg = f"downloading {n} {type}s into '{output_directory}'..."
             logger.info(msg)
 
     iterator = [raw_files[i:i + chunk_size] for i in range(0, n, chunk_size)]
@@ -394,7 +424,7 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
         download(files, type, output_directory)
         extract_fits(output_directory)
 
-    logger.info('Extracted .fits files')
+    logger.info('extracted .fits files')
 
 
 # def do_download_s1d(raw_files, output_directory, clobber=False, verbose=True):

arvi/gaia_wrapper.py

@@ -22,11 +22,24 @@ CONTAINS(
 )=1
 """
 
+QUERY_ID = """
+SELECT TOP 20 gaia_source.designation,gaia_source.source_id,gaia_source.ra,gaia_source.dec,gaia_source.parallax,gaia_source.pmra,gaia_source.pmdec,gaia_source.ruwe,gaia_source.phot_g_mean_mag,gaia_source.bp_rp,gaia_source.radial_velocity,gaia_source.phot_variable_flag,gaia_source.non_single_star,gaia_source.has_xp_continuous,gaia_source.has_xp_sampled,gaia_source.has_rvs,gaia_source.has_epoch_photometry,gaia_source.has_epoch_rv,gaia_source.has_mcmc_gspphot,gaia_source.has_mcmc_msc,gaia_source.teff_gspphot,gaia_source.logg_gspphot,gaia_source.mh_gspphot,gaia_source.distance_gspphot,gaia_source.azero_gspphot,gaia_source.ag_gspphot,gaia_source.ebpminrp_gspphot
+FROM gaiadr3.gaia_source 
+WHERE 
+gaia_source.source_id = {id}
+"""
+
+translate = {
+    'Proxima': '5853498713190525696',
+    'LS II +14 13': '4318465066420528000',
+}
+
+
 def run_query(query):
     url = 'https://gea.esac.esa.int/tap-server/tap/sync'
     data = dict(query=query, request='doQuery', lang='ADQL', format='csv')
     try:
-        response = requests.post(url, data=data, timeout=5)
+        response = requests.post(url, data=data, timeout=2)
     except requests.ReadTimeout as err:
         raise IndexError(err)
     except requests.ConnectionError as err:
@@ -71,8 +84,13 @@ class gaia:
         args = dict(ra=ra, dec=dec, plx=plx, pmra=pmra, pmdec=pmdec, rv=rv)          
 
         try:
-            table1 = run_query(query=QUERY.format(**args))
-            results = parse_csv(table1)[0]
+            if star in translate:
+                table = run_query(query=QUERY_ID.format(id=translate[star]))
+            elif hasattr(simbad, 'gaia_id'):
+                table = run_query(query=QUERY_ID.format(id=simbad.gaia_id))
+            else:
+                table = run_query(query=QUERY.format(**args))
+            results = parse_csv(table)[0]
         except IndexError:
             raise ValueError(f'Gaia query for {star} failed')
         

arvi/instrument_specific.py

@@ -3,13 +3,99 @@ import numpy as np
 
 from .setup_logger import logger
 
+
+# HARPS fiber upgrade (28 May 2015)
+# https://www.eso.org/sci/facilities/lasilla/instruments/harps/news/harps_upgrade_2015.html
+HARPS_technical_intervention = 57170
+
+# ESPRESSO fiber link upgrade (1 July 2019)
+ESPRESSO_technical_intervention = 58665
+
+
+def divide_ESPRESSO(self):
+    """ Split ESPRESSO data into separate sub ESP18 and ESP19 subsets """
+    if self._check_instrument('ESPRESSO', strict=False) is None:
+        return
+    if 'ESPRESSO18' in self.instruments and 'ESPRESSO19' in self.instruments:
+        if self.verbose:
+            logger.info('ESPRESSO data seems to be split already, doing nothing')
+        return
+
+    from .timeseries import RV
+
+    before = self.time < ESPRESSO_technical_intervention
+    after = self.time >= ESPRESSO_technical_intervention
+    new_instruments = []
+
+
+    for inst, mask in zip(['ESPRESSO18', 'ESPRESSO19'], [before, after]):
+        if not mask.any():
+            continue
+
+        _s = RV.from_arrays(self.star, self.time[mask], self.vrad[mask], self.svrad[mask],
+                            inst=inst)
+        for q in self._quantities:
+            setattr(_s, q, getattr(self, q)[mask])
+        setattr(self, inst, _s)
+        _s._quantities = self._quantities
+        _s.mask = self.mask[mask]
+        new_instruments.append(inst)
+
+    delattr(self, 'ESPRESSO')
+    self.instruments = new_instruments
+    self._build_arrays()
+
+    if self.verbose:
+        logger.info(f'divided ESPRESSO into {self.instruments}')
+    
+
+def divide_HARPS(self):
+    """ Split HARPS data into separate sub HARPS03 and HARPS15 subsets """
+    if self._check_instrument('HARPS', strict=False) is None:
+        return
+    if 'HARPS03' in self.instruments and 'HARPS15' in self.instruments:
+        if self.verbose:
+            logger.info('HARPS data seems to be split already, doing nothing')
+        return
+
+    from .timeseries import RV
+
+    new_instruments = []
+    before = self.time < HARPS_technical_intervention
+    if before.any():
+        new_instruments += ['HARPS03']
+
+    after = self.time >= HARPS_technical_intervention
+    if after.any():
+        new_instruments += ['HARPS15']
+
+    for inst, mask in zip(new_instruments, [before, after]):
+        _s = RV.from_arrays(self.star, self.time[mask], self.vrad[mask], self.svrad[mask],
+                            inst=inst)
+        for q in self._quantities:
+            setattr(_s, q, getattr(self, q)[mask])
+        setattr(self, inst, _s)
+        _s._quantities = self._quantities
+        _s.mask = self.mask[mask]
+
+    delattr(self, 'HARPS')
+    self.instruments = new_instruments
+    self._build_arrays()
+
+    if self.verbose:
+        logger.info(f'divided HARPS into {self.instruments}')
+    
+
+
 # ESPRESSO ADC issues
 from .utils import ESPRESSO_ADC_issues
 
-def ADC_issues(self, plot=True, check_headers=False):
-    """ Identify and mask points affected by ADC issues (ESPRESSO).
+def ADC_issues(self, mask=True, plot=True, check_headers=False):
+    """ Identify and optionally mask points affected by ADC issues (ESPRESSO).
 
     Args:
+        mask (bool, optional):
+            Whether to mask out the points.
         plot (bool, optional):
             Whether to plot the masked points.
         check_headers (bool, optional):
@@ -17,11 +103,10 @@ def ADC_issues(self, plot=True, check_headers=False):
     """
     instruments = self._check_instrument('ESPRESSO')
     
-    if len(instruments) < 1:
+    if instruments is None:
         if self.verbose:
-            logger.error(f"no data from ESPRESSO")
-            logger.info(f'available: {self.instruments}')
-    
+            logger.error(f"ADC_issues: no data from ESPRESSO")
+        return
 
     affected_file_roots = ESPRESSO_ADC_issues()
     file_roots = [os.path.basename(f).replace('.fits', '') for f in self.raw_file]
@@ -42,29 +127,31 @@ def ADC_issues(self, plot=True, check_headers=False):
         logger.info(f"there {'are'[:n^1]}{'is'[n^1:]} {n} frame{'s'[:n^1]} "
                      "affected by ADC issues")
 
-    self.mask[intersect] = False
-    self._propagate_mask_changes()
+    if mask:
+        self.mask[intersect] = False
+        self._propagate_mask_changes()
 
-    if plot:
-        self.plot(show_masked=True)
+        if plot:
+            self.plot(show_masked=True)
 
     return intersect
 
 # ESPRESSO cryostat issues
 from .utils import ESPRESSO_cryostat_issues
 
-def blue_cryostat_issues(self, plot=True):
+def blue_cryostat_issues(self, mask=True, plot=True):
     """ Identify and mask points affected by blue cryostat issues (ESPRESSO).
 
     Args:
+        mask (bool, optional): Whether to mask out the points.
         plot (bool, optional): Whether to plot the masked points.
     """
     instruments = self._check_instrument('ESPRESSO')
     
-    if len(instruments) < 1:
+    if instruments is None:
         if self.verbose:
-            logger.error(f"no data from ESPRESSO")
-            logger.info(f'available: {self.instruments}')
+            logger.error(f"blue_cryostat_issues: no data from ESPRESSO")
+        return
 
     affected_file_roots = ESPRESSO_cryostat_issues()
     file_roots = [os.path.basename(f).replace('.fits', '') for f in self.raw_file]
@@ -77,11 +164,12 @@ def blue_cryostat_issues(self, plot=True):
         logger.info(f"there {'are'[:n^1]}{'is'[n^1:]} {n} frame{'s'[:n^1]} "
                      "affected by blue cryostat issues")
 
-    self.mask[intersect] = False
-    self._propagate_mask_changes()
+    if mask:
+        self.mask[intersect] = False
+        self._propagate_mask_changes()
 
-    if plot:
-        self.plot(show_masked=True)
+        if plot:
+            self.plot(show_masked=True)
 
     return intersect
 
@@ -132,24 +220,27 @@ def qc_scired_issues(self, plot=False, **kwargs):
     return affected
 
 
-def known_issues(self, plot=False, **kwargs):
-    """ Identify and mask known instrumental issues (ADC and blue cryostat for ESPRESSO)
+def known_issues(self, mask=True, plot=False, **kwargs):
+    """ Identify and optionally mask known instrumental issues (ADC and blue cryostat for ESPRESSO)
 
     Args:
+        mask (bool, optional): Whether to mask out the points.
         plot (bool, optional): Whether to plot the masked points.
     """
     try:
-        adc = ADC_issues(self, plot, **kwargs)
-    except IndexError as e:
+        adc = ADC_issues(self, mask, plot, **kwargs)
+    except IndexError:
         # logger.error(e)
         logger.error('are the data binned? cannot proceed to mask these points...')
 
     try:
-        cryostat = blue_cryostat_issues(self, plot)
-    except IndexError as e:
+        cryostat = blue_cryostat_issues(self, mask, plot)
+    except IndexError:
         # logger.error(e)
         logger.error('are the data binned? cannot proceed to mask these points...')
 
+    if adc is None and cryostat is None:
+        return
     try:
         return adc | cryostat
     except UnboundLocalError:

arvi/kima_wrapper.py

@@ -0,0 +1,74 @@
+import os
+import numpy as np
+
+from .setup_logger import logger
+
+try:
+    import kima
+    from kima.pykima.utils import chdir
+    from kima import distributions
+    from kima import RVData, RVmodel
+    kima_available = True
+except ImportError:
+    kima_available = False
+
+
+def try_to_guess_prior(model, prior):
+    if 'jitter' in prior:
+        return 'Jprior'
+    if 'vsys' in prior:
+        return 'Cprior'
+    return None
+
+
+def run_kima(self, run=False, load=False, run_directory=None, priors={}, **kwargs):
+    if not kima_available:
+        raise ImportError('kima not available, please install with `pip install kima`')
+
+    time = [getattr(self, inst).mtime for inst in self.instruments]
+    vrad = [getattr(self, inst).mvrad for inst in self.instruments]
+    err = [getattr(self, inst).msvrad for inst in self.instruments]
+    data = RVData(time, vrad, err, instruments=self.instruments)
+
+    fix = kwargs.pop('fix', False)
+    npmax = kwargs.pop('npmax', 1)
+    model = RVmodel(fix=fix, npmax=npmax, data=data)
+
+    model.trend = kwargs.pop('trend', False)
+    model.degree = kwargs.pop('degree', 0)
+
+    model.studentt = kwargs.pop('studentt', False)
+    model.enforce_stability = kwargs.pop('enforce_stability', False)
+    model.star_mass = kwargs.pop('star_mass', 1.0)
+
+    for k, v in priors.items():
+        try:
+            if 'conditional' in k:
+                setattr(model.conditional, k.replace('conditional.', ''), v)
+            else:
+                setattr(model, k, v)
+
+        except AttributeError:
+            msg = f'`RVmodel` has no attribute `{k}`, '
+            if guess := try_to_guess_prior(model, k):
+                msg += f'did you mean `{guess}`?'
+            logger.warning(msg)
+            return
+
+    if run:
+        if run_directory is None:
+            run_directory = os.getcwd()
+        
+        # TODO: use signature of kima.run to pop the correct kwargs
+        # model_name = model.__class__.__name__
+        # model_name = f'kima.{model_name}.{model_name}'
+        # signature, defaults = [sig for sig in kima.run.__nb_signature__ if model_name in sig[0]]
+
+        with chdir(run_directory):
+            kima.run(model, **kwargs)
+        
+        if load:
+            res = kima.load_results(model)
+            return data, model, res
+
+    return data, model