arvi 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

arvi/dace_wrapper.py

@@ -10,7 +10,7 @@ from .setup_logger import setup_logger
 from .utils import create_directory, all_logging_disabled, stdout_disabled, timer, tqdm
 
 
-def load_spectroscopy(user=None):
+def load_spectroscopy(user=None, verbose=True):
     logger = setup_logger()
     with all_logging_disabled():
         from dace_query.spectroscopy import SpectroscopyClass, Spectroscopy as default_Spectroscopy
@@ -19,7 +19,8 @@ def load_spectroscopy(user=None):
     from .config import config
     # requesting as public
     if config.request_as_public:
-        logger.warning('requesting DACE data as public')
+        if verbose:
+            logger.warning('requesting DACE data as public')
         with all_logging_disabled():
             dace = DaceClass(dace_rc_config_path='none')
         return SpectroscopyClass(dace_instance=dace)
@@ -168,7 +169,7 @@ def get_observations_from_instrument(star, instrument, user=None, main_id=None,
         dict:
             dictionary with data from DACE
     """
-    Spectroscopy = load_spectroscopy(user)
+    Spectroscopy = load_spectroscopy(user, verbose)
     found_dace_id = False
     with timer('dace_id query'):
         try:
@@ -192,12 +193,13 @@ def get_observations_from_instrument(star, instrument, user=None, main_id=None,
         except TypeError:
             msg = f'no {instrument} observations for {star}'
             raise ValueError(msg) from None
+
     if (isinstance(instrument, str)):
         filters = {
             "ins_name": {"contains": [instrument]},
             "obj_id_daceid": {"contains": [dace_id]}
         }
-    elif (isinstance(instrument, list)):
+    elif (isinstance(instrument, (list, tuple, np.ndarray))):
         filters = {
             "ins_name": {"contains": instrument},
             "obj_id_daceid": {"contains": [dace_id]}
@@ -283,7 +285,7 @@ def get_observations_from_instrument(star, instrument, user=None, main_id=None,
 def get_observations(star, instrument=None, user=None, main_id=None, verbose=True):
     logger = setup_logger()
     if instrument is None:
-        Spectroscopy = load_spectroscopy(user)
+        Spectroscopy = load_spectroscopy(user, verbose)
 
         try:
             with stdout_disabled(), all_logging_disabled():

arvi/instrument_specific.py

@@ -123,7 +123,10 @@ def HARPS_commissioning(self, mask=True, plot=True):
     if check(self, 'HARPS') is None:
         return
 
-    affected = self.time < HARPS_start
+    affected = np.logical_and(
+        self.instrument_array == 'HARPS03', 
+        self.time < HARPS_start
+    )
     total_affected = affected.sum()
 
     if self.verbose:
@@ -133,7 +136,7 @@ def HARPS_commissioning(self, mask=True, plot=True):
 
     if mask:
         self.mask[affected] = False
-        self._propagate_mask_changes()
+        self._propagate_mask_changes(_remove_instrument=False)
 
         if plot:
             self.plot(show_masked=True)
@@ -155,7 +158,14 @@ def HARPS_fiber_commissioning(self, mask=True, plot=True):
     if check(self, 'HARPS') is None:
         return
 
-    affected = (self.time >= HARPS_technical_intervention_range[0]) & (self.time <= HARPS_technical_intervention_range[1])
+    affected = np.logical_and(
+        self.time >= HARPS_technical_intervention_range[0],
+        self.time <= HARPS_technical_intervention_range[1]
+    )
+    affected = np.logical_and(
+        affected,
+        np.char.find(self.instrument_array, 'HARPS') == 0
+    )
     total_affected = affected.sum()
 
     if self.verbose:
@@ -165,7 +175,7 @@ def HARPS_fiber_commissioning(self, mask=True, plot=True):
 
     if mask:
         self.mask[affected] = False
-        self._propagate_mask_changes()
+        self._propagate_mask_changes(_remove_instrument=False)
 
         if plot:
             self.plot(show_masked=True)
@@ -187,7 +197,10 @@ def ESPRESSO_commissioning(self, mask=True, plot=True):
     if check(self, 'ESPRESSO') is None:
         return
 
-    affected = self.time < ESPRESSO_start
+    affected = np.logical_and(
+        self.instrument_array == 'ESPRESSO18',
+        self.time < ESPRESSO_start
+    )
     total_affected = affected.sum()
 
     if self.verbose:
@@ -197,7 +210,7 @@ def ESPRESSO_commissioning(self, mask=True, plot=True):
 
     if mask:
         self.mask[affected] = False
-        self._propagate_mask_changes()
+        self._propagate_mask_changes(_remove_instrument=False)
 
         if plot and total_affected > 0:
             self.plot(show_masked=True)
@@ -246,7 +259,7 @@ def ADC_issues(self, mask=True, plot=True, check_headers=False):
 
     if mask:
         self.mask[intersect] = False
-        self._propagate_mask_changes()
+        self._propagate_mask_changes(_remove_instrument=False)
 
         if plot:
             self.plot(show_masked=True)
@@ -282,7 +295,7 @@ def blue_cryostat_issues(self, mask=True, plot=True):
 
     if mask:
         self.mask[intersect] = False
-        self._propagate_mask_changes()
+        self._propagate_mask_changes(_remove_instrument=False)
 
         if plot:
             self.plot(show_masked=True)
@@ -330,7 +343,7 @@ def qc_scired_issues(self, plot=False, **kwargs):
         return
 
     self.mask[affected] = False
-    self._propagate_mask_changes()
+    self._propagate_mask_changes(_remove_instrument=False)
 
     if plot:
         self.plot(show_masked=True)
@@ -364,6 +377,7 @@ class ISSUES:
                 logger.error('are the data binned? cannot proceed to mask these points...')
         
         results = list(filter(lambda x: x is not None, results))
+        self._propagate_mask_changes()
 
         try:
             return np.logical_or.reduce(results)

arvi/kepmodel_wrapper.py

@@ -0,0 +1,296 @@
+import io
+from contextlib import redirect_stdout, contextmanager
+from string import ascii_lowercase
+from matplotlib import pyplot as plt
+import numpy as np
+
+from kepmodel.rv import RvModel
+from spleaf.cov import merge_series
+from spleaf.term import Error, InstrumentJitter
+
+from .setup_logger import setup_logger
+from .utils import timer, adjust_lightness
+
+
+class model:
+    logger = setup_logger()
+    # periodogram settings
+    Pmin, Pmax, nfreq = 1.5, 10_000, 100_000
+
+    @contextmanager
+    def ew(self):
+        for name in self.model.keplerian:
+            self.model.set_keplerian_param(name, param=['P', 'la0', 'K', 'e', 'w'])
+        try:
+            yield
+        finally:
+            for name in self.model.keplerian:
+                self.model.set_keplerian_param(name, param=['P', 'la0', 'K', 'esinw', 'ecosw'])
+
+    @property
+    def nu0(self):
+        return 2 * np.pi / self.Pmax
+    
+    @property
+    def dnu(self):
+        return (2 * np.pi / self.Pmin - self.nu0) / (self.nfreq - 1)
+
+    def __init__(self, s):
+        self.s = s
+        self.instruments = s.instruments
+        self.Pmax = 2 * np.ptp(s.time)
+        ts = self.ts = self.s._mtime_sorter
+
+        # t, y_ ye, series_index = merge_series(
+        #     [_s.mtime for _s in s],
+        #     [_s.mvrad for _s in s],
+        #     [_s.msvrad for _s in s],
+        # )
+
+        inst_jit = self._get_jitters()
+
+        self.model = RvModel(self.s.mtime[ts], self.s.mvrad[ts],
+                             err=Error(self.s.msvrad[ts]), **inst_jit)
+        self.np = 0
+        self._add_means()
+
+    def _add_means(self):
+        for inst in self.s.instruments:
+            # if inst not in self.s.instrument_array[self.s.mask]:
+            #     continue
+            mask = self.s.instrument_array[self.s.mask][self.ts] == inst
+            self.model.add_lin(
+                derivative=1.0 * mask,
+                name=f"offset_{inst}",
+                value=getattr(self.s, inst).mvrad.mean(),
+            )
+        self.model.fit_lin()
+    
+    def _get_jitters(self):
+        inst_jit = {}
+        for inst in self.s.instruments:
+            inst_jit[f'jit_{inst}'] = InstrumentJitter(
+                indices=self.s.instrument_array[self.s.mask] == inst,
+                sig=self.s.svrad[self.s.mask].min()
+            )
+        return inst_jit
+
+    def _set_jitters(self, value=0.0):
+        for par in self.model.cov.param:
+            if 'jit' in par:
+                self.model.set_param(value, f'cov.{par}')
+        # self.model.fit()
+    
+    def _equal_coralie_offsets(self):
+        if self.s._check_instrument('CORALIE') is None:
+            return
+        mask = np.char.find(self.s.instrument_array, 'CORALIE') == 0
+        mean = self.s.vrad[mask].mean()
+        for inst in self.instruments:
+            if 'CORALIE' in inst:
+                self.model.set_param(mean, f'lin.offset_{inst}')
+
+
+    def __repr__(self):
+        with self.ew():
+            with io.StringIO() as buf, redirect_stdout(buf):
+                self.model.show_param()
+                output = buf.getvalue()
+        return output
+
+    def to_table(self, **kwargs):
+        from .utils import pretty_print_table
+        lines = repr(self)
+        lines = lines.replace(' [deg]', '_[deg]')
+        lines = lines.encode().replace(b'\xc2\xb1', b'').decode()
+        lines = lines.split('\n')
+        lines = [line.split() for line in lines]
+        lines = [[col.replace('_[deg]', ' [deg]') for col in line] for line in lines]
+        pretty_print_table(lines[:-2], **kwargs)
+
+    @property
+    def fit_param(self):
+        return self.model.fit_param
+
+    def fit(self):
+        # fit offsets
+        self.model.fit_param = [f'lin.offset_{inst}' for inst in self.instruments]
+        # fit jitters
+        self.model.fit_param += [f'cov.{par}' for par in self.model.cov.param]
+        # fit keplerian(s)
+        self.model.fit_param += [
+            f'kep.{k}.{p}' 
+            for k, v in self.model.keplerian.items() 
+            for p in v._param
+        ]
+        # if self.np == 0:
+        #     self._set_jitters(0.1 * np.std(self.model.y - self.model.model()))
+        try:
+            self.model.fit()
+        except Exception as e:
+            print(e)
+            
+
+    def plot(self, **kwargs):
+        fig, ax = self.s.plot(**kwargs)
+        tt = self.s._tt()
+        time_offset = 50000 if 'remove_50000' in kwargs else 0
+
+        for i, inst in enumerate(self.s):
+            inst_name = inst.instruments[0].replace('-', '_')
+            val = self.model.get_param(f'lin.offset_{inst_name}')
+            x = np.array([inst.mtime.min(), inst.mtime.max()]) - time_offset
+            y = [val, val]
+            ax.plot(x, y, ls='--', color=f'C{i}')
+            mask = (tt > inst.mtime.min()) & (tt < inst.mtime.max())
+            color = adjust_lightness(f'C{i}', 1.2)
+            ax.plot(tt[mask] - time_offset,
+                    val + self.model.keplerian_model(tt)[mask],
+                    color=color)
+
+        return fig, ax
+
+    def plot_phasefolding(self, planets=None, ax=None):
+        t = self.model.t
+        res = self.model.residuals()
+        sig = np.sqrt(self.model.cov.A)
+
+        Msmooth = np.linspace(0, 360, 1000)
+
+        if planets is None:
+            planets = list(self.model.keplerian.keys())
+
+        if ax is None:
+            fig, axs = plt.subplots(
+                1, len(planets), sharex=True, sharey=True, constrained_layout=True,
+                squeeze=False
+            )
+        else:
+            axs = np.atleast_1d(ax)
+            fig = axs[0].figure
+
+        for p, ax in zip(planets, axs.flat):
+            self.model.set_keplerian_param(p, param=['P', 'la0', 'K', 'e', 'w'])
+            kep = self.model.keplerian[p]
+            P = self.model.get_param(f'kep.{p}.P')
+            M0 = (180 / np.pi * (self.model.get_param(f'kep.{p}.la0') - self.model.get_param(f'kep.{p}.w')))
+            M = (M0 + 360 / P * t) % 360
+            reskep = res + kep.rv(t)
+            tsmooth = (Msmooth - M0) * P / 360
+            mod = kep.rv(tsmooth)
+
+            ax.plot([0, 360], [0, 0], '--', c='gray', lw=1)
+            ax.plot(Msmooth, mod, 'k-', lw=3, rasterized=True)
+            for inst in self.instruments:
+                sel = self.s.instrument_array[self.s.mask] == inst
+                ax.errorbar(M[sel], reskep[sel], sig[sel], fmt='.',
+                            rasterized=True, alpha=0.7)
+
+            ax.set(ylabel='RV [m/s]', xlabel='Mean anomaly [deg]',
+                   xticks=np.arange(0, 361, 90))
+            ax.minorticks_on()
+            self.model.set_keplerian_param(p, param=['P', 'la0', 'K', 'esinw', 'ecosw'])
+
+        # handles, labels = ax.get_legend_handles_labels()
+        # fig.legend(handles, labels, loc='center left', bbox_to_anchor=(0.9, 0.5))
+        return fig, axs
+
+    def add_planet_from_period(self, period):
+        self.model.add_keplerian_from_period(period, fit=True)
+        self.model.fit()
+        self.np += 1
+
+    def _plot_periodogram(self, P=None, power=None, kmax=None, faplvl=None,
+                          **kwargs):
+        if P is None and power is None:
+            with timer('periodogram'):
+                nu, power = self.model.periodogram(self.nu0, self.dnu, self.nfreq)
+                P = 2 * np.pi / nu
+
+        if 'ax' in kwargs:
+            ax = kwargs.pop('ax')
+            fig = ax.figure
+        else:
+            fig, ax = plt.subplots(1, 1, constrained_layout=True)
+        ax.semilogx(P, power, 'k', lw=1, rasterized=True)
+        ax.set_ylim(0, 1.2 * power.max())
+        ax.set(xlabel='Period [days]', ylabel='Normalized power')
+
+        if kmax is None:
+            kmax = np.argmax(power)
+        ax.plot(P[kmax], power[kmax], 'or', ms=4)
+        ax.text(P[kmax], power[kmax] * 1.1, f'{P[kmax]:.3f} d',
+                ha='right', va='center', color='r')
+
+        if faplvl is None:
+            faplvl = self.model.fap(power[kmax], nu.max())
+        ax.text(0.99, 0.95, f'FAP = {faplvl:.2g}', transform=ax.transAxes,
+                ha='right', va='top')
+
+        return fig, ax
+
+    def add_keplerian_from_periodogram(self, fap_max=0.001, plot=False,
+                                       fit_first=True):
+        if fit_first and self.np == 0:
+            self.fit()
+
+        self._equal_coralie_offsets()
+
+        with timer('periodogram'):
+            nu, power = self.model.periodogram(self.nu0, self.dnu, self.nfreq)
+
+        P = 2 * np.pi / nu
+        # Compute FAP
+        kmax = np.argmax(power)
+        faplvl = self.model.fap(power[kmax], nu.max())
+        self.logger.info('highest periodogram peak:')
+        self.logger.info(f'P={P[kmax]:.4f} d, power={power[kmax]:.3f}, FAP={faplvl:.2e}')
+        if plot:
+            self._plot_periodogram(P, power, kmax, faplvl)
+
+        if faplvl > fap_max:
+            print('non-significant peak')
+            self.fit()
+            return False
+
+        # add new planet
+        letter = ascii_lowercase[1:][self.np]
+        self.model.add_keplerian_from_period(P[kmax], name=letter,
+                                             guess_kwargs={'emax': 0.8})
+        # self.model.set_keplerian_param(letter, param=['P', 'la0', 'K', 'e', 'w'])
+        self.model.set_keplerian_param(letter, param=['P', 'la0', 'K', 'esinw', 'ecosw'])
+        self.np += 1
+        self.fit()
+        
+        if plot:
+            self.plot()
+
+        return True
+    
+    @property
+    def offsets(self):
+        names = [f'lin.offset_{inst}' for inst in self.instruments]
+        return {
+            name.replace('lin.', ''): self.model.get_param(name)
+            for name in names
+        }
+
+    @property
+    def jitters(self):
+        names = [f'cov.{par}' for par in self.model.cov.param]
+        return {
+            name.replace('cov.', '').replace('.sig', ''): self.model.get_param(name)
+            for name in names
+        }
+    
+    @property
+    def keplerians(self):
+        keps = {name: {} for name in self.model.keplerian.keys()}
+        for name in keps:
+            params = self.model.keplerian[name]._param
+            pars = [f'kep.{name}.{p}' for p in params]
+            keps[name] = {
+                par.replace(f'kep.{name}.', ''): self.model.get_param(par)
+                for par in pars
+            }
+        return keps

arvi/nasaexo_wrapper.py

@@ -6,7 +6,7 @@ from io import StringIO
 import numpy as np
 from astropy.timeseries import LombScargle
 
-from .setup_logger import logger
+from .setup_logger import setup_logger
 from kepmodel.rv import RvModel
 from spleaf.term import Error
 
@@ -32,6 +32,7 @@ def run_query(query):
 
 class Planets:
     def __init__(self, system):
+        logger = setup_logger()
         self.s = system
         self.verbose = system.verbose
 
@@ -163,6 +164,7 @@ class Planets:
         self.model.show_param()
 
     def fit_all(self, adjust_data=False):
+        logger = setup_logger()
         self.model.fit()
 
         newP = np.array([self.model.get_param(f'kep.{i}.P') for i in range(self.np)])
@@ -187,5 +189,7 @@ class Planets:
             self.s._build_arrays()
 
     def __repr__(self):
-        return f'{self.star}({self.np} planets, '\
-               f'P={list(self.P)}, K={list(self.K)}, e={list(self.e)})'
+        P = list(map(float, self.P))
+        K = list(map(float, self.K))
+        e = list(map(float, self.e))
+        return f'{self.star}({self.np} planets, {P=}, {K=}, {e=})'

arvi/plots.py

@@ -1,6 +1,7 @@
 from functools import partialmethod, wraps
 from itertools import cycle
 
+import matplotlib.pyplot as plt
 import numpy as np
 
 from astropy.timeseries import LombScargle
@@ -9,9 +10,6 @@ from .setup_logger import setup_logger
 from .config import config
 from .stats import wmean
 
-from .utils import lazy_import
-plt = lazy_import('matplotlib.pyplot')
-
 
 def plot_settings(func):
     @wraps(func)

arvi/reports.py

@@ -40,6 +40,7 @@ class REPORTS:
             rows.append([self.star] + [''] * len(self.instruments) + [''])
             rows.append([''] + self.instruments + ['full'])
             rows.append(['N'] + list(self.NN.values()) + [self.N])
+            rows.append(['T span'] + [np.ptp(s.mtime).round(1) for s in self] + [np.ptp(self.mtime).round(1)])
             rows.append(['RV span'] + [np.ptp(s.mvrad).round(3) for s in self] + [np.ptp(self.mvrad).round(3)])
             rows.append(['RV std'] + [s.mvrad.std().round(3) for s in self] + [self.mvrad.std().round(3)])
             rows.append(['eRV mean'] + [s.msvrad.mean().round(3) for s in self] + [self.msvrad.mean().round(3)])
@@ -201,4 +202,110 @@ class REPORTS:
                     pdf.savefig(fig)
                 # os.system(f'evince {save} &')
 
-        return fig
+        return fig
+
+
+def kepmodel_report(self, fit_keplerians=3, save=None, nasaexo_title=False):
+    import matplotlib.pyplot as plt
+    import matplotlib.gridspec as gridspec
+    from matplotlib.backends.backend_pdf import PdfPages
+    logger = setup_logger()
+
+    def set_align_for_column(table, col, align="left"):
+        cells = [key for key in table._cells if key[1] == col]
+        for cell in cells:
+            table._cells[cell]._loc = align
+            table._cells[cell]._text.set_horizontalalignment(align) 
+
+    from .kepmodel_wrapper import model
+    m = model(self)
+
+    while fit_keplerians > 0:
+        if m.add_keplerian_from_periodogram():
+            fit_keplerians -= 1
+        else:
+            break
+
+    m.fit()
+
+
+    # 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, 1, 1, 1, 1])
+
+    # first row, all columns
+    ax1 = plt.subplot(gs[0, :])
+
+    if nasaexo_title:
+        title = str(self.planets).replace('(', '\n').replace(')', '')
+        star, planets = title.split('\n')
+        planets = planets.replace('planets,', 'known planets\n')
+        ax1.set_title(star, loc='left', fontsize=14)
+        ax1.set_title(planets, loc='right', fontsize=10)
+    else:
+        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')
+
+    m.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)
+    
+    ax2 = plt.subplot(gs[1, :-1])
+    m._plot_periodogram(ax=ax2)
+
+    ax3 = plt.subplot(gs[2, 0])
+    ax3.axis('off')
+    items = list(m.offsets.items())
+    items = [[item[0].replace('offset_', 'offet '), item[1].round(3)] for item in items]
+    table = ax3.table(items, loc='center', edges='open')
+    table.auto_set_font_size(False)
+    table.set_fontsize(9)
+    set_align_for_column(table, 1, align="left")
+
+    ax4 = plt.subplot(gs[2, 1])
+    ax4.axis('off')
+    items = list(m.jitters.items())
+    items = [[item[0].replace('jit_', 'jitter '), item[1].round(3)] for item in items]
+    table = ax4.table(items, loc='center', edges='open')
+    table.auto_set_font_size(False)
+    table.set_fontsize(9)
+    set_align_for_column(table, 1, align="left")
+
+    ax5 = plt.subplot(gs[2, 2])
+    ax5.axis('off')
+    items = [
+        ['N', m.model.n],
+        [r'N$_{\rm free}$', len(m.model.fit_param)],
+        [r'$\chi^2$', round(m.model.chi2(), 2)],
+        [r'$\chi^2_r$', round(m.model.chi2() / (m.model.n - len(m.model.fit_param)), 2)],
+        [r'$\log L$', round(m.model.loglike(), 2)],
+    ]
+    table = ax5.table(items, loc='center', edges='open')
+    table.auto_set_font_size(False)
+    table.set_fontsize(9)
+    set_align_for_column(table, 1, align="left")
+
+    for i, name in enumerate(m.keplerians):
+        ax = plt.subplot(gs[3, i])
+        m.plot_phasefolding(planets=name, ax=ax)
+
+        ax = plt.subplot(gs[4, i])
+        ax.axis('off')
+        with m.ew():
+            items = list(m.keplerians[name].items())
+        items = [[item[0], item[1].round(3)] for item in items]
+        table = ax.table(items, loc='center', edges='open')
+        table.auto_set_font_size(False)
+        table.set_fontsize(9)
+        set_align_for_column(table, 1, align="left")
+
+
+    return fig, m

arvi/stats.py

@@ -1,4 +1,6 @@
+from functools import partial
 import numpy as np
+from scipy.stats import norm
 
 def wmean(a, e):
     """Weighted mean of array `a`, with uncertainties given by `e`.
@@ -50,16 +52,39 @@ def wrms(a, e, ignore_nans=False):
     w = 1 / e**2
     return np.sqrt(np.sum(w * (a - np.average(a, weights=w))**2) / sum(w))
 
+# from https://stackoverflow.com/questions/20601872/numpy-or-scipy-to-calculate-weighted-median
+def weighted_quantiles_interpolate(values, weights, quantiles):
+    i = np.argsort(values)
+    c = np.cumsum(weights[i])
+    q = np.searchsorted(c, quantiles * c[-1])
+    # Ensure right-end isn't out of bounds. Thanks @Jeromino!
+    q_plus1 = np.clip(q + 1, a_min=None, a_max=values.shape[0] - 1)
+    return np.where(
+        c[q] / c[-1] == quantiles,
+        0.5 * (values[i[q]] + values[i[q_plus1]]),
+        values[i[q]],
+    )
 
-def sigmaclip_median(a, low=4.0, high=4.0):
+weighted_median = partial(weighted_quantiles_interpolate, quantiles=0.5)
+
+
+
+def sigmaclip_median(a, low=4.0, high=4.0, k=1/norm.ppf(3/4)):
     """
     Same as scipy.stats.sigmaclip but using the median and median absolute
     deviation instead of the mean and standard deviation.
 
     Args:
-        a (array): Array containing data
-        low (float): Number of MAD to use for the lower clipping limit
-        high (float): Number of MAD to use for the upper clipping limit
+        a (array):
+            Array containing data
+        low (float):
+            Number of MAD to use for the lower clipping limit
+        high (float):
+            Number of MAD to use for the upper clipping limit
+        k (float):
+            Scale factor for the MAD to be an estimator of the standard
+            deviation. Depends on the (assumed) distribution of the data.
+            Default value is for the normal distribution (=1/norm.ppf(3/4)).
     Returns:
         SigmaclipResult: Object with the following attributes:
             - `clipped`: Masked array of data
@@ -71,7 +96,7 @@ def sigmaclip_median(a, low=4.0, high=4.0):
     c = np.asarray(a).ravel()
     delta = 1
     while delta:
-        c_mad = median_abs_deviation(c)
+        c_mad = median_abs_deviation(c) * k
         c_median = np.median(c)
         size = c.size
         critlower = c_median - c_mad * low