redback 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

redback/utils.py

@@ -44,7 +44,7 @@ def download_pointing_tables():
     """
     return logger.info("Pointing tables downloaded and stored in redback/tables")
 
-def sncosmo_bandname_from_band(bands, warning_style='soft'):
+def sncosmo_bandname_from_band(bands, warning_style='softest'):
     """
     Convert redback data band names to sncosmo compatible band names
 
@@ -65,12 +65,14 @@ def sncosmo_bandname_from_band(bands, warning_style='soft'):
         try:
             res.append(bands_to_flux[band])
         except KeyError as e:
-            logger.info(e)
             if warning_style == 'hard':
                 raise KeyError(f"Band {band} is not defined in filters.csv!")
-            else:
+            elif warning_style == 'soft':
+                logger.info(e)
                 logger.info(f"Band {band} is not defined in filters.csv!")
                 res.append('r')
+            else:
+                res.append('r')
     return np.array(res)
 
 def check_kwargs_validity(kwargs):
@@ -374,7 +376,7 @@ def check_element(driver, id_number):
     checks that an element exists on a website, and provides an exception
     """
     try:
-        driver.find_element_by_id(id_number)
+        driver.find_element('id', id_number)
     except NoSuchElementException as e:
         print(e)
         return False
@@ -549,7 +551,10 @@ def frequency_to_bandname(frequency):
 
 def fetch_driver():
     # open the webdriver
-    return webdriver.PhantomJS()
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless=new")
+    driver = webdriver.Chrome(options=options)
+    return driver
 
 
 def calc_credible_intervals(samples, interval=0.9):
@@ -767,14 +772,17 @@ def interpolated_barnes_and_kasen_thermalisation_efficiency(mej, vej):
     :param vej: initial ejecta velocity as a fraction of speed of light
     :return: av, bv, dv constants in the thermalisation efficiency equation Eq 25 in Metzger 2017
     """
-    v_array = np.array([0.1, 0.2, 0.3])
-    mass_array = np.array([1.0e-3, 5.0e-3, 1.0e-2, 5.0e-2])
-    a_array = np.asarray([[2.01, 4.52, 8.16], [0.81, 1.9, 3.2],
-                     [0.56, 1.31, 2.19], [.27, .55, .95]])
-    b_array = np.asarray([[0.28, 0.62, 1.19], [0.19, 0.28, 0.45],
-                     [0.17, 0.21, 0.31], [0.10, 0.13, 0.15]])
-    d_array = np.asarray([[1.12, 1.39, 1.52], [0.86, 1.21, 1.39],
-                     [0.74, 1.13, 1.32], [0.6, 0.9, 1.13]])
+    v_array = np.asarray([0.1, 0.2, 0.3, 0.4])
+    mass_array = np.asarray([1.e-3, 5.e-3, 1.e-2, 5.e-2, 1.e-1])
+    a_array = np.asarray([[2.01, 4.52, 8.16, 16.3], [0.81, 1.9, 3.2, 5.0],
+                              [0.56, 1.31, 2.19, 3.0], [.27, .55, .95, 2.0],
+                              [0.20, 0.39, 0.65, 0.9]])
+    b_array = np.asarray([[0.28, 0.62, 1.19, 2.4], [0.19, 0.28, 0.45, 0.65],
+                              [0.17, 0.21, 0.31, 0.45], [0.10, 0.13, 0.15, 0.17],
+                              [0.06, 0.11, 0.12, 0.12]])
+    d_array = np.asarray([[1.12, 1.39, 1.52, 1.65], [0.86, 1.21, 1.39, 1.5],
+                              [0.74, 1.13, 1.32, 1.4], [0.6, 0.9, 1.13, 1.25],
+                              [0.63, 0.79, 1.04, 1.5]])
     a_func = RegularGridInterpolator((mass_array, v_array), a_array, bounds_error=False, fill_value=None)
     b_func = RegularGridInterpolator((mass_array, v_array), b_array, bounds_error=False, fill_value=None)
     d_func = RegularGridInterpolator((mass_array, v_array), d_array, bounds_error=False, fill_value=None)
@@ -785,6 +793,278 @@ def interpolated_barnes_and_kasen_thermalisation_efficiency(mej, vej):
     return av, bv, dv
 
 
