arvi 0.1.15__tar.gz → 0.1.18__tar.gz

{arvi-0.1.15 → arvi-0.1.18}/.gitignore

@@ -1,4 +1,8 @@
 *.fits
+*.pkl
+*.rdb
+arvi/data/KOBE-translate.csv
+
 
 
 # Byte-compiled / optimized / DLL files

{arvi-0.1.15 → arvi-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arvi
-Version: 0.1.15
+Version: 0.1.18
 Summary: The Automated RV Inspector
 Author-email: João Faria <joao.faria@unige.ch>
 License: MIT

{arvi-0.1.15 → arvi-0.1.18}/arvi/dace_wrapper.py

@@ -36,23 +36,23 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
     arrays = []
     instruments = list(result.keys())
 
-    # if verbose:
-    #     if latest_pipeline:
-    #         logger.info('selecting latest pipeline version')
-
     for inst in instruments:
         pipelines = list(result[inst].keys())
 
         # 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:
@@ -63,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:
@@ -74,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}")
@@ -119,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):
@@ -226,11 +248,12 @@ def get_observations(star, instrument=None, main_id=None, verbose=True):
         raise ValueError(msg)
 
     # sort pipelines, being extra careful with HARPS pipeline names
-    # (i.e. ensure that 3.0.0 > 3.5)
+    # (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 b[0] == '3.0.0':
+        if a[0] in ('3.5', '3.5 EGGS') and match(r'3.\d.\d', b[0]):
             return -1
-        if b[0] in ('3.5', '3.5 EGGS') and a[0] == '3.0.0':
+        if b[0] in ('3.5', '3.5 EGGS') and match(r'3.\d.\d', a[0]):
             return 1
 
         if a[0] == b[0]:
@@ -243,8 +266,7 @@ def get_observations(star, instrument=None, main_id=None, verbose=True):
     from functools import cmp_to_key
     new_result = {}
     for inst in instruments:
-        new_result[inst] = dict(sorted(result[inst].items(),
-                                       key=cmp_to_key(cmp), reverse=True))
+        new_result[inst] = dict(sorted(result[inst].items(), key=cmp_to_key(cmp), reverse=True))
 
     if verbose:
         logger.info('RVs available from')
@@ -252,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
 

{arvi-0.1.15 → arvi-0.1.18}/arvi/gaia_wrapper.py

@@ -22,6 +22,18 @@ 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 = {
+    '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')
@@ -71,8 +83,11 @@ 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]))
+            else:
+                table = run_query(query=QUERY.format(**args))
+            results = parse_csv(table)[0]
         except IndexError:
             raise ValueError(f'Gaia query for {star} failed')
         

{arvi-0.1.15 → arvi-0.1.18}/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):
@@ -42,21 +128,23 @@ 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')
@@ -77,11 +165,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,20 +221,21 @@ 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)
+        adc = ADC_issues(self, mask, plot, **kwargs)
     except IndexError as e:
         # logger.error(e)
         logger.error('are the data binned? cannot proceed to mask these points...')
 
     try:
-        cryostat = blue_cryostat_issues(self, plot)
+        cryostat = blue_cryostat_issues(self, mask, plot)
     except IndexError as e:
         # logger.error(e)
         logger.error('are the data binned? cannot proceed to mask these points...')

{arvi-0.1.15 → arvi-0.1.18}/arvi/plots.py

