arvi 0.0.1.dev1__py3-none-any.whl → 0.0.3__py3-none-any.whl

arvi/__init__.py

@@ -1 +1,13 @@
-__version__ = '0.0.1dev1'
+__version__ = '0.0.3'
+__all__ = []
+
+from .timeseries import RV
+
+_ran_once = False
+
+def __getattr__(name: str):
+    global _ran_once  # can't do it any other way :(
+    if _ran_once:
+        return RV(name)
+    else:
+        _ran_once = True

arvi/dace_wrapper.py

@@ -0,0 +1,92 @@
+import os
+import tarfile
+import numpy as np
+from dace_query import DaceClass
+from dace_query.spectroscopy import SpectroscopyClass, Spectroscopy as default_Spectroscopy
+from .setup_logger import logger
+
+def load_spectroscopy():
+    if 'DACERC' in os.environ:
+         dace = DaceClass(dace_rc_config_path=os.environ['DACERC'])
+         return SpectroscopyClass(dace_instance=dace)
+    # elif os.path.exists(os.path.expanduser('~/.dacerc')):
+    return default_Spectroscopy
+
+
+def get_arrays(result, latest_pipeline=True):
+    arrays = []
+    instruments = list(result.keys())
+    for inst in instruments:
+        pipelines = list(result[inst].keys())
+        if latest_pipeline:
+            pipelines = [pipelines[-1]]
+        for pipe in pipelines:
+            modes = list(result[inst][pipe].keys())
+            for mode in modes:
+                if 'rjd' not in result[inst][pipe][mode]:
+                    logger.error(f"No 'rjd' key for {inst} - {pipe}")
+                    raise ValueError
+
+                arrays.append(
+                    ((inst, pipe, mode), result[inst][pipe][mode])
+                )
+
+    return arrays
+
+
+def get_observations(star, save_rdb=False, verbose=True):
+    Spectroscopy = load_spectroscopy()
+    result = Spectroscopy.get_timeseries(target=star,
+                                         sorted_by_instrument=True,
+                                         output_format='numpy')
+    instruments = list(result.keys())
+
+    # sort pipelines, being extra careful with HARPS pipeline names
+    # (i.e. ensure that 3.0.0 > 3.5)
+    class sorter:
+        def __call__(self, x):
+            return '0.3.5' if x == '3.5' else x
+
+    for inst in instruments:
+        result[inst] = dict(sorted(result[inst].items(), 
+                                   key=sorter(), reverse=True))
+
+    if verbose:
+        logger.info('RVs available from')
+        with logger.contextualize(indent='   '):
+            for inst in instruments:
+                pipelines = list(result[inst].keys())
+                for pipe in pipelines:
+                    mode = list(result[inst][pipe].keys())[0]
+                    N = len(result[inst][pipe][mode]['rjd'])
+                    # LOG
+                    logger.info(f'{inst:12s} {pipe:10s} ({N} observations)')
+
+    return result
+
+
+def do_download_ccf(raw_files, output_directory, verbose=True):
+    raw_files = np.atleast_1d(raw_files)
+    if not os.path.isdir(output_directory):
+        os.makedirs(output_directory)
+    if verbose:
+        logger.info(f"Downloading {len(raw_files)} CCFs into '{output_directory}'...")
+
+    Spectroscopy = load_spectroscopy()
+    
+    from .utils import all_logging_disabled, stdout_disabled
+    with stdout_disabled(), all_logging_disabled():
+        Spectroscopy.download_files(raw_files[:2],
+                                    file_type='ccf',
+                                    output_directory=output_directory)
+
+    if verbose:
+        logger.info('Extracting .fits files')
+    
+    file = os.path.join(output_directory, 'spectroscopy_download.tar.gz')
+    tar = tarfile.open(file, "r")
+    for member in tar.getmembers():
+        if member.isreg():  # skip if the TarInfo is not a file
+            member.name = os.path.basename(member.name)  # remove the path
+            tar.extract(member, output_directory)
+    os.remove(file)

arvi/plots.py