+def heatinggrids():
+    # Grid of velocity and Ye
+    YE_GRID = np.array([0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5], dtype=np.float64)
+    V_GRID = np.array([0.05, 0.1, 0.2, 0.3, 0.4, 0.5], dtype=np.float64)
+
+    # Approximant coefficients on the grid
+    E0_GRID = np.array([
+        1.000, 1.000, 1.000, 1.000, 1.000, 1.000,
+        1.000, 1.000, 1.041, 1.041, 1.041, 1.041,
+        1.146, 1.000, 1.041, 1.041, 1.041, 1.041,
+        1.146, 1.000, 1.000, 1.000, 1.041, 1.041,
+        1.301, 1.398, 1.602, 1.580, 1.763, 1.845,
+        0.785, 1.255, 1.673, 1.673, 1.874, 1.874,
+        0.863, 0.845, 1.212, 1.365, 1.635, 2.176,
+        -2.495, -2.495, -2.097, -2.155, -2.046, -1.824,
+        -0.699, -0.699, -0.222, 0.176, 0.176, 0.176,
+        -0.398, 0.000, 0.301, 0.477, 0.477, 0.477], dtype=np.float64)
+
+    # Reshape GRIDs to a 2D array
+    E0_GRID = E0_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    # ALP_GRID
+    ALP_GRID = np.array([
+        1.37, 1.38, 1.41, 1.41, 1.41, 1.41,
+        1.41, 1.38, 1.37, 1.37, 1.37, 1.37,
+        1.41, 1.38, 1.37, 1.37, 1.37, 1.37,
+        1.36, 1.25, 1.32, 1.32, 1.34, 1.34,
+        1.44, 1.40, 1.46, 1.66, 1.60, 1.60,
+        1.36, 1.33, 1.33, 1.33, 1.374, 1.374,
+        1.40, 1.358, 1.384, 1.384, 1.384, 1.344,
+        1.80, 1.80, 2.10, 2.10, 1.90, 1.90,
+        8.00, 8.00, 7.00, 7.00, 7.00, 7.00,
+        1.40, 1.40, 1.40, 1.60, 1.60, 1.60
+    ], dtype=np.float64)
+
+    ALP_GRID = ALP_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    # T0_GRID
+    T0_GRID = np.array([
+        1.80, 1.40, 1.20, 1.20, 1.20, 1.20,
+        1.40, 1.00, 0.85, 0.85, 0.85, 0.85,
+        1.00, 0.80, 0.65, 0.65, 0.61, 0.61,
+        0.85, 0.60, 0.45, 0.45, 0.45, 0.45,
+        0.65, 0.38, 0.22, 0.18, 0.12, 0.095,
+        0.540, 0.31, 0.18, 0.13, 0.095, 0.081,
+        0.385, 0.235, 0.1, 0.06, 0.035, 0.025,
+        26.0, 26.0, 0.4, 0.4, 0.12, -20.0,
+        0.20, 0.12, 0.05, 0.03, 0.025, 0.021,
+        0.16, 0.08, 0.04, 0.02, 0.018, 0.016
+    ], dtype=np.float64)
+
+    T0_GRID = T0_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    # SIG_GRID
+    SIG_GRID = np.array([
+        0.08, 0.08, 0.095, 0.095, 0.095, 0.095,
+        0.10, 0.08, 0.070, 0.070, 0.070, 0.070,
+        0.07, 0.08, 0.070, 0.065, 0.070, 0.070,
+        0.040, 0.030, 0.05, 0.05, 0.05, 0.050,
+        0.05, 0.030, 0.025, 0.045, 0.05, 0.05,
+        0.11, 0.04, 0.021, 0.021, 0.017, 0.017,
+        0.10, 0.094, 0.068, 0.05, 0.03, 0.01,
+        45.0, 45.0, 45.0, 45.0, 25.0, 40.0,
+        0.20, 0.12, 0.05, 0.03, 0.025, 0.021,
+        0.03, 0.015, 0.007, 0.01, 0.009, 0.007
+    ], dtype=np.float64)
+
+    SIG_GRID = SIG_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    # ALP1_GRID
+    ALP1_GRID = np.array([
+        7.50, 7.50, 7.50, 7.50, 7.50, 7.50,
+        9.00, 9.00, 7.50, 7.50, 7.00, 7.00,
+        8.00, 8.00, 7.50, 7.50, 7.00, 7.00,
+        8.00, 8.00, 7.50, 7.50, 7.00, 7.00,
+        8.00, 8.00, 5.00, 7.50, 7.00, 6.50,
+        4.5, 3.8, 4.0, 4.0, 4.0, 4.0,
+        2.4, 3.8, 3.8, 3.21, 2.91, 3.61,
+        -1.55, -1.55, -0.75, -0.75, -2.50, -5.00,
+        -1.55, -1.55, -1.55, -1.55, -1.55, -1.55,
+        3.00, 3.00, 3.00, 3.00, 3.00, 3.00
+    ], dtype=np.float64)
+
+    ALP1_GRID = ALP1_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    # T1_GRID
+    T1_GRID = np.array([
+        0.040, 0.025, 0.014, 0.010, 0.008, 0.006,
+        0.040, 0.035, 0.020, 0.012, 0.010, 0.008,
+        0.080, 0.040, 0.020, 0.012, 0.012, 0.009,
+        0.080, 0.040, 0.030, 0.018, 0.012, 0.009,
+        0.080, 0.060, 0.065, 0.028, 0.020, 0.015,
+        0.14, 0.123, 0.089, 0.060, 0.045, 0.031,
+        0.264, 0.1, 0.07, 0.055, 0.042, 0.033,
+        1.0, 1.0, 1.0, 1.0, 0.02, 0.01,
+        1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+        0.04, 0.02, 0.01, 0.002, 0.002, 0.002
+    ], dtype=np.float64)
+
+    T1_GRID = T1_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    SIG1_GRID = np.array([0.250, 0.120, 0.045, 0.028, 0.020, 0.015,
+                          0.250, 0.060, 0.035, 0.020, 0.016, 0.012,
+                          0.170, 0.090, 0.035, 0.020, 0.012, 0.009,
+                          0.170, 0.070, 0.035, 0.015, 0.012, 0.009,
+                          0.170, 0.070, 0.050, 0.025, 0.020, 0.020,
+                          0.065, 0.067, 0.053, 0.032, 0.032, 0.024,
+                          0.075, 0.044, 0.03, 0.02, 0.02, 0.014,
+                          10.0, 10.0, 10.0, 10.0, 0.02, 0.01,
+                          10.0, 10.0, 10.0, 10.0, 10.0, 10.0,
+                          0.01, 0.005, 0.002, 1e-4, 1e-4, 1e-4])
+
+    SIG1_GRID = SIG1_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    C1_GRID = np.array([27.2, 27.8, 28.2, 28.2, 28.2, 28.2,
+                        28.0, 27.8, 27.8, 27.8, 27.8, 27.8,
+                        27.5, 27.0, 27.8, 27.8, 27.8, 27.8,
+                        28.8, 28.1, 27.8, 27.8, 27.5, 27.5,
+                        28.5, 28.0, 27.5, 28.5, 29.2, 29.0,
+                        25.0, 27.5, 25.8, 20.9, 29.3, 1.0,
+                        28.7, 27.0, 28.0, 28.0, 27.4, 25.3,
+                        28.5, 29.1, 29.5, 30.1, 30.4, 29.9,
+                        20.4, 20.6, 20.8, 20.9, 20.9, 21.0,
+                        29.9, 30.1, 30.1, 30.2, 30.3, 30.3])
+
+    C1_GRID = C1_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    TAU1_GRID = np.array([4.07, 4.07, 4.07, 4.07, 4.07, 4.07,
+                          4.07, 4.07, 4.07, 4.07, 4.07, 4.07,
+                          4.07, 4.07, 4.07, 4.07, 4.07, 4.07,
+                          4.07, 4.07, 4.07, 4.07, 4.07, 4.07,
+                          4.77, 4.77, 4.77, 4.77, 4.07, 4.07,
+                          4.77, 4.77, 28.2, 1.03, 0.613, 1.0,
+                          3.4, 14.5, 11.4, 14.3, 13.3, 13.3,
+                          2.52, 2.52, 2.52, 2.52, 2.52, 2.52,
+                          1.02, 1.02, 1.02, 1.02, 1.02, 1.02,
+                          0.22, 0.22, 0.22, 0.22, 0.22, 0.22])
+
+    TAU1_GRID = TAU1_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    C2_GRID = np.array([21.5, 21.5, 22.1, 22.1, 22.1, 22.1,
+                        22.3, 21.5, 21.5, 21.8, 21.8, 21.8,
+                        22.0, 21.5, 21.5, 22.0, 21.8, 21.8,
+                        23.5, 22.5, 22.1, 22.0, 22.2, 22.2,
+                        22.0, 22.8, 23.0, 23.0, 23.5, 23.5,
+                        10.0, 0.0, 0.0, 19.8, 22.0, 21.0,
+                        26.2, 14.1, 18.8, 19.1, 23.8, 19.2,
+                        25.4, 25.4, 25.8, 26.0, 26.0, 25.8,
+                        18.4, 18.4, 18.6, 18.6, 18.6, 18.6,
+                        27.8, 28.0, 28.2, 28.2, 28.3, 28.3])
+
+    C2_GRID = C2_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    TAU2_GRID = np.array([4.62, 4.62, 4.62, 4.62, 4.62, 4.62,
+                          4.62, 4.62, 4.62, 4.62, 4.62, 4.62,
+                          4.62, 4.62, 4.62, 4.62, 4.62, 4.62,
+                          4.62, 4.62, 4.62, 4.62, 4.62, 4.62,
+                          5.62, 5.62, 5.62, 5.62, 4.62, 4.62,
+                          5.62, 5.18, 5.18, 34.7, 8.38, 22.6,
+                          0.15, 4.49, 95.0, 95.0, 0.95, 146.,
+                          0.12, 0.12, 0.12, 0.12, 0.12, 0.14,
+                          0.32, 0.32, 0.32, 0.32, 0.32, 0.32,
+                          0.02, 0.02, 0.02, 0.02, 0.02, 0.02])
+
+    TAU2_GRID = TAU2_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    C3_GRID = np.array([19.4, 19.8, 20.1, 20.1, 20.1, 20.1,
+                        20.0, 19.8, 19.8, 19.8, 19.8, 19.8,
+                        19.9, 19.8, 19.8, 19.8, 19.8, 19.8,
+                        5.9, 9.8, 23.5, 23.5, 23.5, 23.5,
+                        27.3, 26.9, 26.6, 27.4, 25.8, 25.8,
+                        27.8, 26.9, 18.9, 25.4, 24.8, 25.8,
+                        22.8, 17.9, 18.9, 25.4, 24.8, 25.5,
+                        20.6, 20.2, 19.8, 19.2, 19.5, 18.4,
+                        12.6, 13.1, 14.1, 14.5, 14.5, 14.5,
+                        24.3, 24.2, 24.0, 24.0, 24.0, 23.9])
+
+    C3_GRID = C3_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    TAU3_GRID = np.array([18.2, 18.2, 18.2, 18.2, 18.2, 18.2,
+                          18.2, 18.2, 18.2, 18.2, 18.2, 18.2,
+                          18.2, 18.2, 18.2, 18.2, 18.2, 18.2,
+                          18.2, 18.2, 0.62, 0.62, 0.62, 0.62,
+                          0.18, 0.18, 0.18, 0.18, 0.32, 0.32,
+                          0.12, 0.18, 50.8, 0.18, 0.32, 0.32,
+                          2.4, 51.8, 50.8, 0.18, 0.32, 0.32,
+                          3.0, 2.5, 2.4, 2.4, 2.4, 60.4,
+                          200., 200., 200., 200., 200., 200.,
+                          8.76, 8.76, 8.76, 8.76, 8.76, 8.76])
+
+    TAU3_GRID = TAU3_GRID.reshape((len(V_GRID), len(YE_GRID)), order='F')
+
+    # make interpolants
+    E0_interp = RegularGridInterpolator((V_GRID, YE_GRID), E0_GRID, bounds_error=False, fill_value=None)
+    ALP_interp = RegularGridInterpolator((V_GRID, YE_GRID), ALP_GRID, bounds_error=False, fill_value=None)
+    T0_interp = RegularGridInterpolator((V_GRID, YE_GRID), T0_GRID, bounds_error=False, fill_value=None)
+    SIG_interp = RegularGridInterpolator((V_GRID, YE_GRID), SIG_GRID, bounds_error=False, fill_value=None)
+    ALP1_interp = RegularGridInterpolator((V_GRID, YE_GRID), ALP1_GRID, bounds_error=False, fill_value=None)
+    T1_interp = RegularGridInterpolator((V_GRID, YE_GRID), T1_GRID, bounds_error=False, fill_value=None)
+    SIG1_interp = RegularGridInterpolator((V_GRID, YE_GRID), SIG1_GRID, bounds_error=False, fill_value=None)
+    C1_interp = RegularGridInterpolator((V_GRID, YE_GRID), C1_GRID, bounds_error=False, fill_value=None)
+    TAU1_interp = RegularGridInterpolator((V_GRID, YE_GRID), TAU1_GRID, bounds_error=False, fill_value=None)
+    C2_interp = RegularGridInterpolator((V_GRID, YE_GRID), C2_GRID, bounds_error=False, fill_value=None)
+    TAU2_interp = RegularGridInterpolator((V_GRID, YE_GRID), TAU2_GRID, bounds_error=False, fill_value=None)
+    C3_interp = RegularGridInterpolator((V_GRID, YE_GRID), C3_GRID, bounds_error=False, fill_value=None)
+    TAU3_interp = RegularGridInterpolator((V_GRID, YE_GRID), TAU3_GRID, bounds_error=False, fill_value=None)
+
+
+    interpolators = namedtuple('interpolators', ['E0', 'ALP', 'T0', 'SIG', 'ALP1', 'T1', 'SIG1',
+                                                 'C1', 'TAU1', 'C2', 'TAU2', 'C3', 'TAU3'])
+    interpolators.E0 = E0_interp
+    interpolators.ALP = ALP_interp
+    interpolators.T0 = T0_interp
+    interpolators.SIG = SIG_interp
+    interpolators.ALP1 = ALP1_interp
+    interpolators.T1 = T1_interp
+    interpolators.SIG1 = SIG1_interp
+    interpolators.C1 = C1_interp
+    interpolators.TAU1 = TAU1_interp
+    interpolators.C2 = C2_interp
+    interpolators.TAU2 = TAU2_interp
+    interpolators.C3 = C3_interp
+    interpolators.TAU3 = TAU3_interp
+    return interpolators
+
+def get_heating_terms(ye, vel, **kwargs):
+    ints = heatinggrids()
+    e0 = ints.E0([vel, ye])[0]
+    alp = ints.ALP([vel, ye])[0]
+    t0 = ints.T0([vel, ye])[0]
+    sig = ints.SIG([vel, ye])[0]
+    alp1 = ints.ALP1([vel, ye])[0]
+    t1 = ints.T1([vel, ye])[0]
+    sig1 = ints.SIG1([vel, ye])[0]
+    c1 = ints.C1([vel, ye])[0]
+    tau1 = ints.TAU1([vel, ye])[0]
+    c2 = ints.C2([vel, ye])[0]
+    tau2 = ints.TAU2([vel, ye])[0]
+    c3 = ints.C3([vel, ye])[0]
+    tau3 = ints.TAU3([vel, ye])[0]
+    heating_terms = namedtuple('heating_terms', ['e0', 'alp', 't0', 'sig', 'alp1', 't1', 'sig1', 'c1',
+                                                 'tau1', 'c2', 'tau2', 'c3', 'tau3'])
+
+    heating_rate_fudge = kwargs.get('heating_rate_fudge', 1.0)
+    heating_terms.e0 = e0 * heating_rate_fudge
+    heating_terms.alp = alp * heating_rate_fudge
+    heating_terms.t0 = t0 * heating_rate_fudge
+    heating_terms.sig = sig * heating_rate_fudge
+    heating_terms.alp1 = alp1 * heating_rate_fudge
+    heating_terms.t1 = t1 * heating_rate_fudge
+    heating_terms.sig1 = sig1 * heating_rate_fudge
+    heating_terms.c1 = c1 * heating_rate_fudge
+    heating_terms.tau1 = tau1 * heating_rate_fudge
+    heating_terms.c2 = c2 * heating_rate_fudge
+    heating_terms.tau2 = tau2 * heating_rate_fudge
+    heating_terms.c3 = c3 * heating_rate_fudge
+    heating_terms.tau3 = tau3 * heating_rate_fudge
+    return heating_terms
+
+def _calculate_rosswogkorobkin24_qdot(time_array, ejecta_velocity, electron_fraction):
+    import pickle
+    import os
+    dirname = os.path.dirname(__file__)
+    with open(f"{dirname}/tables/qdot_rosswogkorobkin24.pck", 'rb') as file_handle:
+        qdot_object = pickle.load(file_handle)
+    steps = len(time_array)
+    _ej_velocity = np.repeat(ejecta_velocity, steps)
+    _ye = np.repeat(electron_fraction, steps)
+    full_array = np.array([_ej_velocity, _ye, time_array]).T
+    lum_in = qdot_object(full_array)
+    return lum_in
+
 def electron_fraction_from_kappa(kappa):
     """
     Uses interpolation from Tanaka+19 to calculate
@@ -793,11 +1073,24 @@ def electron_fraction_from_kappa(kappa):
     :return: electron_fraction
     """
 