@@ -431,12 +431,16 @@ def plot_quantity(self, quantity, ax=None, show_masked=False, instrument=None,
             p = p.replace('_', '.')
             label = f'{i}-{p}'
 
-        y = getattr(s, quantity)
+        y = getattr(s, quantity).copy()
         try:
-            ye = getattr(s, quantity + '_err')
+            ye = getattr(s, quantity + '_err').copy()
         except AttributeError:
             ye = np.zeros_like(y)
 
+        if (nans := np.isnan(y)).any():
+            if self.verbose:
+                logger.warning(f'{nans.sum()} NaN values for {inst}')
+            ye[nans] = np.nan
 
         if np.isnan(y).all() or np.isnan(ye).all():
             lines, *_ = ax.errorbar([], [], [],
@@ -464,7 +468,7 @@ def plot_quantity(self, quantity, ax=None, show_masked=False, instrument=None,
     ax.minorticks_on()
 
     ylabel = {
-        quantity: quantity,
+        quantity.lower(): quantity,
         'fwhm': f'FWHM [{self.units}]',
         'bispan': f'BIS [{self.units}]',
         'rhk': r"$\log$ R'$_{HK}$",
@@ -485,6 +489,7 @@ def plot_quantity(self, quantity, ax=None, show_masked=False, instrument=None,
 
 plot_fwhm = partialmethod(plot_quantity, quantity='fwhm')
 plot_bis = partialmethod(plot_quantity, quantity='bispan')
+plot_contrast = partialmethod(plot_quantity, quantity='contrast')
 plot_rhk = partialmethod(plot_quantity, quantity='rhk')
 plot_berv = partialmethod(plot_quantity, quantity='berv')
 
@@ -518,7 +523,7 @@ def gls(self, ax=None, label=None, fap=True, instrument=None, adjust_means=confi
 
     if not self._did_adjust_means and not adjust_means:
         logger.warning('gls() called before adjusting instrument means, '
-                       'consider using `adjust_means` argument')
+                       'consider using the `adjust_means` argument')
 
     if instrument is not None:
         strict = kwargs.pop('strict', False)
@@ -536,11 +541,11 @@ def gls(self, ax=None, label=None, fap=True, instrument=None, adjust_means=confi
         if adjust_means and not self._child:
             if self.verbose:
                 logger.info('adjusting instrument means before gls')
-            means = np.empty_like(y)
+            means = np.zeros_like(y)
             for i in instrument:
                 mask = self.instrument_array[instrument_mask & self.mask] == i
                 if len(y[mask]) > 0:
-                    means += wmean(y[mask], e[mask]) * mask
+                    means = means + wmean(y[mask], e[mask]) * mask
             y = y - means
 
     else:
@@ -551,11 +556,11 @@ def gls(self, ax=None, label=None, fap=True, instrument=None, adjust_means=confi
         if adjust_means and not self._child:
             if self.verbose:
                 logger.info('adjusting instrument means before gls')
-            means = np.empty_like(y)
+            means = np.zeros_like(y)
             for i in self.instruments:
                 mask = self.instrument_array[self.mask] == i
                 if len(y[mask]) > 0:
-                    means += wmean(y[mask], e[mask]) * mask
+                    means = means + wmean(y[mask], e[mask]) * mask
             y = y - means
 
     self._gls = gls = LombScargle(t, y, e)
@@ -623,31 +628,70 @@ def gls(self, ax=None, label=None, fap=True, instrument=None, adjust_means=confi
         return fig, ax
 
 
-@plot_fast
-def gls_quantity(self, quantity, ax=None, fap=True, picker=True):
+# @plot_fast
+def gls_quantity(self, quantity, ax=None, fap=True, instrument=None,
+                 adjust_means=True, picker=True, **kwargs):
+
     if not hasattr(self, quantity):
-        logger.error(f"cannot find '{quantity}' attribute")
+        if self.verbose:
+            logger.error(f"cannot find '{quantity}' attribute")
         return
 
-    if ax is None:
-        fig, ax = plt.subplots(1, 1, constrained_layout=True)
-    else:
-        fig = ax.figure
+    if self.N == 0:
+        if self.verbose:
+            logger.error('no data to compute gls')
+        return
+
+    if not self._did_adjust_means and not adjust_means:
+        logger.warning('gls() called before adjusting instrument means, '
+                       'consider using the `adjust_means` argument')
+
+    strict = kwargs.pop('strict', False)
+    instrument = self._check_instrument(instrument, strict=strict, log=True)
+    if instrument is None:
+        return
+
+    instrument_mask = np.isin(self.instrument_array, instrument)
+    final_mask = instrument_mask & self.mask
 
-    t = self.mtime
-    y = getattr(self, quantity)[self.mask]
+    t = self.time[final_mask].copy()
+    y = getattr(self, quantity)[final_mask].copy()
     try:
-        ye = getattr(self, quantity + '_err')[self.mask]
+        ye = getattr(self, quantity + '_err')[final_mask].copy()
     except AttributeError:
         ye = None
 
-    if np.isnan(y).any():
+    if self.verbose:
+        logger.info(f'calculating periodogram for instrument {instrument}')
+
+    nan_mask = np.isnan(y)
+    if nan_mask.any():
         if self.verbose:
             logger.warning(f'{quantity} contains NaNs, ignoring them')
-        m = np.isnan(y)
-        t = t[~m]
-        y = y[~m]
-        ye = ye[~m]
+
+    if adjust_means and not self._child:
+        if self.verbose:
+            logger.info('adjusting instrument means before gls')
+        means = np.zeros_like(y)
+        for i in instrument:
+            mask = (self.instrument_array[final_mask] == i) & ~nan_mask
+            if len(y[mask]) > 0:
+                # print(wmean(y[mask], ye[mask]))
+                means += wmean(y[mask], ye[mask]) * mask
+        y = y - means
+
+    t = t[~nan_mask]
+    y = y[~nan_mask]
+    ye = ye[~nan_mask]
+
+    if len(y) == 0:
+        logger.error('no data left to compute gls after removing NaNs')
+        return
+
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, constrained_layout=True)
+    else:
+        fig = ax.figure
 
     gls = LombScargle(t, y, ye)
     freq, power = gls.autopower(maximum_frequency=1.0)

{arvi-0.1.15 → arvi-0.1.18}/arvi/simbad_wrapper.py

@@ -108,7 +108,10 @@ class simbad:
                     for line in f.readlines():
                         kobe_id, catname = line.strip().split(',')
                         kobe_translate[kobe_id] = catname
-                self.star = star = kobe_translate[self.star]
+                try:
+                    self.star = star = kobe_translate[self.star]
+                except KeyError:
+                    raise ValueError(f'simbad query for {star} failed')
 
         # oid = run_query(query=OID_QUERY.format(star=star))
         # self.oid = str(oid.split()[-1])

{arvi-0.1.15 → arvi-0.1.18}/arvi/stellar.py

@@ -1,22 +1,32 @@
+
 import numpy as np
 
 class prot_age_result:
-    prot_n84: float
-    prot_n84_err: float
-    prot_m08: float
-    prot_m08_err: float
-    age_m08: float
-    age_m08_err: float
+    prot_n84 = None #: float | np.ndarray
+    prot_n84_err = None #: float | np.ndarray
+    prot_m08 = None #: float | np.ndarray
+    prot_m08_err = None #: float | np.ndarray
+    age_m08 = None #: float | np.ndarray
+    age_m08_err = None #: float | np.ndarray
     def __init__(self):
         pass
     def __repr__(self):
-        s = f'{self.prot_n84=:.2f} ± {self.prot_n84_err:.2f}, '
-        s += f'{self.prot_m08=:.2f} ± {self.prot_m08_err:.2f}, '
-        s += f'{self.age_m08=:.2f} ± {self.age_m08_err:.2f}'
+        if isinstance(self.prot_n84, np.ndarray):
+            s = f'{self.prot_n84.mean()=:.2f} ± {self.prot_n84_err.mean():.2f}, '
+        else:
+            s = f'{self.prot_n84=:.2f} ± {self.prot_n84_err:.2f}, '
+        if isinstance(self.prot_m08, np.ndarray):
+            s += f'{self.prot_m08.mean()=:.2f} ± {self.prot_m08_err.mean():.2f}, '
+        else:
+            s += f'{self.prot_m08=:.2f} ± {self.prot_m08_err:.2f}, '
+        if isinstance(self.age_m08, np.ndarray):
+            s += f'{self.age_m08.mean()=:.2f} ± {self.age_m08_err.mean():.2f}'
+        else:
+            s += f'{self.age_m08=:.2f} ± {self.age_m08_err:.2f}'
         return s.replace('self.', '')
 
 
-def calc_prot_age(self, bv=None):
+def calc_prot_age(self, bv=None, array=False):
     """
     Calculate rotation period and age from logR'HK activity level, based on the
     empirical relations of Noyes et al. (1984) and Mamajek & Hillenbrand (2008).
@@ -46,7 +56,12 @@ def calc_prot_age(self, bv=None):
     Range of logR'HK-Prot relation: -5.5 < logR'HK < -4.3
     Range of Mamajek & Hillenbrand (2008) relation for ages: 0.5 < B-V < 0.9
     """
-    log_rhk = np.nanmean(self.rhk[self.mask])
+
+    if array:
+        log_rhk = self.rhk[~np.isnan(self.rhk)]
+    else:
+        log_rhk = np.nanmean(self.rhk[self.mask])
+
     if bv is None:
         bv = self.simbad.B - self.simbad.V
 
@@ -60,9 +75,13 @@ def calc_prot_age(self, bv=None):
         prot_n84 = 0.324 - 0.400*(5 + log_rhk) - 0.283*(5 + log_rhk)**2 - 1.325*(5 + log_rhk)**3 + tau
         prot_n84 = 10**prot_n84
         prot_n84_err = np.log(10)*0.08*prot_n84
+        if array:
+            prot_n84_err = np.full_like(log_rhk, prot_n84_err)
 
         prot_m08 = (0.808 - 2.966*(log_rhk + 4.52))*10**tau
         prot_m08_err = 4.4*bv*1.7 - 1.7
+        if array:
+            prot_m08_err = np.full_like(log_rhk, prot_m08_err)
     else:
         prot_n84 = np.nan
         prot_n84_err = np.nan

{arvi-0.1.15 → arvi-0.1.18}/arvi/utils.py

@@ -1,4 +1,5 @@
 import os
+import sys
 import time
 from contextlib import contextmanager
 try:
@@ -82,6 +83,39 @@ def timer():
         logger.debug(f'elapsed time: {end - start:.2f} seconds')
 
 
+def pretty_print_table(rows, line_between_rows=True, logger=None):
+    """
+    Example Output
+    ┌──────┬─────────────┬────┬───────┐
+    │ True │ short       │ 77 │ catty │
+    ├──────┼─────────────┼────┼───────┤
+    │ 36   │ long phrase │ 9  │ dog   │
+    ├──────┼─────────────┼────┼───────┤
+    │ 8    │ medium      │ 3  │ zebra │
+    └──────┴─────────────┴────┴───────┘
+    """
+    _print = logger.info if logger else print
+
+    # find the max length of each column
+    max_col_lens = list(map(max, zip(*[(len(str(cell)) for cell in row) for row in rows])))
+
+    # print the table's top border
+    _print('┌' + '┬'.join('─' * (n + 2) for n in max_col_lens) + '┐')
+
+    rows_separator = '├' + '┼'.join('─' * (n + 2) for n in max_col_lens) + '┤'
+
+    row_fstring = ' │ '.join("{: <%s}" % n for n in max_col_lens)
+
+    for i, row in enumerate(rows):
+        _print('│ ' + row_fstring.format(*map(str, row)) + ' │')
+        
+        if line_between_rows and i < len(rows) - 1:
+            _print(rows_separator)
+
+    # print the table's bottom border
+    _print('└' + '┴'.join('─' * (n + 2) for n in max_col_lens) + '┘')
+
+
 def strtobool(val):
     """Convert a string representation of truth to true (1) or false (0).
 
@@ -163,4 +197,12 @@ def get_max_berv_span(self, n=None):
         inds.append(b2)
     return np.array(inds[:n])
 
+def get_object_fast(file):
+    with open(file, 'rb') as f:
+        f.read(800) # read first 10 keywords
+        key = f.read(8)
+        assert key == b'OBJECT  ', 'Object keyword not found.'
+        f.read(2)
+        value = f.read(20)
+    return value.decode().split("'")[1].strip()
 

{arvi-0.1.15 → arvi-0.1.18}/arvi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arvi
-Version: 0.1.15
+Version: 0.1.18
 Summary: The Automated RV Inspector
 Author-email: João Faria <joao.faria@unige.ch>
 License: MIT

{arvi-0.1.15 → arvi-0.1.18}/pyproject.toml

@@ -8,7 +8,7 @@ authors = [
     {name = "João Faria", email = "joao.faria@unige.ch"},
 ]
 description = "The Automated RV Inspector"
-version = "0.1.15"
+version = "0.1.18"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.8"
 keywords = ["RV", "exoplanets"]

arvi-0.1.18/tests/test_import_object.py

@@ -0,0 +1,17 @@
+import pytest
+import os
+
+def test_import():
+    import arvi
+    from arvi import RV
+
+
+def test_import_object():
+    from arvi import _51Peg
+
+    from arvi import HD10180
+    # if os.path.exists(os.path.expanduser('~/.dacerc')):
+    # else:
+    #     with pytest.raises(ImportError):
+    #         from arvi import HD10180
+

arvi-0.1.15/tests/test_import_object.py

@@ -1,17 +0,0 @@
-import pytest
-import os
-
-def test_import():
-    import arvi
-    from arvi import RV
-
-
-def test_import_object():
-    from arvi import _51Peg
-
-    if os.path.exists(os.path.expanduser('~/.dacerc')):
-        from arvi import HD10180
-    else:
-        with pytest.raises(ImportError):
-            from arvi import HD10180
-