rubin-sim 2.6.1.dev2__py3-none-any.whl

rubin_sim/maf/maf_contrib/star_count_metric.py

@@ -0,0 +1,56 @@
+__all__ = ("StarCountMetric",)
+
+import numpy as np
+
+from rubin_sim.maf.metrics import BaseMetric
+
+from .star_counts import starcount
+
+# Example for CountMetric
+# Mike Lund - Vanderbilt University
+# mike.lund@gmail.com
+# Last edited 8/15/2015
+# Motivation: The distances to stars in LSST will be significant enough
+# that the structure of the Galaxy will be readily apparent because of
+# its influence on the number of stars in a given field.
+# Any metric concerned with the number of potential objects to be
+# detected will need to feature not only the effects of the cadence
+# but also the number of objects per field.
+# This metric identifies the number of stars in a given field in a
+# particular distance range.
+# D1 and D2 are the close and far distances in parsecs.
+# Requires StarCounts.StarCounts
+
+# NOTE
+# There are stellar luminosity function maps available within MAF
+# that may supersede these StarCount functions
+
+
+class StarCountMetric(BaseMetric):
+    """Find the number of stars in a given field between d1 and d2 in parsecs.
+
+    This metric uses the stellar distance and luminosity equations
+    contributed by Mike Lund, which are based on the Galfast model.
+    There are some imposed limitations on the expected magnitudes
+    of the stars included for the metric, based on assuming saturation
+    at 16th magnitude and not considering stars with magnitude
+    uncertainties greater than 0.03 (based on photometry/m5 alone).
+
+
+    Parameters
+    ----------
+    d1 : `float`
+        d1 in parsecs
+    d2 : `float`
+        d2 in parsecs
+    """
+
+    def __init__(self, d1=100, d2=1000, **kwargs):
+        self.d1 = d1
+        self.d2 = d2
+        super(StarCountMetric, self).__init__(col=[], **kwargs)
+
+    def run(self, data_slice, slice_point=None):
+        self.dec_col = np.degrees(data_slice[0][3])
+        self.ra_col = np.degrees(data_slice[0][2])
+        return starcount(self.ra_col, self.dec_col, self.d1, self.d2)

rubin_sim/maf/maf_contrib/star_counts/__init__.py

@@ -0,0 +1,8 @@
+__all__ = (
+    "abs_mag",
+    "coords",
+    "spec_type",
+    "starcount",
+    "starcount_bymass",
+    "stellardensity",
+)

rubin_sim/maf/maf_contrib/star_counts/abs_mag.py