@@ -0,0 +1,235 @@
+from functools import partial, partialmethod
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.collections import LineCollection
+from astropy.timeseries import LombScargle
+
+from .setup_logger import logger
+
+
+def plot(self,
+         ax=None,
+         show_masked=False,
+         time_offset=0,
+         remove_50000=False,
+         tooltips=True,
+         N_in_label=False,
+         **kwargs):
+    """ Plot the RVs
+
+    Args:
+        ax (Axes, optional): Axis to plot to. Defaults to None.
+        show_masked (bool, optional): Show masked points. Defaults to False.
+        time_offset (int, optional): Value to subtract from time. Defaults to 0.
+        remove_50000 (bool, optional): Whether to subtract 50000 from time. Defaults to False.
+        tooltips (bool, optional): TBD. Defaults to True.
+        N_in_label (bool, optional): Show number of observations in legend. Defaults to False.
+
+    Returns:
+        Figure: the figure
+        Axes: the axis
+    """
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, constrained_layout=True)
+    else:
+        fig = ax.figure
+
+    kwargs.setdefault('fmt', 'o')
+    kwargs.setdefault('capsize', 0)
+    kwargs.setdefault('ms', 4)
+
+    if remove_50000:
+        time_offset = 50000
+
+    all_lines = []
+    for inst in self.instruments:
+        s = self if self._child else getattr(self, inst)
+        label = f'{inst:10s} ({s.N})' if N_in_label else inst
+        lines, *_ = ax.errorbar(s.mtime - time_offset,
+                                s.mvrad,
+                                s.msvrad,
+                                label=label,
+                                picker=True,
+                                **kwargs)
+        all_lines.append(lines)
+    if show_masked:
+        ax.errorbar(self.time[~self.mask] - time_offset,
+                    self.vrad[~self.mask],
+                    self.svrad[~self.mask],
+                    label='masked', fmt='x', color='k')
+
+    ax.legend()
+
+    ax.set_ylabel(f'RV [{self.units}]')
+    if remove_50000:
+        ax.set_xlabel('BJD - 2450000 [days]')
+    else:
+        ax.set_xlabel('BJD - 2400000 [days]')
+
+    if tooltips:
+        inds = []
+        def onpick(event):
+            if isinstance(event.artist, LineCollection):
+                return
+            xdata, ydata = event.artist.get_data()
+            ind = event.ind
+            if ind in inds:
+                inds.remove(ind)
+            else:
+                inds.append(ind)
+
+            try:
+                reds.remove()
+            except UnboundLocalError:
+                pass
+
+            if len(inds) > 0:
+                reds = ax.plot(xdata[np.array(inds)], ydata[np.array(inds)],
+                                'ro', ms=10, zorder=-1)
+            fig.canvas.draw()
+        fig.canvas.mpl_connect('pick_event', onpick)
+
+    return fig, ax
+
+
+def plot_quantity(self,
+                  quantity,
+                  ax=None,
+                  time_offset=0,
+                  remove_50000=False,
+                  tooltips=True,
+                  N_in_label=False,
+                  **kwargs):
+
+    if not hasattr(self, quantity):
+        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
+
+    kwargs.setdefault('fmt', 'o')
+    kwargs.setdefault('capsize', 0)
+    kwargs.setdefault('ms', 4)
+
+    if remove_50000:
+        time_offset = 50000
+
+    all_lines = []
+    for inst in self.instruments:
+        s = self if self._child else getattr(self, inst)
+        label = f'{inst:10s} ({s.N})' if N_in_label else inst
+
+        y = getattr(s, quantity)[s.mask]
+        ye = getattr(s, quantity + '_err')[s.mask]
+
+        if np.isnan(y).all() or np.isnan(ye).all():
+            lines, *_ = ax.errorbar([], [], [],
+                                    label=label, picker=True, **kwargs)
+            continue
+
+        lines, *_ = ax.errorbar(s.mtime - time_offset, y, ye,
+                                label=label, picker=True, **kwargs)
+        all_lines.append(lines)
+
+    ax.legend()
+
+    if quantity == 'fwhm':
+        ax.set_ylabel(f'FWHM [{self.units}]')
+    elif quantity == 'bispan':
+        ax.set_ylabel(f'BIS [{self.units}]')
+    elif quantity == 'rhk':
+        ax.set_ylabel("$\log$ R'$_{HK}")
+
+    if remove_50000:
+        ax.set_xlabel('BJD - 2450000 [days]')
+    else:
+        ax.set_xlabel('BJD - 2400000 [days]')
+
+    if tooltips:
+        inds = []
+        def onpick(event):
+            if isinstance(event.artist, LineCollection):
+                return
+            xdata, ydata = event.artist.get_data()
+            ind = event.ind
+            if ind in inds:
+                inds.remove(ind)
+            else:
+                inds.append(ind)
+
+            try:
+                reds.remove()
+            except UnboundLocalError:
+                pass
+
+            if len(inds) > 0:
+                reds = ax.plot(xdata[np.array(inds)], ydata[np.array(inds)],
+                                'ro', ms=10, zorder=-1)
+            fig.canvas.draw()
+        fig.canvas.mpl_connect('pick_event', onpick)
+
+    return fig, ax
+
+
+plot_fwhm = partialmethod(plot_quantity, quantity='fwhm')
+plot_bis = partialmethod(plot_quantity, quantity='bispan')
+
+
+def gls(self, ax=None, fap=True, picker=True):
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, constrained_layout=True)
+    else:
+        fig = ax.figure
+
+    gls = LombScargle(self.mtime, self.mvrad, self.msvrad)
+    freq, power = gls.autopower(maximum_frequency=1.0)
+    ax.semilogx(1/freq, power, picker=picker)
+    if fap:
+        ax.axhline(gls.false_alarm_level(0.01),
+                   color='k',
+                   alpha=0.2,
+                   zorder=-1)
+    ax.set(xlabel='Period [days]', ylabel='Normalized power')
+    return fig, ax
+
+
+def gls_quantity(self, quantity, ax=None, fap=True, picker=True):
+    if not hasattr(self, quantity):
+        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
+
+    t = self.mtime
+    y = getattr(self, quantity)[self.mask]
+    ye = getattr(self, quantity + '_err')[self.mask]
+
+    if np.isnan(y).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]
+
+    gls = LombScargle(t, y, ye)
+    freq, power = gls.autopower(maximum_frequency=1.0)
+    ax.semilogx(1/freq, power, picker=picker)
+    if fap:
+        ax.axhline(gls.false_alarm_level(0.01),
+                   color='k',
+                   alpha=0.2,
+                   zorder=-1)
+    ax.set(xlabel='Period [days]', ylabel='Normalized power')
+    return fig, ax
+
+
+gls_fwhm = partialmethod(gls_quantity, quantity='fwhm')
+gls_bis = partialmethod(gls_quantity, quantity='bispan')

