exoatlas 0.3.7__tar.gz

exoatlas-0.3.7/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2024 Zach Berta-Thompson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exoatlas-0.3.7/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.1
+Name: exoatlas
+Version: 0.3.7
+Summary: Tools for working with transiting exoplanet populations.
+Home-page: https://github.com/zkbt/exoatlas
+Author: Zach Berta-Thompson
+Author-email: zach.bertathompson@colorado.edu
+License: MIT
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: numpy>=1.13
+Requires-Dist: matplotlib>=2.0
+Requires-Dist: astropy>=3.2.3
+Requires-Dist: astroquery>=0.3.9
+Requires-Dist: astroplan>=0.10
+Requires-Dist: rainbow-connection>=0.0.1
+Requires-Dist: PyYAML
+Requires-Dist: tqdm
+Requires-Dist: pytz
+Provides-Extra: develop
+Requires-Dist: pytest; extra == "develop"
+Requires-Dist: black; extra == "develop"
+Requires-Dist: black[jupyter]; extra == "develop"
+Requires-Dist: jupyter; extra == "develop"
+Requires-Dist: ipython; extra == "develop"
+Requires-Dist: mkdocs; extra == "develop"
+Requires-Dist: mkdocs-material; extra == "develop"
+Requires-Dist: mkdocstrings; extra == "develop"
+Requires-Dist: mkdocstrings-python; extra == "develop"
+Requires-Dist: pytkdocs[numpy-style]; extra == "develop"
+Requires-Dist: mkdocs-jupyter; extra == "develop"
+Requires-Dist: mkdocs-exclude; extra == "develop"
+Requires-Dist: twine; extra == "develop"
+Requires-Dist: pre-commit; extra == "develop"
+
+For detailed usage, please read the documentation at https://zkbt.github.io/exoatlas/

exoatlas-0.3.7/README.md