@@ -0,0 +1,324 @@
+#!/usr/bin/env python
+
+# Mike Lund - Vanderbilt University
+# mike.lund@gmail.com
+# Last edited 8/15/2015
+# Description: Calculates absolute magnitudes as a function of spectral type.
+# For use with Field Star Count metric
+import sys
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+
+def extrap1d(interpolator):
+    xs = interpolator.x
+    ys = interpolator.y
+
+    def pointwise(x):
+        if x < xs[0]:
+            return ys[0]
+        elif x > xs[-1]:
+            return ys[-1]
+        else:
+            return interpolator(x)
+
+    def ufunclike(xs):
+        return np.array(list(map(pointwise, np.array(xs))))
+
+    return ufunclike
+
+
+def abs_mag(spec_type):
+    spec_range = [
+        5,
+        9,
+        10,
+        11,
+        13,
+        16,
+        18,
+        19,
+        20,
+        22,
+        23,
+        25,
+        27,
+        30,
+        32,
+        35,
+        36,
+        38,
+        40,
+        42,
+        45,
+        48,
+        50,
+        52,
+        53,
+        54,
+        55,
+        57,
+        60,
+        61,
+        62,
+        62.5,
+        63,
+        64,
+        65,
+        66,
+    ]
+    abs_u = [
+        -5.8,
+        -4.92,
+        -3.78,
+        -2.75,
+        -1.51,
+        -0.54,
+        0.17,
+        1.14,
+        2.72,
+        3.55,
+        3.64,
+        4.12,
+        4.52,
+        5.24,
+        5.4,
+        5.52,
+        5.97,
+        6.29,
+        6.65,
+        7.23,
+        7.52,
+        8.17,
+        8.66,
+        9.74,
+        10.58,
+        11.18,
+        12.19,
+        12.74,
+        13.33,
+        13.92,
+        14.11,
+        14.95,
+        15.35,
+        17.15,
+        18.12,
+        19.37,
+    ]
+    abs_g = [
+        -5.41,
+        -4.6,
+        -3.53,
+        -2.62,
+        -1.69,
+        -1.05,
+        -0.58,
+        0.28,
+        1.63,
+        2.39,
+        2.49,
+        2.92,
+        3.31,
+        4.08,
+        4.28,
+        4.43,
+        4.83,
+        5.07,
+        5.35,
+        5.86,
+        6.03,
+        6.57,
+        6.98,
+        7.79,
+        8.48,
+        8.97,
+        9.65,
+        10.18,
+        10.68,
+        11.2,
+        11.52,
+        12.21,
+        12.68,
+        14.02,
+        15.07,
+        16.38,
+    ]
+    abs_r = [
+        -5.02,
+        -4.28,
+        -3.28,
+        -2.49,
+        -1.87,
+        -1.56,
+        -1.33,
+        -0.58,
+        0.54,
+        1.23,
+        1.34,
+        1.72,
+        2.1,
+        2.92,
+        3.16,
+        3.34,
+        3.69,
+        3.85,
+        4.05,
+        4.49,
+        4.54,
+        4.97,
+        5.3,
+        5.84,
+        6.38,
+        6.76,
+        7.11,
+        7.62,
+        8.03,
+        8.48,
+        8.93,
+        9.47,
+        10.01,
+        10.89,
+        12.02,
+        13.39,
+    ]
+    abs_i = [
+        -4.65,
+        -3.93,
+        -2.93,
+        -2.16,
+        -1.61,
+        -1.33,
+        -1.1,
+        -0.35,
+        0.72,
+        1.4,
+        1.49,
+        1.83,
+        2.18,
+        2.93,
+        3.13,
+        3.31,
+        3.61,
+        3.75,
+        3.91,
+        4.33,
+        4.38,
+        4.78,
+        5.08,
+        5.6,
+        6.06,
+        6.38,
+        6.71,
+        7.08,
+        7.39,
+        7.7,
+        8.08,
+        8.46,
+        8.81,
+        9.38,
+        10.29,
+        11.27,
+    ]
+    abs_z = [
+        -4.3,
+        -3.57,
+        -2.61,
+        -1.9,
+        -1.35,
+        -1.1,
+        -0.93,
+        -0.17,
+        0.89,
+        1.55,
+        1.64,
+        1.93,
+        2.26,
+        3.02,
+        3.15,
+        3.33,
+        3.62,
+        3.72,
+        3.89,
+        4.29,
+        4.32,
+        4.72,
+        5.01,
+        5.49,
+        5.93,
+        6.22,
+        6.51,
+        6.78,
+        7.01,
+        7.24,
+        7.56,
+        7.83,
+        8.14,
+        8.62,
+        9.35,
+        10.03,
+    ]
+    abs_y = [
+        -4.96,
+        -4.18,
+        -3.05,
+        -2.22,
+        -1.95,
+        -1.5,
+        -1.27,
+        -0.61,
+        0.32,
+        0.96,
+        0.99,
+        1.38,
+        1.79,
+        2.51,
+        2.57,
+        2.74,
+        3.04,
+        3.11,
+        3.36,
+        3.7,
+        3.76,
+        4.16,
+        4.61,
+        4.98,
+        5.43,
+        5.8,
+        6.07,
+        6.38,
+        6.45,
+        6.86,
+        6.97,
+        7.25,
+        7.52,
+        7.82,
+        8.39,
+        8.6,
+    ]
+    f1 = interp1d(spec_range, abs_z)
+    func_z = extrap1d(f1)
+    f2 = interp1d(spec_range, abs_i)
+    func_i = extrap1d(f2)
+    f3 = interp1d(spec_range, abs_r)
+    func_r = extrap1d(f3)
+    f4 = interp1d(spec_range, abs_g)
+    func_g = extrap1d(f4)
+    f5 = interp1d(spec_range, abs_u)
+    func_u = extrap1d(f5)
+    f6 = interp1d(spec_range, abs_y)
+    func_y = extrap1d(f6)
+    abs_all = [
+        func_z([spec_type])[0],
+        func_y([spec_type])[0],
+        func_i([spec_type])[0],
+        func_r([spec_type])[0],
+        func_g([spec_type])[0],
+        func_u([spec_type])[0],
+    ]
+    bands = ["z", "y", "i", "r", "g", "u"]
+    return abs_all, bands
+
+
+if __name__ == "__main__":
+    print(abs_mag(float(sys.argv[1]))[0])  # spectral type