arvi/reports.py

@@ -0,0 +1,102 @@
+from functools import partial
+import numpy as np
+from astropy.timeseries import LombScargle
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+from matplotlib.backends.backend_pdf import PdfPages
+
+from .setup_logger import logger
+
+
+sine_line = None
+residual_gls = None
+def sine_picker(event, self, fig, ax, ax1):
+    from .timeseries import fit_sine
+    global sine_line, residual_gls
+    if sine_line is not None:
+        sine_line[0].remove()
+    if residual_gls is not None:
+        residual_gls[0].remove()
+    xdata, ydata = event.artist.get_data()
+    ind = event.ind
+    period = xdata[ind][0]
+    p, sine = fit_sine(self.mtime, self.mvrad, self.msvrad, period=period)
+    tt = np.linspace(self.mtime.min(), self.mtime.max(), 100)
+    tt -= 50000
+    sine_line = ax1.plot(tt, sine(tt), 'k')
+    #
+    f, p = LombScargle(self.mtime, self.mvrad - sine(self.mtime), self.msvrad).autopower()
+    residual_gls = ax.semilogx(1/f, p, 'r')
+    fig.canvas.draw_idle()
+
+
+def report(self, save=None):
+    # size = A4
+    size = 8.27, 11.69
+    fig = plt.figure(figsize=size, constrained_layout=True)
+    gs = gridspec.GridSpec(5, 3, figure=fig, height_ratios=[2, 2, 1, 1, 0.1])
+
+    # first row, all columns
+    ax1 = plt.subplot(gs[0, :])
+
+    title = f'{self.star}'
+    ax1.set_title(title, loc='left', fontsize=14)
+    # ax1.set_title(r"\href{http://www.google.com}{link}", color='blue',
+    #               loc='center')
+
+    if self._did_adjust_means:
+        title = '(instrument means subtracted) '
+    else:
+        title = ''
+    title += f'V={self.simbad.V}, {self.simbad.sp_type}'
+    ax1.set_title(title, loc='right', fontsize=12)
+
+    self.plot(ax=ax1, N_in_label=True, tooltips=False, remove_50000=True)
+
+
+    ax1.legend().remove()
+    legend_ax = plt.subplot(gs[1, -1])
+    legend_ax.axis('off')
+    leg = plt.legend(*ax1.get_legend_handles_labels(),
+                     prop={'family': 'monospace'})
+    legend_ax.add_artist(leg)
+    second_legend = f'rms  : {self.rms:.2f} {self.units}\n'
+    second_legend += f'error: {self.error:.2f} {self.units}'
+    legend_ax.legend([],
+                     title=second_legend,
+                     loc='lower right', frameon=False,
+                     prop={'family': 'monospace'})
+
+    ax2 = plt.subplot(gs[1, :-1])
+    self.gls(ax=ax2, picker=True)
+
+    ax3 = plt.subplot(gs[2, :-1])
+    self.plot_fwhm(ax=ax3, tooltips=False, remove_50000=True)
+    ax3.legend().remove()
+    ax3p = plt.subplot(gs[2, -1])
+    self.gls_fwhm(ax=ax3p, picker=False)
+
+    ax4 = plt.subplot(gs[3, :-1])
+    self.plot_bis(ax=ax4, tooltips=False, remove_50000=True)
+    ax4.legend().remove()
+    ax4p = plt.subplot(gs[3, -1])
+    self.gls_bis(ax=ax4p, picker=False)
+
+
+    if save is None:
+        fig.canvas.mpl_connect(
+            'pick_event',
+            partial(sine_picker, self=self, fig=fig, ax=ax2, ax1=ax1))
+
+    if save is not None:
+        if save is True:
+            save = f'report_{"".join(self.star.split())}.pdf'
+
+        with PdfPages(save) as pdf:
+            pdf.attach_note('hello', positionRect=[5, 15, 20, 30])
+
+            if self.verbose:
+                logger.info(f'saving to {save}')
+            pdf.savefig(fig)
+        plt.close('all')
+        # os.system(f'evince {save} &')

