arvi 0.1.22__tar.gz → 0.1.24__tar.gz

{arvi-0.1.22 → arvi-0.1.24}/.github/workflows/install.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
     steps:
     - uses: actions/checkout@v4

{arvi-0.1.22 → arvi-0.1.24}/.gitignore

@@ -2,7 +2,7 @@
 *.pkl
 *.rdb
 arvi/data/KOBE-translate.csv
-
+*_downloads
 
 
 # Byte-compiled / optimized / DLL files

{arvi-0.1.22 → arvi-0.1.24}/PKG-INFO

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

{arvi-0.1.22 → arvi-0.1.24}/arvi/dace_wrapper.py

@@ -1,7 +1,9 @@
 import os
+import sys
 import tarfile
 import collections
 from functools import lru_cache
+from itertools import islice
 import numpy as np
 from dace_query import DaceClass
 from dace_query.spectroscopy import SpectroscopyClass, Spectroscopy as default_Spectroscopy
@@ -22,22 +24,23 @@ def load_spectroscopy() -> SpectroscopyClass:
     return default_Spectroscopy
 
 @lru_cache()
-def get_dace_id(star):
+def get_dace_id(star, verbose=True):
     filters = {"obj_id_catname": {"equal": [star]}}
     try:
-        with stdout_disabled(), all_logging_disabled():
+        with all_logging_disabled():
             r = load_spectroscopy().query_database(filters=filters, limit=1)
         return r['obj_id_daceid'][0]
     except KeyError:
-        logger.error(f"Could not find DACE ID for {star}")
+        if verbose:
+            logger.error(f"Could not find DACE ID for {star}")
         raise ValueError from None
 
 def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='HE', verbose=True):
     arrays = []
-    instruments = list(result.keys())
+    instruments = [str(i) for i in result.keys()]
 
     for inst in instruments:
-        pipelines = list(result[inst].keys())
+        pipelines = [str(p) for p in result[inst].keys()]
 
         # select ESPRESSO mode, which is defined at the level of the pipeline
         if 'ESPRESSO' in inst:
@@ -55,20 +58,27 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
                 pipelines = [pipelines[i]]
 
         if latest_pipeline:
-            if verbose and len(pipelines) > 1:
+            npipe = len(pipelines)
+            if 'NIRPS' in inst and any(['LBL' in p for p in pipelines]):
+                # TODO: correctly load both CCF and LBL
+                pipelines = [pipelines[1]]
+            if 'HARPS' in inst and npipe > 1 and pipelines[1] == pipelines[0] + '-EGGS':
+                pipelines = pipelines[:2]
+            else:
+                pipelines = [pipelines[0]]
+
+            if verbose and npipe > 1:
                 logger.info(f'selecting latest pipeline ({pipelines[0]}) for {inst}')
 
-            pipelines = [pipelines[0]]
 
         for pipe in pipelines:
-            modes = list(result[inst][pipe].keys())
+            modes = [m for m in result[inst][pipe].keys()]
 
-                
             # select NIRPS mode, which is defined at the level of the mode
-            if 'NIRPS' in inst:
+            if 'NIRPS' in inst and len(modes) > 1:
                 if NIRPS_mode in modes:
                     if verbose:
-                        logger.info(f'selecting mode {NIRPS_mode} for NIRPS')
+                        logger.info(f'selecting mode {NIRPS_mode} for NIRPS - {pipe}')
                     i = modes.index(NIRPS_mode)
                     modes = [modes[i]]
                 else:
@@ -77,15 +87,25 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
 
             # 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)
-                )
+            if 'HARPS15' in inst:
+                if '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(
+                        ((str(inst), str(pipe), str(m0)), data)
+                    )
+                if 'EGGS+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(
+                        ((str(inst + '_EGGS'), str(pipe), str(m0)), data)
+                    )
                 continue
 
             for mode in modes:
@@ -94,39 +114,61 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
                     raise ValueError
 
                 arrays.append(
-                    ((inst, pipe, mode), result[inst][pipe][mode])
+                    ((str(inst), str(pipe), str(mode)), result[inst][pipe][mode])
                 )
 
     return arrays
 