rubin_sim/maf/maf_contrib/star_counts/coords.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+
+# Mike Lund - Vanderbilt University
+# mike.lund@gmail.com
+# Last edited 8/15/2015
+# Description: Provides the coordinate conversions between equatorial and
+# galactic coordinates, as well as to galactic cylindrical coordinates.
+# Two different functions are present that do the conversion, and a third
+# that uses ephem package, for redundancy purposes.
+# For use with Field Star Count metric
+import astropy.units as u
+import numpy as np
+from astropy.coordinates import SkyCoord
+from scipy.optimize import fsolve
+
+rad1 = np.radians(282.25)
+rad2 = np.radians(62.6)
+rad3 = np.radians(33.0)
+
+
+def eq_gal(eq_ra, eq_dec):
+    d = np.radians(eq_dec)
+    a = np.radians(eq_ra)
+
+    def equations(p):
+        b, ll, x = p
+        f1a = np.cos(d) * (np.cos(a - rad1))
+        f2a = np.sin(d) * np.sin(rad2) + np.cos(d) * np.sin(a - rad1) * np.cos(rad2)
+        f3a = np.sin(d) * np.cos(rad2) - np.cos(d) * np.sin(a - rad1) * np.sin(rad2)
+        f1 = np.cos(b) * np.cos(ll - rad3) - f1a
+        f2 = np.cos(b) * np.sin(ll - rad3) - f2a
+        f3 = np.sin(b) - f3a
+        return (f1, f2, f3)
+
+    b, ll, x = fsolve(equations, (0, 0, 0))
+    b_deg = np.degrees(b) % 360  # galactic latitude
+    if b_deg >= 270:
+        b_deg = b_deg - 360
+    if b_deg > 90:
+        b_deg = 180 - b_deg
+        ll = ll + np.pi
+    l_deg = np.degrees(ll) % 360  # galactic longitude
+    return b_deg, l_deg
+    # http://scienceworld.wolfram.com/astronomy/GalacticCoordinates.html
+
+
+def eq_gal2(eq_ra, eq_dec):
+    d = np.radians(eq_dec)
+    p = np.radians(eq_ra)
+    AB = np.radians(62.8717)
+    CAB = np.radians(192.8585) - p
+    cos_bc = np.sin(d) * np.cos(AB) + np.cos(d) * np.sin(AB) * np.cos(CAB)
+    BC = np.arccos(cos_bc)
+    AD = np.radians(118.9362)
+    CAD = np.radians(266.4051) - p
+    cos_cd = np.sin(d) * np.cos(AD) + np.cos(d) * np.sin(AD) * np.cos(CAD)
+    cos_cbd = cos_cd / np.sin(BC)
+    if cos_cbd > 1:
+        cos_cbd = 1
+    elif cos_cbd < -1:
+        cos_cbd = -1
+    CBD = np.arccos(cos_cbd)
+    b_deg = 90.0 - np.degrees(BC)
+    cad = np.radians(282.8595) - p
+    coscbd = np.cos(cad) * np.cos(d) / np.sin(BC)
+    if coscbd > 1:
+        coscbd = 1
+    elif coscbd < -1:
+        coscbd = -1
+    cbd = np.arccos(coscbd)
+    if cbd - CBD < 32.9319:
+        l_deg = 360.0 - np.degrees(CBD)
+    else:
+        l_deg = np.degrees(CBD)
+    return b_deg, l_deg
+
+
+def eq_gal3(eq_ra, eq_dec):
+    # assume input ra, dec are in deg
+    coordset = SkyCoord(
+        ra=np.radians(eq_ra) * u.radians, dec=np.rad(eq_dec) * u.rad, frame="icrs", unit="deg"
+    )
+    # convert to galactic
+    galactic = coordset.galactic
+    # return b,l in deg
+    return galactic.b.value, galactic.l.values
+
+
+def gal_cyn(b_deg, l_deg, dist):
+    b_rad = np.radians(b_deg)
+    l_rad = np.radians(l_deg)
+    Z = np.sin(b_rad) * dist
+    xy = np.cos(b_rad) * dist
+    x = np.cos(l_rad) * xy
+    y = np.sin(l_rad) * xy
+    x_new = 8000.0 - x
+    R = np.power(x_new**2 + y**2, 0.5)
+    rho = np.arctan(y / x)
+    return R, rho, Z