arvi/setup_logger.py

@@ -0,0 +1,11 @@
+import sys
+from loguru import logger
+
+logger.remove()
+logger.configure(extra={"indent": ""})
+logger.add(
+    sys.stdout,
+    colorize=True,
+    # format="<green>{time:YYYY-MM-DDTHH:mm:ss}</green> <level>{message}</level>",
+    format="{extra[indent]}<level>{message}</level>",
+)

arvi/simbad_wrapper.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass, field
+import requests
+
+from astropy.coordinates import SkyCoord
+
+QUERY = """
+SELECT basic.OID,
+       RA,
+       DEC,
+       main_id,
+       plx_value,
+       rvz_radvel,
+       sp_type
+FROM basic JOIN ident ON oidref = oid
+WHERE id = '{star}';
+"""
+
+BV_QUERY = """
+SELECT B, V from allfluxes
+JOIN ident USING(oidref)
+WHERE id = '{star}';
+"""
+
+IDS_QUERY = """
+SELECT ids from ids
+JOIN ident USING(oidref)
+WHERE id = '{star}';
+"""
+
+def run_query(query):
+    url = 'http://simbad.u-strasbg.fr/simbad/sim-tap/sync'
+    response = requests.post(url,
+                             data=dict(query=query,
+                                       request='doQuery',
+                                       lang='ADQL',
+                                       format='text/plain',
+                                       phase='run'))
+    return response.content.decode()
+
+def parse_table(table, cols=None, values=None):
+    header = table.splitlines()[0].split('|')
+    if cols is None:
+        cols = list(map(str.strip, header))
+    else:
+        cols = cols + list(map(str.strip, header))
+    if values is None:
+        values = table.splitlines()[2].split('|')
+    else:
+        values = values + table.splitlines()[2].split('|')
+    values = list(map(str.strip, values))
+    values = [value.replace('"', '') for value in values]
+    return cols, values
+
+
+class simbad:
+    """
+    A very simple wrapper around a TAP query to simbad for a given target. This
+    class simply runs a few TAP queries and stores the result as attributes.
+
+    Attributes:
+        ra (float): right ascension
+        dec (float): declination
+        coords (SkyCoord): coordinates as a SkyCoord object
+        main_id (str): main identifier
+        plx_value (float): parallax
+        rvz_radvel (float): radial velocity
+        sp_type (str): spectral type
+        B (float): B magnitude 
+        V (float): V magnitude
+        ids (list): list of identifiers
+    """
+    def __init__(self, star:str):
+        """
+        Args:
+            star (str): The name of the star to query simbad
+        """
+        self.star = star
+        try:
+            table1 = run_query(query=QUERY.format(star=star))
+            cols, values = parse_table(table1)
+
+            table2 = run_query(query=BV_QUERY.format(star=star))
+            cols, values = parse_table(table2, cols, values)
+
+            table3 = run_query(query=IDS_QUERY.format(star=star))
+            line = table3.splitlines()[2]
+            self.ids = line.replace('"', '').replace('    ', ' ').split('|')
+        except IndexError:
+            raise ValueError(f'simbad query for {star} failed')
+
+        for col, val in zip(cols, values):
+            try:
+                setattr(self, col, float(val))
+            except ValueError:
+                setattr(self, col, val)
+
+        self.coords = SkyCoord(self.ra, self.dec, unit='deg')
+
+
+    def __repr__(self):
+        V = self.V
+        sp_type = self.sp_type
+        return f'{self.star} ({V=}, {sp_type=})'