-def get_observations_from_instrument(star, instrument, main_id=None):
+def get_observations_from_instrument(star, instrument, main_id=None, verbose=True):
     """ Query DACE for all observations of a given star and instrument
 
     Args:
-        star (str): name of the star
-        instrument (str): instrument name
-        main_id (str, optional): Simbad main id of target to query DACE id. Defaults to None.
+        star (str):
+            name of the star
+        instrument (str):
+            instrument name
+        main_id (str, optional):
+            Simbad main id of target to query DACE id. Defaults to None.
+        verbose (bool, optional):
+            whether to print warnings. Defaults to True.
 
     Raises:
-        ValueError: If query for DACE id fails
+        ValueError:
+            If query for DACE id fails
 
     Returns:
-        dict: dictionary with data from DACE
+        dict:
+            dictionary with data from DACE
     """
+    Spectroscopy = load_spectroscopy()
+    found_dace_id = False
     try:
-        dace_id = get_dace_id(star)
+        dace_id = get_dace_id(star, verbose=verbose)
+        found_dace_id = True
     except ValueError as e:
         if main_id is not None:
-            dace_id = get_dace_id(main_id)
-        else:
-            raise e
+            try:
+                dace_id = get_dace_id(main_id, verbose=verbose)
+                found_dace_id = True
+            except ValueError:
+                pass
+    
+    if not found_dace_id:
+        try:
+            with all_logging_disabled():
+                result = Spectroscopy.get_timeseries(target=star,
+                                                     sorted_by_instrument=True,
+                                                     output_format='numpy')
+                return result
+        except TypeError:
+            msg = f'no {instrument} observations for {star}'
+            raise ValueError(msg) from None
 
-    Spectroscopy = load_spectroscopy()
     filters = {
         "ins_name": {"contains": [instrument]},
         "obj_id_daceid": {"contains": [dace_id]}
     }
-    with stdout_disabled(), all_logging_disabled():
+    with all_logging_disabled():
         result = Spectroscopy.query_database(filters=filters)
     
     if len(result) == 0:
@@ -215,7 +257,7 @@ def get_observations(star, instrument=None, main_id=None, verbose=True):
             raise ValueError(msg) from None
     else:
         try:
-            result = get_observations_from_instrument(star, instrument, main_id)
+            result = get_observations_from_instrument(star, instrument, main_id, verbose)
         except ValueError:
             msg = f'no {instrument} observations for {star}'
             raise ValueError(msg) from None
@@ -320,16 +362,29 @@ def check_existing(output_directory, files, type):
 
     return np.array(missing)
 
-def download(files, type, output_directory):
+def download(files, type, output_directory, output_filename=None, quiet=True, pbar=None):
     """ Download files from DACE """
     Spectroscopy = load_spectroscopy()
-    with stdout_disabled(), all_logging_disabled():
+    if isinstance(files, str):
+        files = [files]
+    if quiet:
+        with all_logging_disabled():
+            Spectroscopy.download_files(files, file_type=type.lower(),
+                                        output_directory=output_directory,
+                                        output_filename=output_filename)
+    else:
         Spectroscopy.download_files(files, file_type=type.lower(),
-                                    output_directory=output_directory)
+                                    output_directory=output_directory,
+                                    output_filename=output_filename)
+    if pbar is not None:
+        pbar.update()
 
-def extract_fits(output_directory):
+
+def extract_fits(output_directory, filename=None):
     """ Extract fits files from tar.gz file """
-    file = os.path.join(output_directory, 'spectroscopy_download.tar.gz')
+    if filename is None:
+        filename = 'spectroscopy_download.tar.gz'
+    file = os.path.join(output_directory, filename)
     with tarfile.open(file, "r") as tar:
         files = []
         for member in tar.getmembers():
@@ -387,7 +442,7 @@ def do_symlink_filetype(type, raw_files, output_directory, clobber=False, top_le
 
 
 def do_download_filetype(type, raw_files, output_directory, clobber=False,
-                         verbose=True, chunk_size=20):
+                         verbose=True, chunk_size=20, parallel_limit=30):
     """ Download CCFs / S1Ds / S2Ds from DACE """
     raw_files = np.atleast_1d(raw_files)
 
@@ -407,7 +462,7 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
 
     # avoid an empty chunk
     if chunk_size > n:
-        chunk_size = n
+        chunk_size = n  
 
     if verbose:
         if chunk_size < n:
@@ -419,11 +474,36 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
             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)]
