arvi 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

arvi/HZ.py

@@ -1,4 +1,3 @@
-from collections import namedtuple
 import numpy as np
 from astropy.constants import G
 from astropy import units

arvi/__init__.py

@@ -8,6 +8,7 @@ def __getattr__(name: str):
     if name in (
         '_ipython_canary_method_should_not_exist_',
         '_repr_mimebundle_',
+        '__wrapped__'
     ):
         return
 

arvi/ariadne_wrapper.py

@@ -0,0 +1,70 @@
+import os
+import sys
+from matplotlib import pyplot as plt
+
+try:
+    from astroARIADNE.star import Star
+    from astroARIADNE.fitter import Fitter
+except ImportError:
+    print('This module requires astroARIADNE. Install with `pip install astroARIADNE`')
+    sys.exit(0)
+
+
+def run_ariadne(self, fit=True, plot=True, priors={},
+                models = ('phoenix', 'btsettl', 'btnextgen', 'btcond', 'kurucz', 'ck04'),
+                nlive=300, dlogz=1, threads=6, dynamic=False, **kwargs):
+    if hasattr(self, 'gaia'):
+        s = Star(self.star, self.gaia.ra, self.gaia.dec, g_id=self.gaia.dr3_id,
+                 search_radius=1)
+    else:
+        s = Star(self.star, self.simbad.ra, self.simbad.dec, g_id=self.simbad.gaia_id,
+                 search_radius=1)
+
+    out_folder = f'{self.star}_ariadne'
+
+    setup = dict(engine='dynesty', nlive=nlive, dlogz=dlogz,
+                 bound='multi', sample='auto', threads=threads, dynamic=dynamic)
+    setup = list(setup.values())
+
+    f = Fitter()
+    f.star = s
+    f.setup = setup
+    f.av_law = 'fitzpatrick'
+    f.out_folder = out_folder
+    f.bma = True
+    f.models = models
+    f.n_samples = 10_000
+
+    f.prior_setup = {
+            'teff': priors.get('teff', ('default')),
+            'logg': ('default'),
+            'z': priors.get('feh', ('default')),
+            'dist': ('default'),
+            'rad': ('default'),
+            'Av': ('default')
+    }
+
+    if fit:
+        f.initialize()
+        f.fit_bma()
+
+    if plot:
+        from pkg_resources import resource_filename
+        from astroARIADNE.plotter import SEDPlotter
+        modelsdir = resource_filename('astroARIADNE', 'Datafiles/models')
+        artist = SEDPlotter(os.path.join(out_folder, 'BMA.pkl'), out_folder, models_dir=modelsdir)
+
+        artist.plot_SED_no_model()
+        try:
+            artist.plot_SED()
+        except FileNotFoundError as e:
+            print('No model found:', e)
+        except IndexError as e:
+            print('Error!')
+        artist.plot_bma_hist()
+        artist.plot_bma_HR(10)
+        artist.plot_corner()
+        plt.close('all')
+        return s, f, artist
+
+    return s, f

arvi/binning.py

@@ -1,6 +1,9 @@
 import numpy as np
 from numpy.testing import suppress_warnings
 
+from scipy.stats import binned_statistic as old_binned_statistic,\
+                        binned_statistic_dd as old_binned_statistic_dd
+
 from .setup_logger import logger
 
 ###############################################################################
@@ -212,8 +215,6 @@ def binned_statistic_dd(sample, values, statistic='mean', bins=10, range=None,
 
 
 # put back the documentation
-from scipy.stats import binned_statistic as old_binned_statistic,\
-                        binned_statistic_dd as old_binned_statistic_dd
 doc1 = old_binned_statistic.__doc__
 doc2 = old_binned_statistic_dd.__doc__
 binned_statistic.__doc__ = doc1

arvi/config.py

@@ -1,2 +1,14 @@
+# whether to return self from (some) RV methods
 return_self = False
+
+# whether to check internet connection before querying DACE
 check_internet = False
+
+# make all DACE requests without using a .dacerc file
+request_as_public = False
+
+# whether to adjust instrument means before gls by default
+adjust_means_gls = True
+
+# debug
+debug = False

arvi/dace_wrapper.py

@@ -1,6 +1,7 @@
 import os
 import tarfile
 import collections
+from functools import lru_cache
 import numpy as np
 from dace_query import DaceClass
 from dace_query.spectroscopy import SpectroscopyClass, Spectroscopy as default_Spectroscopy
@@ -9,12 +10,28 @@ from .utils import create_directory, all_logging_disabled, stdout_disabled, tqdm
 
 
 def load_spectroscopy() -> SpectroscopyClass:
+    from .config import request_as_public
+    if request_as_public:
+        with all_logging_disabled():
+            dace = DaceClass(dace_rc_config_path='none')
+        return SpectroscopyClass(dace_instance=dace)
     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
 
+@lru_cache()
+def get_dace_id(star):
+    filters = {"obj_id_catname": {"contains": [star]}}
+    try:
+        with stdout_disabled(), 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}")
+        raise ValueError from None
+
 def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='HE', verbose=True):
     arrays = []
     instruments = list(result.keys())