arvi/stats.py

@@ -0,0 +1,36 @@
+import numpy as np
+
+
+def wmean(a, e):
+    """
+    Weighted mean of array `a`, with uncertainty given by `e`.
+    The weighted mean is calculated using weights equal to 1/e**2
+
+    Args:
+        a (array): Array containing data
+        e (array): Uncertainties on `a`
+    """
+    return np.average(a, weights=1 / e**2)
+
+
+def rms(a):
+    """
+    Root mean square of array `a`
+    Args:
+        a (array): Array containing data
+    """
+    return np.sqrt((a**2).mean())
+
+
+def wrms(a, e):
+    """ 
+    Weighted root mean square of array `a`, with uncertanty given by `e`.
+    The weighted rms is calculated using the weighted mean, where the 
+    weights are equal to 1/e**2.
+    
+    Args:
+        a (array): Array containing data
+        e (array): Uncertainties on `a`
+    """
+    w = 1 / e**2
+    return np.sqrt(np.sum(w * (a - np.average(a, weights=w))**2) / sum(w))

arvi/timeseries.py

@@ -0,0 +1,328 @@
+from dataclasses import dataclass, field
+from typing import Union
+from functools import partial
+from datetime import datetime, timezone
+import numpy as np
+
+from .setup_logger import logger
+from .translations import translate
+from .dace_wrapper import get_observations, get_arrays, do_download_ccf
+from .simbad_wrapper import simbad
+from .stats import wmean, wrms
+
+@dataclass
+class RV:
+    """
+    A class holding RV observations
+
+    Attributes:
+        star (str):
+            The name of the star
+        N (int):
+            Total number of observations
+        verbose (bool):
+            Log some operations to the terminal
+        instruments (list):
+            List of instruments for which there are RVs. Each instrument is also
+            stored as an attribute (e.g. `self.CORALIE98` or `self.HARPS`)
+    """
+    star: str
+    N: int = field(init=False, repr=True)
+    verbose: bool = field(init=True, repr=False, default=True)
+    do_sigma_clip: bool = field(init=True, repr=False, default=True)
+    do_maxerror: Union[bool, float] = field(init=True, repr=False, default=100)
+    do_adjust_means: bool = field(init=True, repr=False, default=True)
+    #
+    _child: bool = field(init=True, 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)
+
+    def __post_init__(self):
+        self.__star__ = translate(self.star)
+        try:
+            self.simbad = simbad(self.__star__)
+        except ValueError as e:
+            logger.error(e.msg)
+
+        if not self._child:
+            if self.verbose:
+                logger.info('querying DACE...')
+            self.dace_result = get_observations(self.__star__,
+                                                verbose=self.verbose)
+            # 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'
+
+        # build children
+        if not self._child:
+            arrays = get_arrays(self.dace_result)
+            for (inst, pipe, mode), data in arrays:
+                child = RV.from_dace_data(self.star, inst, pipe, mode, data, _child=True)
+                setattr(self, inst, child)
+
+        # build joint arrays
+        if not self._child:
+            self.instruments = list(self.dace_result.keys())
+            # self.pipelines =
+            # "observatory" (or instrument id)
+            self.obs = np.concatenate(
+                [np.full(getattr(self, inst).N, i+1) for i, inst in enumerate(self.instruments)],
+                dtype=int
+            )
+            # mask
+            self.mask = np.full_like(self.obs, True, dtype=bool)
+            # all other quantities
+            self._build_arrays()
+
+        # do clip_maxerror, sigmaclip, adjust_means
+        if not self._child:
+            if self.do_maxerror:
+                self.clip_maxerror(self.do_maxerror)
+
+            if self.do_sigma_clip:
+                self.sigmaclip()
+
+            if self.do_adjust_means:
+                self.adjust_means()
+
+
+    def reload(self):
+        self.__post_init__()
+
+    @property
+    def N(self):
+        return self.time.size
+
+    @N.setter
+    def N(self, value):
+        if not isinstance(value, property):
+            logger.error('Cannot set N directly')
+
+    @property
+    def mtime(self):
+        return self.time[self.mask]
+
+    @property
+    def mvrad(self):
+        return self.vrad[self.mask]
+
+    @property
+    def msvrad(self):
+        return self.svrad[self.mask]
+
+    @property
+    def rms(self):
+        """ Weighted rms of the (masked) radial velocities """
+        if self.mask.sum() == 0:  # only one point
+            return np.nan
+        else:
+            return wrms(self.vrad[self.mask], self.svrad[self.mask])
+
+    @property
+    def sigma(self):
+        """ Average error bar """
+        if self.mask.sum() == 0:  # only one point
+            return np.nan
+        else:
+            return self.svrad[self.mask].mean()
+
+    error = sigma  # alias!
+
+    @classmethod
+    def from_dace_data(cls, star, inst, pipe, mode, data, **kwargs):
+        s = cls(star, **kwargs)
+        #
+        ind = np.argsort(data['rjd'])
+        # time, RVs, uncertainties
+        s.time = data['rjd'][ind]
+        s.vrad = data['rv'][ind]
+        s.svrad = data['rv_err'][ind]
+        # mask
+        s.mask = np.full_like(s.time, True, dtype=bool)
+        # all other quantities
+        for arr in data.keys():
+            if arr not in ('rjd', 'rv', 'rv_err'):
+                if arr == 'mask':
+                    # change name mask -> ccf_mask
+                    setattr(s, 'ccf_mask', data[arr][ind])
+                else:
+                    setattr(s, arr, data[arr][ind])
+        #
+        s.instruments = [inst]
+        s.pipelines = [pipe]
+        return s
+
+    def _build_arrays(self):
+        if self._child:
+            return
+        # time
+        self.time = np.concatenate(
+            [getattr(self, inst).time for inst in self.instruments]
+        )
+        # RVs
+        self.vrad = np.concatenate(
+            [getattr(self, inst).vrad for inst in self.instruments]
+        )
+        # uncertainties
+        self.svrad = np.concatenate(
+            [getattr(self, inst).svrad for inst in self.instruments]
+        )
+        arrays = get_arrays(self.dace_result)
+        quantities = list(arrays[0][-1].keys())
+        # all other quantities
+        for q in quantities:
+            if q not in ('rjd', 'rv', 'rv_err'):
+                if q == 'mask':  # change mask -> ccf_mask
+                    q = 'ccf_mask'
+                arr = np.concatenate(
+                    [getattr(getattr(self, inst), q) for inst in self.instruments]
+                )
+                setattr(self, q, arr)
+
+
+    def download_ccf(self, instrument=None):
+        directory = f'{self.star}_downloads'
+        if instrument is None:
+            files = [file for file in self.raw_file if file.endswith('.fits')]
+        else:
+            if instrument not in self.instruments:
+                logger.error(f"No data from instrument '{instrument}'")
+                logger.info(f'available: {self.instruments}')
+                return
+            files = getattr(self, instrument).raw_file
+
+        do_download_ccf(files, directory)
+
+
+    from .plots import plot, plot_fwhm, plot_bis
+    from .plots import gls, gls_fwhm, gls_bis
+    from .reports import report
+
+
+    def remove_instrument(self, instrument):
+        """ Remove all observations from `instrument` """
+        if instrument not in self.instruments:
+            logger.error(f"No data from instrument '{instrument}'")
+            logger.info(f'available: {self.instruments}')
+            return
+
+        ind = self.instruments.index(instrument) + 1
+        remove = np.where(self.obs == ind)
+        self.obs = np.delete(self.obs, remove)
+        self.obs[self.obs > ind] -= 1
+        #
+        self.time = np.delete(self.time, remove)
+        self.vrad = np.delete(self.vrad, remove)
+        self.svrad = np.delete(self.svrad, remove)
+        #
+        self.instruments.remove(instrument)
+        #
+        delattr(self, instrument)
+
+        if self.verbose:
+            logger.info(f"Removed observations from '{instrument}'")
+
+    def remove_point(self, index):
+        """ Remove individual observations at a given `index` (or indices) """
+        index = np.atleast_1d(index)
+        try:
+            instrument_index = self.obs[index]
+            instrument = np.array(self.instruments)[instrument_index - 1]
+        except IndexError:
+            logger.errors(f'index {index} is out of bounds for N={self.N}')
+            return
+
+        self.mask[index] = False
+        self._propagate_mask_changes()
+        # for i, inst in zip(index, instrument):
+        #     index_in_instrument = i - (self.obs < instrument_index).sum()
+        #     getattr(self, inst).mask[index_in_instrument] = False
+
+    def _propagate_mask_changes(self):
+        """ link self.mask with each self.`instrument`.mask """
+        masked = np.where(~self.mask)[0]
+        for m in masked:
+            inst = self.instruments[self.obs[m] - 1]
+            n_before = (self.obs < self.obs[m]).sum()
+            getattr(self, inst).mask[m - n_before] = False
+
+    def sigmaclip(self, sigma=3):
+        """ Sigma-clip RVs """
+        if self._child or self._did_sigma_clip:
+            return
+        from scipy.stats import sigmaclip as dosigmaclip
+        result = dosigmaclip(self.vrad, low=sigma, high=sigma)
+        n = self.vrad.size - result.clipped.size
+        if self.verbose and n > 0:
+            s = 's' if (n == 0 or n > 1) else ''
+            logger.warning(f'sigma-clip RVs removed {n} point' + s)
+        ind = (self.vrad > result.lower) & (self.vrad < result.upper)
+        self.mask[~ind] = False
+        self._propagate_mask_changes()
+
+    def clip_maxerror(self, maxerror:float, plot=False):
+        """ Mask out points with RV error larger than `maxerror` """
+        if self._child:
+            return
+        self.maxerror = maxerror
+        above = self.svrad > maxerror
+        n = above.sum()
+        self.mask[above] = False
+
+        if self.verbose and above.sum() > 0:
+            s = 's' if (n == 0 or n > 1) else ''
+            logger.warning(f'clip_maxerror removed {n} point' + s)
+
+        self._propagate_mask_changes()
+
+    def adjust_means(self, just_rv=False):
+        if self._child or self._did_adjust_means:
+            return
+
+        others = ('fwhm', 'bispan', )
+        for inst in self.instruments:
+            s = getattr(self, inst)
+            s.rv_mean = wmean(s.mvrad, s.msvrad)
+            s.vrad -= s.rv_mean
+            if self.verbose:
+                logger.info(f'subtracted weighted average from {inst:10s}: ({s.rv_mean:.3f} {self.units})')
+            if just_rv:
+                continue
+            log_msg = 'same for '
+            for i, other in enumerate(others):
+                y, ye = getattr(s, other), getattr(s, other + '_err')
+                m = wmean(y, ye)
+                setattr(s, f'{other}_mean', m)
+                setattr(s, other, getattr(s, other) - m)
+                log_msg += other
+                if i < len(others) - 1:
+                    log_msg += ', '
+            
+            if self.verbose:
+                logger.info(log_msg)
+
+        self._build_arrays()
+        self._did_adjust_means = True
+
+
+def fit_sine(t, y, yerr, period='gls', fix_period=False):
+    from scipy.optimize import leastsq
+    if period == 'gls':
+        from astropy.timeseries import LombScargle
+        gls = LombScargle(t, y, yerr)
+        freq, power = gls.autopower()
+        period = 1 / freq[power.argmax()]
+
+    if fix_period and period is None:
+        logger.error('period is fixed but no value provided')
+        return
+
+    def sine(t, p):
+        return p[0] * np.sin(2 * np.pi * t / p[1] + p[2]) + p[3]
+
+    p0 = [y.ptp(), period, 0.0, 0.0]
+    xbest, _ = leastsq(lambda p, t, y, ye: (sine(t, p) - y) / ye,
+                       p0, args=(t, y, yerr))
+    return xbest, partial(sine, p=xbest)