-    for files in tqdm(iterator, total=len(iterator)):
-        download(files, type, output_directory)
-        extract_fits(output_directory)
+    if n < parallel_limit:
+        iterator = [raw_files[i:i + chunk_size] for i in range(0, n, chunk_size)]
+        for files in tqdm(iterator, total=len(iterator)):
+            download(files, type, output_directory, quiet=False)
+            extract_fits(output_directory)
 
+    else:
+        def chunker(it, size):
+            iterator = iter(it)
+            while chunk := list(islice(iterator, size)):
+                yield chunk
+
+        chunks = list(chunker(raw_files, chunk_size))
+        pbar = tqdm(total=len(chunks))
+        it1 = [
+            (files, type, output_directory, f'spectroscopy_download{i+1}.tar.gz', True, pbar)
+            for i, files in enumerate(chunks)
+        ]
+        it2 = [(output_directory, f'spectroscopy_download{i+1}.tar.gz') for i in range(len(chunks))]
+
+        # import multiprocessing as mp
+        # with mp.Pool(4) as pool:
+        from multiprocessing.pool import ThreadPool
+
+        with ThreadPool(4) as pool:
+            pool.starmap(download, it1)
+            pool.starmap(extract_fits, it2)
+            print('')
+
+    sys.stdout.flush()
     logger.info('extracted .fits files')
 
 

{arvi-0.1.22 → arvi-0.1.24}/arvi/kima_wrapper.py

@@ -25,10 +25,11 @@ def run_kima(self, run=False, load=False, run_directory=None, priors={}, **kwarg
     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)
+    instruments = [inst for inst in self.instruments if self.NN[inst] > 1]
+    time = [getattr(self, inst).mtime for inst in instruments]
+    vrad = [getattr(self, inst).mvrad for inst in instruments]
+    err = [getattr(self, inst).msvrad for inst in instruments]
+    data = RVData(time, vrad, err, instruments=instruments)
 
     fix = kwargs.pop('fix', False)
     npmax = kwargs.pop('npmax', 1)