rubin_sim/maf/maf_contrib/star_counts/readme.txt

@@ -0,0 +1 @@
+The codes included in StarCounts.StarCounts are required for use with the field star count metrics (CountMassMetric and CountMetric)

rubin_sim/maf/maf_contrib/star_counts/spec_type.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+
+# Mike Lund - Vanderbilt University
+# mike.lund@gmail.com
+# Last edited 8/15/2015
+# Description: Calculates spectral types for stars on the main sequence as
+# a function of stellar mass. For use with Field Star Count metric
+import sys
+
+import numpy as np
+from scipy.interpolate import interp1d
+
+
+def extrap1d(interpolator):
+    xs = interpolator.x
+    ys = interpolator.y
+
+    def pointwise(x):
+        if x < xs[0]:
+            return ys[0]
+        elif x > xs[-1]:
+            return ys[-1]
+        else:
+            return interpolator(x)
+
+    def ufunclike(xs):
+        return np.array(list(map(pointwise, np.array(xs))))
+
+    return ufunclike
+
+
+def spec_type(mass):
+    mass_range = [
+        0.06,
+        0.21,
+        0.40,
+        0.51,
+        0.67,
+        0.79,
+        0.92,
+        1.05,
+        1.4,
+        1.6,
+        2.0,
+        2.9,
+        3.8,
+        5.9,
+        7.6,
+        17.5,
+        23,
+        37,
+        60,
+        120,
+    ]
+    spec_range = [
+        68,
+        65,
+        62,
+        60,
+        55,
+        50,
+        45,
+        40,
+        35,
+        30,
+        25,
+        20,
+        18,
+        15,
+        13,
+        10,
+        8,
+        6,
+        5,
+        3,
+    ]
+    f = interp1d(mass_range, spec_range)
+    f2 = extrap1d(f)
+    # f2=interp1d(mass_range, spec_range, kind='slinear')
+    if mass == 0:
+        xnew = np.logspace(-2, 3, 100)
+        import matplotlib.pyplot as plt
+
+        plt.plot(mass_range, spec_range, "o", xnew, f2(xnew), "-")  # , xnew, f2(xnew),'--')
+        plt.xscale("log")
+        plt.show()
+    return f2([mass])
+
+
+if __name__ == "__main__":
+    print(spec_type(float(sys.argv[1])))  # mass

rubin_sim/maf/maf_contrib/star_counts/starcount.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python
+
+# Mike Lund - Vanderbilt University
+# mike.lund@gmail.com
+# Last edited 8/15/2015
+# Description: Calculates the number of stars in a given direction and
+# between a given set of distances. For use with Field Star Count metric
+
+import numpy as np
+
+from . import coords, stellardensity
+
+skyarea = 41253.0
+distancebins = 51
+
+
+def star_vols(d1, d2, area):
+    distance_edges = (np.linspace((d1**3.0), (d2**3.0), num=distancebins)) ** (1.0 / 3)
+    volumeshell = (area / skyarea) * (4.0 * np.pi / 3) * (distance_edges[1:] ** 3 - distance_edges[:-1] ** 3)
+    distances = ((distance_edges[1:] ** 3 + distance_edges[:-1] ** 3) / 2.0) ** (1.0 / 3)
+    return volumeshell, distances
+
+
+def starcount(eq_ra, eq_dec, d1, d2):
+    volumes, distances = star_vols(d1, d2, 9.62)
+    b_deg, l_deg = coords.eq_gal3(eq_ra, eq_dec)
+    positions = [coords.gal_cyn(b_deg, l_deg, x) for x in distances]
+    densities = [stellardensity.stellardensity(x[0], x[2]) for x in positions]
+    totalcount = np.sum(np.asarray(volumes) * np.asarray(densities))
+    return totalcount