@@ -0,0 +1,42 @@
+# exoatlas
+Tools for compiling and plotting populations of transiting exoplanets. This package still a bit of a work in progress, but can be generally useful for downloading and working with exoplanet populations. For draft documentation explaing how to use `exoatlas`, please [read the documentation](https://zkbt.github.io/exoatlas/build/html/index.html).
+
+### Installation
+If you want the most recent stable version, the simplest way is to install it from PyPI directly via `pip` from any UNIX prompt:
+```bash
+pip install exoatlas
+```
+
+Or, if you want the very-most-up-to-date version, you can install directly from this repository via:
+```bash
+pip install git+https://github.com/zkbt/exoatlas
+```
+
+Or, if you want to be able to modify the code yourself, please also feel free to fork/clone this repository onto your own computer and install directly from that editable package. For example, this might look like:
+```bash
+git clone https://github.com/zkbt/exoatlas.git
+cd exoatlas
+pip install -e .
+```
+The `pip install -e .` command will link the installed version of the package to the directory of your local repository. Changes you make to the code in that directory should be reflected in the version Python sees when it tries to `import exoatlas`.
+
+### Usage
+Here's a quick preview:
+
+
+```python
+# import some population definitions and plotting tool
+from exoatlas import *
+
+# create a dictionary of populations
+exo = TransitingExoplanets()
+solar = SolarSystem()
+pops = {'solar':solar,
+        'exo':exo}
+
+# use a default visualization to summarize these populations
+physical_summary(pops)
+```
+
+### Authors
+This toolkit was made by [Zach Berta-Thompson](http://casa.colorado.edu/~bertathompson/). It relies heavily on the incredible work done by the folks over at the [NASA Exoplanet Archive](https://exoplanetarchive.ipac.caltech.edu), and their generously designed API.

exoatlas-0.3.7/exoatlas/__init__.py

@@ -0,0 +1,6 @@
+from .populations import *
+from .visualizations import *
+from .models import *
+from .telescopes import *
+from .imports import plt, np, u
+from .version import __version__, version

exoatlas-0.3.7/exoatlas/imports.py

@@ -0,0 +1,192 @@
+from .version import *
+
+# imports that are need by many exoatlas subsections
+from ast import Import
+import os, sys, time, shutil, warnings, copy
+from tqdm import tqdm
+
+# (possibly different on Mac, Linux, Windows, even for Python versions 3.8-3.12)
+try:
+    from importlib.resources import files
+except (ModuleNotFoundError, AttributeError, ImportError):
+    from importlib_resources import files
+
+code_directory = files(import_name)
+
+
+import numpy as np, matplotlib.pyplot as plt, matplotlib.animation as animation
+from matplotlib.ticker import ScalarFormatter, FormatStrFormatter, LogLocator
+
+
+from astropy.utils.exceptions import AstropyDeprecationWarning
+
+warnings.simplefilter("ignore", category=AstropyDeprecationWarning)
+
+# this function downloads a file and returns its filepath
+from astropy.utils.data import download_file
+from astropy.io import ascii
+from astropy.table import Table, vstack, join, setdiff
+from astropy.visualization import quantity_support
+from astropy.coordinates import SkyCoord
+
+quantity_support()
+
+# some general custom utilities from Zach
+from .talker import Talker
+
+# units and constants from astropy
+import astropy.units as u, astropy.constants as con
+from astropy.time import Time
+
+
+def mkdir(path):
+    """A mkdir that doesn't complain if it fails."""
+    try:
+        os.mkdir(path)
+    except:
+        pass
+
+
+import matplotlib.colors as co
+
+
+def name2color(name):
+    """
+    Return the 3-element RGB array of a given color name.
+
+    Parameters
+    ----------
+    name : str
+            The name ('black') or hex ('#000000')
+            for a particular color.
+
+    Returns
+    -------
+    rgb : tuple
+            Three-elements array of floats,
+            expressing brightness in RGB.
+    """
+    if "#" in name:
+        h = name
+    else:
+        h = co.cnames[name].lower()
+    return co.hex2color(h)
+
+
+# create a directory structure ()
+try:
+    # search for an environment variable
+    base = os.getenv("exoatlas_DATA")
+    assert base is not None
+except AssertionError:
+    # otherwise put it in the local directory
+    cwd = os.getcwd()
+    base = os.path.join(cwd, "downloads-for-exoatlas")
+mkdir(base)
+
+
+def locate_local_data():
+    print("💾 `exoatlas` archive data will be stored in:")
+    print(base)
+
+
+directories = dict(data=os.path.join(base, "data/"))
+for k in directories.keys():
+    mkdir(directories[k])
+
+
+def reset_local_data():
+    if "y" in input(
+        "Are you sure you want to wipe all " "local exoatlas data files? [y/N]"
+    ):
+        shutil.rmtree(directories["data"])
+        mkdir(directories["data"])
+        print(f"Removed all local data from {directories['data']}")
+
+
+# some kludge for dealing with Python 3 vs 2?
+try:
+    FileNotFoundError
+except NameError:
+    FileNotFoundError = IOError
+
+
+def clean(s):
+    """
+    A wrapper function to clean up complicated strings.
+    """
+    bad = """ !@#$%^&*()+-_'",./<>?"""
+    cleaned = str(s) + ""
+    for c in bad:
+        cleaned = cleaned.replace(c, "")
+    return cleaned
+
+
+def time_from_modified(filename):
+    """
+    How long ago was this file last modified?
+    """
+    try:
+        dt = Time.now().unix - os.path.getmtime(filename)
+        return dt / 60 / 60 / 24
+    except FileNotFoundError:
+        return np.inf
+
+
+def check_if_needs_updating(filename, maximum_age=1.0):
+    """
+    Do a (possibly interactive) check to see if this file
+    is so old that it needs to be updated.
+
+    Returns
+    -------
+    old : bool
+            True if the file is so old it needs updating
+            False if the file doesn't need updating
+    """
+
+    # how long ago was the data updated?
+    dt = time_from_modified(filename)
+
+    old = False
+    if dt == np.inf:
+        old = True
+    elif dt > maximum_age:
+        print(f"{filename} is {dt:.3f} days old.")
+        old = "y" in input("Should it be updated? [y/N]").lower()
+
+    return old
+
+
+def one2another(bottom="white", top="red", alphabottom=1.0, alphatop=1.0, N=256):
+    """
+    Create a cmap that goes smoothly (linearly in RGBA) from "bottom" to "top".
+    """
+    try:
+        rgb_bottom = bottom[0:3] + 0
+    except:
+        rgb_bottom = name2color(bottom or "white")
+    try:
+        rgb_top = top[0:3] + 0
+    except:
+        rgb_top = name2color(top or "black")
+
+    r = np.linspace(rgb_bottom[0], rgb_top[0], N)
+    g = np.linspace(rgb_bottom[1], rgb_top[1], N)
+    b = np.linspace(rgb_bottom[2], rgb_top[2], N)
+    a = np.linspace(alphabottom, alphatop, N)
+    colors = np.transpose(np.vstack([r, g, b, a]))
+    cmap = co.ListedColormap(colors, name="{bottom}2{top}".format(**locals()))
+    return cmap
+
+
+class AtlasError(ValueError):
+    pass
+
+
+# KLUDGE
+
+import warnings
+
+warnings.catch_warnings()
+warnings.simplefilter("ignore")

exoatlas-0.3.7/exoatlas/models/__init__.py

@@ -0,0 +1,4 @@
+from .seager import *
+from .zeng import *
+from .kopparapu import *
+from .chen import *

exoatlas-0.3.7/exoatlas/models/chen.py

@@ -0,0 +1,81 @@
+"""
+A simple cartoon of the Chen & Kipping (2017) forecaster model,
+using the values quoted in their Table 2.
+"""
+
+__all__ = ["estimate_radius", "plot_chen"]
+
+import numpy as np
+import matplotlib.pyplot as plt
+from astropy.units import Rearth, Mearth, Rjupiter, Mjupiter, Rsun, Msun
+
+T_min, T_max, C, S = {}, {}, {}, {}
+
+# define the terran range
+T_min["terran"] = 1.0 * Mearth
+T_max["terran"] = 2.04 * Mearth
+S["terran"] = 0.2790
+C["terran"] = 1.008 * Rearth
+
+# define the neptunian range
+T_min["neptunian"] = T_max["terran"]
+T_max["neptunian"] = 0.414 * Mjupiter
+S["neptunian"] = 0.589
+C["neptunian"] = (
+    C["terran"] * (T_min["neptunian"] / T_min["terran"]).decompose() ** S["terran"]
+)
+
+# define the jovian range
+T_min["jovian"] = T_max["neptunian"]
+T_max["jovian"] = 0.0800 * Msun
+S["jovian"] = -0.044
+C["jovian"] = (
+    C["neptunian"]
+    * (T_min["jovian"] / T_min["neptunian"]).decompose() ** S["neptunian"]
+)
+
+# define the jovian range
+T_min["stellar"] = T_max["jovian"]
+T_max["stellar"] = 1 * Msun
+S["stellar"] = 0.881
+C["stellar"] = (
+    C["jovian"] * (T_min["stellar"] / T_min["jovian"]).decompose() ** S["jovian"]
+)
+
+
+def estimate_radius(M):
+    """
+    Estimate the radii, given an array of masses.
+
+    Parameters
+    ----------
+    M : astropy.units.quantity.quantity
+        The masses of the planets.
+    """
+
+    # create an empty array of radii
+    original_shape = np.shape(M)
+    M = np.atleast_1d(M)
+    R = np.zeros(np.shape(M)) * Rearth
+
+    # work our way down in mass, updating radii as we go
+    for this in ["stellar", "jovian", "neptunian", "terran"]:
+        # which planets are below this maximum?
+        x = M < T_max[this]
+
+        # calculate the radius
+        R[x] = C[this] * (M[x] / T_min[this]).decompose() ** S[this]
+
+    # return the same shape
+    return R.reshape(original_shape)
+
+
+def plot_chen(**kw):
+    """
+    Plot the MAP mass-radius curve from Chen and Kipping (2017).
+    This is mostly a wrapper to make testing easier.
+    """
+
+    M = np.logspace(-1, 5, 1000) * Mearth
+    R = estimate_radius(M)
+    plt.loglog(M, R, **kw)

exoatlas-0.3.7/exoatlas/models/kopparapu.py

@@ -0,0 +1,63 @@
+"""
+Tools for working with the habitable zone definitions
+in Kopparapu et al. (2013).
+"""
+
+coefficients = {}
+coefficients["recent-venus"] = [1.7753, 1.4316e-4, 2.9875e-9, -7.5702e-12, -1.1635e-15]
+coefficients["runaway-greenhouse"] = [
+    1.0512,
+    1.3242e-4,
+    1.5418e-8,
+    -7.9895e-12,
+    -1.8328e-15,
+]
+coefficients["moist-greenhouse"] = [
+    1.0140,
+    8.1774e-5,
+    1.7063e-9,
+    -4.3241e-12,
+    -6.6462e-16,
+]
+coefficients["maximum-greenhouse"] = [
+    0.348,
+    5.8924e-5,
+    1.6558e-9,
+    -3.0045e-12,
+    -5.2983e-16,
+]
+coefficients["early-mars"] = [0.3179, 5.4513e-5, 1.5313e-9, -2.7786e-12, -4.8997e-16]
+
+
+def make_hz(which="runaway-greenhouse"):
+    """
+    Create a function f(Teff) describing one of
+    the habitable zone boundaries presented in
+    Table 3 of Kopparapu et al. (2013).
+    """
+
+    # pull out the coefficients
+    try:
+        S_o, a, b, c, d = coefficients[which]
+    except KeyError:
+        error_message = f"""
+        Alas! There seems to be no way to determine
+        coefficients for your choice of `{which}`.
+        The available options are:
+        """
+        for k in which:
+            error_message += k + "\n"
+        raise ValueError(error_message)
+
+    # define the function
+    def f(Teff):
+        f"""
+        The `{which}` HZ boundary from Kopparapu et al. (2013),
+        as a function of stellar effective temperature.
+        """
+
+        T = Teff - 5780
+        return S_o + a * T + b * T**2 + c * T**3 + d * T**4
+
+    # return that function definition
+    return f

exoatlas-0.3.7/exoatlas/models/seager.py

@@ -0,0 +1,39 @@
+from ..imports import *
+
+__all__ = ["plot_seager", "plot_both_seager"]
+
+
+# plot the mass radius models
+def plot_seager(which="rock", **kw):
+    """
+    Plot a single model from Seager et al. (2007). These were
+    originally point-clicked out of the GJ1214b discovery paper.
+
+    Parameters
+    ----------
+    which : str
+        Options are 'rock' or 'HHe'
+    """
+
+    assert (which.lower() == "rock") or (which.lower() == "hhe")
+
+    # load the values
+    file = os.path.join(code_directory, f"models/data/seager/gj1214mr_{which}.txt")
+    m, r = np.transpose(np.loadtxt(file))
+
+    # fit a simply polynomial to smooth out the messiness
+    fit = np.poly1d(np.polyfit(np.log(m), np.log(r), 5))
+
+    # plot over a grid of masses
+    mm = np.logspace(np.log10(min(m)), np.log10(max(m)), 1000)
+    return plt.plot(mm, np.exp(fit(np.log(mm))), **kw)
+
+
+def plot_both_seager(**kw):
+    """
+    Plot both the rock and the cold H/He models from Seager et al. (2007)
+    """
+    zkw = dict(linewidth=4, alpha=0.25, zorder=1.0)
+    zkw.update(**kw)
+    plot_seager("hhe", label="cold H/He", color="darkorange", **zkw)
+    plot_seager("rock", label="rock", color="black", **zkw)

exoatlas-0.3.7/exoatlas/models/zeng.py

@@ -0,0 +1,35 @@
+from ..imports import *
+
+__all__ = ["plot_zeng", "plot_three_zeng"]
+
+
+# plot the mass radius models
+def plot_zeng(which="75pSi_25pFe", **kw):
+    """
+    Plot a single mass-radius model from Zeng & Sasselov (2013).
+
+    Parameters
+    ----------
+    which : str
+        A string to indicate which model to plot.
+
+    """
+
+    file = os.path.join(code_directory, f"models/data/zengandsasselov/MR_{which}.csv")
+
+    # load the values
+    m, r = np.transpose(np.loadtxt(file, delimiter=","))
+
+    # plot the values
+    return plt.plot(m, r, **kw)
+
+
+def plot_three_zeng(**kw):
+    """
+    Plot both the rock and the cold H/He models from Seager et al. (2007)
+    """
+    zkw = dict(linewidth=4, alpha=0.25, zorder=1.0)
+    zkw.update(**kw)
+    plot_zeng("75pSi_25pFe", label="75% Si, 25% Fe", color="sienna", **zkw)
+    plot_zeng("50pSi_50pFe", label="50% Si, 25% 50", color="brown", **zkw)
+    plot_zeng("25pSi_75pFe", label="25% Si, 75% Fe", color="maroon", **zkw)