@@ -41,6 +42,13 @@ def run_kima(self, run=False, load=False, run_directory=None, priors={}, **kwarg
     model.enforce_stability = kwargs.pop('enforce_stability', False)
     model.star_mass = kwargs.pop('star_mass', 1.0)
 
+    if kwargs.pop('gaussian_priors_individual_offsets', False):
+        from kima.pykima.utils import get_gaussian_priors_individual_offsets
+        model.individual_offset_prior = get_gaussian_priors_individual_offsets(data, use_std=True)
+
+    if kwargs.pop('kuma', False):
+        model.conditional.eprior = distributions.Kumaraswamy(0.867, 3.03)
+
     for k, v in priors.items():
         try:
             if 'conditional' in k:
@@ -55,9 +63,10 @@ def run_kima(self, run=False, load=False, run_directory=None, priors={}, **kwarg
             logger.warning(msg)
             return
 
+    if run_directory is None:
+        run_directory = os.getcwd()
+
     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__
@@ -67,8 +76,9 @@ def run_kima(self, run=False, load=False, run_directory=None, priors={}, **kwarg
         with chdir(run_directory):
             kima.run(model, **kwargs)
         
-        if load:
+    if load:
+        with chdir(run_directory):
             res = kima.load_results(model)
-            return data, model, res
+        return data, model, res
 
     return data, model

arvi-0.1.24/arvi/programs.py

@@ -0,0 +1,247 @@
+import os
+import multiprocessing
+from functools import partial, lru_cache
+from itertools import chain
+from collections import namedtuple
+from multiprocessing.pool import ThreadPool
+from tqdm import tqdm
+# import numpy as np
+
+from .setup_logger import logger
+from .timeseries import RV
+
+__all__ = ['ESPRESSO_GTO']
+
+path = os.path.join(os.path.dirname(__file__), 'data')
+
+
+def get_star(star, instrument=None, verbose=False, **kwargs):
+    return RV(star, instrument=instrument,
+              _raise_on_error=False, verbose=verbose, **kwargs)
+
+
+class LazyRV:
+    def __init__(self, stars: list, instrument: str = None,
+                 _parallel_limit=10):
+        self.stars = stars
+        if isinstance(self.stars, str):
+            self.stars = [self.stars]
+        self.instrument = instrument
+        self._saved = None
+        self._parallel_limit = _parallel_limit
+
+    @property
+    def N(self):
+        return len(self.stars)
+
+    def __repr__(self):
+        return f"RV({self.N} stars)"
+
+    def _get(self, **kwargs):
+        if self.N > self._parallel_limit:
+            # logger.info('Querying DACE...')
+            _get_star = partial(get_star, instrument=self.instrument, **kwargs)
+            with ThreadPool(8) as pool:
+                result = list(tqdm(pool.imap(_get_star, self.stars), 
+                                   total=self.N, unit='star',
+                                   desc='Querying DACE (can take a while)'))
+                print('')
+        else:
+            result = []
+            logger.info('querying DACE...')
+            pbar = tqdm(self.stars, total=self.N, unit='star')
+            for star in pbar:
+                pbar.set_description(star)
+                result.append(get_star(star, self.instrument, **kwargs))
+
+        return result
+
+        # # use a with statement to ensure threads are cleaned up promptly
+        # with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:
+        #     star_to_RV = {
+        #         pool.submit(get_star, star, self.instrument): star 
+        #         for star in self.stars
+        #     }
+        #     logger.info('Querying DACE...')
+        #     pbar = tqdm(concurrent.futures.as_completed(star_to_RV),
+        #                 total=self.N, unit='star')
+        #     for future in pbar:
+        #         star = star_to_RV[future]
+        #         pbar.set_description(star)
+        #         try:
+        #             result.append(future.result())
+        #         except ValueError:
+        #             print(f'{star} generated an exception')
+        #             result.append(None)
+        # return result
+
+    def reload(self, **kwargs):
+        self._saved = self._get(**kwargs)
+        return self._saved
+
+    def __iter__(self):
+        return self._get()
+
+    def __call__(self, **kwargs):
+        if not self._saved:
+            self._saved = self._get(**kwargs)
+        return self._saved
+
+    @lru_cache(maxsize=10)
+    def __getitem__(self, index):
+        star = self.stars[index]
+        if self._saved is not None:
+            return self._saved[index]
+        return get_star(star, self.instrument, verbose=True)
+
+
+# sorted by spectral type
+WG1_stars = [
+    "HIP11533",  # F2
+    "HD63077",  # F9
+    "HD102365",  # G2
+    "HD160691",  # G3
+    "HD20794",  # G6
+    "HD115617",  # G6
+    "HD10700",  # G8
+    "HD69830",  # G8
+    "HD26965",  # K0
+    "HD100623",  # K0
+    "HD154088",  # K0
+    "HD72673",  # K1
+    "HD4628",  # K2
+    "HD191408",  # K2
+    "HD192310",  # K2
+    "HD16160",  # K3
+    "HD32147",  # K3
+    "HD22496",  # K5
+    "HIP93069",  # K5
+    "HD209100",  # K5
+    "HIP23708",  # K7
+    "HD152606",  # K8
+    "HD260655",  # M0
+    "HIP40239",  # M0
+    "HD304636",  # M0
+    "HIP85647",  # M0
+    "HD165222",  # M0
+    "HD191849",  # M0
+    "GJ191",  # M1
+    "HD42581",  # M1
+    "HIP42748",  # M1
+    "HIP65859",  # M1
+    "HIP86287",  # M1
+    "HD176029",  # M1
+    "GJ825",  # M1
+    "HD225213",  # M2
+    "GJ54",  # M2
+    "HIP22627",  # M2
+    "HIP51317",  # M2
+    "HD119850",  # M2
+    "GJ832",  # M2
+    "HD217987",  # M2
+    "GJ273",  # M3
+    "GJ388",  # M3
+    "HIP62452",  # M3
+    "HIP67164",  # M3
+    "HIP71253",  # M3
+    "GJ628",  # M3
+    "HIP85523",  # M3
+    "HIP86214",  # M3
+    "HIP92403",  # M3
+    "HIP113020",  # M3
+    "HIP1242",  # M4
+    "GJ83.1",  # M4
+    "HIP53020",  # M4
+    "Ross128",  # M4
+    "GJ699",  # M4
+    "GJ1002",  # M5
+    "GJ1061",  # M5
+    "GJ3618",  # M5
+    "Proxima",  # M5
+    "GJ406",  # M6
+]
+
+ESPRESSO_GTO_nt = namedtuple('ESPRESSO_GTO', ['WG1', 'WG2', 'WG3'])
+ESPRESSO_GTO = ESPRESSO_GTO_nt(
+    WG1=LazyRV(WG1_stars, instrument='ESPRESSO'),
+    WG2=LazyRV([], instrument='ESPRESSO'), # TODO
+    WG3=LazyRV([], instrument='ESPRESSO'), # TODO
+)
+ESPRESSO_GTO.WG1.__doc__ = 'RV observations for all WG1 targets. Call ESPRESSO_GTO.WG1() to load them.'
+ESPRESSO_GTO.WG2.__doc__ = 'RV observations for all WG2 targets. Call ESPRESSO_GTO.WG2() to load them.'
+ESPRESSO_GTO.WG3.__doc__ = 'RV observations for all WG3 targets. Call ESPRESSO_GTO.WG3() to load them.'
+
+
+import requests
+
+def _get_NIRPS_GTO_stars(WP=1):
+    from io import StringIO
+    import numpy as np
+
+    url = 'https://www.eso.org/sci/observing/teles-alloc/gto/113/NIRPS/P113_NIRPS-consortium.csv'
+    file = StringIO(requests.get(url).content.decode())
+    stars_P113 = np.loadtxt(file, delimiter=',', usecols=(0,), dtype=str, skiprows=3)
+    
+    url = 'https://www.eso.org/sci/observing/teles-alloc/gto/114/NIRPS/P114_NIRPS-consortium.csv'
+    file = StringIO(requests.get(url).content.decode())
+    stars_P114 = np.loadtxt(file, delimiter=',', usecols=(0,), dtype=str, skiprows=3)
+
+    url = 'https://www.eso.org/sci/observing/teles-alloc/gto/115/NIRPS/P115_NIRPS-consortium.csv'
+    file = StringIO(requests.get(url).content.decode())
+    stars_P115 = np.loadtxt(file, delimiter=',', usecols=(0,), dtype=str, skiprows=3)
+
+    def _get_stars_period(stars, WP):
+        stars = np.delete(stars, stars=='')
+
+        stars = np.char.replace(stars, '_', ' ')
+        stars = np.char.replace(stars, "Proxima Centauri", "Proxima")
+        stars = np.char.replace(stars, "Barnard's star", "GJ699")
+        stars = np.char.replace(stars, "Teegarden's Star", 'Teegarden')
+
+        if WP in (1, 'WP1'):
+            wp1_indices = slice(np.where(stars == 'WP1')[0][0] + 1, np.where(stars == 'WP2')[0][0])
+            return stars[wp1_indices]
+        elif WP == 2:
+            wp2_indices = slice(np.where(stars == 'WP2')[0][0] + 1, np.where(stars == 'WP3')[0][0])
+            return stars[wp2_indices]
+        elif WP == 3:
+            wp3_indices = slice(np.where(stars == 'WP3')[0][0] + 1, np.where(stars == 'Other Science 1')[0][0])
+            return stars[wp3_indices]
+        elif WP == 'OS1':
+            os1_indices = slice(np.where(stars == 'Other Science 1')[0][0] + 1, np.where(stars == 'Other Science 2')[0][0])
+            return stars[os1_indices]
+        elif WP == 'OS2':
+            os2_indices = slice(np.where(stars == 'Other Science 2')[0][0] + 1, None)
+            stars = np.char.replace(stars, 'MMU', 'No')
+            stars = np.char.replace(stars, 'Cl*', '')
+            return stars[os2_indices]
+    
+    stars_P113 = _get_stars_period(stars_P113, WP)
+    stars_P114 = _get_stars_period(stars_P114, WP)
+    stars_P115 = _get_stars_period(stars_P115, WP)
+    return np.union1d(np.union1d(stars_P113, stars_P114), stars_P115)
+
+try:
+    NIRPS_GTO_WP1_stars = _get_NIRPS_GTO_stars(WP=1)
+    NIRPS_GTO_WP2_stars = _get_NIRPS_GTO_stars(WP=2)
+    NIRPS_GTO_WP3_stars = _get_NIRPS_GTO_stars(WP=3)
+    NIRPS_GTO_OS1_stars = _get_NIRPS_GTO_stars(WP='OS1')
+    NIRPS_GTO_OS2_stars = _get_NIRPS_GTO_stars(WP='OS2')
+except requests.ConnectionError:
+    from .setup_logger import logger
+    logger.error('Cannot download NIRPS GTO protected target list')
+else:
+    NIRPS_GTO_nt = namedtuple('NIRPS_GTO', ['WP1', 'WP2', 'WP3', 'OS1', 'OS2'])
+    NIRPS_GTO_nt.__doc__ = 'RV observations for all NIRPS GTO targets. See NIRPS_GTO.WP1, NIRPS_GTO.WP2, ...'
+    NIRPS_GTO = NIRPS_GTO_nt(
+        WP1=LazyRV(NIRPS_GTO_WP1_stars, instrument='NIRPS'),
+        WP2=LazyRV(NIRPS_GTO_WP2_stars, instrument='NIRPS'),
+        WP3=LazyRV(NIRPS_GTO_WP3_stars, instrument='NIRPS'),
+        OS1=LazyRV(NIRPS_GTO_OS1_stars, instrument='NIRPS'),
+        OS2=LazyRV(NIRPS_GTO_OS2_stars, instrument='NIRPS'),
+    )
+    NIRPS_GTO.WP1.__doc__ = 'RV observations for all WP1 targets. Call NIRPS_GTO.WP1() to load them.'
+    NIRPS_GTO.WP2.__doc__ = 'RV observations for all WP2 targets. Call NIRPS_GTO.WP2() to load them.'
+    NIRPS_GTO.WP3.__doc__ = 'RV observations for all WP3 targets. Call NIRPS_GTO.WP3() to load them.'
+    NIRPS_GTO.OS1.__doc__ = 'RV observations for all OS1 targets. Call NIRPS_GTO.OS1() to load them.'
+    NIRPS_GTO.OS2.__doc__ = 'RV observations for all OS2 targets. Call NIRPS_GTO.OS2() to load them.'

{arvi-0.1.22 → arvi-0.1.24}/arvi/spectra.py

@@ -72,7 +72,7 @@ def fit_gaussian_to_line(wave, flux, center_wavelength, around=0.15 * u.angstrom
     ]).T
 
     try:
-        popt, pcov = curve_fit(gaussian, w, f, p0=[-f.ptp(), center_wavelength.value, 0.1, f.max()],
+        popt, pcov = curve_fit(gaussian, w, f, p0=[-np.ptp(f), center_wavelength.value, 0.1, f.max()],
                                bounds=(lower, upper))
     except RuntimeError as e:
         logger.warning(f'fit_gaussian_to_line: {e}')
@@ -115,7 +115,7 @@ def detrend(w, f):
 def build_master(self, limit=None, plot=True):
     files = sorted(glob(f'{self.star}_downloads/*S1D_A.fits'))
     if self.verbose:
-        logger.info(f'Found {len(files)} S1D files')
+        logger.info(f'found {len(files)} S1D files')
 
     files = files[:limit]
 
@@ -168,8 +168,8 @@ def determine_stellar_parameters(self, linelist: str, plot=True, **kwargs):
     ]
 
     if self.verbose:
-        logger.info(f'Found {len(lines)} lines in linelist')
-        logger.info('Measuring EWs...')
+        logger.info(f'found {len(lines)} lines in linelist')
+        logger.info('measuring EWs...')
 
     EW = []
     pbar = tqdm(linelist)
@@ -183,14 +183,14 @@ def determine_stellar_parameters(self, linelist: str, plot=True, **kwargs):
     EW = np.array(EW)[~np.isnan(EW)]
 
     if self.verbose:
-        logger.info('Determining stellar parameters (can take a few minutes)...')
+        logger.info('determining stellar parameters (can take a few minutes)...')
 
     callback = lambda p, r, A: print('current parameters:', p)
     result = Korg.Fit.ews_to_stellar_parameters(lines, EW, callback=callback)
     par, stat_err, sys_err = result
 
     if self.verbose:
-        logger.info(f'Best fit stellar parameters:')
+        logger.info(f'best-fit stellar parameters:')
         logger.info(f'  Teff: {par[0]:.0f} ± {sys_err[0]:.0f} K')
         logger.info(f'  logg: {par[1]:.2f} ± {sys_err[1]:.2f} dex')
         logger.info(f'  m/H :  {par[3]:.2f} ± {sys_err[3]:.2f} dex')