rubin_sim/maf/maf_contrib/star_counts/starcount_bymass.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+
+# Mike Lund - Vanderbilt University
+# mike.lund@gmail.com
+# Last edited 8/15/2015
+# Description: Takes a given set of galactic coordinates and a stellar
+# mass range, then calculates the number of stars within that range
+# that will be fainter than mag 16, and have sufficiently low noise
+# in the given band. For use with Field Star Count metric
+
+
+import numpy as np
+from scipy.optimize import newton
+
+from . import abs_mag, spec_type
+from .starcount import starcount
+
+xi = 1.0
+alpha = 2.35
+
+
+def IMF(lower, upper):
+    exp = alpha - 1.0
+    part1 = xi / exp
+    part2 = lower**-exp - upper**-exp
+    part3 = part1 * part2
+    return part3
+
+
+def get_distance(apparent, absolute):
+    part1 = (apparent - absolute) / 5.0
+    part2 = 10 * 10**part1
+    return part2
+
+
+def noise_opt(m, band, sigma):
+    part1 = mag_error(m, band)
+    part2 = part1**2.0
+    part3 = sigma**2.0
+    total = part2 - part3
+    return total
+
+
+def mag_error(ap_mag, band, calcm5=0):  # apparent magnitude and band
+    gamma = {"u": 0.037, "g": 0.038, "r": 0.039, "i": 0.039, "z": 0.040, "y": 0.040}
+    m5 = {"u": 23.9, "g": 25.0, "r": 24.7, "i": 24.0, "z": 23.3, "y": 22.1}
+    if calcm5 == 0:
+        calcm5 = m5[band]
+    X = 10.0 ** (0.4 * (ap_mag - calcm5))
+    random_2 = np.sqrt((0.04 - gamma[band]) * X + gamma[band] * X * X)
+    error_2 = random_2**2.0 + (0.005) ** 2.0
+    mag_error = np.sqrt(error_2)
+    return mag_error
+
+
+def noise_calc(band):
+    gamma = {"u": 0.037, "g": 0.038, "r": 0.039, "i": 0.039, "z": 0.040, "y": 0.040}
+    m5 = {"u": 23.9, "g": 25.0, "r": 24.7, "i": 24.0, "z": 23.3, "y": 22.1}
+    sigma = 0.03
+    sigma_sys = 0.005
+
+    def fun(x):
+        sigma_sys**2
+        +(0.04 - gamma[band]) * 10 ** (0.4 * (x - m5[band]))
+        +gamma[band] * 10 ** (0.8 * (x - m5[band]))
+        -(sigma**2)
+
+    return newton(fun, 25)
+
+
+def dist_calc(mass, band):
+    # mass to spectral type
+    # spectral type to absolute mag
+    bands = ["z", "y", "i", "r", "g", "u"]
+    output = abs_mag.abs_mag(spec_type.spec_type(mass))[0]
+    indexvalue = bands.index(band)
+    absolutemag = output[indexvalue][0]
+    apparent = noise_calc(band)
+    dist_min = get_distance(16, absolutemag)
+    dist_max = get_distance(apparent, absolutemag)
+    return dist_min, dist_max
+    # abs mag to apparent mag ranges, > 16, noise dependent upper limit
+
+
+def starcount_bymass(eq_ra, eq_dec, m1, m2, band):
+    masses = np.linspace(m1, m2, num=20)
+    totmass = IMF(m1, m2)
+    totmass = IMF(0.2, 1.04)
+    massbins = IMF(masses[:-1], masses[1:])
+    massfractions = massbins / totmass
+    distances = [dist_calc(x, band) for x in masses[:-1]]
+    starcounts = [y * starcount(eq_ra, eq_dec, x[0], x[1]) for x, y in zip(distances, massfractions)]
+    return sum(starcounts)