arvi/translations.py

@@ -0,0 +1,10 @@
+STARS = {
+    'Barnard': 'GJ699',
+    "Barnard's": 'GJ699',
+}
+
+
+def translate(star):
+    if star in STARS:
+        return STARS[star]
+    return star

arvi/utils.py

@@ -0,0 +1,32 @@
+import os
+from contextlib import contextmanager
+from mock import patch
+import logging
+
+
+@contextmanager
+def stdout_disabled():
+    devnull = open(os.devnull, 'w')
+    with patch('sys.stdout', devnull):
+        yield
+
+
+@contextmanager
+def all_logging_disabled():
+    """
+    A context manager that will prevent any logging messages triggered during
+    the body from being processed.
+    """
+    # two kind-of hacks here:
+    #    * can't get the highest logging level in effect => delegate to the user
+    #    * can't get the current module-level override => use an undocumented
+    #       (but non-private!) interface
+
+    previous_level = logging.root.manager.disable
+
+    logging.disable(logging.CRITICAL)
+
+    try:
+        yield
+    finally:
+        logging.disable(previous_level)

{arvi-0.0.1.dev1.dist-info → arvi-0.0.3.dist-info}/METADATA

@@ -1,14 +1,20 @@
 Metadata-Version: 2.1
 Name: arvi