@@ -34,7 +51,7 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
                 i = [i for i, pipe in enumerate(pipelines) if ESPRESSO_mode in pipe][0]
                 pipelines = [pipelines[i]]
             else:
-                if verbose:
+                if len(pipelines) > 1 and verbose:
                     logger.warning(f'no observations for requested ESPRESSO mode ({ESPRESSO_mode})')
 
         if latest_pipeline:
@@ -68,19 +85,118 @@ def get_arrays(result, latest_pipeline=True, ESPRESSO_mode='HR11', NIRPS_mode='H
 
     return arrays
 
-def get_observations(star, instrument=None, verbose=True):
-    Spectroscopy = load_spectroscopy()
+def get_observations_from_instrument(star, instrument, main_id=None):
+    """ 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.
+
+    Raises:
+        ValueError: If query for DACE id fails
+
+    Returns:
+        dict: dictionary with data from DACE
+    """
     try:
-        with stdout_disabled(), all_logging_disabled():
-            result = Spectroscopy.get_timeseries(target=star,
-                                                sorted_by_instrument=True,
-                                                output_format='numpy')
-    except TypeError:
-        if instrument is None:
-            msg = f'no observations for {star}'
+        dace_id = get_dace_id(star)
+    except ValueError as e:
+        if main_id is not None:
+            dace_id = get_dace_id(main_id)
         else:
+            raise e
+
+    Spectroscopy = load_spectroscopy()
+    filters = {
+        "ins_name": {"contains": [instrument]}, 
+        "obj_id_daceid": {"contains": [dace_id]}
+    }
+    with stdout_disabled(), all_logging_disabled():
+        result = Spectroscopy.query_database(filters=filters)
+    
+    if len(result) == 0:
+        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],
+                    '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],
+                    '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],
+                    '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],
+                    '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],
+                }
+            }
+    return r
+
+def get_observations(star, instrument=None, main_id=None, verbose=True):
+    if instrument is None:
+        Spectroscopy = load_spectroscopy()
+        try:
+            with stdout_disabled(), all_logging_disabled():
+                result = Spectroscopy.get_timeseries(target=star,
+                                                     sorted_by_instrument=True,
+                                                     output_format='numpy')
+        except TypeError:
+            if instrument is None:
+                msg = f'no observations for {star}'
+            else:
+                msg = f'no {instrument} observations for {star}'
+            raise ValueError(msg) from None
+    else:
+        try:
+            result = get_observations_from_instrument(star, instrument, main_id, verbose)
+        except ValueError:
             msg = f'no {instrument} observations for {star}'
-        raise ValueError(msg) from None
+            raise ValueError(msg) from None
 
     # defaultdict --> dict
     if isinstance(result, collections.defaultdict):
@@ -181,9 +297,9 @@ def check_existing(output_directory, files, type):
 def download(files, type, output_directory):
     """ Download files from DACE """
     Spectroscopy = load_spectroscopy()
-    # with stdout_disabled(), all_logging_disabled():
-    Spectroscopy.download_files(files, file_type=type.lower(),
-                                output_directory=output_directory)
+    with stdout_disabled(), all_logging_disabled():
+        Spectroscopy.download_files(files, file_type=type.lower(),
+                                    output_directory=output_directory)
 
 def extract_fits(output_directory):
     """ Extract fits files from tar.gz file """
@@ -201,6 +317,49 @@ def extract_fits(output_directory):
     return files
 
 
+def do_symlink_filetype(type, raw_files, output_directory, clobber=False, top_level=None, verbose=True):
+    terminations = {
+        'CCF': '_CCF_A.fits',
+        'S1D': '_S1D_A.fits',
+        'S2D': '_S2D_A.fits',
+    }
+
+    create_directory(output_directory)
+
+    raw_files = np.atleast_1d(raw_files)
+
+    # check existing files
+    if not clobber:
+        raw_files = check_existing(output_directory, raw_files, type)
+
+    n = raw_files.size
+
+    # any file left?
+    if n == 0:
+        if verbose:
+            logger.info('no files to symlink')
+        return
+
+    if verbose:
+        msg = f"symlinking {n} {type}s into '{output_directory}'..."
+        logger.info(msg)
+
+    for file in tqdm(raw_files):
+        if top_level is not None:
+            top = file.split('/')[0] + '/'
+            if not top_level.endswith('/'):
+                top_level = top_level + '/'
+            file = file.replace(top, top_level)
+
+        file = file.replace('.fits', terminations[type])
+
+        if os.path.exists(file):
+            os.symlink(file, os.path.join(output_directory, os.path.basename(file)))
+            # print(file, os.path.join(output_directory, os.path.basename(file)))
+        else:
+            logger.warning(f'file not found: {file}')
+
+
 def do_download_filetype(type, raw_files, output_directory, clobber=False,
                          verbose=True, chunk_size=20):
     """ Download CCFs / S1Ds / S2Ds from DACE """