-    kappa_array = np.array([1, 3, 5, 20, 30])
-    ye_array = np.array([0.4,0.35,0.25,0.2, 0.1])
-    kappa_func = interp1d(kappa_array, y=ye_array)
+    kappa_array = np.array([35, 32.2, 22.3, 5.60, 5.36, 3.30, 0.96, 0.5])
+    ye_array = np.array([0.10, 0.15, 0.2, 0.25, 0.30, 0.35, 0.4, 0.5])
+    kappa_func = interp1d(kappa_array, y=ye_array, fill_value='extrapolate')
     electron_fraction = kappa_func(kappa)
     return electron_fraction
+
+def kappa_from_electron_fraction(ye):
+    """
+    Uses interpolation from Tanaka+19 to calculate
+    the opacity based on the electron fraction
+    :param ye: electron fraction
+    :return: electron_fraction
+    """
+    kappa_array = np.array([35, 32.2, 22.3, 5.60, 5.36, 3.30, 0.96, 0.5])
+    ye_array = np.array([0.10, 0.15, 0.2, 0.25, 0.30, 0.35, 0.4, 0.5])
+    func = interp1d(ye_array, y=kappa_array, fill_value='extrapolate')
+    kappa = func(ye)
+    return kappa
     
 def lorentz_factor_from_velocity(velocity):
     """

{redback-1.0.1.dist-info → redback-1.0.3.dist-info}/METADATA

@@ -1,17 +1,54 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: redback
-Version: 1.0.1
+Version: 1.0.3
 Summary: A Bayesian inference pipeline for electromagnetic transients
 Home-page: https://github.com/nikhil-sarin/redback
 Author: Nikhil Sarin, Moritz Huebner
-Author-email: nikhil.sarin@su.se
+Author-email: nsarin.astro@gmail.com
 License: GNU General Public License v3 (GPLv3)
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENCE.md
+Requires-Dist: numpy==1.26.0
+Requires-Dist: setuptools
+Requires-Dist: pandas
+Requires-Dist: scipy<1.14.0
+Requires-Dist: selenium
+Requires-Dist: matplotlib
+Requires-Dist: astropy
+Requires-Dist: extinction
+Requires-Dist: requests
+Requires-Dist: lxml
+Requires-Dist: sphinx-rtd-theme
+Requires-Dist: sphinx-tabs
+Requires-Dist: bilby
+Requires-Dist: regex
+Requires-Dist: sncosmo
+Requires-Dist: afterglowpy
+Provides-Extra: all
+Requires-Dist: nestle; extra == "all"
+Requires-Dist: sherpa; extra == "all"
+Requires-Dist: scikit-learn; extra == "all"
+Requires-Dist: PyQt5; extra == "all"
+Requires-Dist: lalsuite; extra == "all"
+Requires-Dist: kilonova-heating-rate; extra == "all"
+Requires-Dist: redback-surrogates; extra == "all"
+Requires-Dist: kilonovanet; extra == "all"
+Requires-Dist: astroquery; extra == "all"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Documentation Status](https://readthedocs.org/projects/redback/badge/?version=latest)](https://redback.readthedocs.io/en/latest/?badge=latest)
 ![Python package](https://github.com/nikhil-sarin/redback/workflows/Python%20application/badge.svg)
@@ -45,9 +82,12 @@ Simulate single transients or populations or simulate a full survey including no
 
 ### Contributing
 If you are interested in contributing please join the redback 
-[slack](https://join.slack.com/t/redback-group/shared_invite/zt-21rsoa26s-kibI8MiA1JiIKM0wCMp5rQ)
+[slack](https://join.slack.com/t/redback-group/shared_invite/zt-2503mmkaq-EMEAgz7i3mY0pg1o~VUdqw)
 and email [Nikhil Sarin](mailto:nikhil.sarin@su.se?subject=Contributing%20to%20redback).
 
 To make changes to redback, we require users to use a merge request system. 
 
-
+### User/Dev calls
+We have regular calls for users and developers. 
+These include tutorials on specific redback functionality as well as discussions of new features/feature requests, 
+and Q/A. Please join the slack to get details of these calls.