-Version: 0.0.1.dev1
+Version: 0.0.3
 Summary: The Automated RV Inspector
 Author-email: João Faria <joao.faria@astro.up.pt>
 License: MIT
+Project-URL: Repository, https://github.com/j-faria/arvi
 Keywords: RV,exoplanets
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: loguru
+Requires-Dist: mpldatacursor
+Requires-Dist: tqdm
+Requires-Dist: pyexoplaneteu
+Requires-Dist: dace-query
 
 <p align="center">
   <img width = "140" src="https://github.com/j-faria/arvi/blob/main/docs/logo/logo.png?raw=true"/>

arvi-0.0.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+arvi/__init__.py,sha256=d4UTdSj3oRwFvO1a_m5uz_fqEVFR9U-afio38MNuESU,241
+arvi/dace_wrapper.py,sha256=0zId_2uti-_UOkCZHJnRvajO5EMNgwNfc5AgV-LjSPQ,3340
+arvi/plots.py,sha256=uOruz1xhlx7nNjIEtLTX6gs_iya2Yds71eIYoYt2LVw,6925
+arvi/reports.py,sha256=FtalLbmBHOSHQ3RldImUZTHPc3cc3Z3W5r3d-31FIo8,3261
+arvi/setup_logger.py,sha256=nvnd2PtXYnpYMGleTeqAKFe-TnC6SjNlTZ-EmiewLyY,278
+arvi/simbad_wrapper.py,sha256=7XnuM7Kq5kK4EchHjh-uyRoTWm6kCx0sx7Ak0eDaALo,3023
+arvi/stats.py,sha256=OIlXisf_kuUhfDRhvCirmJ2e-YSIJnoBjdFOXaYd0bQ,868
+arvi/timeseries.py,sha256=tWKAn5tCQpI1YaCE_breyQ_dXAsj0X06jox4nH9ES5E,11159
+arvi/translations.py,sha256=eyUJei8wlsyBecTz8E_ntpP35-Mre2Tzm_mUMMGaZWY,150
+arvi/utils.py,sha256=OPb6rXafv7b8vRRTEg9zQAQnhi3lRLICF62R8Fhy43A,788
+arvi-0.0.3.dist-info/LICENSE,sha256=6JfQgl7SpM55t0EHMFNMnNh-AdkpGW25MwMiTnhdWQg,1068
+arvi-0.0.3.dist-info/METADATA,sha256=01PYughU6O-f6cwMA_6elKUMallpnN5uaxN6k8xgeys,827
+arvi-0.0.3.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+arvi-0.0.3.dist-info/top_level.txt,sha256=4EeiKDVLD45ztuflTGfQ3TU8GVjJg5Y95xS5XjI-utU,5
+arvi-0.0.3.dist-info/RECORD,,

{arvi-0.0.1.dev1.dist-info → arvi-0.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.1)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

arvi-0.0.1.dev1.dist-info/RECORD

@@ -1,6 +0,0 @@
-arvi/__init__.py,sha256=BNInQtK0-v5cqZ_-bX0s_c8AB_Ky08gDUCNP_oy__6Y,25
-arvi-0.0.1.dev1.dist-info/LICENSE,sha256=6JfQgl7SpM55t0EHMFNMnNh-AdkpGW25MwMiTnhdWQg,1068
-arvi-0.0.1.dev1.dist-info/METADATA,sha256=hgc8fc8h5k7IYdd7jOP4BdPShppngl4axsyGk7cUlIE,649
-arvi-0.0.1.dev1.dist-info/WHEEL,sha256=5sUXSg9e4bi7lTLOHcm6QEYwO5TIF1TNbTSVFVjcJcc,92
-arvi-0.0.1.dev1.dist-info/top_level.txt,sha256=4EeiKDVLD45ztuflTGfQ3TU8GVjJg5Y95xS5XjI-utU,5
-arvi-0.0.1.dev1.dist-info/RECORD,,