@@ -212,21 +371,30 @@ def do_download_filetype(type, raw_files, output_directory, clobber=False,
     if not clobber:
         raw_files = check_existing(output_directory, raw_files, type)
 
+    n = raw_files.size
+
     # any file left to download?
-    if raw_files.size == 0:
+    if n == 0:
         if verbose:
             logger.info('no files to download')
         return
 
-    if verbose:
-        n = raw_files.size
-        logger.info(f"Downloading {n} {type}s into '{output_directory}'...")
-
     # avoid an empty chunk
     if chunk_size > n:
         chunk_size = n
 
-    for files in tqdm(zip(*(iter(raw_files),) * chunk_size), total=n // chunk_size):
+    if verbose:
+        if chunk_size < n:
+            msg = f"Downloading {n} {type}s "
+            msg += f"(in chunks of {chunk_size}) "
+            msg += f"into '{output_directory}'..."
+            logger.info(msg)
+        else:
+            msg = f"Downloading {n} {type}s into '{output_directory}'..."
+            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)
 

arvi/data/obs_affected_ADC_issues.dat

@@ -155,4 +155,7 @@
 2021-01-28      r.ESPRE.2021-01-29T01:46:34.785   106.21M2.002    2897966
 2021-01-28      r.ESPRE.2021-01-29T02:06:35.596   106.21M2.002    2899965
 2021-01-31      r.ESPRE.2021-02-01T01:34:18.507   106.21M2.001    2899996
-2019-12-22      r.ESPRE.2019-12-23T00:30:55.824   1104.C-0350(A)  2496531
+2019-12-22      r.ESPRE.2019-12-23T00:30:55.824   1104.C-0350(A)  2496531
+# additional frames with ADC2 absent or set to zero
+2021-04-06      r.ESPRE.2021-04-06T23:30:53.085   1104.C-0350     3026604
+2021-04-09      r.ESPRE.2021-04-10T00:40:18.132   1104.C-0350     3027219

arvi/gaia_wrapper.py

@@ -0,0 +1,98 @@
+import os
+from io import StringIO
+from csv import DictReader
+import requests
+
+from astropy.coordinates import SkyCoord
+
+DATA_PATH = os.path.dirname(__file__)
+DATA_PATH = os.path.join(DATA_PATH, 'data')
+
+QUERY = """
+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 
+CONTAINS(
+	POINT('ICRS',gaiadr3.gaia_source.ra,gaiadr3.gaia_source.dec),
+	CIRCLE(
+		'ICRS',
+		COORD1(EPOCH_PROP_POS({ra},{dec},{plx},{pmra},{pmdec},{rv},2000,2016.0)),
+		COORD2(EPOCH_PROP_POS({ra},{dec},{plx},{pmra},{pmdec},{rv},2000,2016.0)),
+		0.001388888888888889)
+)=1
+"""
+
+def run_query(query):
+    url = 'https://gea.esac.esa.int/tap-server/tap/sync'
+    data = dict(query=query, request='doQuery', lang='ADQL', format='csv')
+    try:
+        response = requests.post(url, data=data, timeout=10)
+    except requests.ReadTimeout as err:
+        raise IndexError(err)
+    except requests.ConnectionError as err:
+        raise IndexError(err)
+    return response.content.decode()
+
+def parse_csv(csv):
+    reader = DictReader(StringIO(csv))
+    return list(reader)
+
+
+class gaia:
+    """
+    A very simple wrapper around a TAP query to gaia 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
+        dr3_id (int): Gaia DR3 identifier
+        plx (float): parallax
+        radial_velocity (float): radial velocity
+    """
+    def __init__(self, star:str, simbad=None):
+        """
+        Args:
+            star (str): The name of the star to query simbad
+        """
+        self.star = star
+
+        if simbad is None:
+            from .simbad_wrapper import simbad as Simbad
+            simbad = Simbad(star)
+
+        ra = simbad.ra
+        dec = simbad.dec
+        plx = simbad.plx
+        pmra = simbad.pmra
+        pmdec = simbad.pmdec
+        rv = simbad.rvz_radvel
+        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]
+        except IndexError:
+            raise ValueError(f'Gaia query for {star} failed')
+        
+        try:
+            self.dr3_id = int(results['source_id'])
+        except KeyError:
+            raise ValueError(f'Gaia query for {star} failed')
+
+        self.ra = float(results['ra'])
+        self.dec = float(results['dec'])
+        self.pmra = float(results['pmra'])
+        self.pmdec = float(results['pmdec'])
+        self.coords = SkyCoord(self.ra, self.dec, unit='deg')
+        self.plx = float(results['parallax'])
+        try:
+            self.radial_velocity = float(results['radial_velocity'])
+        except ValueError:
+            self.radial_velocity = None
+
+        return
+
+    def __repr__(self):
+        return f'{self.star} (DR3 id={self.dr3_id})'

arvi/instrument_specific.py

@@ -1,17 +1,19 @@
 import os, sys
 import numpy as np
-import matplotlib.pyplot as plt
 
 from .setup_logger import logger
 
 # ESPRESSO ADC issues
 from .utils import ESPRESSO_ADC_issues
 
-def ADC_issues(self, plot=True):
+def ADC_issues(self, plot=True, check_headers=False):
     """ Identify and mask points affected by ADC issues (ESPRESSO).
 
     Args:
-        plot (bool, optional): Whether to plot the masked points.
+        plot (bool, optional):
+            Whether to plot the masked points.
+        check_headers (bool, optional):
+            Whether to (double-)check the headers for missing/zero keywords.
     """
     instruments = self._check_instrument('ESPRESSO')
     
@@ -25,6 +27,14 @@ def ADC_issues(self, plot=True):
     file_roots = [os.path.basename(f).replace('.fits', '') for f in self.raw_file]
     intersect = np.in1d(file_roots, affected_file_roots)
 
+    if check_headers:
+        from .headers import get_headers
+        H = get_headers(self, check_lesta=False, check_exo2=False, instrument='ESPRE')
+        badACD2 = np.array([h['*ADC2 RA'][0] for h in H]) == 0
+        badACD2 |= np.array([h['*ADC2 SENS1'][0] for h in H]) == 0
+        badACD2 |= np.array([h['*ADC2 TEMP'][0] for h in H]) == 0
+        intersect = np.logical_or(intersect, badACD2)
+
     total_affected = intersect.sum()
 
     if self.verbose:
@@ -76,6 +86,52 @@ def blue_cryostat_issues(self, plot=True):
     return intersect
 
 
+def qc_scired_issues(self, plot=False, **kwargs):
+    """ Identify and mask points with failed SCIRED QC
+
+    Args:
+        plot (bool, optional): Whether to plot the masked points.
+    """
+    from .headers import get_headers
+
+    instruments = self._check_instrument('ESPRESSO')
+    
+    if instruments is None:
+        if self.verbose:
+            logger.error(f"no data from ESPRESSO")
+            logger.info(f'available: {self.instruments}')
+        return
+
+    H = kwargs.get('H', None)
+    if H is None:
+        H = get_headers(self, check_lesta=False, check_exo2=False, instrument='ESPRE')
+    if len(H) == 0:
+        if self.verbose:
+            logger.warning('this function requires access to headers, but none found')
+            logger.warning('trying to download')
+        self.download_ccf()
+        H = get_headers(self, check_lesta=False, check_exo2=False, instrument='ESPRE')
+    
+    scired_check = np.array([h['HIERARCH ESO QC SCIRED CHECK'] for h in H])
+    affected = scired_check == 0
+    n = affected.sum()
+
+    if self.verbose:
+        logger.info(f"there {'are'[:n^1]}{'is'[n^1:]} {n} frame{'s'[:n^1]} "
+                     "where QC SCIRED CHECK is 0")
+
+    if n == 0:
+        return
+
+    self.mask[affected] = False
+    self._propagate_mask_changes()
+
+    if plot:
+        self.plot(show_masked=True)
+
+    return affected
+
+
 def known_issues(self, plot=False, **kwargs):
     """ Identify and mask known instrumental issues (ADC and blue cryostat for ESPRESSO)
 

arvi/nasaexo_wrapper.py

@@ -125,7 +125,7 @@ class Planets:
             self.model.keplerian.uid = 0
 
         for i in range(self.np):
-            if self.K[i] == False or np.isnan(self.K[i]):
+            if not self.K[i] or np.isnan(self.K[i]):
                 self.model.add_keplerian_from_period(self.P[i], fit=True)
             else:
                 self.model.add_keplerian([self.P[i], self.K[i], self.e[i], 0.0, self.w[i]],