+0001: """Module for methods implemented in cython.

  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0002: 

 0003: To use and load this module, you will need to build the cython extension using:

 0004: 

 0005: $ python setup.py build_ext -i

 0006: 

 0007: from the holodeck root directory (containing the `setup.py` file).

 0008: 

 0009: And you still need to install holodeck in develop mode, using:

 0010: 

 0011: $ python setup.py develop

 0012: 

 0013: """

 0014: 

 0015: cimport cython

+0016: import numpy as np

  __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 16, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;

 0017: cimport numpy as np

+0018: np.import_array()

  __pyx_t_2 = __pyx_f_5numpy_import_array(); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(0, 18, __pyx_L1_error)

 0019: 

 0020: # There is a special implementation of `scipy.special` for use with cython

 0021: cimport scipy.special.cython_special as sp_special

 0022: 

 0023: from libc.stdio cimport printf

 0024: from libc.stdlib cimport malloc, free, qsort

 0025: # make sure to use c-native math functions instead of python/numpy

 0026: from libc.math cimport pow, sqrt, abs, M_PI, NAN, cos, sin

 0027: 

 0028: from cpython.pycapsule cimport PyCapsule_IsValid, PyCapsule_GetPointer

 0029: from numpy.random cimport bitgen_t

+0030: from numpy.random import PCG64

  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_n_s_PCG64);
  __Pyx_GIVEREF(__pyx_n_s_PCG64);
  PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PCG64);
  __pyx_t_3 = __Pyx_Import(__pyx_n_s_numpy_random, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_PCG64, __pyx_t_1) < 0) __PYX_ERR(0, 30, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 0031: from numpy.random.c_distributions cimport random_poisson, random_normal

 0032: 

 0033: 

 0034: # DTYPE = np.float64 # define as this type

 0035: # ctypedef np.float64_t DTYPE_t # accept in cython function as this type

 0036: 

 0037: # ---- Define Parameters

 0038: 

+0039: cdef double ECCEN_ZERO_LIMIT = 1.0e-12   #: below this value, strains are calculated as circular

  __pyx_v_8holodeck_7cyutils_ECCEN_ZERO_LIMIT = 1.0e-12;

 0040: 

 0041: # ---- Define Constants

 0042: 

+0043: cdef double MY_NWTG = 6.6742999e-08

  __pyx_v_8holodeck_7cyutils_MY_NWTG = 6.6742999e-08;

+0044: cdef double MY_SPLC = 29979245800.0

  __pyx_v_8holodeck_7cyutils_MY_SPLC = 29979245800.0;

+0045: cdef double MY_MPC = 3.08567758e+24

  __pyx_v_8holodeck_7cyutils_MY_MPC = 3.08567758e+24;

+0046: cdef double MY_YR = 31557600.0

  __pyx_v_8holodeck_7cyutils_MY_YR = 31557600.0;

+0047: cdef double GW_DADT_SEP_CONST = - 64.0 * pow(MY_NWTG, 3) / 5.0 / pow(MY_SPLC, 5)

  __pyx_t_4 = ((-64.0 * pow(__pyx_v_8holodeck_7cyutils_MY_NWTG, 3.0)) / 5.0);
  __pyx_t_5 = pow(__pyx_v_8holodeck_7cyutils_MY_SPLC, 5.0);
  if (unlikely(__pyx_t_5 == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 47, __pyx_L1_error)
  }
  __pyx_v_8holodeck_7cyutils_GW_DADT_SEP_CONST = (__pyx_t_4 / __pyx_t_5);

+0048: cdef double GW_SRC_CONST = 8.0 * pow(MY_NWTG, 5.0/3.0) * pow(M_PI, 2.0/3.0) / sqrt(10.0) / pow(MY_SPLC, 4.0)

  __pyx_t_5 = ((8.0 * pow(__pyx_v_8holodeck_7cyutils_MY_NWTG, (5.0 / 3.0))) * pow(M_PI, (2.0 / 3.0)));
  __pyx_t_4 = sqrt(10.0);
  if (unlikely(__pyx_t_4 == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 48, __pyx_L1_error)
  }
  __pyx_t_6 = (__pyx_t_5 / __pyx_t_4);
  __pyx_t_4 = pow(__pyx_v_8holodeck_7cyutils_MY_SPLC, 4.0);
  if (unlikely(__pyx_t_4 == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 48, __pyx_L1_error)
  }
  __pyx_v_8holodeck_7cyutils_GW_SRC_CONST = (__pyx_t_6 / __pyx_t_4);

 0049: 

 0050: 

 0051: # ====    Utility Functions    ====

 0052: 

 0053: 

+0054: cdef double bessel_recursive(int nn, double ne, double jn_m1, double jn_m2):

static double __pyx_f_8holodeck_7cyutils_bessel_recursive(int __pyx_v_nn, double __pyx_v_ne, double __pyx_v_jn_m1, double __pyx_v_jn_m2) {
  double __pyx_v_jn;
  double __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("bessel_recursive", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("holodeck.cyutils.bessel_recursive", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0055:     """Recursive relation for calculating bessel functions

 0056: 

 0057:     J_n(x) = 2 * [(n-1) / x] * J_n-1(x) - J_n-2(x)

 0058: 

 0059:     NOTE: the recursive function fails when the argument `ne` is zero (divide by zero).  These

 0060:           cases should be caught manually and set to the known values.

 0061:           This happens at the level of calculating the frequency distribution function g(n,e).

 0062: 

 0063:     Parameters

 0064:     ----------

 0065:     int nn : order of the bessel function

 0066:     double ne : argument of the bessel function (in this case, product of order and eccentricity)

 0067:     double jn_m1 : the value of the Bessel function of order n-1 of the same argument

 0068:     double jn_m2 : the value of the Bessel function of order n-2 of the same argument

 0069: 

 0070:     Returns

 0071:     -------

 0072:     double jn : the value of the Bessel function of the desired order.

 0073: 

 0074:     """

+0075:     cdef double jn = (2*(nn-1) / ne) * jn_m1 - jn_m2

  __pyx_t_1 = (2 * (__pyx_v_nn - 1));
  if (unlikely(__pyx_v_ne == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 75, __pyx_L1_error)
  }
  __pyx_v_jn = (((((double)__pyx_t_1) / __pyx_v_ne) * __pyx_v_jn_m1) - __pyx_v_jn_m2);

+0076:     return jn

  __pyx_r = __pyx_v_jn;
  goto __pyx_L0;

 0077: 

 0078: 

+0079: cdef double _gw_ecc_func(double eccen):

static double __pyx_f_8holodeck_7cyutils__gw_ecc_func(double __pyx_v_eccen) {
  double __pyx_v_e2;
  double __pyx_v_fe;
  double __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_gw_ecc_func", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("holodeck.cyutils._gw_ecc_func", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0080:     """Calculate the GW Hardening rate eccentricitiy dependence F(e).

 0081: 

 0082:     See [Peters1964]_ Eq. 5.6, or [EN2007]_ Eq. 2.3

 0083: 

 0084:     Parameters

 0085:     ----------

 0086:     eccen : double

 0087:         Eccentricity

 0088: 

 0089:     Returns

 0090:     -------

 0091:     fe : double

 0092:         The value of F(e).

 0093: 

 0094:     """

+0095:     cdef double e2 = eccen*eccen

  __pyx_v_e2 = (__pyx_v_eccen * __pyx_v_eccen);

+0096:     cdef double fe = (1.0 + (73.0/24.0)*e2 + (37.0/96.0)*e2*e2) / pow(1.0 - e2, 7.0/2.0)

  __pyx_t_1 = ((1.0 + ((73.0 / 24.0) * __pyx_v_e2)) + (((37.0 / 96.0) * __pyx_v_e2) * __pyx_v_e2));
  __pyx_t_2 = pow((1.0 - __pyx_v_e2), (7.0 / 2.0));
  if (unlikely(__pyx_t_2 == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 96, __pyx_L1_error)
  }
  __pyx_v_fe = (__pyx_t_1 / __pyx_t_2);

+0097:     return fe

  __pyx_r = __pyx_v_fe;
  goto __pyx_L0;

 0098: 

 0099: 

 0100: @cython.boundscheck(False)

 0101: @cython.wraparound(False)

+0102: cdef void my_trapz_grid_weight(int index, int size, double[:] grid, double *rv):

static void __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(int __pyx_v_index, int __pyx_v_size, __Pyx_memviewslice __pyx_v_grid, double *__pyx_v_rv) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("my_trapz_grid_weight", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
}

 0103:     """Determine the trapezoid-rule weight and bin-width for the given grid point.

 0104: 

 0105:     Parameters

 0106:     ----------

 0107:     index : int,

 0108:         Index into the array of `grid` positions along the desired dimension.

 0109:     size : int,

 0110:         Size of the array of grid positions along the desired dimension.

 0111:     grid : double *

 0112:         Pointer to an array that specifies the location of grid points along the desired dimension.

 0113:     rv : double *

 0114:         Pointer to a (2,) array to store the output values.  The two values are:

 0115:         0: the (inverse) weight of this grid point,

 0116:         1: the grid-width for this grid point (i.e. 'dx').

 0117: 

 0118:     Returns

 0119:     -------

 0120:     None

 0121:         Note that output values are stored in the `rv` parameter.

 0122: 

 0123:     """

 0124:     # Left edge

+0125:     if index == 0:

  __pyx_t_1 = ((__pyx_v_index == 0) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0126:         rv[0] = 2.0

    (__pyx_v_rv[0]) = 2.0;

+0127:         rv[1] = <double>(grid[1] - grid[0])   # i.e. grid[index+1] - grid[index]

    __pyx_t_2 = 1;
    __pyx_t_3 = 0;
    (__pyx_v_rv[1]) = ((double)((*((double *) ( /* dim=0 */ (__pyx_v_grid.data + __pyx_t_2 * __pyx_v_grid.strides[0]) ))) - (*((double *) ( /* dim=0 */ (__pyx_v_grid.data + __pyx_t_3 * __pyx_v_grid.strides[0]) )))));

+0128:         return

    goto __pyx_L0;

 0129: 

 0130:     # Right edge

+0131:     if index == size - 1:

  __pyx_t_1 = ((__pyx_v_index == (__pyx_v_size - 1)) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0132:         rv[0] = 2.0

    (__pyx_v_rv[0]) = 2.0;

+0133:         rv[1] = <double>(grid[index] - grid[index-1])

    __pyx_t_3 = __pyx_v_index;
    __pyx_t_2 = (__pyx_v_index - 1);
    (__pyx_v_rv[1]) = ((double)((*((double *) ( /* dim=0 */ (__pyx_v_grid.data + __pyx_t_3 * __pyx_v_grid.strides[0]) ))) - (*((double *) ( /* dim=0 */ (__pyx_v_grid.data + __pyx_t_2 * __pyx_v_grid.strides[0]) )))));

+0134:         return

    goto __pyx_L0;

 0135: 

 0136:     # center points

+0137:     rv[0] = 1.0

  (__pyx_v_rv[0]) = 1.0;

 0138:     # this is the same as the average of dx values on each side of the grid-point, i.e.:

 0139:     #     0.5 * ((grid[index] - grid[index-1]) + (grid[index+1] - grid[index]))

+0140:     rv[1] = 0.5 * (<double>(grid[index+1] - grid[index-1]))

  __pyx_t_2 = (__pyx_v_index + 1);
  __pyx_t_3 = (__pyx_v_index - 1);
  (__pyx_v_rv[1]) = (0.5 * ((double)((*((double *) ( /* dim=0 */ (__pyx_v_grid.data + __pyx_t_2 * __pyx_v_grid.strides[0]) ))) - (*((double *) ( /* dim=0 */ (__pyx_v_grid.data + __pyx_t_3 * __pyx_v_grid.strides[0]) ))))));

 0141: 

+0142:     return

  goto __pyx_L0;

 0143: 

 0144: 

+0145: cdef double gw_freq_dist_func__scalar_scalar(int nn, double ee):

static double __pyx_f_8holodeck_7cyutils_gw_freq_dist_func__scalar_scalar(int __pyx_v_nn, double __pyx_v_ee) {
  double __pyx_v_jn_m2;
  double __pyx_v_jn_m1;
  double __pyx_v_jn;
  double __pyx_v_jn_p1;
  double __pyx_v_jn_p2;
  double __pyx_v_aa;
  double __pyx_v_bb;
  double __pyx_v_cc;
  double __pyx_v_gg;
  double __pyx_v_ne;
  double __pyx_v_n2;
  double __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("gw_freq_dist_func__scalar_scalar", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("holodeck.cyutils.gw_freq_dist_func__scalar_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0146:     """Calculate the GW frequency distribution function at the given harmonic and eccentricity, g(n,e).

 0147: 

 0148:     See [EN2007]_ Eq. 2.4

 0149: 

 0150:     NOTE: the recursive Bessel-function calculation is much faster, but fails when the argument (n*e) is zero.

 0151:         For this reason, zero arguments are manually detected and the known values of the function are returned.

 0152:         g(n, e=0.0) is 1.0 if n=2, and otherwise 0

 0153: 

 0154:     Parameters

 0155:     ----------

 0156:     nn : int,

 0157:         The harmonic to consider.

 0158:     ee : double,

 0159:         The eccentricity value.

 0160: 

 0161:     Returns

 0162:     -------

 0163:     gg : double,

 0164:         The value of g(n,e).

 0165: 

 0166:     """

 0167: 

+0168:     if ee < ECCEN_ZERO_LIMIT:

  __pyx_t_1 = ((__pyx_v_ee < __pyx_v_8holodeck_7cyutils_ECCEN_ZERO_LIMIT) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0169:         if nn == 2:

    __pyx_t_1 = ((__pyx_v_nn == 2) != 0);
    if (__pyx_t_1) {
/* … */
    }

+0170:             return 1.0

      __pyx_r = 1.0;
      goto __pyx_L0;

 0171: 

+0172:         return 0.0

    __pyx_r = 0.0;
    goto __pyx_L0;

 0173: 

 0174:     cdef double jn_m2, jn_m1, jn, jn_p1, jn_p2

 0175:     cdef double aa, bb, cc, gg

 0176: 

+0177:     cdef double ne = nn*ee

  __pyx_v_ne = (__pyx_v_nn * __pyx_v_ee);

+0178:     cdef double n2 = nn * nn

  __pyx_v_n2 = (__pyx_v_nn * __pyx_v_nn);

 0179: 

+0180:     jn_m2 = sp_special.jv(nn-2, ne)

  __pyx_v_jn_m2 = __pyx_fuse_1__pyx_f_5scipy_7special_14cython_special_jv((__pyx_v_nn - 2), __pyx_v_ne, 0);

+0181:     jn_m1 = sp_special.jv(nn-1, ne)

  __pyx_v_jn_m1 = __pyx_fuse_1__pyx_f_5scipy_7special_14cython_special_jv((__pyx_v_nn - 1), __pyx_v_ne, 0);

 0182: 

+0183:     jn = bessel_recursive(nn, ne, jn_m1, jn_m2)

  __pyx_v_jn = __pyx_f_8holodeck_7cyutils_bessel_recursive(__pyx_v_nn, __pyx_v_ne, __pyx_v_jn_m1, __pyx_v_jn_m2);

+0184:     jn_p1 = bessel_recursive(nn+1, ne, jn, jn_m1)

  __pyx_v_jn_p1 = __pyx_f_8holodeck_7cyutils_bessel_recursive((__pyx_v_nn + 1), __pyx_v_ne, __pyx_v_jn, __pyx_v_jn_m1);

+0185:     jn_p2 = bessel_recursive(nn+2, ne, jn_p1, jn)

  __pyx_v_jn_p2 = __pyx_f_8holodeck_7cyutils_bessel_recursive((__pyx_v_nn + 2), __pyx_v_ne, __pyx_v_jn_p1, __pyx_v_jn);

 0186: 

+0187:     aa = jn_m2 - 2.0*ee*jn_m1 + (2/nn)*jn + 2*ee*jn_p1 - jn_p2

  if (unlikely(__pyx_v_nn == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 187, __pyx_L1_error)
  }
  __pyx_v_aa = ((((__pyx_v_jn_m2 - ((2.0 * __pyx_v_ee) * __pyx_v_jn_m1)) + ((2.0 / ((double)__pyx_v_nn)) * __pyx_v_jn)) + ((2.0 * __pyx_v_ee) * __pyx_v_jn_p1)) - __pyx_v_jn_p2);

+0188:     aa = aa * aa

  __pyx_v_aa = (__pyx_v_aa * __pyx_v_aa);

+0189:     bb = jn_m2 - 2*ee*jn + jn_p2

  __pyx_v_bb = ((__pyx_v_jn_m2 - ((2.0 * __pyx_v_ee) * __pyx_v_jn)) + __pyx_v_jn_p2);

+0190:     bb = (1 - ee*ee)*bb*bb

  __pyx_v_bb = (((1.0 - (__pyx_v_ee * __pyx_v_ee)) * __pyx_v_bb) * __pyx_v_bb);

+0191:     cc = (4.0/(3.0*n2)) * jn * jn

  __pyx_t_2 = (3.0 * __pyx_v_n2);
  if (unlikely(__pyx_t_2 == 0)) {
    PyErr_SetString(PyExc_ZeroDivisionError, "float division");
    __PYX_ERR(0, 191, __pyx_L1_error)
  }
  __pyx_v_cc = (((4.0 / __pyx_t_2) * __pyx_v_jn) * __pyx_v_jn);

+0192:     gg = (n2*n2/32) * (aa + bb + cc)

  __pyx_v_gg = (((__pyx_v_n2 * __pyx_v_n2) / 32.0) * ((__pyx_v_aa + __pyx_v_bb) + __pyx_v_cc));

 0193: 

+0194:     return gg

  __pyx_r = __pyx_v_gg;
  goto __pyx_L0;

 0195: 

 0196: 

 0197: @cython.boundscheck(False)

 0198: @cython.wraparound(False)

 0199: @cython.nonecheck(False)

 0200: @cython.cdivision(True)

+0201: cdef void unravel(int idx, int[] shape, int *ii_out, int *jj_out):

static void __pyx_f_8holodeck_7cyutils_unravel(int __pyx_v_idx, int *__pyx_v_shape, int *__pyx_v_ii_out, int *__pyx_v_jj_out) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("unravel", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
}

 0202:     """Convert from a 1D/flattened index into a 2D pair of (unraveled) indices.

 0203: 

 0204:     NOTE: row-major / c-style ordering is assumed.  This is the numpy default.

 0205: 

 0206:     Parameters

 0207:     ----------

 0208:     idx : int,

 0209:         Index into a 1D array to be unraveled.

 0210:     shape : int *,

 0211:         Array specifying the 2D shape of the array being indexed.

 0212:     ii_out : int *,

 0213:         Pointer to the memory location to store the output value for the 0th dimension index (x/i).

 0214:     jj_out : int *,

 0215:         Pointer to the memory location to store the output value for the 1th dimension index (y/j).

 0216: 

 0217:     Returns

 0218:     -------

 0219:     None

 0220:         NOTE: return values are set to the `ii_out` and `jj_out` parameters.

 0221: 

 0222:     """

 0223:     # find the 0th index from the size of each 0th element, `shape[1]`

+0224:     ii_out[0] = idx // shape[1]

  (__pyx_v_ii_out[0]) = (__pyx_v_idx / (__pyx_v_shape[1]));

 0225:     # find the 1th index based on the remainder

+0226:     jj_out[0] = idx - ii_out[0] * shape[1]

  (__pyx_v_jj_out[0]) = (__pyx_v_idx - ((__pyx_v_ii_out[0]) * (__pyx_v_shape[1])));

+0227:     return

  goto __pyx_L0;

 0228: 

 0229: 

 0230: # @cython.boundscheck(False)

 0231: # @cython.wraparound(False)

 0232: # @cython.nonecheck(False)

 0233: # @cython.cdivision(True)

 0234: # cdef void ravel(int ii, int jj, int[] shape, int *idx_out):

 0235: #     """Convert from a 2D pair of indices into a 1D (raveled) index.

 0236: 

 0237: #     NOTE: row-major / c-style ordering is assumed.  This is the numpy default.

 0238: 

 0239: #     Parameters

 0240: #     ----------

 0241: #     ii : int,

 0242: #         0th dimension index (i.e. x).

 0243: #     jj : int,

 0244: #         1th dimension index (i.e. y).

 0245: #     shape : int *,

 0246: #         Array specifying the 2D shape of the array being indexed.

 0247: #     idx_out : int *,

 0248: #         Pointer to the memory location to store the 1D/flattened index.

 0249: 

 0250: #     Returns

 0251: #     -------

 0252: #     None

 0253: #         NOTE: return values are set to the `idx_out` parameter.

 0254: 

 0255: #     """

 0256: #     idx_out[0] = ii * shape[1] + jj

 0257: #     return

 0258: 

 0259: 

 0260: """Structure that stores both the index and value of a given array element to use in sorting.

 0261: """

+0262: cdef struct sorter:

struct __pyx_t_8holodeck_7cyutils_sorter {
  int index;
  double value;
};

 0263:     int index

 0264:     double value

 0265: 

 0266: 

+0267: cdef int sort_compare(const void *a, const void *b) noexcept nogil:

static int __pyx_f_8holodeck_7cyutils_sort_compare(void const *__pyx_v_a, void const *__pyx_v_b) {
  struct __pyx_t_8holodeck_7cyutils_sorter *__pyx_v_a1;
  struct __pyx_t_8holodeck_7cyutils_sorter *__pyx_v_a2;
  int __pyx_r;
/* … */
  /* function exit code */
  __pyx_L0:;
  return __pyx_r;
}

 0268:     """Comparison function used by the `qsort` builtin method to perform an array-sort by index.

 0269: 

 0270:     Parameters

 0271:     ----------

 0272:     a : void *

 0273:         Pointer to first  element of comparison, should point to a `sorter` struct instance.

 0274:     b : void *

 0275:         Pointer to second element of comparison, should point to a `sorter` struct instance.

 0276: 

 0277:     Returns

 0278:     -------

 0279:     int

 0280:         -1 if a < b, +1 if b > a, and 0 otherwise

 0281: 

 0282:     """

+0283:     cdef sorter *a1 = <sorter *>a;

  __pyx_v_a1 = ((struct __pyx_t_8holodeck_7cyutils_sorter *)__pyx_v_a);

+0284:     cdef sorter *a2 = <sorter *>b;

  __pyx_v_a2 = ((struct __pyx_t_8holodeck_7cyutils_sorter *)__pyx_v_b);

+0285:     if ((a1[0]).value < (a2[0]).value):

  __pyx_t_1 = (((__pyx_v_a1[0]).value < (__pyx_v_a2[0]).value) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0286:         return -1

    __pyx_r = -1;
    goto __pyx_L0;

+0287:     elif ((a1[0]).value > (a2[0]).value):

  __pyx_t_1 = (((__pyx_v_a1[0]).value > (__pyx_v_a2[0]).value) != 0);
  if (__pyx_t_1) {
/* … */
  }

+0288:         return 1

    __pyx_r = 1;
    goto __pyx_L0;

 0289:     else:

+0290:         return 0

  /*else*/ {
    __pyx_r = 0;
    goto __pyx_L0;
  }

 0291: 

 0292: 

+0293: cdef void argsort(double *values, int size, int **indices):

static void __pyx_f_8holodeck_7cyutils_argsort(double *__pyx_v_values, int __pyx_v_size, int **__pyx_v_indices) {
  struct __pyx_t_8holodeck_7cyutils_sorter *__pyx_v_testers;
  int __pyx_v_ii;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("argsort", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
}

 0294:     """Find the indices that sort the given 1D array of double values.

 0295: 

 0296:     This is done using an array of `sorter` struct instances which store both index and value.

 0297: 

 0298:     Usage example:

 0299: 

 0300:         ```

 0301:         cdef double test[4]

 0302:         test[:] = [1.0, -2.3, 7.8, 0.0]

 0303: 

 0304:         cdef (int *)indices = <int *>malloc(4 * sizeof(int))

 0305:         argsort(test, 4, &indices)

 0306:         ```

 0307: 

 0308:     """

+0309:     cdef (sorter *)testers = <sorter *>malloc(size * sizeof(sorter))

  __pyx_v_testers = ((struct __pyx_t_8holodeck_7cyutils_sorter *)malloc((__pyx_v_size * (sizeof(struct __pyx_t_8holodeck_7cyutils_sorter)))));

 0310:     cdef int ii

+0311:     for ii in range(size):

  __pyx_t_1 = __pyx_v_size;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_ii = __pyx_t_3;

+0312:         testers[ii].index = ii

    (__pyx_v_testers[__pyx_v_ii]).index = __pyx_v_ii;

+0313:         testers[ii].value = values[ii]

    (__pyx_v_testers[__pyx_v_ii]).value = (__pyx_v_values[__pyx_v_ii]);
  }

 0314: 

+0315:     qsort(testers, size, sizeof(testers[0]), sort_compare)

  qsort(__pyx_v_testers, __pyx_v_size, (sizeof((__pyx_v_testers[0]))), __pyx_f_8holodeck_7cyutils_sort_compare);

+0316:     for ii in range(size):

  __pyx_t_1 = __pyx_v_size;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_ii = __pyx_t_3;

+0317:         indices[0][ii] = testers[ii].index

    __pyx_t_4 = (__pyx_v_testers[__pyx_v_ii]).index;
    ((__pyx_v_indices[0])[__pyx_v_ii]) = __pyx_t_4;
  }

 0318: 

+0319:     return

  goto __pyx_L0;

 0320: 

 0321: 

 0322: @cython.boundscheck(False)

 0323: @cython.wraparound(False)

 0324: @cython.nonecheck(False)

 0325: @cython.cdivision(True)

+0326: cdef double _interp_between_vals(double xnew, double xl, double xr, double yl, double yr):

static double __pyx_f_8holodeck_7cyutils__interp_between_vals(double __pyx_v_xnew, double __pyx_v_xl, double __pyx_v_xr, double __pyx_v_yl, double __pyx_v_yr) {
  double __pyx_v_ynew;
  double __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_interp_between_vals", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

+0327:     cdef double ynew = yl + (yr - yl) * (xnew - xl) / (xr - xl)

  __pyx_v_ynew = (__pyx_v_yl + (((__pyx_v_yr - __pyx_v_yl) * (__pyx_v_xnew - __pyx_v_xl)) / (__pyx_v_xr - __pyx_v_xl)));

+0328:     return ynew

  __pyx_r = __pyx_v_ynew;
  goto __pyx_L0;

 0329: 

 0330: 

 0331: @cython.boundscheck(False)

 0332: @cython.wraparound(False)

 0333: @cython.nonecheck(False)

 0334: @cython.cdivision(True)

+0335: cdef double interp_at_index(int idx, double xnew, double[:] xold, double[:] yold):

static double __pyx_f_8holodeck_7cyutils_interp_at_index(int __pyx_v_idx, double __pyx_v_xnew, __Pyx_memviewslice __pyx_v_xold, __Pyx_memviewslice __pyx_v_yold) {
  double __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("interp_at_index", 0);
/* … */
  /* function exit code */
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0336:     """Perform linear interpolation at the given index in a pair of arrays.

 0337: 

 0338:     Parameters

 0339:     ----------

 0340:     idx : int

 0341:         Index in the arrays specifying the left reference value to interpolate between, with `idx+1`

 0342:         giving the right value.

 0343:     xnew : double

 0344:         The independent (x) value to interpolate to.

 0345:     xold : double *

 0346:         Array of x-values giving the independent variables where the functions are evaluated.

 0347:     yold : double *

 0348:         Array of y-values giving the dependent variable (function values) of array.

 0349: 

 0350:     Returns

 0351:     -------

 0352:     ynew : double

 0353:         Interpolated function value.

 0354: 

 0355:     """

 0356:     # cdef double ynew = yold[idx] + (yold[idx+1] - yold[idx])/(xold[idx+1] - xold[idx]) * (xnew - xold[idx])

 0357:     # return ynew

+0358:     return _interp_between_vals(xnew, xold[idx], xold[idx+1], yold[idx], yold[idx+1])

  __pyx_t_1 = __pyx_v_idx;
  __pyx_t_2 = (__pyx_v_idx + 1);
  __pyx_t_3 = __pyx_v_idx;
  __pyx_t_4 = (__pyx_v_idx + 1);
  __pyx_r = __pyx_f_8holodeck_7cyutils__interp_between_vals(__pyx_v_xnew, (*((double *) ( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_1 * __pyx_v_xold.strides[0]) ))), (*((double *) ( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_2 * __pyx_v_xold.strides[0]) ))), (*((double *) ( /* dim=0 */ (__pyx_v_yold.data + __pyx_t_3 * __pyx_v_yold.strides[0]) ))), (*((double *) ( /* dim=0 */ (__pyx_v_yold.data + __pyx_t_4 * __pyx_v_yold.strides[0]) ))));
  goto __pyx_L0;

 0359: 

 0360: 

+0361: def sam_calc_gwb_single_eccen(ndens, mtot_log10, mrat, redz, dcom, gwfobs, sepa_evo, eccen_evo, nharms=100):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_1sam_calc_gwb_single_eccen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_sam_calc_gwb_single_eccen[] = "Pure-python wrapper for the SAM eccentric GWB calculation method.  See: `_sam_calc_gwb_single_eccen()`.\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_1sam_calc_gwb_single_eccen = {"sam_calc_gwb_single_eccen", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_1sam_calc_gwb_single_eccen, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_sam_calc_gwb_single_eccen};
static PyObject *__pyx_pw_8holodeck_7cyutils_1sam_calc_gwb_single_eccen(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ndens = 0;
  PyObject *__pyx_v_mtot_log10 = 0;
  PyObject *__pyx_v_mrat = 0;
  PyObject *__pyx_v_redz = 0;
  PyObject *__pyx_v_dcom = 0;
  PyObject *__pyx_v_gwfobs = 0;
  PyObject *__pyx_v_sepa_evo = 0;
  PyObject *__pyx_v_eccen_evo = 0;
  PyObject *__pyx_v_nharms = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sam_calc_gwb_single_eccen (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ndens,&__pyx_n_s_mtot_log10,&__pyx_n_s_mrat,&__pyx_n_s_redz,&__pyx_n_s_dcom,&__pyx_n_s_gwfobs,&__pyx_n_s_sepa_evo,&__pyx_n_s_eccen_evo,&__pyx_n_s_nharms,0};
    PyObject* values[9] = {0,0,0,0,0,0,0,0,0};
    values[8] = ((PyObject *)__pyx_int_100);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ndens)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mtot_log10)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 1); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mrat)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 2); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_redz)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 3); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dcom)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 4); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gwfobs)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 5); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sepa_evo)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 6); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eccen_evo)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, 7); __PYX_ERR(0, 361, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nharms);
          if (value) { values[8] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sam_calc_gwb_single_eccen") < 0)) __PYX_ERR(0, 361, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_ndens = values[0];
    __pyx_v_mtot_log10 = values[1];
    __pyx_v_mrat = values[2];
    __pyx_v_redz = values[3];
    __pyx_v_dcom = values[4];
    __pyx_v_gwfobs = values[5];
    __pyx_v_sepa_evo = values[6];
    __pyx_v_eccen_evo = values[7];
    __pyx_v_nharms = values[8];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen", 0, 8, 9, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 361, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.sam_calc_gwb_single_eccen", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_sam_calc_gwb_single_eccen(__pyx_self, __pyx_v_ndens, __pyx_v_mtot_log10, __pyx_v_mrat, __pyx_v_redz, __pyx_v_dcom, __pyx_v_gwfobs, __pyx_v_sepa_evo, __pyx_v_eccen_evo, __pyx_v_nharms);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_sam_calc_gwb_single_eccen(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ndens, PyObject *__pyx_v_mtot_log10, PyObject *__pyx_v_mrat, PyObject *__pyx_v_redz, PyObject *__pyx_v_dcom, PyObject *__pyx_v_gwfobs, PyObject *__pyx_v_sepa_evo, PyObject *__pyx_v_eccen_evo, PyObject *__pyx_v_nharms) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sam_calc_gwb_single_eccen", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __PYX_XDEC_MEMVIEW(&__pyx_t_1, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_4, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("holodeck.cyutils.sam_calc_gwb_single_eccen", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__26 = PyTuple_Pack(9, __pyx_n_s_ndens, __pyx_n_s_mtot_log10, __pyx_n_s_mrat, __pyx_n_s_redz, __pyx_n_s_dcom, __pyx_n_s_gwfobs, __pyx_n_s_sepa_evo, __pyx_n_s_eccen_evo, __pyx_n_s_nharms); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__26);
  __Pyx_GIVEREF(__pyx_tuple__26);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_1sam_calc_gwb_single_eccen, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sam_calc_gwb_single_eccen, __pyx_t_3) < 0) __PYX_ERR(0, 361, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(9, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__26, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_sam_calc_gwb_single_eccen, 361, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(0, 361, __pyx_L1_error)

 0362:     """Pure-python wrapper for the SAM eccentric GWB calculation method.  See: `_sam_calc_gwb_single_eccen()`.

 0363:     """

+0364:     return _sam_calc_gwb_single_eccen(ndens, mtot_log10, mrat, redz, dcom, gwfobs, sepa_evo, eccen_evo, nharms)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_v_ndens, PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mtot_log10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mrat, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_redz, PyBUF_WRITABLE); if (unlikely(!__pyx_t_4.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_dcom, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_gwfobs, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_sepa_evo, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_eccen_evo, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_nharms); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 364, __pyx_L1_error)
  __pyx_t_10 = __pyx_f_8holodeck_7cyutils__sam_calc_gwb_single_eccen(__pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 364, __pyx_L1_error)
  __PYX_XDEC_MEMVIEW(&__pyx_t_1, 1);
  __pyx_t_1.memview = NULL;
  __pyx_t_1.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
  __pyx_t_2.memview = NULL;
  __pyx_t_2.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1);
  __pyx_t_3.memview = NULL;
  __pyx_t_3.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_4, 1);
  __pyx_t_4.memview = NULL;
  __pyx_t_4.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;
  __pyx_t_11 = __pyx_memoryview_fromslice(__pyx_t_10, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 364, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_11);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;
  __pyx_r = __pyx_t_11;
  __pyx_t_11 = 0;
  goto __pyx_L0;

 0365: 

 0366: @cython.boundscheck(False)

 0367: @cython.wraparound(False)

 0368: @cython.nonecheck(False)

 0369: @cython.cdivision(True)

+0370: cdef double[:, :] _sam_calc_gwb_single_eccen(

static __Pyx_memviewslice __pyx_f_8holodeck_7cyutils__sam_calc_gwb_single_eccen(__Pyx_memviewslice __pyx_v_ndens, __Pyx_memviewslice __pyx_v_mtot_log10, __Pyx_memviewslice __pyx_v_mrat, __Pyx_memviewslice __pyx_v_redz, __Pyx_memviewslice __pyx_v_dcom, __Pyx_memviewslice __pyx_v_gwfobs, __Pyx_memviewslice __pyx_v_sepa_evo_in, __Pyx_memviewslice __pyx_v_eccen_evo_in, int __pyx_v_nharms) {
  int __pyx_v_nfreqs;
  int __pyx_v_n_mtot;
  int __pyx_v_n_mrat;
  int __pyx_v_n_redz;
  int __pyx_v_n_eccs;
  int __pyx_v_num_freq_harm;
  int *__pyx_v_shape;
  int __pyx_v_ii;
  int __pyx_v_nh;
  int __pyx_v_jj;
  int __pyx_v_kk;
  int __pyx_v_aa;
  int __pyx_v_bb;
  int __pyx_v_ff;
  int __pyx_v_ecc_idx;
  int __pyx_v_ecc_idx_beg;
  int __pyx_v_ii_mm;
  double __pyx_v_m1;
  double __pyx_v_m2;
  double __pyx_v_mchirp;
  double __pyx_v_sa;
  double __pyx_v_tau;
  double __pyx_v_gwfr;
  double __pyx_v_zterm;
  double __pyx_v_dc_cm;
  double __pyx_v_dc_mpc;
  double __pyx_v_dc_term;
  double __pyx_v_gne;
  double __pyx_v_hterm;
  double __pyx_v_weight_ik;
  double __pyx_v_weight;
  double __pyx_v_four_over_nh_squared;
  double __pyx_v_sa_fourth;
  double __pyx_v_fe_ecc;
  double __pyx_v_mt;
  double __pyx_v_mt_sqrt;
  double __pyx_v_hterm_pref;
  double __pyx_v_frst_evo_lo;
  double __pyx_v_frst_evo_hi;
  double __pyx_v_four_pi_c_mpc;
  double __pyx_v_kep_sa_term;
  double __pyx_v_one_third;
  double __pyx_v_two_third;
  double __pyx_v_four_third;
  double __pyx_v_three_fifths;
  double __pyx_v_six_fifths;
  PyArrayObject *__pyx_v_gwb = 0;
  double *__pyx_v_mtot;
  double *__pyx_v_ival;
  double *__pyx_v_jval;
  double *__pyx_v_kval;
  double *__pyx_v_sepa_evo;
  double *__pyx_v_eccen_evo;
  double __pyx_v__freq_pref;
  double *__pyx_v_frst_evo_pref;
  double *__pyx_v_freq_harms;
  int *__pyx_v_sorted_index;
  double __pyx_v_kep_sa_mass_term;
  double __pyx_v_ecc;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_gwb;
  __Pyx_Buffer __pyx_pybuffer_gwb;
  __Pyx_memviewslice __pyx_r = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_sam_calc_gwb_single_eccen", 0);
  __pyx_pybuffer_gwb.pybuffer.buf = NULL;
  __pyx_pybuffer_gwb.refcount = 0;
  __pyx_pybuffernd_gwb.data = NULL;
  __pyx_pybuffernd_gwb.rcbuffer = &__pyx_pybuffer_gwb;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __pyx_r.data = NULL;
  __pyx_r.memview = NULL;
  __Pyx_AddTraceback("holodeck.cyutils._sam_calc_gwb_single_eccen", __pyx_clineno, __pyx_lineno, __pyx_filename);
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer);
  if (unlikely(!__pyx_r.memview)) {
    PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");
  }
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_gwb);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0371:     double[:, :, :] ndens,

 0372:     double[:] mtot_log10,

 0373:     double[:] mrat,

 0374:     double[:] redz,

 0375:     double[:] dcom,

 0376:     double[:] gwfobs,

 0377:     double[:] sepa_evo_in,

 0378:     double[:] eccen_evo_in,

 0379:     int nharms

 0380: ):

 0381:     """Calculate the GWB from an eccentric SAM evolution model.

 0382: 

 0383:     This function uses the precomputed binary-evolution of eccentricities over some range of separations.

 0384:     This assumes a single eccentricity evolution e(a) for all binaries.

 0385:     Redshifts are assumed to stay constant during this evolution.

 0386: 

 0387:     h_c^2 = (dn/dz) * h_{s,n}^2 * 4*pi*c * d_c^2 * (1+z) * tau

 0388: 

 0389:     h_{s,n}^2 = (32 / 5) * c^-8 * (2/n)^2 * (G Mchirp)^(10/3) * d_c^-2 * (2*pi*forb_r)^(4/3) * g(n,e)

 0390:               = GW_SRC_CONST^2 * (2/n)^2 * Mchirp^(10/3) * d_c^-2 * forb_r^(4/3) * g(n,e)

 0391: 

 0392: 

 0393:     Parameters

 0394:     ----------

 0395:     ndens : (double ***)

 0396:         3D array specifying the SAM number-density of binaries in each bin, in total-mass, mass-ratio, and redshift.

 0397:         This is typically `sam.static_binary_density`, corresponding to 'd^3 n / [dlog10M dq dz]' in units of [Mpc^-3].

 0398:     mtot_log10 : (double *)

 0399:         Array of log10 values of the total-mass (in grams) grid edges in the SAM model.  i.e. `log10(sam.mtot)`.

 0400:     mrat : (double *)

 0401:         Array of mass-ratio grid edges in the SAM model.  i.e. `sam.mrat`.

 0402:     redz : (double *)

 0403:         Array of values for the redshift grid edges in the SAM model.  i.e. `sam.redz`.

 0404:     dcom : (double *)

 0405:         Comoving distances in units of [Mpc] corresponding to each `redz` value.

 0406:     gwfobs : (double *)

 0407:         Array of GW observer-frame frequencies at which to evaluate the GWB.

 0408:     sepa_evo_in : (double *)

 0409:         The values of binary separation in units of [cm] at which the binaries have been evolved.

 0410:     eccen_evo_in : (double *)

 0411:         The values of binary eccentricity at each separation at which the binaries have been evolved.

 0412:     nharms : int,

 0413:         Number of harmonics at which to calculate GW strains.

 0414: 

 0415:     Returns

 0416:     -------

 0417:     gwb : (double **)

 0418:         2D array giving the characteristic-strain _squared_, at each observer-frame frequency and each harmonic.

 0419:         Shape is (nfreqs, nharms), where `nfreqs` is the length of the `gwfobs` parameters, and `nharms` is given

 0420:         as an input parameter directly.

 0421:         The characteristic strain spectrum, h_c(f) is then `np.sqrt(gwb.sum(axis=1))`; i.e. the sum in quadrature of

 0422:         strain at each harmonic.

 0423: 

 0424:     """

 0425: 

 0426:     # Initialize sizes and shapes

+0427:     cdef int nfreqs = len(gwfobs)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_gwfobs); 
  __pyx_v_nfreqs = __pyx_t_1;

+0428:     cdef int n_mtot = len(mtot_log10)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_mtot_log10); 
  __pyx_v_n_mtot = __pyx_t_1;

+0429:     cdef int n_mrat = len(mrat)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_mrat); 
  __pyx_v_n_mrat = __pyx_t_1;

+0430:     cdef int n_redz = len(redz)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_redz); 
  __pyx_v_n_redz = __pyx_t_1;

+0431:     cdef int n_eccs = len(sepa_evo_in)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_sepa_evo_in); 
  __pyx_v_n_eccs = __pyx_t_1;

+0432:     cdef int num_freq_harm = nfreqs * nharms

  __pyx_v_num_freq_harm = (__pyx_v_nfreqs * __pyx_v_nharms);

+0433:     cdef (int *)shape = <int *>malloc(2 * sizeof(int))

  __pyx_v_shape = ((int *)malloc((2 * (sizeof(int)))));

+0434:     shape[0] = nfreqs

  (__pyx_v_shape[0]) = __pyx_v_nfreqs;

+0435:     shape[1] = nharms

  (__pyx_v_shape[1]) = __pyx_v_nharms;

 0436: 

 0437:     # Declare variables used later

 0438:     cdef int ii, nh, jj, kk, aa, bb, ff, ecc_idx, ecc_idx_beg, ii_mm, kk_zz

 0439:     cdef double m1, m2, mchirp, sa, qq, tau, num_pois

 0440:     cdef double gwfr, zterm, dc_cm, dc_mpc, dc_term, gne, hterm, number_term, number_term_pref

 0441:     cdef double weight_ik, weight, volume_ik, volume, four_over_nh_squared, sa_fourth

 0442:     cdef double fe_ecc, mt, mt_sqrt, nd, hterm_pref, frst_evo_lo, frst_evo_hi

 0443: 

 0444:     # Initialize constants

+0445:     cdef double four_pi_c_mpc = 4 * M_PI * (MY_SPLC / MY_MPC)

  __pyx_v_four_pi_c_mpc = ((4.0 * M_PI) * (__pyx_v_8holodeck_7cyutils_MY_SPLC / __pyx_v_8holodeck_7cyutils_MY_MPC));

+0446:     cdef double kep_sa_term = MY_NWTG / pow(2.0*M_PI, 2)

  __pyx_v_kep_sa_term = (__pyx_v_8holodeck_7cyutils_MY_NWTG / pow((2.0 * M_PI), 2.0));

+0447:     cdef double one_third = 1.0 / 3.0

  __pyx_v_one_third = (1.0 / 3.0);

+0448:     cdef double two_third = 2.0 / 3.0

  __pyx_v_two_third = (2.0 / 3.0);

+0449:     cdef double four_third = 4.0 / 3.0

  __pyx_v_four_third = (4.0 / 3.0);

+0450:     cdef double three_fifths = 3.0 / 5.0

  __pyx_v_three_fifths = (3.0 / 5.0);

+0451:     cdef double six_fifths = 6.0 / 5.0

  __pyx_v_six_fifths = (6.0 / 5.0);

 0452: 

 0453:     # Initialize arrays

+0454:     cdef np.ndarray[np.double_t, ndim=2] gwb = np.zeros((nfreqs, nharms))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_nfreqs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_nharms); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5);
  __pyx_t_3 = 0;
  __pyx_t_5 = 0;
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6);
  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 454, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 454, __pyx_L1_error)
  __pyx_t_7 = ((PyArrayObject *)__pyx_t_2);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer, (PyObject*)__pyx_t_7, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_gwb = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 454, __pyx_L1_error)
    } else {__pyx_pybuffernd_gwb.diminfo[0].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_gwb.diminfo[0].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_gwb.diminfo[1].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_gwb.diminfo[1].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_7 = 0;
  __pyx_v_gwb = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;

+0455:     cdef double *mtot = <double *>malloc(n_mtot * sizeof(double))

  __pyx_v_mtot = ((double *)malloc((__pyx_v_n_mtot * (sizeof(double)))));

+0456:     cdef double *ival = <double *>malloc(2 * sizeof(double))

  __pyx_v_ival = ((double *)malloc((2 * (sizeof(double)))));

+0457:     cdef double *jval = <double *>malloc(2 * sizeof(double))

  __pyx_v_jval = ((double *)malloc((2 * (sizeof(double)))));

+0458:     cdef double *kval = <double *>malloc(2 * sizeof(double))

  __pyx_v_kval = ((double *)malloc((2 * (sizeof(double)))));

+0459:     cdef double *sepa_evo = <double *>malloc(n_eccs * sizeof(double))

  __pyx_v_sepa_evo = ((double *)malloc((__pyx_v_n_eccs * (sizeof(double)))));

+0460:     cdef double *eccen_evo = <double *>malloc(n_eccs * sizeof(double))

  __pyx_v_eccen_evo = ((double *)malloc((__pyx_v_n_eccs * (sizeof(double)))));

+0461:     cdef double _freq_pref = (1.0/(2.0*M_PI)) * sqrt(MY_NWTG)

  __pyx_v__freq_pref = ((1.0 / (2.0 * M_PI)) * sqrt(__pyx_v_8holodeck_7cyutils_MY_NWTG));

+0462:     cdef double *frst_evo_pref = <double *>malloc(n_eccs * sizeof(double))

  __pyx_v_frst_evo_pref = ((double *)malloc((__pyx_v_n_eccs * (sizeof(double)))));

 0463:     # Convert from numpy arrays to c-arrays (for possible speed improvements)

+0464:     for ii in range(n_eccs):

  __pyx_t_8 = __pyx_v_n_eccs;
  __pyx_t_9 = __pyx_t_8;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
    __pyx_v_ii = __pyx_t_10;

+0465:         sepa_evo[ii] = <double>sepa_evo_in[ii]

    __pyx_t_11 = __pyx_v_ii;
    (__pyx_v_sepa_evo[__pyx_v_ii]) = ((double)(*((double *) ( /* dim=0 */ (__pyx_v_sepa_evo_in.data + __pyx_t_11 * __pyx_v_sepa_evo_in.strides[0]) ))));

+0466:         eccen_evo[ii] = <double>eccen_evo_in[ii]

    __pyx_t_11 = __pyx_v_ii;
    (__pyx_v_eccen_evo[__pyx_v_ii]) = ((double)(*((double *) ( /* dim=0 */ (__pyx_v_eccen_evo_in.data + __pyx_t_11 * __pyx_v_eccen_evo_in.strides[0]) ))));

 0467:         # calculate the prefactor (i.e. everything except the mass) for kepler's law

+0468:         frst_evo_pref[ii] = _freq_pref / pow(sepa_evo[ii], 1.5)

    (__pyx_v_frst_evo_pref[__pyx_v_ii]) = (__pyx_v__freq_pref / pow((__pyx_v_sepa_evo[__pyx_v_ii]), 1.5));
  }

 0469: 

 0470:     # Calculate all of the frequency harmonics (flattened) that are needed

+0471:     cdef (double *)freq_harms = <double *>malloc(num_freq_harm * sizeof(double))

  __pyx_v_freq_harms = ((double *)malloc((__pyx_v_num_freq_harm * (sizeof(double)))));

+0472:     for ii in range(num_freq_harm):

  __pyx_t_8 = __pyx_v_num_freq_harm;
  __pyx_t_9 = __pyx_t_8;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
    __pyx_v_ii = __pyx_t_10;

 0473:         # convert from 1D index to 2D grid of (F, H) frequencies and harmonics

+0474:         unravel(ii, shape, &aa, &bb)

    __pyx_f_8holodeck_7cyutils_unravel(__pyx_v_ii, __pyx_v_shape, (&__pyx_v_aa), (&__pyx_v_bb));

 0475:         # calculate the n = bb+1 harmonic

+0476:         freq_harms[ii] = gwfobs[aa] / (bb + 1)

    __pyx_t_11 = __pyx_v_aa;
    (__pyx_v_freq_harms[__pyx_v_ii]) = ((*((double *) ( /* dim=0 */ (__pyx_v_gwfobs.data + __pyx_t_11 * __pyx_v_gwfobs.strides[0]) ))) / ((double)(__pyx_v_bb + 1)));
  }

 0477: 

 0478:     # Find the indices by which to sort the frequency harmonics (flattened)

+0479:     cdef (int *)sorted_index = <int *>malloc(num_freq_harm * sizeof(int))

  __pyx_v_sorted_index = ((int *)malloc((__pyx_v_num_freq_harm * (sizeof(int)))));

+0480:     argsort(freq_harms, num_freq_harm, &sorted_index)

  __pyx_f_8holodeck_7cyutils_argsort(__pyx_v_freq_harms, __pyx_v_num_freq_harm, (&__pyx_v_sorted_index));

 0481: 

 0482:     # iterate over redshifts Z

+0483:     for kk in range(n_redz):

  __pyx_t_8 = __pyx_v_n_redz;
  __pyx_t_9 = __pyx_t_8;
  for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_9; __pyx_t_10+=1) {
    __pyx_v_kk = __pyx_t_10;

 0484:         # fill `kval` with the weight of this grid point (kval[0]), and the grid-width (kval[1])

+0485:         my_trapz_grid_weight(kk, n_redz, redz, kval)

    __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(__pyx_v_kk, __pyx_v_n_redz, __pyx_v_redz, __pyx_v_kval);

+0486:         zterm = (1.0 + redz[kk])

    __pyx_t_11 = __pyx_v_kk;
    __pyx_v_zterm = (1.0 + (*((double *) ( /* dim=0 */ (__pyx_v_redz.data + __pyx_t_11 * __pyx_v_redz.strides[0]) ))));

+0487:         dc_mpc = dcom[kk]   # this is still in units of [Mpc]

    __pyx_t_11 = __pyx_v_kk;
    __pyx_v_dc_mpc = (*((double *) ( /* dim=0 */ (__pyx_v_dcom.data + __pyx_t_11 * __pyx_v_dcom.strides[0]) )));

+0488:         dc_cm = dc_mpc * MY_MPC  # convert to [cm]

    __pyx_v_dc_cm = (__pyx_v_dc_mpc * __pyx_v_8holodeck_7cyutils_MY_MPC);

+0489:         dc_term = four_pi_c_mpc * pow(dc_mpc, 2)

    __pyx_v_dc_term = (__pyx_v_four_pi_c_mpc * pow(__pyx_v_dc_mpc, 2.0));

 0490: 

 0491:         # iterate over mtot M

+0492:         ecc_idx_beg = 0   # we will keep track of evolution/eccentricity indices for our target

    __pyx_v_ecc_idx_beg = 0;

 0493:                           # frequencies to make suring the arrays faster

 0494:         # iterate over total masses in reverse, so that's we're always going to increasing frequencies

+0495:         for ii_mm in range(n_mtot):

    __pyx_t_12 = __pyx_v_n_mtot;
    __pyx_t_13 = __pyx_t_12;
    for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
      __pyx_v_ii_mm = __pyx_t_14;

 0496:             # convert from forward to backward indices

+0497:             ii = n_mtot - 1 - ii_mm

      __pyx_v_ii = ((__pyx_v_n_mtot - 1) - __pyx_v_ii_mm);

 0498: 

 0499:             # convert from log10 to regular total masses, only the first time through the loop

+0500:             if kk == 0:

      __pyx_t_15 = ((__pyx_v_kk == 0) != 0);
      if (__pyx_t_15) {
/* … */
        goto __pyx_L11;
      }

+0501:                 mt = pow(10.0, mtot_log10[ii])

        __pyx_t_11 = __pyx_v_ii;
        __pyx_v_mt = pow(10.0, (*((double *) ( /* dim=0 */ (__pyx_v_mtot_log10.data + __pyx_t_11 * __pyx_v_mtot_log10.strides[0]) ))));

+0502:                 mtot[ii] = mt

        (__pyx_v_mtot[__pyx_v_ii]) = __pyx_v_mt;

 0503:             else:

+0504:                 mt = mtot[ii]

      /*else*/ {
        __pyx_v_mt = (__pyx_v_mtot[__pyx_v_ii]);
      }
      __pyx_L11:;

 0505: 

 0506:             # calculate some needed quantities

+0507:             mt_sqrt = sqrt(mt)

      __pyx_v_mt_sqrt = sqrt(__pyx_v_mt);

+0508:             kep_sa_mass_term = kep_sa_term * mt

      __pyx_v_kep_sa_mass_term = (__pyx_v_kep_sa_term * __pyx_v_mt);

 0509:             # fill `ival` with weight and grid-width in the mtot dimension

+0510:             my_trapz_grid_weight(ii, n_mtot, mtot_log10, ival)

      __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(__pyx_v_ii, __pyx_v_n_mtot, __pyx_v_mtot_log10, __pyx_v_ival);

 0511: 

 0512:             # precalculate some of the weighting factors over the 2D we have so far

+0513:             weight_ik = ival[1] * kval[1] / (ival[0] * kval[0])

      __pyx_v_weight_ik = (((__pyx_v_ival[1]) * (__pyx_v_kval[1])) / ((__pyx_v_ival[0]) * (__pyx_v_kval[0])));

 0514: 

 0515:             # iterate over mass ratios

+0516:             for jj in range(n_mrat):

      __pyx_t_16 = __pyx_v_n_mrat;
      __pyx_t_17 = __pyx_t_16;
      for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
        __pyx_v_jj = __pyx_t_18;

 0517:                 # fill `jval` with weight and grid-width in the mrat dimension

+0518:                 my_trapz_grid_weight(jj, n_mrat, mrat, jval)

        __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(__pyx_v_jj, __pyx_v_n_mrat, __pyx_v_mrat, __pyx_v_jval);

 0519:                 # calculate the weight factor for this grid-cell

 0520: 

+0521:                 weight = weight_ik * (jval[1] / jval[0])

        __pyx_v_weight = (__pyx_v_weight_ik * ((__pyx_v_jval[1]) / (__pyx_v_jval[0])));

 0522: 

 0523:                 # convert for mtot, mrat to m1, m2 s.t. m2 <= m1    [grams]

+0524:                 m1 = mt / (1.0 + mrat[jj])

        __pyx_t_11 = __pyx_v_jj;
        __pyx_v_m1 = (__pyx_v_mt / (1.0 + (*((double *) ( /* dim=0 */ (__pyx_v_mrat.data + __pyx_t_11 * __pyx_v_mrat.strides[0]) )))));

+0525:                 m2 = mt - m1

        __pyx_v_m2 = (__pyx_v_mt - __pyx_v_m1);

 0526:                 # calculate chirp-mass [grams]

+0527:                 mchirp = mt * pow(mrat[jj], three_fifths) / pow(1 + mrat[jj], six_fifths)

        __pyx_t_11 = __pyx_v_jj;
        __pyx_t_19 = __pyx_v_jj;
        __pyx_v_mchirp = ((__pyx_v_mt * pow((*((double *) ( /* dim=0 */ (__pyx_v_mrat.data + __pyx_t_11 * __pyx_v_mrat.strides[0]) ))), __pyx_v_three_fifths)) / pow((1.0 + (*((double *) ( /* dim=0 */ (__pyx_v_mrat.data + __pyx_t_19 * __pyx_v_mrat.strides[0]) )))), __pyx_v_six_fifths));

 0528: 

 0529:                 # n_c * (4*pi*c*d_c^2) * (1 + z)

+0530:                 hterm_pref = ndens[ii, jj, kk] * dc_term * zterm

        __pyx_t_19 = __pyx_v_ii;
        __pyx_t_11 = __pyx_v_jj;
        __pyx_t_20 = __pyx_v_kk;
        __pyx_v_hterm_pref = (((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ndens.data + __pyx_t_19 * __pyx_v_ndens.strides[0]) ) + __pyx_t_11 * __pyx_v_ndens.strides[1]) ) + __pyx_t_20 * __pyx_v_ndens.strides[2]) ))) * __pyx_v_dc_term) * __pyx_v_zterm);

 0531:                 # GW_SRC_CONST^2 * 2^(4/3) * Mc^(10/3) * dc^-2 * n_c * (4*pi*d_c^2) * (1 + z)

+0532:                 hterm_pref *= pow(GW_SRC_CONST * mchirp * pow(2.0*mchirp, two_third) / dc_cm, 2)

        __pyx_v_hterm_pref = (__pyx_v_hterm_pref * pow((((__pyx_v_8holodeck_7cyutils_GW_SRC_CONST * __pyx_v_mchirp) * pow((2.0 * __pyx_v_mchirp), __pyx_v_two_third)) / __pyx_v_dc_cm), 2.0));

 0533: 

+0534:                 ecc_idx = ecc_idx_beg

        __pyx_v_ecc_idx = __pyx_v_ecc_idx_beg;

+0535:                 for ff in range(num_freq_harm):

        __pyx_t_21 = __pyx_v_num_freq_harm;
        __pyx_t_22 = __pyx_t_21;
        for (__pyx_t_23 = 0; __pyx_t_23 < __pyx_t_22; __pyx_t_23+=1) {
          __pyx_v_ff = __pyx_t_23;

+0536:                     unravel(sorted_index[ff], shape, &aa, &bb)

          __pyx_f_8holodeck_7cyutils_unravel((__pyx_v_sorted_index[__pyx_v_ff]), __pyx_v_shape, (&__pyx_v_aa), (&__pyx_v_bb));

 0537: 

+0538:                     nh = bb + 1

          __pyx_v_nh = (__pyx_v_bb + 1);

+0539:                     four_over_nh_squared = 4.0 / (nh * nh)

          __pyx_v_four_over_nh_squared = (4.0 / ((double)(__pyx_v_nh * __pyx_v_nh)));

+0540:                     gwfr = gwfobs[aa] * zterm / nh

          __pyx_t_20 = __pyx_v_aa;
          __pyx_v_gwfr = (((*((double *) ( /* dim=0 */ (__pyx_v_gwfobs.data + __pyx_t_20 * __pyx_v_gwfobs.strides[0]) ))) * __pyx_v_zterm) / ((double)__pyx_v_nh));

 0541: 

 0542:                     # rest-frame frequency corresponding to target observer-frame frequency of GW observations

+0543:                     sa = pow(kep_sa_mass_term / pow(gwfr, 2), one_third)

          __pyx_v_sa = pow((__pyx_v_kep_sa_mass_term / pow(__pyx_v_gwfr, 2.0)), __pyx_v_one_third);

+0544:                     sa_fourth = pow(sa, 4)

          __pyx_v_sa_fourth = pow(__pyx_v_sa, 4.0);

 0545: 

 0546:                     # ---- Interpolate eccentricity to this frequency

 0547: 

 0548:                     # try to get `ecc_idx` such that   frst[idx] < gwfr < frst[idx+1]

+0549:                     frst_evo_lo = frst_evo_pref[ecc_idx] * mt_sqrt

          __pyx_v_frst_evo_lo = ((__pyx_v_frst_evo_pref[__pyx_v_ecc_idx]) * __pyx_v_mt_sqrt);

+0550:                     frst_evo_hi = frst_evo_pref[ecc_idx+1] * mt_sqrt

          __pyx_v_frst_evo_hi = ((__pyx_v_frst_evo_pref[(__pyx_v_ecc_idx + 1)]) * __pyx_v_mt_sqrt);

+0551:                     while (gwfr > frst_evo_hi) & (ecc_idx < n_eccs - 2):

          while (1) {
            __pyx_t_15 = (((__pyx_v_gwfr > __pyx_v_frst_evo_hi) & (__pyx_v_ecc_idx < (__pyx_v_n_eccs - 2))) != 0);
            if (!__pyx_t_15) break;

+0552:                         frst_evo_lo = frst_evo_hi

            __pyx_v_frst_evo_lo = __pyx_v_frst_evo_hi;

+0553:                         ecc_idx += 1

            __pyx_v_ecc_idx = (__pyx_v_ecc_idx + 1);

+0554:                         frst_evo_hi = frst_evo_pref[ecc_idx+1] * mt_sqrt

            __pyx_v_frst_evo_hi = ((__pyx_v_frst_evo_pref[(__pyx_v_ecc_idx + 1)]) * __pyx_v_mt_sqrt);
          }

 0555: 

+0556:                     if jj == 0 and ff == 0:

          __pyx_t_24 = ((__pyx_v_jj == 0) != 0);
          if (__pyx_t_24) {
          } else {
            __pyx_t_15 = __pyx_t_24;
            goto __pyx_L19_bool_binop_done;
          }
          __pyx_t_24 = ((__pyx_v_ff == 0) != 0);
          __pyx_t_15 = __pyx_t_24;
          __pyx_L19_bool_binop_done:;
          if (__pyx_t_15) {
/* … */
          }

+0557:                         ecc_idx_beg = ecc_idx

            __pyx_v_ecc_idx_beg = __pyx_v_ecc_idx;

 0558: 

 0559:                     # if `gwfr` is lower than lowest evolution point, continue to next frequency

+0560:                     if (gwfr < frst_evo_lo):

          __pyx_t_15 = ((__pyx_v_gwfr < __pyx_v_frst_evo_lo) != 0);
          if (__pyx_t_15) {
/* … */
          }

+0561:                         continue

            goto __pyx_L14_continue;

 0562: 

 0563:                     # if `gwfr` is > highest evolution point, also be true for all following frequencies, so break

+0564:                     if (gwfr > frst_evo_hi):

          __pyx_t_15 = ((__pyx_v_gwfr > __pyx_v_frst_evo_hi) != 0);
          if (__pyx_t_15) {
/* … */
          }

+0565:                         break

            goto __pyx_L15_break;

 0566: 

 0567:                     # calculate slope M

+0568:                     ecc = ((eccen_evo[ecc_idx+1] - eccen_evo[ecc_idx])/(frst_evo_hi - frst_evo_lo))

          __pyx_v_ecc = (((__pyx_v_eccen_evo[(__pyx_v_ecc_idx + 1)]) - (__pyx_v_eccen_evo[__pyx_v_ecc_idx])) / (__pyx_v_frst_evo_hi - __pyx_v_frst_evo_lo));

 0569:                     # y = y_0 + M * dx

+0570:                     ecc = eccen_evo[ecc_idx] + (gwfr - frst_evo_lo) * ecc

          __pyx_v_ecc = ((__pyx_v_eccen_evo[__pyx_v_ecc_idx]) + ((__pyx_v_gwfr - __pyx_v_frst_evo_lo) * __pyx_v_ecc));

 0571: 

 0572:                     # ---- Calculate GWB contribution with this eccentricity

 0573: 

+0574:                     gne = gw_freq_dist_func__scalar_scalar(nh, ecc)

          __pyx_v_gne = __pyx_f_8holodeck_7cyutils_gw_freq_dist_func__scalar_scalar(__pyx_v_nh, __pyx_v_ecc);

 0575: 

+0576:                     fe_ecc = _gw_ecc_func(ecc)

          __pyx_v_fe_ecc = __pyx_f_8holodeck_7cyutils__gw_ecc_func(__pyx_v_ecc);

 0577:                     # da/dt values are negative, convert to a positive timescale

+0578:                     tau = - sa_fourth / (GW_DADT_SEP_CONST * fe_ecc * m1 * m2 * mt)

          __pyx_v_tau = ((-__pyx_v_sa_fourth) / ((((__pyx_v_8holodeck_7cyutils_GW_DADT_SEP_CONST * __pyx_v_fe_ecc) * __pyx_v_m1) * __pyx_v_m2) * __pyx_v_mt));

 0579: 

 0580:                     # Calculate the GW spectral strain at each harmonic

 0581:                     #    see: [Amaro-seoane+2010 Eq.9]

 0582:                     # GW_SRC_CONST^2 * 2^(4/3) * Mc^(10/3) * dc^-2 * n_c * (4*pi*c*d_c^2) * (1 + z)

 0583:                     #     tau * gne * (2/n)^2 * forb_r^(4/3)

+0584:                     hterm = hterm_pref * tau * gne * four_over_nh_squared * pow(gwfr, four_third)

          __pyx_v_hterm = ((((__pyx_v_hterm_pref * __pyx_v_tau) * __pyx_v_gne) * __pyx_v_four_over_nh_squared) * pow(__pyx_v_gwfr, __pyx_v_four_third));

+0585:                     gwb[aa, bb] += hterm * weight

          __pyx_t_20 = __pyx_v_aa;
          __pyx_t_11 = __pyx_v_bb;
          *__Pyx_BufPtrStrided2d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf, __pyx_t_20, __pyx_pybuffernd_gwb.diminfo[0].strides, __pyx_t_11, __pyx_pybuffernd_gwb.diminfo[1].strides) += (__pyx_v_hterm * __pyx_v_weight);
          __pyx_L14_continue:;
        }
        __pyx_L15_break:;
      }
    }
  }

 0586: 

+0587:     free(shape)

  free(__pyx_v_shape);

+0588:     free(sepa_evo)

  free(__pyx_v_sepa_evo);

+0589:     free(eccen_evo)

  free(__pyx_v_eccen_evo);

+0590:     free(frst_evo_pref)

  free(__pyx_v_frst_evo_pref);

+0591:     free(freq_harms)

  free(__pyx_v_freq_harms);

+0592:     free(sorted_index)

  free(__pyx_v_sorted_index);

+0593:     free(mtot)

  free(__pyx_v_mtot);

+0594:     free(ival)

  free(__pyx_v_ival);

+0595:     free(jval)

  free(__pyx_v_jval);

+0596:     free(kval)

  free(__pyx_v_kval);

+0597:     return gwb

  __pyx_t_25 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_gwb), PyBUF_WRITABLE); if (unlikely(!__pyx_t_25.memview)) __PYX_ERR(0, 597, __pyx_L1_error)
  __pyx_r = __pyx_t_25;
  __pyx_t_25.memview = NULL;
  __pyx_t_25.data = NULL;
  goto __pyx_L0;

 0598: 

 0599: 

+0600: def sam_calc_gwb_single_eccen_discrete(ndens, mtot_log10, mrat, redz, dcom, gwfobs, sepa_evo, eccen_evo, nharms, nreals):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_3sam_calc_gwb_single_eccen_discrete(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_2sam_calc_gwb_single_eccen_discrete[] = "Pure-python wrapper for the SAM eccentric GWB calculation method.  See: `_sam_calc_gwb_single_eccen()`.\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_3sam_calc_gwb_single_eccen_discrete = {"sam_calc_gwb_single_eccen_discrete", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_3sam_calc_gwb_single_eccen_discrete, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_2sam_calc_gwb_single_eccen_discrete};
static PyObject *__pyx_pw_8holodeck_7cyutils_3sam_calc_gwb_single_eccen_discrete(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_ndens = 0;
  PyObject *__pyx_v_mtot_log10 = 0;
  PyObject *__pyx_v_mrat = 0;
  PyObject *__pyx_v_redz = 0;
  PyObject *__pyx_v_dcom = 0;
  PyObject *__pyx_v_gwfobs = 0;
  PyObject *__pyx_v_sepa_evo = 0;
  PyObject *__pyx_v_eccen_evo = 0;
  PyObject *__pyx_v_nharms = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sam_calc_gwb_single_eccen_discrete (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ndens,&__pyx_n_s_mtot_log10,&__pyx_n_s_mrat,&__pyx_n_s_redz,&__pyx_n_s_dcom,&__pyx_n_s_gwfobs,&__pyx_n_s_sepa_evo,&__pyx_n_s_eccen_evo,&__pyx_n_s_nharms,&__pyx_n_s_nreals,0};
    PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        CYTHON_FALLTHROUGH;
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ndens)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mtot_log10)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 1); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mrat)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 2); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_redz)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 3); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dcom)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 4); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gwfobs)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 5); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sepa_evo)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 6); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_eccen_evo)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 7); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nharms)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 8); __PYX_ERR(0, 600, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  9:
        if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, 9); __PYX_ERR(0, 600, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sam_calc_gwb_single_eccen_discrete") < 0)) __PYX_ERR(0, 600, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 10) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
      values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
      values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
    }
    __pyx_v_ndens = values[0];
    __pyx_v_mtot_log10 = values[1];
    __pyx_v_mrat = values[2];
    __pyx_v_redz = values[3];
    __pyx_v_dcom = values[4];
    __pyx_v_gwfobs = values[5];
    __pyx_v_sepa_evo = values[6];
    __pyx_v_eccen_evo = values[7];
    __pyx_v_nharms = values[8];
    __pyx_v_nreals = values[9];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("sam_calc_gwb_single_eccen_discrete", 1, 10, 10, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 600, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.sam_calc_gwb_single_eccen_discrete", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_2sam_calc_gwb_single_eccen_discrete(__pyx_self, __pyx_v_ndens, __pyx_v_mtot_log10, __pyx_v_mrat, __pyx_v_redz, __pyx_v_dcom, __pyx_v_gwfobs, __pyx_v_sepa_evo, __pyx_v_eccen_evo, __pyx_v_nharms, __pyx_v_nreals);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_2sam_calc_gwb_single_eccen_discrete(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ndens, PyObject *__pyx_v_mtot_log10, PyObject *__pyx_v_mrat, PyObject *__pyx_v_redz, PyObject *__pyx_v_dcom, PyObject *__pyx_v_gwfobs, PyObject *__pyx_v_sepa_evo, PyObject *__pyx_v_eccen_evo, PyObject *__pyx_v_nharms, PyObject *__pyx_v_nreals) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sam_calc_gwb_single_eccen_discrete", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __PYX_XDEC_MEMVIEW(&__pyx_t_1, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_4, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __Pyx_XDECREF(__pyx_t_12);
  __Pyx_AddTraceback("holodeck.cyutils.sam_calc_gwb_single_eccen_discrete", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__28 = PyTuple_Pack(10, __pyx_n_s_ndens, __pyx_n_s_mtot_log10, __pyx_n_s_mrat, __pyx_n_s_redz, __pyx_n_s_dcom, __pyx_n_s_gwfobs, __pyx_n_s_sepa_evo, __pyx_n_s_eccen_evo, __pyx_n_s_nharms, __pyx_n_s_nreals); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(0, 600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__28);
  __Pyx_GIVEREF(__pyx_tuple__28);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_3sam_calc_gwb_single_eccen_discrete, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sam_calc_gwb_single_eccen_discre, __pyx_t_3) < 0) __PYX_ERR(0, 600, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(10, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__28, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_sam_calc_gwb_single_eccen_discre, 600, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(0, 600, __pyx_L1_error)

 0601:     """Pure-python wrapper for the SAM eccentric GWB calculation method.  See: `_sam_calc_gwb_single_eccen()`.

 0602:     """

+0603:     return _sam_calc_gwb_single_eccen_discrete(ndens, mtot_log10, mrat, redz, dcom, gwfobs, sepa_evo, eccen_evo, nharms, nreals)

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_v_ndens, PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mtot_log10, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mrat, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_redz, PyBUF_WRITABLE); if (unlikely(!__pyx_t_4.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_dcom, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_gwfobs, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_sepa_evo, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_eccen_evo, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_v_nharms); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_v_nreals); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 603, __pyx_L1_error)
  __pyx_t_11 = __pyx_f_8holodeck_7cyutils__sam_calc_gwb_single_eccen_discrete(__pyx_t_1, __pyx_t_2, __pyx_t_3, __pyx_t_4, __pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 603, __pyx_L1_error)
  __PYX_XDEC_MEMVIEW(&__pyx_t_1, 1);
  __pyx_t_1.memview = NULL;
  __pyx_t_1.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_2, 1);
  __pyx_t_2.memview = NULL;
  __pyx_t_2.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_3, 1);
  __pyx_t_3.memview = NULL;
  __pyx_t_3.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_4, 1);
  __pyx_t_4.memview = NULL;
  __pyx_t_4.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;
  __pyx_t_12 = __pyx_memoryview_fromslice(__pyx_t_11, 3, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_12);
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __pyx_t_11.memview = NULL;
  __pyx_t_11.data = NULL;
  __pyx_r = __pyx_t_12;
  __pyx_t_12 = 0;
  goto __pyx_L0;

 0604: 

 0605: @cython.boundscheck(False)

 0606: @cython.wraparound(False)

 0607: @cython.nonecheck(False)

 0608: @cython.cdivision(True)

+0609: cdef double[:, :, :] _sam_calc_gwb_single_eccen_discrete(

static __Pyx_memviewslice __pyx_f_8holodeck_7cyutils__sam_calc_gwb_single_eccen_discrete(__Pyx_memviewslice __pyx_v_ndens, __Pyx_memviewslice __pyx_v_mtot_log10, __Pyx_memviewslice __pyx_v_mrat, __Pyx_memviewslice __pyx_v_redz, __Pyx_memviewslice __pyx_v_dcom, __Pyx_memviewslice __pyx_v_gwfobs, __Pyx_memviewslice __pyx_v_sepa_evo_in, __Pyx_memviewslice __pyx_v_eccen_evo_in, int __pyx_v_nharms, int __pyx_v_nreals) {
  int __pyx_v_nfreqs;
  int __pyx_v_n_mtot;
  int __pyx_v_n_mrat;
  int __pyx_v_n_redz;
  int __pyx_v_n_eccs;
  int __pyx_v_num_freq_harm;
  int *__pyx_v_shape;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  int __pyx_v_ii;
  int __pyx_v_nh;
  int __pyx_v_jj;
  int __pyx_v_kk;
  int __pyx_v_aa;
  int __pyx_v_bb;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_ecc_idx;
  int __pyx_v_ecc_idx_beg;
  int __pyx_v_ii_mm;
  double __pyx_v_m1;
  double __pyx_v_m2;
  double __pyx_v_mchirp;
  double __pyx_v_sa;
  double __pyx_v_tau;
  double __pyx_v_gwfr;
  double __pyx_v_zterm;
  double __pyx_v_dc_cm;
  double __pyx_v_dc_mpc;
  double __pyx_v_dc_term;
  double __pyx_v_gne;
  double __pyx_v_hterm;
  double __pyx_v_number_term;
  double __pyx_v_weight_ik;
  double __pyx_v_weight;
  double __pyx_v_four_over_nh_squared;
  double __pyx_v_sa_fourth;
  double __pyx_v_fe_ecc;
  double __pyx_v_mt;
  double __pyx_v_mt_sqrt;
  double __pyx_v_hterm_pref;
  double __pyx_v_frst_evo_lo;
  double __pyx_v_frst_evo_hi;
  double __pyx_v_four_pi_c_mpc;
  double __pyx_v_kep_sa_term;
  double __pyx_v_one_third;
  double __pyx_v_two_third;
  double __pyx_v_four_third;
  double __pyx_v_three_fifths;
  double __pyx_v_six_fifths;
  PyArrayObject *__pyx_v_gwb = 0;
  double *__pyx_v_mtot;
  double *__pyx_v_ival;
  double *__pyx_v_jval;
  double *__pyx_v_kval;
  double *__pyx_v_sepa_evo;
  double *__pyx_v_eccen_evo;
  double __pyx_v__freq_pref;
  double *__pyx_v_frst_evo_pref;
  double *__pyx_v_freq_harms;
  int *__pyx_v_sorted_index;
  double __pyx_v_kep_sa_mass_term;
  double __pyx_v_volume_ik;
  double __pyx_v_volume;
  PyObject *__pyx_v_number_term_pref = NULL;
  double __pyx_v_ecc;
  double __pyx_v_num_pois;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_gwb;
  __Pyx_Buffer __pyx_pybuffer_gwb;
  __Pyx_memviewslice __pyx_r = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_sam_calc_gwb_single_eccen_discrete", 0);
  __pyx_pybuffer_gwb.pybuffer.buf = NULL;
  __pyx_pybuffer_gwb.refcount = 0;
  __pyx_pybuffernd_gwb.data = NULL;
  __pyx_pybuffernd_gwb.rcbuffer = &__pyx_pybuffer_gwb;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __Pyx_XDECREF(__pyx_t_8);
  __PYX_XDEC_MEMVIEW(&__pyx_t_31, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __pyx_r.data = NULL;
  __pyx_r.memview = NULL;
  __Pyx_AddTraceback("holodeck.cyutils._sam_calc_gwb_single_eccen_discrete", __pyx_clineno, __pyx_lineno, __pyx_filename);
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer);
  if (unlikely(!__pyx_r.memview)) {
    PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");
  }
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_XDECREF((PyObject *)__pyx_v_gwb);
  __Pyx_XDECREF(__pyx_v_number_term_pref);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0610:     double[:, :, :] ndens,

 0611:     double[:] mtot_log10,

 0612:     double[:] mrat,

 0613:     double[:] redz,

 0614:     double[:] dcom,

 0615:     double[:] gwfobs,

 0616:     double[:] sepa_evo_in,

 0617:     double[:] eccen_evo_in,

 0618:     int nharms,

 0619:     int nreals

 0620: ):

 0621:     """Calculate the GWB from an eccentric SAM evolution model.

 0622: 

 0623:     This function uses the precomputed binary-evolution of eccentricities over some range of separations.

 0624:     This assumes a single eccentricity evolution e(a) for all binaries.

 0625:     Redshifts are assumed to stay constant during this evolution.

 0626: 

 0627:     Parameters

 0628:     ----------

 0629:     ndens : (double ***)

 0630:         3D array specifying the SAM number-density of binaries in each bin, in total-mass, mass-ratio, and redshift.

 0631:         This is typically `sam.static_binary_density`, corresponding to 'd^3 n / [dlog10M dq dz]' in units of [Mpc^-3].

 0632:     mtot_log10 : (double *)

 0633:         Array of log10 values of the total-mass (in grams) grid edges in the SAM model.  i.e. `log10(sam.mtot)`.

 0634:     mrat : (double *)

 0635:         Array of mass-ratio grid edges in the SAM model.  i.e. `sam.mrat`.

 0636:     redz : (double *)

 0637:         Array of values for the redshift grid edges in the SAM model.  i.e. `sam.redz`.

 0638:     dcom : (double *)

 0639:         Comoving distances in units of [Mpc] corresponding to each `redz` value.

 0640:     gwfobs : (double *)

 0641:         Array of GW observer-frame frequencies at which to evaluate the GWB.

 0642:     sepa_evo_in : (double *)

 0643:         The values of binary separation in units of [cm] at which the binaries have been evolved.

 0644:     eccen_evo_in : (double *)

 0645:         The values of binary eccentricity at each separation at which the binaries have been evolved.

 0646:     nharms : int,

 0647:         Number of harmonics at which to calculate GW strains.

 0648: 

 0649:     Returns

 0650:     -------

 0651:     gwb : (double **)

 0652:         2D array giving the characteristic-strain _squared_, at each observer-frame frequency and each harmonic.

 0653:         Shape is (nfreqs, nharms), where `nfreqs` is the length of the `gwfobs` parameters, and `nharms` is given

 0654:         as an input parameter directly.

 0655:         The characteristic strain spectrum, h_c(f) is then `np.sqrt(gwb.sum(axis=1))`; i.e. the sum in quadrature of

 0656:         strain at each harmonic.

 0657: 

 0658:     """

 0659: 

 0660:     # Initialize sizes and shapes

+0661:     cdef int nfreqs = len(gwfobs)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_gwfobs); 
  __pyx_v_nfreqs = __pyx_t_1;

+0662:     cdef int n_mtot = len(mtot_log10)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_mtot_log10); 
  __pyx_v_n_mtot = __pyx_t_1;

+0663:     cdef int n_mrat = len(mrat)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_mrat); 
  __pyx_v_n_mrat = __pyx_t_1;

+0664:     cdef int n_redz = len(redz)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_redz); 
  __pyx_v_n_redz = __pyx_t_1;

+0665:     cdef int n_eccs = len(sepa_evo_in)

  __pyx_t_1 = __Pyx_MemoryView_Len(__pyx_v_sepa_evo_in); 
  __pyx_v_n_eccs = __pyx_t_1;

+0666:     cdef int num_freq_harm = nfreqs * nharms

  __pyx_v_num_freq_harm = (__pyx_v_nfreqs * __pyx_v_nharms);

+0667:     cdef (int *)shape = <int *>malloc(2 * sizeof(int))

  __pyx_v_shape = ((int *)malloc((2 * (sizeof(int)))));

+0668:     shape[0] = nfreqs

  (__pyx_v_shape[0]) = __pyx_v_nfreqs;

+0669:     shape[1] = nharms

  (__pyx_v_shape[1]) = __pyx_v_nharms;

 0670: 

 0671:     # Setup random number generator from numpy library

 0672:     cdef bitgen_t *rng

+0673:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+0674:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_capsule); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 674, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_capsule = __pyx_t_3;
  __pyx_t_3 = 0;

 0675:     # Cast the pointer

+0676:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_5 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 676, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_5);

 0677: 

 0678:     # Declare variables used later

 0679:     cdef int ii, nh, jj, kk, aa, bb, ff, rr, ecc_idx, ecc_idx_beg, ii_mm, kk_zz

 0680:     cdef double m1, m2, mchirp, sa, qq, tau

 0681:     cdef double gwfr, zterm, dc_cm, dc_mpc, dc_term, gne, hterm, number_term

 0682:     cdef double weight_ik, weight, four_over_nh_squared, sa_fourth

 0683:     cdef double fe_ecc, mt, mt_sqrt, nd, hterm_pref, frst_evo_lo, frst_evo_hi

 0684: 

 0685:     # Initialize constants

+0686:     cdef double four_pi_c_mpc = 4 * M_PI * (MY_SPLC / MY_MPC)

  __pyx_v_four_pi_c_mpc = ((4.0 * M_PI) * (__pyx_v_8holodeck_7cyutils_MY_SPLC / __pyx_v_8holodeck_7cyutils_MY_MPC));

+0687:     cdef double kep_sa_term = MY_NWTG / pow(2.0*M_PI, 2)

  __pyx_v_kep_sa_term = (__pyx_v_8holodeck_7cyutils_MY_NWTG / pow((2.0 * M_PI), 2.0));

+0688:     cdef double one_third = 1.0 / 3.0

  __pyx_v_one_third = (1.0 / 3.0);

+0689:     cdef double two_third = 2.0 / 3.0

  __pyx_v_two_third = (2.0 / 3.0);

+0690:     cdef double four_third = 4.0 / 3.0

  __pyx_v_four_third = (4.0 / 3.0);

+0691:     cdef double three_fifths = 3.0 / 5.0

  __pyx_v_three_fifths = (3.0 / 5.0);

+0692:     cdef double six_fifths = 6.0 / 5.0

  __pyx_v_six_fifths = (6.0 / 5.0);

 0693: 

 0694:     # Initialize arrays

+0695:     cdef np.ndarray[np.double_t, ndim=3] gwb = np.zeros((nfreqs, nharms, nreals))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_nfreqs); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nharms); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_nreals); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_8);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6);
  __Pyx_GIVEREF(__pyx_t_7);
  PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7);
  __pyx_t_2 = 0;
  __pyx_t_6 = 0;
  __pyx_t_7 = 0;
  __pyx_t_7 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_3 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_7, __pyx_t_8) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_8);
  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
  __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 695, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_3);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_gwb = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 695, __pyx_L1_error)
    } else {__pyx_pybuffernd_gwb.diminfo[0].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_gwb.diminfo[0].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_gwb.diminfo[1].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_gwb.diminfo[1].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_gwb.diminfo[2].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_gwb.diminfo[2].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_gwb = ((PyArrayObject *)__pyx_t_3);
  __pyx_t_3 = 0;

+0696:     cdef double *mtot = <double *>malloc(n_mtot * sizeof(double))

  __pyx_v_mtot = ((double *)malloc((__pyx_v_n_mtot * (sizeof(double)))));

+0697:     cdef double *ival = <double *>malloc(2 * sizeof(double))

  __pyx_v_ival = ((double *)malloc((2 * (sizeof(double)))));

+0698:     cdef double *jval = <double *>malloc(2 * sizeof(double))

  __pyx_v_jval = ((double *)malloc((2 * (sizeof(double)))));

+0699:     cdef double *kval = <double *>malloc(2 * sizeof(double))

  __pyx_v_kval = ((double *)malloc((2 * (sizeof(double)))));

+0700:     cdef double *sepa_evo = <double *>malloc(n_eccs * sizeof(double))

  __pyx_v_sepa_evo = ((double *)malloc((__pyx_v_n_eccs * (sizeof(double)))));

+0701:     cdef double *eccen_evo = <double *>malloc(n_eccs * sizeof(double))

  __pyx_v_eccen_evo = ((double *)malloc((__pyx_v_n_eccs * (sizeof(double)))));

+0702:     cdef double _freq_pref = (1.0/(2.0*M_PI)) * sqrt(MY_NWTG)

  __pyx_v__freq_pref = ((1.0 / (2.0 * M_PI)) * sqrt(__pyx_v_8holodeck_7cyutils_MY_NWTG));

+0703:     cdef double *frst_evo_pref = <double *>malloc(n_eccs * sizeof(double))

  __pyx_v_frst_evo_pref = ((double *)malloc((__pyx_v_n_eccs * (sizeof(double)))));

 0704:     # Convert from numpy arrays to c-arrays (for possible speed improvements)

+0705:     for ii in range(n_eccs):

  __pyx_t_10 = __pyx_v_n_eccs;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_ii = __pyx_t_12;

+0706:         sepa_evo[ii] = <double>sepa_evo_in[ii]

    __pyx_t_13 = __pyx_v_ii;
    (__pyx_v_sepa_evo[__pyx_v_ii]) = ((double)(*((double *) ( /* dim=0 */ (__pyx_v_sepa_evo_in.data + __pyx_t_13 * __pyx_v_sepa_evo_in.strides[0]) ))));

+0707:         eccen_evo[ii] = <double>eccen_evo_in[ii]

    __pyx_t_13 = __pyx_v_ii;
    (__pyx_v_eccen_evo[__pyx_v_ii]) = ((double)(*((double *) ( /* dim=0 */ (__pyx_v_eccen_evo_in.data + __pyx_t_13 * __pyx_v_eccen_evo_in.strides[0]) ))));

 0708:         # calculate the prefactor (i.e. everything except the mass) for kepler's law

+0709:         frst_evo_pref[ii] = _freq_pref / pow(sepa_evo[ii], 1.5)

    (__pyx_v_frst_evo_pref[__pyx_v_ii]) = (__pyx_v__freq_pref / pow((__pyx_v_sepa_evo[__pyx_v_ii]), 1.5));
  }

 0710: 

 0711:     # Calculate all of the frequency harmonics (flattened) that are needed

+0712:     cdef (double *)freq_harms = <double *>malloc(num_freq_harm * sizeof(double))

  __pyx_v_freq_harms = ((double *)malloc((__pyx_v_num_freq_harm * (sizeof(double)))));

+0713:     for ii in range(num_freq_harm):

  __pyx_t_10 = __pyx_v_num_freq_harm;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_ii = __pyx_t_12;

 0714:         # convert from 1D index to 2D grid of (F, H) frequencies and harmonics

+0715:         unravel(ii, shape, &aa, &bb)

    __pyx_f_8holodeck_7cyutils_unravel(__pyx_v_ii, __pyx_v_shape, (&__pyx_v_aa), (&__pyx_v_bb));

 0716:         # calculate the n = bb+1 harmonic

+0717:         freq_harms[ii] = gwfobs[aa] / (bb + 1)

    __pyx_t_13 = __pyx_v_aa;
    (__pyx_v_freq_harms[__pyx_v_ii]) = ((*((double *) ( /* dim=0 */ (__pyx_v_gwfobs.data + __pyx_t_13 * __pyx_v_gwfobs.strides[0]) ))) / ((double)(__pyx_v_bb + 1)));
  }

 0718: 

 0719:     # Find the indices by which to sort the frequency harmonics (flattened)

+0720:     cdef (int *)sorted_index = <int *>malloc(num_freq_harm * sizeof(int))

  __pyx_v_sorted_index = ((int *)malloc((__pyx_v_num_freq_harm * (sizeof(int)))));

+0721:     argsort(freq_harms, num_freq_harm, &sorted_index)

  __pyx_f_8holodeck_7cyutils_argsort(__pyx_v_freq_harms, __pyx_v_num_freq_harm, (&__pyx_v_sorted_index));

 0722: 

 0723:     # iterate over redshifts Z

+0724:     for kk in range(n_redz):

  __pyx_t_10 = __pyx_v_n_redz;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_kk = __pyx_t_12;

 0725:         # fill `kval` with the weight of this grid point (kval[0]), and the grid-width (kval[1])

+0726:         my_trapz_grid_weight(kk, n_redz, redz, kval)

    __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(__pyx_v_kk, __pyx_v_n_redz, __pyx_v_redz, __pyx_v_kval);

+0727:         zterm = (1.0 + redz[kk])

    __pyx_t_13 = __pyx_v_kk;
    __pyx_v_zterm = (1.0 + (*((double *) ( /* dim=0 */ (__pyx_v_redz.data + __pyx_t_13 * __pyx_v_redz.strides[0]) ))));

+0728:         dc_mpc = dcom[kk]   # this is still in units of [Mpc]

    __pyx_t_13 = __pyx_v_kk;
    __pyx_v_dc_mpc = (*((double *) ( /* dim=0 */ (__pyx_v_dcom.data + __pyx_t_13 * __pyx_v_dcom.strides[0]) )));

+0729:         dc_cm = dc_mpc * MY_MPC  # convert to [cm]

    __pyx_v_dc_cm = (__pyx_v_dc_mpc * __pyx_v_8holodeck_7cyutils_MY_MPC);

+0730:         dc_term = four_pi_c_mpc * pow(dc_mpc, 2)

    __pyx_v_dc_term = (__pyx_v_four_pi_c_mpc * pow(__pyx_v_dc_mpc, 2.0));

 0731: 

 0732:         # iterate over mtot M

+0733:         ecc_idx_beg = 0   # we will keep track of evolution/eccentricity indices for our target

    __pyx_v_ecc_idx_beg = 0;

 0734:                           # frequencies to make suring the arrays faster

 0735:         # iterate over total masses in reverse, so that's we're always going to increasing frequencies

+0736:         for ii_mm in range(n_mtot):

    __pyx_t_14 = __pyx_v_n_mtot;
    __pyx_t_15 = __pyx_t_14;
    for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
      __pyx_v_ii_mm = __pyx_t_16;

 0737:             # convert from forward to backward indices

+0738:             ii = n_mtot - 1 - ii_mm

      __pyx_v_ii = ((__pyx_v_n_mtot - 1) - __pyx_v_ii_mm);

 0739: 

 0740:             # convert from log10 to regular total masses, only the first time through the loop

+0741:             if kk == 0:

      __pyx_t_17 = ((__pyx_v_kk == 0) != 0);
      if (__pyx_t_17) {
/* … */
        goto __pyx_L11;
      }

+0742:                 mt = pow(10.0, mtot_log10[ii])

        __pyx_t_13 = __pyx_v_ii;
        __pyx_v_mt = pow(10.0, (*((double *) ( /* dim=0 */ (__pyx_v_mtot_log10.data + __pyx_t_13 * __pyx_v_mtot_log10.strides[0]) ))));

+0743:                 mtot[ii] = mt

        (__pyx_v_mtot[__pyx_v_ii]) = __pyx_v_mt;

 0744:             else:

+0745:                 mt = mtot[ii]

      /*else*/ {
        __pyx_v_mt = (__pyx_v_mtot[__pyx_v_ii]);
      }
      __pyx_L11:;

 0746: 

 0747:             # calculate some needed quantities

+0748:             mt_sqrt = sqrt(mt)

      __pyx_v_mt_sqrt = sqrt(__pyx_v_mt);

+0749:             kep_sa_mass_term = kep_sa_term * mt

      __pyx_v_kep_sa_mass_term = (__pyx_v_kep_sa_term * __pyx_v_mt);

 0750:             # fill `ival` with weight and grid-width in the mtot dimension

+0751:             my_trapz_grid_weight(ii, n_mtot, mtot_log10, ival)

      __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(__pyx_v_ii, __pyx_v_n_mtot, __pyx_v_mtot_log10, __pyx_v_ival);

 0752: 

 0753:             # precalculate some of the weighting factors over the 2D we have so far

+0754:             volume_ik = ival[1] * kval[1]

      __pyx_v_volume_ik = ((__pyx_v_ival[1]) * (__pyx_v_kval[1]));

+0755:             weight_ik = ival[0] * kval[0]

      __pyx_v_weight_ik = ((__pyx_v_ival[0]) * (__pyx_v_kval[0]));

 0756: 

 0757:             # iterate over mass ratios

+0758:             for jj in range(n_mrat):

      __pyx_t_18 = __pyx_v_n_mrat;
      __pyx_t_19 = __pyx_t_18;
      for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
        __pyx_v_jj = __pyx_t_20;

 0759:                 # fill `jval` with weight and grid-width in the mrat dimension

+0760:                 my_trapz_grid_weight(jj, n_mrat, mrat, jval)

        __pyx_f_8holodeck_7cyutils_my_trapz_grid_weight(__pyx_v_jj, __pyx_v_n_mrat, __pyx_v_mrat, __pyx_v_jval);

 0761:                 # calculate the weight factor for this grid-cell

 0762:                 # weight = weight_ik * (jval[1] / jval[0])

 0763: 

+0764:                 volume = volume_ik * jval[1]

        __pyx_v_volume = (__pyx_v_volume_ik * (__pyx_v_jval[1]));

+0765:                 weight = weight_ik * jval[0]

        __pyx_v_weight = (__pyx_v_weight_ik * (__pyx_v_jval[0]));

 0766: 

 0767:                 # convert for mtot, mrat to m1, m2 s.t. m2 <= m1    [grams]

+0768:                 m1 = mt / (1.0 + mrat[jj])

        __pyx_t_13 = __pyx_v_jj;
        __pyx_v_m1 = (__pyx_v_mt / (1.0 + (*((double *) ( /* dim=0 */ (__pyx_v_mrat.data + __pyx_t_13 * __pyx_v_mrat.strides[0]) )))));

+0769:                 m2 = mt - m1

        __pyx_v_m2 = (__pyx_v_mt - __pyx_v_m1);

 0770:                 # calculate chirp-mass [grams]

+0771:                 mchirp = mt * pow(mrat[jj], three_fifths) / pow(1 + mrat[jj], six_fifths)

        __pyx_t_13 = __pyx_v_jj;
        __pyx_t_21 = __pyx_v_jj;
        __pyx_v_mchirp = ((__pyx_v_mt * pow((*((double *) ( /* dim=0 */ (__pyx_v_mrat.data + __pyx_t_13 * __pyx_v_mrat.strides[0]) ))), __pyx_v_three_fifths)) / pow((1.0 + (*((double *) ( /* dim=0 */ (__pyx_v_mrat.data + __pyx_t_21 * __pyx_v_mrat.strides[0]) )))), __pyx_v_six_fifths));

 0772: 

 0773:                 # n_c * (4*pi*c*d_c^2) * (1 + z)

+0774:                 number_term_pref = ndens[ii, jj, kk] * dc_term * zterm

        __pyx_t_21 = __pyx_v_ii;
        __pyx_t_13 = __pyx_v_jj;
        __pyx_t_22 = __pyx_v_kk;
        __pyx_t_3 = PyFloat_FromDouble((((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ndens.data + __pyx_t_21 * __pyx_v_ndens.strides[0]) ) + __pyx_t_13 * __pyx_v_ndens.strides[1]) ) + __pyx_t_22 * __pyx_v_ndens.strides[2]) ))) * __pyx_v_dc_term) * __pyx_v_zterm)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 774, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_XDECREF_SET(__pyx_v_number_term_pref, __pyx_t_3);
        __pyx_t_3 = 0;

 0775:                 # GW_SRC_CONST^2 * 2^(4/3) * Mc^(10/3) * dc^-2

+0776:                 hterm_pref = pow(GW_SRC_CONST * mchirp * pow(2.0*mchirp, two_third) / dc_cm, 2)

        __pyx_v_hterm_pref = pow((((__pyx_v_8holodeck_7cyutils_GW_SRC_CONST * __pyx_v_mchirp) * pow((2.0 * __pyx_v_mchirp), __pyx_v_two_third)) / __pyx_v_dc_cm), 2.0);

 0777: 

+0778:                 ecc_idx = ecc_idx_beg

        __pyx_v_ecc_idx = __pyx_v_ecc_idx_beg;

+0779:                 for ff in range(num_freq_harm):

        __pyx_t_23 = __pyx_v_num_freq_harm;
        __pyx_t_24 = __pyx_t_23;
        for (__pyx_t_25 = 0; __pyx_t_25 < __pyx_t_24; __pyx_t_25+=1) {
          __pyx_v_ff = __pyx_t_25;

+0780:                     unravel(sorted_index[ff], shape, &aa, &bb)

          __pyx_f_8holodeck_7cyutils_unravel((__pyx_v_sorted_index[__pyx_v_ff]), __pyx_v_shape, (&__pyx_v_aa), (&__pyx_v_bb));

 0781: 

+0782:                     nh = bb + 1

          __pyx_v_nh = (__pyx_v_bb + 1);

+0783:                     four_over_nh_squared = 4.0 / (nh * nh)

          __pyx_v_four_over_nh_squared = (4.0 / ((double)(__pyx_v_nh * __pyx_v_nh)));

+0784:                     gwfr = gwfobs[aa] * zterm / nh

          __pyx_t_22 = __pyx_v_aa;
          __pyx_v_gwfr = (((*((double *) ( /* dim=0 */ (__pyx_v_gwfobs.data + __pyx_t_22 * __pyx_v_gwfobs.strides[0]) ))) * __pyx_v_zterm) / ((double)__pyx_v_nh));

 0785: 

 0786:                     # rest-frame frequency corresponding to target observer-frame frequency of GW observations

+0787:                     sa = pow(kep_sa_mass_term / pow(gwfr, 2), one_third)

          __pyx_v_sa = pow((__pyx_v_kep_sa_mass_term / pow(__pyx_v_gwfr, 2.0)), __pyx_v_one_third);

+0788:                     sa_fourth = pow(sa, 4)

          __pyx_v_sa_fourth = pow(__pyx_v_sa, 4.0);

 0789: 

 0790:                     # ---- Interpolate eccentricity to this frequency

 0791: 

 0792:                     # try to get `ecc_idx` such that   frst[idx] < gwfr < frst[idx+1]

+0793:                     frst_evo_lo = frst_evo_pref[ecc_idx] * mt_sqrt

          __pyx_v_frst_evo_lo = ((__pyx_v_frst_evo_pref[__pyx_v_ecc_idx]) * __pyx_v_mt_sqrt);

+0794:                     frst_evo_hi = frst_evo_pref[ecc_idx+1] * mt_sqrt

          __pyx_v_frst_evo_hi = ((__pyx_v_frst_evo_pref[(__pyx_v_ecc_idx + 1)]) * __pyx_v_mt_sqrt);

+0795:                     while (gwfr > frst_evo_hi) & (ecc_idx < n_eccs - 2):

          while (1) {
            __pyx_t_17 = (((__pyx_v_gwfr > __pyx_v_frst_evo_hi) & (__pyx_v_ecc_idx < (__pyx_v_n_eccs - 2))) != 0);
            if (!__pyx_t_17) break;

+0796:                         frst_evo_lo = frst_evo_hi

            __pyx_v_frst_evo_lo = __pyx_v_frst_evo_hi;

+0797:                         ecc_idx += 1

            __pyx_v_ecc_idx = (__pyx_v_ecc_idx + 1);

+0798:                         frst_evo_hi = frst_evo_pref[ecc_idx+1] * mt_sqrt

            __pyx_v_frst_evo_hi = ((__pyx_v_frst_evo_pref[(__pyx_v_ecc_idx + 1)]) * __pyx_v_mt_sqrt);
          }

 0799: 

+0800:                     if jj == 0 and ff == 0:

          __pyx_t_26 = ((__pyx_v_jj == 0) != 0);
          if (__pyx_t_26) {
          } else {
            __pyx_t_17 = __pyx_t_26;
            goto __pyx_L19_bool_binop_done;
          }
          __pyx_t_26 = ((__pyx_v_ff == 0) != 0);
          __pyx_t_17 = __pyx_t_26;
          __pyx_L19_bool_binop_done:;
          if (__pyx_t_17) {
/* … */
          }

+0801:                         ecc_idx_beg = ecc_idx

            __pyx_v_ecc_idx_beg = __pyx_v_ecc_idx;

 0802: 

 0803:                     # if `gwfr` is lower than lowest evolution point, continue to next frequency

+0804:                     if (gwfr < frst_evo_lo):

          __pyx_t_17 = ((__pyx_v_gwfr < __pyx_v_frst_evo_lo) != 0);
          if (__pyx_t_17) {
/* … */
          }

+0805:                         continue

            goto __pyx_L14_continue;

 0806: 

 0807:                     # if `gwfr` is > highest evolution point, also be true for all following frequencies, so break

+0808:                     if (gwfr > frst_evo_hi):

          __pyx_t_17 = ((__pyx_v_gwfr > __pyx_v_frst_evo_hi) != 0);
          if (__pyx_t_17) {
/* … */
          }

+0809:                         break

            goto __pyx_L15_break;

 0810: 

 0811:                     # calculate slope M

+0812:                     ecc = (eccen_evo[ecc_idx+1] - eccen_evo[ecc_idx]) / (frst_evo_hi - frst_evo_lo)

          __pyx_v_ecc = (((__pyx_v_eccen_evo[(__pyx_v_ecc_idx + 1)]) - (__pyx_v_eccen_evo[__pyx_v_ecc_idx])) / (__pyx_v_frst_evo_hi - __pyx_v_frst_evo_lo));

 0813:                     # y = y_0 + M * dx

+0814:                     ecc = eccen_evo[ecc_idx] + (gwfr - frst_evo_lo) * ecc

          __pyx_v_ecc = ((__pyx_v_eccen_evo[__pyx_v_ecc_idx]) + ((__pyx_v_gwfr - __pyx_v_frst_evo_lo) * __pyx_v_ecc));

 0815: 

 0816:                     # ---- Calculate GWB contribution with this eccentricity

 0817: 

+0818:                     gne = gw_freq_dist_func__scalar_scalar(nh, ecc)

          __pyx_v_gne = __pyx_f_8holodeck_7cyutils_gw_freq_dist_func__scalar_scalar(__pyx_v_nh, __pyx_v_ecc);

 0819: 

+0820:                     fe_ecc = _gw_ecc_func(ecc)

          __pyx_v_fe_ecc = __pyx_f_8holodeck_7cyutils__gw_ecc_func(__pyx_v_ecc);

 0821:                     # da/dt values are negative, convert to a positive timescale

+0822:                     tau = - sa_fourth / (GW_DADT_SEP_CONST * fe_ecc * m1 * m2 * mt)

          __pyx_v_tau = ((-__pyx_v_sa_fourth) / ((((__pyx_v_8holodeck_7cyutils_GW_DADT_SEP_CONST * __pyx_v_fe_ecc) * __pyx_v_m1) * __pyx_v_m2) * __pyx_v_mt));

 0823: 

 0824:                     # Calculate the GW spectral strain at each harmonic

 0825:                     #    see: [Amaro-seoane+2010 Eq.9]

 0826: 

 0827:                     # n_c * (4*pi*c*d_c^2) * (1 + z) * tau * dM*dq*dz

+0828:                     number_term = number_term_pref * tau * volume

          __pyx_t_3 = PyFloat_FromDouble(__pyx_v_tau); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 828, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_4 = PyNumber_Multiply(__pyx_v_number_term_pref, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 828, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_4);
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_3 = PyFloat_FromDouble(__pyx_v_volume); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 828, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_3);
          __pyx_t_8 = PyNumber_Multiply(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 828, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_8);
          __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
          __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
          __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_t_8); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 828, __pyx_L1_error)
          __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
          __pyx_v_number_term = __pyx_t_27;

 0829: 

 0830:                     # GW_SRC_CONST^2 * 2^(4/3) * Mc^(10/3) * gne * (2/n)^2 * forb_r^(4/3) * dc^-2

+0831:                     hterm = hterm_pref * gne * four_over_nh_squared * pow(gwfr, four_third)

          __pyx_v_hterm = (((__pyx_v_hterm_pref * __pyx_v_gne) * __pyx_v_four_over_nh_squared) * pow(__pyx_v_gwfr, __pyx_v_four_third));

 0832: 

+0833:                     for rr in range(nreals):

          __pyx_t_28 = __pyx_v_nreals;
          __pyx_t_29 = __pyx_t_28;
          for (__pyx_t_30 = 0; __pyx_t_30 < __pyx_t_29; __pyx_t_30+=1) {
            __pyx_v_rr = __pyx_t_30;

 0834:                         # npy_int64 random_poisson(bitgen_t *bitgen_state, double lam)

+0835:                         num_pois = <double>random_poisson(rng, number_term)

            /* "holodeck/cyutils.pyx":835
 *                     for rr in range(nreals):
 *                         # npy_int64 random_poisson(bitgen_t *bitgen_state, double lam)
 *                         num_pois = <double>random_poisson(rng, number_term)             # <<<<<<<<<<<<<<
 * 
 *                         # GW_SRC_CONST^2 * 2^(4/3) * Mc^(10/3) * gne * (2/n)^2 * forb_r^(4/3) * dc^-2 *
 */
            __pyx_v_num_pois = ((double)random_poisson(__pyx_v_rng, __pyx_v_number_term));

 0836: 

 0837:                         # GW_SRC_CONST^2 * 2^(4/3) * Mc^(10/3) * gne * (2/n)^2 * forb_r^(4/3) * dc^-2 *

 0838:                         #     n_c * (4*pi*c*d_c^2) * (1 + z) * tau * dM*dq*dz * trapz-weight

+0839:                         gwb[aa, bb, rr] += hterm * num_pois / weight

            __pyx_t_22 = __pyx_v_aa;
            __pyx_t_13 = __pyx_v_bb;
            __pyx_t_21 = __pyx_v_rr;
            *__Pyx_BufPtrStrided3d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_gwb.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_gwb.diminfo[1].strides, __pyx_t_21, __pyx_pybuffernd_gwb.diminfo[2].strides) += ((__pyx_v_hterm * __pyx_v_num_pois) / __pyx_v_weight);
          }
          __pyx_L14_continue:;
        }
        __pyx_L15_break:;
      }
    }
  }

 0840: 

+0841:     free(shape)

  free(__pyx_v_shape);

+0842:     free(sepa_evo)

  free(__pyx_v_sepa_evo);

+0843:     free(eccen_evo)

  free(__pyx_v_eccen_evo);

+0844:     free(frst_evo_pref)

  free(__pyx_v_frst_evo_pref);

+0845:     free(freq_harms)

  free(__pyx_v_freq_harms);

+0846:     free(sorted_index)

  free(__pyx_v_sorted_index);

+0847:     free(mtot)

  free(__pyx_v_mtot);

+0848:     free(ival)

  free(__pyx_v_ival);

+0849:     free(jval)

  free(__pyx_v_jval);

+0850:     free(kval)

  free(__pyx_v_kval);

+0851:     return gwb

  __pyx_t_31 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_gwb), PyBUF_WRITABLE); if (unlikely(!__pyx_t_31.memview)) __PYX_ERR(0, 851, __pyx_L1_error)
  __pyx_r = __pyx_t_31;
  __pyx_t_31.memview = NULL;
  __pyx_t_31.data = NULL;
  goto __pyx_L0;

 0852: 

 0853: 

+0854: def sam_poisson_gwb(dist, hc2, nreals, normal_threshold=1e10):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_5sam_poisson_gwb(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_5sam_poisson_gwb = {"sam_poisson_gwb", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_5sam_poisson_gwb, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_8holodeck_7cyutils_5sam_poisson_gwb(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_dist = 0;
  PyObject *__pyx_v_hc2 = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_v_normal_threshold = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sam_poisson_gwb (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dist,&__pyx_n_s_hc2,&__pyx_n_s_nreals,&__pyx_n_s_normal_threshold,0};
    PyObject* values[4] = {0,0,0,0};
    values[3] = ((PyObject *)__pyx_float_1e10);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dist)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_hc2)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_poisson_gwb", 0, 3, 4, 1); __PYX_ERR(0, 854, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("sam_poisson_gwb", 0, 3, 4, 2); __PYX_ERR(0, 854, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normal_threshold);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sam_poisson_gwb") < 0)) __PYX_ERR(0, 854, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_dist = values[0];
    __pyx_v_hc2 = values[1];
    __pyx_v_nreals = values[2];
    __pyx_v_normal_threshold = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("sam_poisson_gwb", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 854, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.sam_poisson_gwb", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_4sam_poisson_gwb(__pyx_self, __pyx_v_dist, __pyx_v_hc2, __pyx_v_nreals, __pyx_v_normal_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_4sam_poisson_gwb(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_dist, PyObject *__pyx_v_hc2, PyObject *__pyx_v_nreals, PyObject *__pyx_v_normal_threshold) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sam_poisson_gwb", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __Pyx_AddTraceback("holodeck.cyutils.sam_poisson_gwb", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__30 = PyTuple_Pack(4, __pyx_n_s_dist, __pyx_n_s_hc2, __pyx_n_s_nreals, __pyx_n_s_normal_threshold); if (unlikely(!__pyx_tuple__30)) __PYX_ERR(0, 854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__30);
  __Pyx_GIVEREF(__pyx_tuple__30);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_5sam_poisson_gwb, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 854, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sam_poisson_gwb, __pyx_t_3) < 0) __PYX_ERR(0, 854, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(4, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_sam_poisson_gwb, 854, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(0, 854, __pyx_L1_error)

+0855:     return _sam_poisson_gwb(np.array(dist.shape), dist, hc2, nreals, long(normal_threshold))

  __Pyx_XDECREF(__pyx_r);
  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dist, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_dist, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 855, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_hc2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 855, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_v_nreals); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 855, __pyx_L1_error)
  __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyLong_Type)), __pyx_v_normal_threshold); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_9 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_9 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_10 = __pyx_f_8holodeck_7cyutils__sam_poisson_gwb(__pyx_t_5, __pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 855, __pyx_L1_error)
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_t_10, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 855, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 0856: 

 0857: 

 0858: @cython.boundscheck(False)

 0859: @cython.wraparound(False)

 0860: @cython.nonecheck(False)

 0861: @cython.cdivision(True)

+0862: cdef double[:, :] _sam_poisson_gwb(

static __Pyx_memviewslice __pyx_f_8holodeck_7cyutils__sam_poisson_gwb(__Pyx_memviewslice __pyx_v_shape, __Pyx_memviewslice __pyx_v_dist, __Pyx_memviewslice __pyx_v_hc2, int __pyx_v_nreals, long __pyx_v_thresh) {
  int __pyx_v_nm;
  int __pyx_v_nq;
  int __pyx_v_nz;
  int __pyx_v_nf;
  int __pyx_v_ii;
  int __pyx_v_jj;
  int __pyx_v_kk;
  int __pyx_v_ff;
  int __pyx_v_rr;
  double __pyx_v_num;
  double __pyx_v_bin_hc2;
  double __pyx_v_bin_num;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  PyArrayObject *__pyx_v_gwb = 0;
  double __pyx_v_bin_std;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_gwb;
  __Pyx_Buffer __pyx_pybuffer_gwb;
  __Pyx_memviewslice __pyx_r = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_sam_poisson_gwb", 0);
  __pyx_pybuffer_gwb.pybuffer.buf = NULL;
  __pyx_pybuffer_gwb.refcount = 0;
  __pyx_pybuffernd_gwb.data = NULL;
  __pyx_pybuffernd_gwb.rcbuffer = &__pyx_pybuffer_gwb;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  __PYX_XDEC_MEMVIEW(&__pyx_t_28, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __pyx_r.data = NULL;
  __pyx_r.memview = NULL;
  __Pyx_AddTraceback("holodeck.cyutils._sam_poisson_gwb", __pyx_clineno, __pyx_lineno, __pyx_filename);
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer);
  if (unlikely(!__pyx_r.memview)) {
    PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");
  }
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_XDECREF((PyObject *)__pyx_v_gwb);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 0863:     long[:] shape, double[:, :, :, :] dist, double[:, :, :, :] hc2, int nreals, long thresh

 0864: ):

+0865:     cdef int nm = shape[0]

  __pyx_t_1 = 0;
  __pyx_v_nm = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0866:     cdef int nq = shape[1]

  __pyx_t_1 = 1;
  __pyx_v_nq = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0867:     cdef int nz = shape[2]

  __pyx_t_1 = 2;
  __pyx_v_nz = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0868:     cdef int nf = shape[3]

  __pyx_t_1 = 3;
  __pyx_v_nf = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

 0869:     cdef int ii, jj, kk, ff, rr

 0870:     cdef double num, bin_hc2, bin_num

 0871: 

 0872:     # Setup random number generator from numpy library

 0873:     cdef bitgen_t *rng

+0874:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+0875:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_capsule); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 875, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_capsule = __pyx_t_3;
  __pyx_t_3 = 0;

 0876:     # Cast the pointer

+0877:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_5 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 877, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_5);

 0878: 

 0879: 

+0880:     cdef np.ndarray[np.double_t, ndim=2] gwb = np.zeros((nf, nreals))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_nf); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_nreals); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6);
  __pyx_t_2 = 0;
  __pyx_t_6 = 0;
  __pyx_t_6 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_6)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7);
  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 880, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 880, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_3);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_gwb.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_gwb = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 880, __pyx_L1_error)
    } else {__pyx_pybuffernd_gwb.diminfo[0].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_gwb.diminfo[0].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_gwb.diminfo[1].strides = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_gwb.diminfo[1].shape = __pyx_pybuffernd_gwb.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_gwb = ((PyArrayObject *)__pyx_t_3);
  __pyx_t_3 = 0;

+0881:     for ii in range(nm):

  __pyx_t_9 = __pyx_v_nm;
  __pyx_t_10 = __pyx_t_9;
  for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
    __pyx_v_ii = __pyx_t_11;

+0882:         for jj in range(nq):

    __pyx_t_12 = __pyx_v_nq;
    __pyx_t_13 = __pyx_t_12;
    for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
      __pyx_v_jj = __pyx_t_14;

+0883:             for kk in range(nz):

      __pyx_t_15 = __pyx_v_nz;
      __pyx_t_16 = __pyx_t_15;
      for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
        __pyx_v_kk = __pyx_t_17;

+0884:                 for ff in range(nf):

        __pyx_t_18 = __pyx_v_nf;
        __pyx_t_19 = __pyx_t_18;
        for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
          __pyx_v_ff = __pyx_t_20;

+0885:                     bin_num = dist[ii, jj, kk, ff]

          __pyx_t_1 = __pyx_v_ii;
          __pyx_t_21 = __pyx_v_jj;
          __pyx_t_22 = __pyx_v_kk;
          __pyx_t_23 = __pyx_v_ff;
          __pyx_v_bin_num = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_dist.data + __pyx_t_1 * __pyx_v_dist.strides[0]) ) + __pyx_t_21 * __pyx_v_dist.strides[1]) ) + __pyx_t_22 * __pyx_v_dist.strides[2]) ) + __pyx_t_23 * __pyx_v_dist.strides[3]) )));

+0886:                     bin_hc2 = hc2[ii, jj, kk, ff]

          __pyx_t_23 = __pyx_v_ii;
          __pyx_t_22 = __pyx_v_jj;
          __pyx_t_21 = __pyx_v_kk;
          __pyx_t_1 = __pyx_v_ff;
          __pyx_v_bin_hc2 = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2.data + __pyx_t_23 * __pyx_v_hc2.strides[0]) ) + __pyx_t_22 * __pyx_v_hc2.strides[1]) ) + __pyx_t_21 * __pyx_v_hc2.strides[2]) ) + __pyx_t_1 * __pyx_v_hc2.strides[3]) )));

+0887:                     if bin_num > thresh:

          __pyx_t_24 = ((__pyx_v_bin_num > __pyx_v_thresh) != 0);
          if (__pyx_t_24) {
/* … */
            goto __pyx_L11;
          }

+0888:                         bin_std = sqrt(bin_num)

            __pyx_v_bin_std = sqrt(__pyx_v_bin_num);

+0889:                         for rr in range(nreals):

            __pyx_t_25 = __pyx_v_nreals;
            __pyx_t_26 = __pyx_t_25;
            for (__pyx_t_27 = 0; __pyx_t_27 < __pyx_t_26; __pyx_t_27+=1) {
              __pyx_v_rr = __pyx_t_27;

+0890:                             num = <double>random_normal(rng, bin_num, bin_std)

              __pyx_v_num = ((double)random_normal(__pyx_v_rng, __pyx_v_bin_num, __pyx_v_bin_std));

+0891:                             gwb[ff, rr] += num * bin_hc2

              __pyx_t_1 = __pyx_v_ff;
              __pyx_t_21 = __pyx_v_rr;
              *__Pyx_BufPtrStrided2d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf, __pyx_t_1, __pyx_pybuffernd_gwb.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_gwb.diminfo[1].strides) += (__pyx_v_num * __pyx_v_bin_hc2);
            }

 0892:                     else:

+0893:                         for rr in range(nreals):

          /*else*/ {
            __pyx_t_25 = __pyx_v_nreals;
            __pyx_t_26 = __pyx_t_25;
            for (__pyx_t_27 = 0; __pyx_t_27 < __pyx_t_26; __pyx_t_27+=1) {
              __pyx_v_rr = __pyx_t_27;

+0894:                             num = <double>random_poisson(rng, bin_num)

              __pyx_v_num = ((double)random_poisson(__pyx_v_rng, __pyx_v_bin_num));

+0895:                             gwb[ff, rr] += num * bin_hc2

              __pyx_t_21 = __pyx_v_ff;
              __pyx_t_1 = __pyx_v_rr;
              *__Pyx_BufPtrStrided2d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_gwb.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_gwb.diminfo[0].strides, __pyx_t_1, __pyx_pybuffernd_gwb.diminfo[1].strides) += (__pyx_v_num * __pyx_v_bin_hc2);
            }
          }
          __pyx_L11:;
        }
      }
    }
  }

 0896: 

+0897:     return gwb

  __pyx_t_28 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_gwb), PyBUF_WRITABLE); if (unlikely(!__pyx_t_28.memview)) __PYX_ERR(0, 897, __pyx_L1_error)
  __pyx_r = __pyx_t_28;
  __pyx_t_28.memview = NULL;
  __pyx_t_28.data = NULL;
  goto __pyx_L0;

 0898: 

 0899: 

+0900: def ss_bg_hc(number, h2fdf, nreals, normal_threshold=1e10):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_7ss_bg_hc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_6ss_bg_hc[] = " Calculates the characteristic strain from loud single sources and a background of all other sources.\n\n    Parameters\n    ----------\n    number : [M, Q, Z, F] ndarray\n        number in each bin\n    h2fdf : [M, Q, Z, F] ndarray\n        strain squared x frequency / frequency bin width for each bin\n    nreals\n        number of realizations\n\n    Returns\n    -------\n    hc2ss : (F, R) Ndarray of scalars\n    hc2bg : (F, R) Ndarray of scalars\n    ssidx : (3, F, R) Ndarray of ints\n        Index of the loudest single source, -1 if there are none at the frequency/realization.\n\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_7ss_bg_hc = {"ss_bg_hc", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_7ss_bg_hc, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_6ss_bg_hc};
static PyObject *__pyx_pw_8holodeck_7cyutils_7ss_bg_hc(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_number = 0;
  PyObject *__pyx_v_h2fdf = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_v_normal_threshold = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ss_bg_hc (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_h2fdf,&__pyx_n_s_nreals,&__pyx_n_s_normal_threshold,0};
    PyObject* values[4] = {0,0,0,0};
    values[3] = ((PyObject *)__pyx_float_1e10);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_number)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_h2fdf)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc", 0, 3, 4, 1); __PYX_ERR(0, 900, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc", 0, 3, 4, 2); __PYX_ERR(0, 900, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normal_threshold);
          if (value) { values[3] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ss_bg_hc") < 0)) __PYX_ERR(0, 900, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_number = values[0];
    __pyx_v_h2fdf = values[1];
    __pyx_v_nreals = values[2];
    __pyx_v_normal_threshold = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ss_bg_hc", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 900, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.ss_bg_hc", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_6ss_bg_hc(__pyx_self, __pyx_v_number, __pyx_v_h2fdf, __pyx_v_nreals, __pyx_v_normal_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_6ss_bg_hc(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_number, PyObject *__pyx_v_h2fdf, PyObject *__pyx_v_nreals, PyObject *__pyx_v_normal_threshold) {
  __Pyx_memviewslice __pyx_v_shape = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_F = NULL;
  PyObject *__pyx_v_R = NULL;
  PyArrayObject *__pyx_v_hc2ss = 0;
  PyArrayObject *__pyx_v_hc2bg = 0;
  PyArrayObject *__pyx_v_ssidx = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2bg;
  __Pyx_Buffer __pyx_pybuffer_hc2bg;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2ss;
  __Pyx_Buffer __pyx_pybuffer_hc2ss;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ssidx;
  __Pyx_Buffer __pyx_pybuffer_ssidx;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ss_bg_hc", 0);
  __pyx_pybuffer_hc2ss.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2ss.refcount = 0;
  __pyx_pybuffernd_hc2ss.data = NULL;
  __pyx_pybuffernd_hc2ss.rcbuffer = &__pyx_pybuffer_hc2ss;
  __pyx_pybuffer_hc2bg.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2bg.refcount = 0;
  __pyx_pybuffernd_hc2bg.data = NULL;
  __pyx_pybuffernd_hc2bg.rcbuffer = &__pyx_pybuffer_hc2bg;
  __pyx_pybuffer_ssidx.pybuffer.buf = NULL;
  __pyx_pybuffer_ssidx.refcount = 0;
  __pyx_pybuffernd_ssidx.data = NULL;
  __pyx_pybuffernd_ssidx.rcbuffer = &__pyx_pybuffer_ssidx;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_15, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_16, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.ss_bg_hc", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer);
  __pyx_L2:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_shape, 1);
  __Pyx_XDECREF(__pyx_v_F);
  __Pyx_XDECREF(__pyx_v_R);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2ss);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2bg);
  __Pyx_XDECREF((PyObject *)__pyx_v_ssidx);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__32 = PyTuple_Pack(10, __pyx_n_s_number, __pyx_n_s_h2fdf, __pyx_n_s_nreals, __pyx_n_s_normal_threshold, __pyx_n_s_shape, __pyx_n_s_F, __pyx_n_s_R, __pyx_n_s_hc2ss, __pyx_n_s_hc2bg, __pyx_n_s_ssidx); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(0, 900, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__32);
  __Pyx_GIVEREF(__pyx_tuple__32);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_7ss_bg_hc, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 900, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ss_bg_hc, __pyx_t_3) < 0) __PYX_ERR(0, 900, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__33 = (PyObject*)__Pyx_PyCode_New(4, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__32, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_ss_bg_hc, 900, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__33)) __PYX_ERR(0, 900, __pyx_L1_error)

 0901:     """ Calculates the characteristic strain from loud single sources and a background of all other sources.

 0902: 

 0903:     Parameters

 0904:     ----------

 0905:     number : [M, Q, Z, F] ndarray

 0906:         number in each bin

 0907:     h2fdf : [M, Q, Z, F] ndarray

 0908:         strain squared x frequency / frequency bin width for each bin

 0909:     nreals

 0910:         number of realizations

 0911: 

 0912:     Returns

 0913:     -------

 0914:     hc2ss : (F, R) Ndarray of scalars

 0915:     hc2bg : (F, R) Ndarray of scalars

 0916:     ssidx : (3, F, R) Ndarray of ints

 0917:         Index of the loudest single source, -1 if there are none at the frequency/realization.

 0918: 

 0919:     """

 0920: 

+0921:     cdef long[:] shape = np.array(number.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_number, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 921, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 921, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_shape = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

+0922:     F = shape[3]

  __pyx_t_6 = 3;
  __pyx_t_7 = -1;
  if (__pyx_t_6 < 0) {
    __pyx_t_6 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_6 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 922, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyInt_From_long((*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_6 * __pyx_v_shape.strides[0]) )))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 922, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_F = __pyx_t_1;
  __pyx_t_1 = 0;

+0923:     R = nreals

  __Pyx_INCREF(__pyx_v_nreals);
  __pyx_v_R = __pyx_v_nreals;

+0924:     cdef np.ndarray[np.double_t, ndim=2] hc2ss = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 924, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 924, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2ss = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 924, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2ss.diminfo[0].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2ss.diminfo[0].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2ss.diminfo[1].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2ss.diminfo[1].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_hc2ss = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+0925:     cdef np.ndarray[np.double_t, ndim=2] hc2bg = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 925, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 925, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2bg = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 925, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2bg.diminfo[0].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2bg.diminfo[0].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2bg.diminfo[1].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2bg.diminfo[1].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_hc2bg = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+0926:     cdef np.ndarray[np.longlong_t, ndim=3] ssidx = np.zeros((3,F,R), dtype=int)

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_R);
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 926, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 926, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 926, __pyx_L1_error)
  __pyx_t_10 = ((PyArrayObject *)__pyx_t_4);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_longlong_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_ssidx = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 926, __pyx_L1_error)
    } else {__pyx_pybuffernd_ssidx.diminfo[0].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ssidx.diminfo[0].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ssidx.diminfo[1].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ssidx.diminfo[1].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_ssidx.diminfo[2].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_ssidx.diminfo[2].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_10 = 0;
  __pyx_v_ssidx = ((PyArrayObject *)__pyx_t_4);
  __pyx_t_4 = 0;

+0927:     _ss_bg_hc(shape, h2fdf, number, nreals, normal_threshold,

  __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_h2fdf, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 927, __pyx_L1_error)
  __pyx_t_12 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_number, PyBUF_WRITABLE); if (unlikely(!__pyx_t_12.memview)) __PYX_ERR(0, 927, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_13 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 927, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_normal_threshold); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 927, __pyx_L1_error)
/* … */
  __pyx_f_8holodeck_7cyutils__ss_bg_hc(__pyx_v_shape, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17);
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __pyx_t_11.memview = NULL;
  __pyx_t_11.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
  __pyx_t_12.memview = NULL;
  __pyx_t_12.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_15, 1);
  __pyx_t_15.memview = NULL;
  __pyx_t_15.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_16, 1);
  __pyx_t_16.memview = NULL;
  __pyx_t_16.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __pyx_t_17.memview = NULL;
  __pyx_t_17.data = NULL;

+0928:                 hc2ss, hc2bg, ssidx)

  __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2ss), PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 928, __pyx_L1_error)
  __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2bg), PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 928, __pyx_L1_error)
  __pyx_t_17 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_long(((PyObject *)__pyx_v_ssidx), PyBUF_WRITABLE); if (unlikely(!__pyx_t_17.memview)) __PYX_ERR(0, 928, __pyx_L1_error)

+0929:     return hc2ss, hc2bg, ssidx

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 929, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2ss));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2ss));
  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_hc2ss));
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2bg));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2bg));
  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_hc2bg));
  __Pyx_INCREF(((PyObject *)__pyx_v_ssidx));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_ssidx));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_ssidx));
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 0930: 

 0931: @cython.boundscheck(False)

 0932: @cython.wraparound(False)

 0933: @cython.nonecheck(False)

 0934: @cython.cdivision(True)

+0935: cdef void _ss_bg_hc(long[:] shape, double[:,:,:,:] h2fdf, double[:,:,:,:] number,

static void __pyx_f_8holodeck_7cyutils__ss_bg_hc(__Pyx_memviewslice __pyx_v_shape, __Pyx_memviewslice __pyx_v_h2fdf, __Pyx_memviewslice __pyx_v_number, long __pyx_v_nreals, long __pyx_v_thresh, __Pyx_memviewslice __pyx_v_hc2ss, __Pyx_memviewslice __pyx_v_hc2bg, __Pyx_memviewslice __pyx_v_ssidx) {
  int __pyx_v_M;
  int __pyx_v_Q;
  int __pyx_v_Z;
  int __pyx_v_F;
  int __pyx_v_R;
  int __pyx_v_mm;
  int __pyx_v_qq;
  int __pyx_v_zz;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_m_max;
  int __pyx_v_q_max;
  int __pyx_v_z_max;
  double __pyx_v_max;
  double __pyx_v_num;
  double __pyx_v_sum;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  PyObject *__pyx_v_cur = NULL;
  double __pyx_v_std;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_ss_bg_hc", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_WriteUnraisable("holodeck.cyutils._ss_bg_hc", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_XDECREF(__pyx_v_cur);
  __Pyx_RefNannyFinishContext();
}

 0936:             long nreals, long thresh,

 0937:             double[:,:] hc2ss, double[:,:] hc2bg, long[:,:,:] ssidx):

 0938:     """

 0939:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 0940: 

 0941:     Parameters

 0942:     ----------

 0943:     shape : long[:] array

 0944:         shape of number, [M, Q, Z, F]

 0945:     number : double[:,:,:,:] array

 0946:         number per bin

 0947:     h2fdf : double[:,:,:,:] array

 0948:         strain amplitude squared * f/Delta f for a single source in each bin.

 0949:     nreals : int

 0950:         number of realizations.

 0951:     hc2ss : double[:,:] array

 0952:         (memory address of) single source characteristic strain squared array.

 0953:     hc2bg : double[:,:] array

 0954:         (memory address of) background characteristic strain squared array.

 0955:     ssidx : [:,:,:] long array

 0956:         (memory address of) array for indices of max strain bins.

 0957:     bgpar :

 0958:         (memory address of) array of effective average parameters

 0959: 

 0960:     Returns

 0961:     -------

 0962:     void

 0963:     updated via memory address: hc2ss, hc2bg, ssidx

 0964:     """

 0965: 

+0966:     cdef int M = shape[0]

  __pyx_t_1 = 0;
  __pyx_v_M = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0967:     cdef int Q = shape[1]

  __pyx_t_1 = 1;
  __pyx_v_Q = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0968:     cdef int Z = shape[2]

  __pyx_t_1 = 2;
  __pyx_v_Z = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0969:     cdef int F = shape[3]

  __pyx_t_1 = 3;
  __pyx_v_F = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+0970:     cdef int R = nreals

  __pyx_v_R = __pyx_v_nreals;

 0971: 

 0972:     cdef int mm, qq, zz, ff, rr, m_max, q_max, z_max

 0973:     cdef double max, num, sum

 0974: 

 0975: 

 0976:     # Setup random number generator from numpy library

 0977:     cdef bitgen_t *rng

+0978:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+0979:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 979, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 979, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_capsule); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 979, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_capsule = __pyx_t_3;
  __pyx_t_3 = 0;

 0980:     # Cast the pointer

+0981:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_5 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 981, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_5);

 0982: 

+0983:     for rr in range(R):

  __pyx_t_6 = __pyx_v_R;
  __pyx_t_7 = __pyx_t_6;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
    __pyx_v_rr = __pyx_t_8;

+0984:         for ff in range(F):

    __pyx_t_9 = __pyx_v_F;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
      __pyx_v_ff = __pyx_t_11;

+0985:             max=0

      __pyx_v_max = 0.0;

+0986:             sum=0

      __pyx_v_sum = 0.0;

+0987:             m_max=-1

      __pyx_v_m_max = -1;

+0988:             q_max=-1

      __pyx_v_q_max = -1;

+0989:             z_max=-1

      __pyx_v_z_max = -1;

+0990:             for mm in range(M):

      __pyx_t_12 = __pyx_v_M;
      __pyx_t_13 = __pyx_t_12;
      for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
        __pyx_v_mm = __pyx_t_14;

+0991:                 for qq in range(Q):

        __pyx_t_15 = __pyx_v_Q;
        __pyx_t_16 = __pyx_t_15;
        for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
          __pyx_v_qq = __pyx_t_17;

+0992:                     for zz in range(Z):

          __pyx_t_18 = __pyx_v_Z;
          __pyx_t_19 = __pyx_t_18;
          for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
            __pyx_v_zz = __pyx_t_20;

+0993:                         num = number[mm,qq,zz,ff]

            __pyx_t_1 = __pyx_v_mm;
            __pyx_t_21 = __pyx_v_qq;
            __pyx_t_22 = __pyx_v_zz;
            __pyx_t_23 = __pyx_v_ff;
            __pyx_v_num = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_number.data + __pyx_t_1 * __pyx_v_number.strides[0]) ) + __pyx_t_21 * __pyx_v_number.strides[1]) ) + __pyx_t_22 * __pyx_v_number.strides[2]) ) + __pyx_t_23 * __pyx_v_number.strides[3]) )));

+0994:                         cur = h2fdf[mm,qq,zz,ff]

            __pyx_t_23 = __pyx_v_mm;
            __pyx_t_22 = __pyx_v_qq;
            __pyx_t_21 = __pyx_v_zz;
            __pyx_t_1 = __pyx_v_ff;
            __pyx_t_3 = PyFloat_FromDouble((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_23 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_22 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_21 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[3]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 994, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_XDECREF_SET(__pyx_v_cur, __pyx_t_3);
            __pyx_t_3 = 0;

+0995:                         if (num>thresh):

            __pyx_t_24 = ((__pyx_v_num > __pyx_v_thresh) != 0);
            if (__pyx_t_24) {
/* … */
              goto __pyx_L13;
            }

+0996:                             std = sqrt(num)

              __pyx_v_std = sqrt(__pyx_v_num);

+0997:                             num = <double>random_normal(rng, num, std)

              __pyx_v_num = ((double)random_normal(__pyx_v_rng, __pyx_v_num, __pyx_v_std));

 0998:                         else:

+0999:                             num = <double>random_poisson(rng, num)

            /*else*/ {
              __pyx_v_num = ((double)random_poisson(__pyx_v_rng, __pyx_v_num));
            }
            __pyx_L13:;

+1000:                         if(cur > max and num > 0):

            __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1000, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_2 = PyObject_RichCompare(__pyx_v_cur, __pyx_t_3, Py_GT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1000, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_25 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_25 < 0)) __PYX_ERR(0, 1000, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            if (__pyx_t_25) {
            } else {
              __pyx_t_24 = __pyx_t_25;
              goto __pyx_L15_bool_binop_done;
            }
            __pyx_t_25 = ((__pyx_v_num > 0.0) != 0);
            __pyx_t_24 = __pyx_t_25;
            __pyx_L15_bool_binop_done:;
            if (__pyx_t_24) {
/* … */
            }

+1001:                             max = h2fdf[mm,qq,zz,ff]

              __pyx_t_1 = __pyx_v_mm;
              __pyx_t_21 = __pyx_v_qq;
              __pyx_t_22 = __pyx_v_zz;
              __pyx_t_23 = __pyx_v_ff;
              __pyx_v_max = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_1 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_21 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_22 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_23 * __pyx_v_h2fdf.strides[3]) )));

+1002:                             m_max = mm # -1 if no single sources

              __pyx_v_m_max = __pyx_v_mm;

+1003:                             q_max = qq # -1 if no single sources

              __pyx_v_q_max = __pyx_v_qq;

+1004:                             z_max = zz # -1 if no single sources

              __pyx_v_z_max = __pyx_v_zz;

+1005:                         sum += num * cur

            __pyx_t_2 = PyFloat_FromDouble(__pyx_v_sum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1005, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_3 = PyFloat_FromDouble(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1005, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_v_cur); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1005, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1005, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_26 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_26 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1005, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_v_sum = __pyx_t_26;
          }
        }
      }

+1006:             hc2ss[ff,rr] = max

      __pyx_t_23 = __pyx_v_ff;
      __pyx_t_22 = __pyx_v_rr;
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2ss.data + __pyx_t_23 * __pyx_v_hc2ss.strides[0]) ) + __pyx_t_22 * __pyx_v_hc2ss.strides[1]) )) = __pyx_v_max;

+1007:             hc2bg[ff,rr] = sum - max

      __pyx_t_22 = __pyx_v_ff;
      __pyx_t_23 = __pyx_v_rr;
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2bg.data + __pyx_t_22 * __pyx_v_hc2bg.strides[0]) ) + __pyx_t_23 * __pyx_v_hc2bg.strides[1]) )) = (__pyx_v_sum - __pyx_v_max);

 1008:             # ssidx[:,ff,rr] = m_max, q_max, z_max

+1009:             ssidx[0,ff,rr] = m_max

      __pyx_t_23 = 0;
      __pyx_t_22 = __pyx_v_ff;
      __pyx_t_21 = __pyx_v_rr;
      *((long *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_23 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_22 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[2]) )) = __pyx_v_m_max;

+1010:             ssidx[1,ff,rr] = q_max

      __pyx_t_21 = 1;
      __pyx_t_22 = __pyx_v_ff;
      __pyx_t_23 = __pyx_v_rr;
      *((long *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_21 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_22 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_23 * __pyx_v_ssidx.strides[2]) )) = __pyx_v_q_max;

+1011:             ssidx[2,ff,rr] = z_max

      __pyx_t_23 = 2;
      __pyx_t_22 = __pyx_v_ff;
      __pyx_t_21 = __pyx_v_rr;
      *((long *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_23 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_22 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[2]) )) = __pyx_v_z_max;
    }
  }

 1012:     # still need to sqrt and sum! (or do this back in python)

 1013: 

+1014:     return

  goto __pyx_L0;

 1015: 

 1016: # I also need to pass the edges to calculate the avged ones

+1017: def ss_bg_hc_and_par(number, h2fdf, nreals, mt, mr, rz, normal_threshold=1e10):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_9ss_bg_hc_and_par(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_8ss_bg_hc_and_par[] = "\n    Calculates the characteristic strain from loud single sources and a background of all other sources.\n\n    Parameters\n    ------------------------\n    number : [M, Q, Z, F] NDarray\n        number in each bin\n    h2fdf : [M, Q, Z, F] NDarray\n        Strain amplitude squared x frequency / frequency bin width for each bin.\n    nreals\n        Number of realizations.\n    mt : (M,) 1Darray of scalars\n        Total masses, M, of each bin center.\n    mr : (Q,) 1Darray of scalars\n        Mass ratios, q, of each bin center.\n    rz : (Z,) 1Darray of scalars\n        Redshifts, z, of each bin center.\n\n    Returns\n    --------------------------\n    hc2ss : (F, R) Ndarray of scalars\n        Char strain squared of the loudest single sources.\n    hc2bg : (F, R) Ndarray of scalars\n        Char strain squared of the background.\n    ssidx : (3, F, R) NDarray of ints\n        Indices of the loudest single sources. -1 if there are\n        no single sources at that frequency/realization.\n    bgpar : (3, F, R) NDarray of scalars\n        Average effective M, q, z parameters of the background.\n    sspar : (3, F, R) NDarray of scalars\n        M, q, z parameters of the loudest single sources.\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_9ss_bg_hc_and_par = {"ss_bg_hc_and_par", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_9ss_bg_hc_and_par, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_8ss_bg_hc_and_par};
static PyObject *__pyx_pw_8holodeck_7cyutils_9ss_bg_hc_and_par(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_number = 0;
  PyObject *__pyx_v_h2fdf = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_v_mt = 0;
  PyObject *__pyx_v_mr = 0;
  PyObject *__pyx_v_rz = 0;
  PyObject *__pyx_v_normal_threshold = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ss_bg_hc_and_par (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_h2fdf,&__pyx_n_s_nreals,&__pyx_n_s_mt,&__pyx_n_s_mr,&__pyx_n_s_rz,&__pyx_n_s_normal_threshold,0};
    PyObject* values[7] = {0,0,0,0,0,0,0};
    values[6] = ((PyObject *)__pyx_float_1e10);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_number)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_h2fdf)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc_and_par", 0, 6, 7, 1); __PYX_ERR(0, 1017, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc_and_par", 0, 6, 7, 2); __PYX_ERR(0, 1017, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mt)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc_and_par", 0, 6, 7, 3); __PYX_ERR(0, 1017, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mr)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc_and_par", 0, 6, 7, 4); __PYX_ERR(0, 1017, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rz)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("ss_bg_hc_and_par", 0, 6, 7, 5); __PYX_ERR(0, 1017, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normal_threshold);
          if (value) { values[6] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ss_bg_hc_and_par") < 0)) __PYX_ERR(0, 1017, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_number = values[0];
    __pyx_v_h2fdf = values[1];
    __pyx_v_nreals = values[2];
    __pyx_v_mt = values[3];
    __pyx_v_mr = values[4];
    __pyx_v_rz = values[5];
    __pyx_v_normal_threshold = values[6];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("ss_bg_hc_and_par", 0, 6, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1017, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.ss_bg_hc_and_par", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_8ss_bg_hc_and_par(__pyx_self, __pyx_v_number, __pyx_v_h2fdf, __pyx_v_nreals, __pyx_v_mt, __pyx_v_mr, __pyx_v_rz, __pyx_v_normal_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_8ss_bg_hc_and_par(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_number, PyObject *__pyx_v_h2fdf, PyObject *__pyx_v_nreals, PyObject *__pyx_v_mt, PyObject *__pyx_v_mr, PyObject *__pyx_v_rz, PyObject *__pyx_v_normal_threshold) {
  __Pyx_memviewslice __pyx_v_shape = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_F = NULL;
  PyObject *__pyx_v_R = NULL;
  PyArrayObject *__pyx_v_hc2ss = 0;
  PyArrayObject *__pyx_v_hc2bg = 0;
  PyArrayObject *__pyx_v_ssidx = 0;
  PyArrayObject *__pyx_v_bgpar = 0;
  PyArrayObject *__pyx_v_sspar = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_bgpar;
  __Pyx_Buffer __pyx_pybuffer_bgpar;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2bg;
  __Pyx_Buffer __pyx_pybuffer_hc2bg;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2ss;
  __Pyx_Buffer __pyx_pybuffer_hc2ss;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ssidx;
  __Pyx_Buffer __pyx_pybuffer_ssidx;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_sspar;
  __Pyx_Buffer __pyx_pybuffer_sspar;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("ss_bg_hc_and_par", 0);
  __pyx_pybuffer_hc2ss.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2ss.refcount = 0;
  __pyx_pybuffernd_hc2ss.data = NULL;
  __pyx_pybuffernd_hc2ss.rcbuffer = &__pyx_pybuffer_hc2ss;
  __pyx_pybuffer_hc2bg.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2bg.refcount = 0;
  __pyx_pybuffernd_hc2bg.data = NULL;
  __pyx_pybuffernd_hc2bg.rcbuffer = &__pyx_pybuffer_hc2bg;
  __pyx_pybuffer_ssidx.pybuffer.buf = NULL;
  __pyx_pybuffer_ssidx.refcount = 0;
  __pyx_pybuffernd_ssidx.data = NULL;
  __pyx_pybuffernd_ssidx.rcbuffer = &__pyx_pybuffer_ssidx;
  __pyx_pybuffer_bgpar.pybuffer.buf = NULL;
  __pyx_pybuffer_bgpar.refcount = 0;
  __pyx_pybuffernd_bgpar.data = NULL;
  __pyx_pybuffernd_bgpar.rcbuffer = &__pyx_pybuffer_bgpar;
  __pyx_pybuffer_sspar.pybuffer.buf = NULL;
  __pyx_pybuffer_sspar.refcount = 0;
  __pyx_pybuffernd_sspar.data = NULL;
  __pyx_pybuffernd_sspar.rcbuffer = &__pyx_pybuffer_sspar;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_14, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_23, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sspar.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.ss_bg_hc_and_par", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sspar.rcbuffer->pybuffer);
  __pyx_L2:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_shape, 1);
  __Pyx_XDECREF(__pyx_v_F);
  __Pyx_XDECREF(__pyx_v_R);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2ss);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2bg);
  __Pyx_XDECREF((PyObject *)__pyx_v_ssidx);
  __Pyx_XDECREF((PyObject *)__pyx_v_bgpar);
  __Pyx_XDECREF((PyObject *)__pyx_v_sspar);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__34 = PyTuple_Pack(15, __pyx_n_s_number, __pyx_n_s_h2fdf, __pyx_n_s_nreals, __pyx_n_s_mt, __pyx_n_s_mr, __pyx_n_s_rz, __pyx_n_s_normal_threshold, __pyx_n_s_shape, __pyx_n_s_F, __pyx_n_s_R, __pyx_n_s_hc2ss, __pyx_n_s_hc2bg, __pyx_n_s_ssidx, __pyx_n_s_bgpar, __pyx_n_s_sspar); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(0, 1017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__34);
  __Pyx_GIVEREF(__pyx_tuple__34);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_9ss_bg_hc_and_par, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1017, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_ss_bg_hc_and_par, __pyx_t_3) < 0) __PYX_ERR(0, 1017, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(7, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__34, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_ss_bg_hc_and_par, 1017, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(0, 1017, __pyx_L1_error)

 1018:     """

 1019:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1020: 

 1021:     Parameters

 1022:     ------------------------

 1023:     number : [M, Q, Z, F] NDarray

 1024:         number in each bin

 1025:     h2fdf : [M, Q, Z, F] NDarray

 1026:         Strain amplitude squared x frequency / frequency bin width for each bin.

 1027:     nreals

 1028:         Number of realizations.

 1029:     mt : (M,) 1Darray of scalars

 1030:         Total masses, M, of each bin center.

 1031:     mr : (Q,) 1Darray of scalars

 1032:         Mass ratios, q, of each bin center.

 1033:     rz : (Z,) 1Darray of scalars

 1034:         Redshifts, z, of each bin center.

 1035: 

 1036:     Returns

 1037:     --------------------------

 1038:     hc2ss : (F, R) Ndarray of scalars

 1039:         Char strain squared of the loudest single sources.

 1040:     hc2bg : (F, R) Ndarray of scalars

 1041:         Char strain squared of the background.

 1042:     ssidx : (3, F, R) NDarray of ints

 1043:         Indices of the loudest single sources. -1 if there are

 1044:         no single sources at that frequency/realization.

 1045:     bgpar : (3, F, R) NDarray of scalars

 1046:         Average effective M, q, z parameters of the background.

 1047:     sspar : (3, F, R) NDarray of scalars

 1048:         M, q, z parameters of the loudest single sources.

 1049:     """

 1050: 

+1051:     cdef long[:] shape = np.array(number.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1051, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1051, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_number, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1051, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1051, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1051, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_shape = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

+1052:     F = shape[3]

  __pyx_t_6 = 3;
  __pyx_t_7 = -1;
  if (__pyx_t_6 < 0) {
    __pyx_t_6 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_6 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1052, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyInt_From_long((*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_6 * __pyx_v_shape.strides[0]) )))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1052, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_F = __pyx_t_1;
  __pyx_t_1 = 0;

+1053:     R = nreals

  __Pyx_INCREF(__pyx_v_nreals);
  __pyx_v_R = __pyx_v_nreals;

+1054:     cdef np.ndarray[np.double_t, ndim=2] hc2ss = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1054, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1054, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1054, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1054, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1054, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2ss = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1054, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2ss.diminfo[0].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2ss.diminfo[0].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2ss.diminfo[1].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2ss.diminfo[1].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_hc2ss = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1055:     cdef np.ndarray[np.double_t, ndim=2] hc2bg = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1055, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1055, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2bg = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1055, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2bg.diminfo[0].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2bg.diminfo[0].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2bg.diminfo[1].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2bg.diminfo[1].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_hc2bg = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1056:     cdef np.ndarray[np.longlong_t, ndim=3] ssidx = np.zeros((3,F,R), dtype=int)

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_R);
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 1056, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1056, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1056, __pyx_L1_error)
  __pyx_t_10 = ((PyArrayObject *)__pyx_t_4);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_longlong_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_ssidx = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1056, __pyx_L1_error)
    } else {__pyx_pybuffernd_ssidx.diminfo[0].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ssidx.diminfo[0].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ssidx.diminfo[1].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ssidx.diminfo[1].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_ssidx.diminfo[2].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_ssidx.diminfo[2].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_10 = 0;
  __pyx_v_ssidx = ((PyArrayObject *)__pyx_t_4);
  __pyx_t_4 = 0;

+1057:     cdef np.ndarray[np.double_t, ndim=3] bgpar = np.zeros((3,F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_R);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_t_1) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1057, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1057, __pyx_L1_error)
  __pyx_t_11 = ((PyArrayObject *)__pyx_t_4);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_bgpar = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1057, __pyx_L1_error)
    } else {__pyx_pybuffernd_bgpar.diminfo[0].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_bgpar.diminfo[0].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_bgpar.diminfo[1].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_bgpar.diminfo[1].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_bgpar.diminfo[2].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_bgpar.diminfo[2].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_11 = 0;
  __pyx_v_bgpar = ((PyArrayObject *)__pyx_t_4);
  __pyx_t_4 = 0;

+1058:     cdef np.ndarray[np.double_t, ndim=3] sspar = np.zeros((3,F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1058, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1058, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1058, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_R);
  __pyx_t_3 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
    __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
    if (likely(__pyx_t_3)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
      __Pyx_INCREF(__pyx_t_3);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_1, function);
    }
  }
  __pyx_t_4 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1058, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1058, __pyx_L1_error)
  __pyx_t_12 = ((PyArrayObject *)__pyx_t_4);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sspar.rcbuffer->pybuffer, (PyObject*)__pyx_t_12, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_sspar = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sspar.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1058, __pyx_L1_error)
    } else {__pyx_pybuffernd_sspar.diminfo[0].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sspar.diminfo[0].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sspar.diminfo[1].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sspar.diminfo[1].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_sspar.diminfo[2].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_sspar.diminfo[2].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_12 = 0;
  __pyx_v_sspar = ((PyArrayObject *)__pyx_t_4);
  __pyx_t_4 = 0;

+1059:     _ss_bg_hc_and_par(shape, h2fdf, number, nreals, normal_threshold,

  __pyx_t_13 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_h2fdf, PyBUF_WRITABLE); if (unlikely(!__pyx_t_13.memview)) __PYX_ERR(0, 1059, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_number, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 1059, __pyx_L1_error)
  __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1059, __pyx_L1_error)
  __pyx_t_16 = __Pyx_PyInt_As_long(__pyx_v_normal_threshold); if (unlikely((__pyx_t_16 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1059, __pyx_L1_error)
/* … */
  __pyx_f_8holodeck_7cyutils__ss_bg_hc_and_par(__pyx_v_shape, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __pyx_t_13.memview = NULL;
  __pyx_t_13.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_14, 1);
  __pyx_t_14.memview = NULL;
  __pyx_t_14.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __pyx_t_17.memview = NULL;
  __pyx_t_17.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __pyx_t_18.memview = NULL;
  __pyx_t_18.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __pyx_t_19.memview = NULL;
  __pyx_t_19.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __pyx_t_20.memview = NULL;
  __pyx_t_20.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __pyx_t_21.memview = NULL;
  __pyx_t_21.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1);
  __pyx_t_22.memview = NULL;
  __pyx_t_22.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_23, 1);
  __pyx_t_23.memview = NULL;
  __pyx_t_23.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1);
  __pyx_t_24.memview = NULL;
  __pyx_t_24.data = NULL;

+1060:                  mt, mr, rz,

  __pyx_t_17 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mt, PyBUF_WRITABLE); if (unlikely(!__pyx_t_17.memview)) __PYX_ERR(0, 1060, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(0, 1060, __pyx_L1_error)
  __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_rz, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(0, 1060, __pyx_L1_error)

+1061:                 hc2ss, hc2bg, ssidx, bgpar, sspar)

  __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2ss), PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(0, 1061, __pyx_L1_error)
  __pyx_t_21 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2bg), PyBUF_WRITABLE); if (unlikely(!__pyx_t_21.memview)) __PYX_ERR(0, 1061, __pyx_L1_error)
  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_long(((PyObject *)__pyx_v_ssidx), PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 1061, __pyx_L1_error)
  __pyx_t_23 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_bgpar), PyBUF_WRITABLE); if (unlikely(!__pyx_t_23.memview)) __PYX_ERR(0, 1061, __pyx_L1_error)
  __pyx_t_24 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_sspar), PyBUF_WRITABLE); if (unlikely(!__pyx_t_24.memview)) __PYX_ERR(0, 1061, __pyx_L1_error)

+1062:     return hc2ss, hc2bg, ssidx, bgpar, sspar

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1062, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2ss));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2ss));
  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_hc2ss));
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2bg));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2bg));
  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_hc2bg));
  __Pyx_INCREF(((PyObject *)__pyx_v_ssidx));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_ssidx));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_ssidx));
  __Pyx_INCREF(((PyObject *)__pyx_v_bgpar));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_bgpar));
  PyTuple_SET_ITEM(__pyx_t_4, 3, ((PyObject *)__pyx_v_bgpar));
  __Pyx_INCREF(((PyObject *)__pyx_v_sspar));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_sspar));
  PyTuple_SET_ITEM(__pyx_t_4, 4, ((PyObject *)__pyx_v_sspar));
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 1063: 

 1064: @cython.boundscheck(True)

 1065: @cython.wraparound(True)

 1066: @cython.nonecheck(True)

 1067: @cython.cdivision(True)

+1068: cdef void _ss_bg_hc_and_par(long[:] shape, double[:,:,:,:] h2fdf, double[:,:,:,:] number,

static void __pyx_f_8holodeck_7cyutils__ss_bg_hc_and_par(__Pyx_memviewslice __pyx_v_shape, __Pyx_memviewslice __pyx_v_h2fdf, __Pyx_memviewslice __pyx_v_number, long __pyx_v_nreals, long __pyx_v_thresh, __Pyx_memviewslice __pyx_v_mt, __Pyx_memviewslice __pyx_v_mr, __Pyx_memviewslice __pyx_v_rz, __Pyx_memviewslice __pyx_v_hc2ss, __Pyx_memviewslice __pyx_v_hc2bg, __Pyx_memviewslice __pyx_v_ssidx, __Pyx_memviewslice __pyx_v_bgpar, __Pyx_memviewslice __pyx_v_sspar) {
  int __pyx_v_M;
  int __pyx_v_Q;
  int __pyx_v_Z;
  int __pyx_v_F;
  int __pyx_v_R;
  int __pyx_v_mm;
  int __pyx_v_qq;
  int __pyx_v_zz;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_m_max;
  int __pyx_v_q_max;
  int __pyx_v_z_max;
  double __pyx_v_max;
  double __pyx_v_num;
  double __pyx_v_sum;
  double __pyx_v_m_avg;
  double __pyx_v_q_avg;
  double __pyx_v_z_avg;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  PyObject *__pyx_v_cur = NULL;
  double __pyx_v_std;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_ss_bg_hc_and_par", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_28);
  __Pyx_WriteUnraisable("holodeck.cyutils._ss_bg_hc_and_par", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_XDECREF(__pyx_v_cur);
  __Pyx_RefNannyFinishContext();
}

 1069:             long nreals, long thresh,

 1070:             double[:] mt, double[:] mr, double[:] rz,

 1071:             double[:,:] hc2ss, double[:,:] hc2bg, long[:,:,:] ssidx,

 1072:             double[:,:,:] bgpar, double[:,:,:] sspar):

 1073:     """

 1074:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1075: 

 1076:     Parameters

 1077:     __________

 1078:     shape : long[:] array

 1079:         shape of number, [M, Q, Z, F]

 1080:     number : double[:,:,:,:] array

 1081:         number per bin

 1082:     h2fdf : double[:,:,:,:] array

 1083:         strain amplitude squared * f/Delta f for a single source in each bin.

 1084:     nreals : int

 1085:         number of realizations.

 1086:     mt : (M,) 1Darray of scalars

 1087:         total masses of each bin center

 1088:     mr : (Q,) 1Darray of scalars

 1089:         mass ratios of each bin center

 1090:     rz : (Z,) 1Darray of scalars

 1091:         redshifts of each bin center

 1092: 

 1093:     hc2ss : double[:,:] array

 1094:         (memory address of) single source characteristic strain squared array.

 1095:     hc2bg : double[:,:] array

 1096:         (memory address of) background characteristic strain squared array.

 1097:     ssidx : [:,:,:] long array

 1098:         (memory address of) array for indices of max strain bins.

 1099:     bgpar :

 1100:         (memory address of) array of effective average parameters

 1101:     Returns

 1102:     _________

 1103:     void

 1104:     updated via memory address: hc2ss, hc2bg, ssidx, bg_par

 1105:     """

 1106: 

+1107:     cdef int M = shape[0]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1107, __pyx_L1_error)
  }
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1107, __pyx_L1_error)
  }
  __pyx_v_M = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1108:     cdef int Q = shape[1]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1108, __pyx_L1_error)
  }
  __pyx_t_1 = 1;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1108, __pyx_L1_error)
  }
  __pyx_v_Q = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1109:     cdef int Z = shape[2]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1109, __pyx_L1_error)
  }
  __pyx_t_1 = 2;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1109, __pyx_L1_error)
  }
  __pyx_v_Z = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1110:     cdef int F = shape[3]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1110, __pyx_L1_error)
  }
  __pyx_t_1 = 3;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1110, __pyx_L1_error)
  }
  __pyx_v_F = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1111:     cdef int R = nreals

  __pyx_v_R = __pyx_v_nreals;

 1112: 

 1113:     cdef int mm, qq, zz, ff, rr, m_max, q_max, z_max

 1114:     cdef double max, num, sum, m_avg, q_avg, z_avg

 1115: 

 1116: 

 1117:     # Setup random number generator from numpy library

 1118:     cdef bitgen_t *rng

+1119:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+1120:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_capsule); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1120, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_capsule = __pyx_t_4;
  __pyx_t_4 = 0;

 1121:     # Cast the pointer

+1122:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_6 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_6 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1122, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_6);

+1123:     for rr in range(R):

  __pyx_t_2 = __pyx_v_R;
  __pyx_t_7 = __pyx_t_2;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
    __pyx_v_rr = __pyx_t_8;

+1124:         for ff in range(F):

    __pyx_t_9 = __pyx_v_F;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
      __pyx_v_ff = __pyx_t_11;

+1125:             max=0

      __pyx_v_max = 0.0;

+1126:             sum=0

      __pyx_v_sum = 0.0;

+1127:             m_avg=0

      __pyx_v_m_avg = 0.0;

+1128:             q_avg=0

      __pyx_v_q_avg = 0.0;

+1129:             z_avg=0

      __pyx_v_z_avg = 0.0;

+1130:             m_max=-1

      __pyx_v_m_max = -1;

+1131:             q_max=-1

      __pyx_v_q_max = -1;

+1132:             z_max=-1

      __pyx_v_z_max = -1;

+1133:             for mm in range(M):

      __pyx_t_12 = __pyx_v_M;
      __pyx_t_13 = __pyx_t_12;
      for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
        __pyx_v_mm = __pyx_t_14;

+1134:                 for qq in range(Q):

        __pyx_t_15 = __pyx_v_Q;
        __pyx_t_16 = __pyx_t_15;
        for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) {
          __pyx_v_qq = __pyx_t_17;

+1135:                     for zz in range(Z):

          __pyx_t_18 = __pyx_v_Z;
          __pyx_t_19 = __pyx_t_18;
          for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) {
            __pyx_v_zz = __pyx_t_20;

+1136:                         num = number[mm,qq,zz,ff]

            if (unlikely(((PyObject *) __pyx_v_number.memview) == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
              __PYX_ERR(0, 1136, __pyx_L1_error)
            }
            __pyx_t_1 = __pyx_v_mm;
            __pyx_t_21 = __pyx_v_qq;
            __pyx_t_22 = __pyx_v_zz;
            __pyx_t_23 = __pyx_v_ff;
            __pyx_t_24 = -1;
            if (__pyx_t_1 < 0) {
              __pyx_t_1 += __pyx_v_number.shape[0];
              if (unlikely(__pyx_t_1 < 0)) __pyx_t_24 = 0;
            } else if (unlikely(__pyx_t_1 >= __pyx_v_number.shape[0])) __pyx_t_24 = 0;
            if (__pyx_t_21 < 0) {
              __pyx_t_21 += __pyx_v_number.shape[1];
              if (unlikely(__pyx_t_21 < 0)) __pyx_t_24 = 1;
            } else if (unlikely(__pyx_t_21 >= __pyx_v_number.shape[1])) __pyx_t_24 = 1;
            if (__pyx_t_22 < 0) {
              __pyx_t_22 += __pyx_v_number.shape[2];
              if (unlikely(__pyx_t_22 < 0)) __pyx_t_24 = 2;
            } else if (unlikely(__pyx_t_22 >= __pyx_v_number.shape[2])) __pyx_t_24 = 2;
            if (__pyx_t_23 < 0) {
              __pyx_t_23 += __pyx_v_number.shape[3];
              if (unlikely(__pyx_t_23 < 0)) __pyx_t_24 = 3;
            } else if (unlikely(__pyx_t_23 >= __pyx_v_number.shape[3])) __pyx_t_24 = 3;
            if (unlikely(__pyx_t_24 != -1)) {
              __Pyx_RaiseBufferIndexError(__pyx_t_24);
              __PYX_ERR(0, 1136, __pyx_L1_error)
            }
            __pyx_v_num = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_number.data + __pyx_t_1 * __pyx_v_number.strides[0]) ) + __pyx_t_21 * __pyx_v_number.strides[1]) ) + __pyx_t_22 * __pyx_v_number.strides[2]) ) + __pyx_t_23 * __pyx_v_number.strides[3]) )));

+1137:                         cur = h2fdf[mm,qq,zz,ff]

            if (unlikely(((PyObject *) __pyx_v_h2fdf.memview) == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
              __PYX_ERR(0, 1137, __pyx_L1_error)
            }
            __pyx_t_23 = __pyx_v_mm;
            __pyx_t_22 = __pyx_v_qq;
            __pyx_t_21 = __pyx_v_zz;
            __pyx_t_1 = __pyx_v_ff;
            __pyx_t_24 = -1;
            if (__pyx_t_23 < 0) {
              __pyx_t_23 += __pyx_v_h2fdf.shape[0];
              if (unlikely(__pyx_t_23 < 0)) __pyx_t_24 = 0;
            } else if (unlikely(__pyx_t_23 >= __pyx_v_h2fdf.shape[0])) __pyx_t_24 = 0;
            if (__pyx_t_22 < 0) {
              __pyx_t_22 += __pyx_v_h2fdf.shape[1];
              if (unlikely(__pyx_t_22 < 0)) __pyx_t_24 = 1;
            } else if (unlikely(__pyx_t_22 >= __pyx_v_h2fdf.shape[1])) __pyx_t_24 = 1;
            if (__pyx_t_21 < 0) {
              __pyx_t_21 += __pyx_v_h2fdf.shape[2];
              if (unlikely(__pyx_t_21 < 0)) __pyx_t_24 = 2;
            } else if (unlikely(__pyx_t_21 >= __pyx_v_h2fdf.shape[2])) __pyx_t_24 = 2;
            if (__pyx_t_1 < 0) {
              __pyx_t_1 += __pyx_v_h2fdf.shape[3];
              if (unlikely(__pyx_t_1 < 0)) __pyx_t_24 = 3;
            } else if (unlikely(__pyx_t_1 >= __pyx_v_h2fdf.shape[3])) __pyx_t_24 = 3;
            if (unlikely(__pyx_t_24 != -1)) {
              __Pyx_RaiseBufferIndexError(__pyx_t_24);
              __PYX_ERR(0, 1137, __pyx_L1_error)
            }
            __pyx_t_4 = PyFloat_FromDouble((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_23 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_22 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_21 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[3]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1137, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_XDECREF_SET(__pyx_v_cur, __pyx_t_4);
            __pyx_t_4 = 0;

+1138:                         if (num>thresh):

            __pyx_t_25 = ((__pyx_v_num > __pyx_v_thresh) != 0);
            if (__pyx_t_25) {
/* … */
              goto __pyx_L13;
            }

+1139:                             std = sqrt(num)

              __pyx_v_std = sqrt(__pyx_v_num);

+1140:                             num = <double>random_normal(rng, num, std)

              __pyx_v_num = ((double)random_normal(__pyx_v_rng, __pyx_v_num, __pyx_v_std));

 1141:                         else:

+1142:                             num = <double>random_poisson(rng, num)

            /*else*/ {
              __pyx_v_num = ((double)random_poisson(__pyx_v_rng, __pyx_v_num));
            }
            __pyx_L13:;

+1143:                         if(cur > max and num > 0):

            __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1143, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_3 = PyObject_RichCompare(__pyx_v_cur, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1143, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_26 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_26 < 0)) __PYX_ERR(0, 1143, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (__pyx_t_26) {
            } else {
              __pyx_t_25 = __pyx_t_26;
              goto __pyx_L15_bool_binop_done;
            }
            __pyx_t_26 = ((__pyx_v_num > 0.0) != 0);
            __pyx_t_25 = __pyx_t_26;
            __pyx_L15_bool_binop_done:;
            if (__pyx_t_25) {
/* … */
            }

+1144:                             max = cur

              __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_v_cur); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1144, __pyx_L1_error)
              __pyx_v_max = __pyx_t_27;

+1145:                             m_max = mm

              __pyx_v_m_max = __pyx_v_mm;

+1146:                             q_max = qq

              __pyx_v_q_max = __pyx_v_qq;

+1147:                             z_max = zz

              __pyx_v_z_max = __pyx_v_zz;

+1148:                         sum += num * cur

            __pyx_t_3 = PyFloat_FromDouble(__pyx_v_sum); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1148, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_4 = PyFloat_FromDouble(__pyx_v_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1148, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_5 = PyNumber_Multiply(__pyx_t_4, __pyx_v_cur); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1148, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1148, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_t_4); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1148, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_v_sum = __pyx_t_27;

+1149:                         m_avg += num * cur * mt[mm]

            __pyx_t_4 = PyFloat_FromDouble(__pyx_v_m_avg); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __pyx_t_5 = PyFloat_FromDouble(__pyx_v_num); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_3 = PyNumber_Multiply(__pyx_t_5, __pyx_v_cur); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            if (unlikely(((PyObject *) __pyx_v_mt.memview) == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
              __PYX_ERR(0, 1149, __pyx_L1_error)
            }
            __pyx_t_1 = __pyx_v_mm;
            __pyx_t_24 = -1;
            if (__pyx_t_1 < 0) {
              __pyx_t_1 += __pyx_v_mt.shape[0];
              if (unlikely(__pyx_t_1 < 0)) __pyx_t_24 = 0;
            } else if (unlikely(__pyx_t_1 >= __pyx_v_mt.shape[0])) __pyx_t_24 = 0;
            if (unlikely(__pyx_t_24 != -1)) {
              __Pyx_RaiseBufferIndexError(__pyx_t_24);
              __PYX_ERR(0, 1149, __pyx_L1_error)
            }
            __pyx_t_5 = PyFloat_FromDouble((*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_1 * __pyx_v_mt.strides[0]) )))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_28 = PyNumber_Multiply(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_28);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_t_5 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_28); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
            __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_t_5); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1149, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __pyx_v_m_avg = __pyx_t_27;

+1150:                         q_avg += num * cur * mr[qq]

            __pyx_t_5 = PyFloat_FromDouble(__pyx_v_q_avg); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __pyx_t_28 = PyFloat_FromDouble(__pyx_v_num); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_28);
            __pyx_t_4 = PyNumber_Multiply(__pyx_t_28, __pyx_v_cur); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
            if (unlikely(((PyObject *) __pyx_v_mr.memview) == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
              __PYX_ERR(0, 1150, __pyx_L1_error)
            }
            __pyx_t_1 = __pyx_v_qq;
            __pyx_t_24 = -1;
            if (__pyx_t_1 < 0) {
              __pyx_t_1 += __pyx_v_mr.shape[0];
              if (unlikely(__pyx_t_1 < 0)) __pyx_t_24 = 0;
            } else if (unlikely(__pyx_t_1 >= __pyx_v_mr.shape[0])) __pyx_t_24 = 0;
            if (unlikely(__pyx_t_24 != -1)) {
              __Pyx_RaiseBufferIndexError(__pyx_t_24);
              __PYX_ERR(0, 1150, __pyx_L1_error)
            }
            __pyx_t_28 = PyFloat_FromDouble((*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_1 * __pyx_v_mr.strides[0]) )))); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_28);
            __pyx_t_3 = PyNumber_Multiply(__pyx_t_4, __pyx_t_28); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
            __pyx_t_28 = PyNumber_InPlaceAdd(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_28);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_t_28); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1150, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
            __pyx_v_q_avg = __pyx_t_27;

+1151:                         z_avg += num * cur * rz[zz]

            __pyx_t_28 = PyFloat_FromDouble(__pyx_v_z_avg); if (unlikely(!__pyx_t_28)) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_28);
            __pyx_t_3 = PyFloat_FromDouble(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_v_cur); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_5);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            if (unlikely(((PyObject *) __pyx_v_rz.memview) == Py_None)) {
              PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
              __PYX_ERR(0, 1151, __pyx_L1_error)
            }
            __pyx_t_1 = __pyx_v_zz;
            __pyx_t_24 = -1;
            if (__pyx_t_1 < 0) {
              __pyx_t_1 += __pyx_v_rz.shape[0];
              if (unlikely(__pyx_t_1 < 0)) __pyx_t_24 = 0;
            } else if (unlikely(__pyx_t_1 >= __pyx_v_rz.shape[0])) __pyx_t_24 = 0;
            if (unlikely(__pyx_t_24 != -1)) {
              __Pyx_RaiseBufferIndexError(__pyx_t_24);
              __PYX_ERR(0, 1151, __pyx_L1_error)
            }
            __pyx_t_3 = PyFloat_FromDouble((*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_1 * __pyx_v_rz.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_4 = PyNumber_Multiply(__pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_t_28, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_28); __pyx_t_28 = 0;
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __pyx_t_27 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_27 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1151, __pyx_L1_error)
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __pyx_v_z_avg = __pyx_t_27;
          }
        }
      }

 1152:             # characteristic frequencies squared

+1153:             hc2ss[ff,rr] = max

      if (unlikely(((PyObject *) __pyx_v_hc2ss.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1153, __pyx_L1_error)
      }
      __pyx_t_1 = __pyx_v_ff;
      __pyx_t_21 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_hc2ss.shape[0];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_hc2ss.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_hc2ss.shape[1];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_hc2ss.shape[1])) __pyx_t_12 = 1;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1153, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2ss.data + __pyx_t_1 * __pyx_v_hc2ss.strides[0]) ) + __pyx_t_21 * __pyx_v_hc2ss.strides[1]) )) = __pyx_v_max;

+1154:             hc2bg[ff,rr] = sum - max

      if (unlikely(((PyObject *) __pyx_v_hc2bg.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1154, __pyx_L1_error)
      }
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_1 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_hc2bg.shape[0];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_hc2bg.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_hc2bg.shape[1];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_hc2bg.shape[1])) __pyx_t_12 = 1;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1154, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2bg.data + __pyx_t_21 * __pyx_v_hc2bg.strides[0]) ) + __pyx_t_1 * __pyx_v_hc2bg.strides[1]) )) = (__pyx_v_sum - __pyx_v_max);

 1155: 

 1156:             # single source indices

+1157:             if (m_max<0):

      __pyx_t_25 = ((__pyx_v_m_max < 0) != 0);
      if (unlikely(__pyx_t_25)) {
/* … */
      }

+1158:                 raise

        __Pyx_ReraiseException(); __PYX_ERR(0, 1158, __pyx_L1_error)

+1159:             ssidx[0,ff,rr] = m_max # -1 if no single sources

      if (unlikely(((PyObject *) __pyx_v_ssidx.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1159, __pyx_L1_error)
      }
      __pyx_t_1 = 0;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_22 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_ssidx.shape[0];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_ssidx.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_ssidx.shape[1];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_ssidx.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_22 < 0) {
        __pyx_t_22 += __pyx_v_ssidx.shape[2];
        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_ssidx.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1159, __pyx_L1_error)
      }
      *((long *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_1 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_22 * __pyx_v_ssidx.strides[2]) )) = __pyx_v_m_max;

+1160:             ssidx[1,ff,rr] = q_max # -1 if no single sources

      if (unlikely(((PyObject *) __pyx_v_ssidx.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1160, __pyx_L1_error)
      }
      __pyx_t_22 = 1;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_1 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_22 < 0) {
        __pyx_t_22 += __pyx_v_ssidx.shape[0];
        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_ssidx.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_ssidx.shape[1];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_ssidx.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_ssidx.shape[2];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_ssidx.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1160, __pyx_L1_error)
      }
      *((long *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_22 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_1 * __pyx_v_ssidx.strides[2]) )) = __pyx_v_q_max;

+1161:             ssidx[2,ff,rr] = z_max # -1 if no single sources

      if (unlikely(((PyObject *) __pyx_v_ssidx.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1161, __pyx_L1_error)
      }
      __pyx_t_1 = 2;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_22 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_ssidx.shape[0];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_ssidx.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_ssidx.shape[1];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_ssidx.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_22 < 0) {
        __pyx_t_22 += __pyx_v_ssidx.shape[2];
        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_ssidx.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1161, __pyx_L1_error)
      }
      *((long *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_1 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_22 * __pyx_v_ssidx.strides[2]) )) = __pyx_v_z_max;

 1162: 

 1163:             # background average parameters

+1164:             bgpar[0,ff,rr] = ((m_avg - h2fdf[m_max, q_max, z_max, ff] * mt[m_max])

      if (unlikely(((PyObject *) __pyx_v_h2fdf.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1164, __pyx_L1_error)
      }
      __pyx_t_22 = __pyx_v_m_max;
      __pyx_t_21 = __pyx_v_q_max;
      __pyx_t_1 = __pyx_v_z_max;
      __pyx_t_23 = __pyx_v_ff;
      __pyx_t_12 = -1;
      if (__pyx_t_22 < 0) {
        __pyx_t_22 += __pyx_v_h2fdf.shape[0];
        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_h2fdf.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_h2fdf.shape[1];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_h2fdf.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_h2fdf.shape[2];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_h2fdf.shape[2])) __pyx_t_12 = 2;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_v_h2fdf.shape[3];
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_12 = 3;
      } else if (unlikely(__pyx_t_23 >= __pyx_v_h2fdf.shape[3])) __pyx_t_12 = 3;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1164, __pyx_L1_error)
      }
      if (unlikely(((PyObject *) __pyx_v_mt.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1164, __pyx_L1_error)
      }
      __pyx_t_29 = __pyx_v_m_max;
      __pyx_t_12 = -1;
      if (__pyx_t_29 < 0) {
        __pyx_t_29 += __pyx_v_mt.shape[0];
        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_29 >= __pyx_v_mt.shape[0])) __pyx_t_12 = 0;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1164, __pyx_L1_error)
      }
/* … */
      if (unlikely(((PyObject *) __pyx_v_bgpar.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1164, __pyx_L1_error)
      }
/* … */
      __pyx_t_30 = 0;
      __pyx_t_31 = __pyx_v_ff;
      __pyx_t_32 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_30 < 0) {
        __pyx_t_30 += __pyx_v_bgpar.shape[0];
        if (unlikely(__pyx_t_30 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_30 >= __pyx_v_bgpar.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_31 < 0) {
        __pyx_t_31 += __pyx_v_bgpar.shape[1];
        if (unlikely(__pyx_t_31 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_31 >= __pyx_v_bgpar.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_32 < 0) {
        __pyx_t_32 += __pyx_v_bgpar.shape[2];
        if (unlikely(__pyx_t_32 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_32 >= __pyx_v_bgpar.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1164, __pyx_L1_error)
      }
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_30 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_31 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_32 * __pyx_v_bgpar.strides[2]) )) = ((__pyx_v_m_avg - ((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_22 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_21 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_23 * __pyx_v_h2fdf.strides[3]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_29 * __pyx_v_mt.strides[0]) ))))) / (__pyx_v_sum - __pyx_v_max));

 1165:                                 /(sum-max))

+1166:             bgpar[1,ff,rr] = ((q_avg - h2fdf[m_max, q_max, z_max, ff] * mr[q_max])

      if (unlikely(((PyObject *) __pyx_v_h2fdf.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1166, __pyx_L1_error)
      }
      __pyx_t_29 = __pyx_v_m_max;
      __pyx_t_23 = __pyx_v_q_max;
      __pyx_t_1 = __pyx_v_z_max;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_12 = -1;
      if (__pyx_t_29 < 0) {
        __pyx_t_29 += __pyx_v_h2fdf.shape[0];
        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_29 >= __pyx_v_h2fdf.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_v_h2fdf.shape[1];
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_23 >= __pyx_v_h2fdf.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_h2fdf.shape[2];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_h2fdf.shape[2])) __pyx_t_12 = 2;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_h2fdf.shape[3];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 3;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_h2fdf.shape[3])) __pyx_t_12 = 3;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1166, __pyx_L1_error)
      }
      if (unlikely(((PyObject *) __pyx_v_mr.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1166, __pyx_L1_error)
      }
      __pyx_t_22 = __pyx_v_q_max;
      __pyx_t_12 = -1;
      if (__pyx_t_22 < 0) {
        __pyx_t_22 += __pyx_v_mr.shape[0];
        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_mr.shape[0])) __pyx_t_12 = 0;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1166, __pyx_L1_error)
      }
/* … */
      if (unlikely(((PyObject *) __pyx_v_bgpar.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1166, __pyx_L1_error)
      }
/* … */
      __pyx_t_32 = 1;
      __pyx_t_31 = __pyx_v_ff;
      __pyx_t_30 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_32 < 0) {
        __pyx_t_32 += __pyx_v_bgpar.shape[0];
        if (unlikely(__pyx_t_32 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_32 >= __pyx_v_bgpar.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_31 < 0) {
        __pyx_t_31 += __pyx_v_bgpar.shape[1];
        if (unlikely(__pyx_t_31 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_31 >= __pyx_v_bgpar.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_30 < 0) {
        __pyx_t_30 += __pyx_v_bgpar.shape[2];
        if (unlikely(__pyx_t_30 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_30 >= __pyx_v_bgpar.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1166, __pyx_L1_error)
      }
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_32 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_31 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_30 * __pyx_v_bgpar.strides[2]) )) = ((__pyx_v_q_avg - ((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_29 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_23 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_21 * __pyx_v_h2fdf.strides[3]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_22 * __pyx_v_mr.strides[0]) ))))) / (__pyx_v_sum - __pyx_v_max));

 1167:                                 /(sum-max))

+1168:             bgpar[2,ff,rr] = ((z_avg - h2fdf[m_max, q_max, z_max, ff] * rz[z_max])

      if (unlikely(((PyObject *) __pyx_v_h2fdf.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1168, __pyx_L1_error)
      }
      __pyx_t_22 = __pyx_v_m_max;
      __pyx_t_21 = __pyx_v_q_max;
      __pyx_t_1 = __pyx_v_z_max;
      __pyx_t_23 = __pyx_v_ff;
      __pyx_t_12 = -1;
      if (__pyx_t_22 < 0) {
        __pyx_t_22 += __pyx_v_h2fdf.shape[0];
        if (unlikely(__pyx_t_22 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_22 >= __pyx_v_h2fdf.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_h2fdf.shape[1];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_h2fdf.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_h2fdf.shape[2];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_h2fdf.shape[2])) __pyx_t_12 = 2;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_v_h2fdf.shape[3];
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_12 = 3;
      } else if (unlikely(__pyx_t_23 >= __pyx_v_h2fdf.shape[3])) __pyx_t_12 = 3;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1168, __pyx_L1_error)
      }
      if (unlikely(((PyObject *) __pyx_v_rz.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1168, __pyx_L1_error)
      }
      __pyx_t_29 = __pyx_v_z_max;
      __pyx_t_12 = -1;
      if (__pyx_t_29 < 0) {
        __pyx_t_29 += __pyx_v_rz.shape[0];
        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_29 >= __pyx_v_rz.shape[0])) __pyx_t_12 = 0;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1168, __pyx_L1_error)
      }
/* … */
      if (unlikely(((PyObject *) __pyx_v_bgpar.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1168, __pyx_L1_error)
      }
/* … */
      __pyx_t_30 = 2;
      __pyx_t_31 = __pyx_v_ff;
      __pyx_t_32 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_30 < 0) {
        __pyx_t_30 += __pyx_v_bgpar.shape[0];
        if (unlikely(__pyx_t_30 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_30 >= __pyx_v_bgpar.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_31 < 0) {
        __pyx_t_31 += __pyx_v_bgpar.shape[1];
        if (unlikely(__pyx_t_31 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_31 >= __pyx_v_bgpar.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_32 < 0) {
        __pyx_t_32 += __pyx_v_bgpar.shape[2];
        if (unlikely(__pyx_t_32 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_32 >= __pyx_v_bgpar.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1168, __pyx_L1_error)
      }
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_30 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_31 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_32 * __pyx_v_bgpar.strides[2]) )) = ((__pyx_v_z_avg - ((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_22 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_21 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_23 * __pyx_v_h2fdf.strides[3]) ))) * (*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_29 * __pyx_v_rz.strides[0]) ))))) / (__pyx_v_sum - __pyx_v_max));

 1169:                                 /(sum-max))

 1170:             # single source parameters

+1171:             sspar[0,ff,rr] = mt[m_max]

      if (unlikely(((PyObject *) __pyx_v_mt.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1171, __pyx_L1_error)
      }
      __pyx_t_29 = __pyx_v_m_max;
      __pyx_t_12 = -1;
      if (__pyx_t_29 < 0) {
        __pyx_t_29 += __pyx_v_mt.shape[0];
        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_29 >= __pyx_v_mt.shape[0])) __pyx_t_12 = 0;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1171, __pyx_L1_error)
      }
      if (unlikely(((PyObject *) __pyx_v_sspar.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1171, __pyx_L1_error)
      }
      __pyx_t_23 = 0;
      __pyx_t_1 = __pyx_v_ff;
      __pyx_t_21 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_v_sspar.shape[0];
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_23 >= __pyx_v_sspar.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_sspar.shape[1];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_sspar.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_sspar.shape[2];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_sspar.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1171, __pyx_L1_error)
      }
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_23 * __pyx_v_sspar.strides[0]) ) + __pyx_t_1 * __pyx_v_sspar.strides[1]) ) + __pyx_t_21 * __pyx_v_sspar.strides[2]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_29 * __pyx_v_mt.strides[0]) )));

+1172:             sspar[1,ff,rr] = mr[q_max]

      if (unlikely(((PyObject *) __pyx_v_mr.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1172, __pyx_L1_error)
      }
      __pyx_t_29 = __pyx_v_q_max;
      __pyx_t_12 = -1;
      if (__pyx_t_29 < 0) {
        __pyx_t_29 += __pyx_v_mr.shape[0];
        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_29 >= __pyx_v_mr.shape[0])) __pyx_t_12 = 0;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1172, __pyx_L1_error)
      }
      if (unlikely(((PyObject *) __pyx_v_sspar.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1172, __pyx_L1_error)
      }
      __pyx_t_21 = 1;
      __pyx_t_1 = __pyx_v_ff;
      __pyx_t_23 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_sspar.shape[0];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_sspar.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_sspar.shape[1];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_sspar.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_v_sspar.shape[2];
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_23 >= __pyx_v_sspar.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1172, __pyx_L1_error)
      }
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_21 * __pyx_v_sspar.strides[0]) ) + __pyx_t_1 * __pyx_v_sspar.strides[1]) ) + __pyx_t_23 * __pyx_v_sspar.strides[2]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_29 * __pyx_v_mr.strides[0]) )));

+1173:             sspar[2,ff,rr] = rz[z_max]

      if (unlikely(((PyObject *) __pyx_v_rz.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1173, __pyx_L1_error)
      }
      __pyx_t_29 = __pyx_v_z_max;
      __pyx_t_12 = -1;
      if (__pyx_t_29 < 0) {
        __pyx_t_29 += __pyx_v_rz.shape[0];
        if (unlikely(__pyx_t_29 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_29 >= __pyx_v_rz.shape[0])) __pyx_t_12 = 0;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1173, __pyx_L1_error)
      }
      if (unlikely(((PyObject *) __pyx_v_sspar.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1173, __pyx_L1_error)
      }
      __pyx_t_23 = 2;
      __pyx_t_1 = __pyx_v_ff;
      __pyx_t_21 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_23 < 0) {
        __pyx_t_23 += __pyx_v_sspar.shape[0];
        if (unlikely(__pyx_t_23 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_23 >= __pyx_v_sspar.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_1 < 0) {
        __pyx_t_1 += __pyx_v_sspar.shape[1];
        if (unlikely(__pyx_t_1 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_1 >= __pyx_v_sspar.shape[1])) __pyx_t_12 = 1;
      if (__pyx_t_21 < 0) {
        __pyx_t_21 += __pyx_v_sspar.shape[2];
        if (unlikely(__pyx_t_21 < 0)) __pyx_t_12 = 2;
      } else if (unlikely(__pyx_t_21 >= __pyx_v_sspar.shape[2])) __pyx_t_12 = 2;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1173, __pyx_L1_error)
      }
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_23 * __pyx_v_sspar.strides[0]) ) + __pyx_t_1 * __pyx_v_sspar.strides[1]) ) + __pyx_t_21 * __pyx_v_sspar.strides[2]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_29 * __pyx_v_rz.strides[0]) )));

+1174:             if (max==0): # sanity check

      __pyx_t_25 = ((__pyx_v_max == 0.0) != 0);
      if (__pyx_t_25) {
/* … */
      }
    }
  }

+1175:                 print('No sources found at %dth frequency' % ff) # could warn

        __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_ff); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1175, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_No_sources_found_at_dth_frequenc, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1175, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1175, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1176:     # still need to sqrt and sum! (back in python)

 1177: 

+1178:     return

  goto __pyx_L0;

 1179: 

+1180: def sort_h2fdf(h2fdf):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_11sort_h2fdf(PyObject *__pyx_self, PyObject *__pyx_v_h2fdf); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_10sort_h2fdf[] = " Get indices of sorted h2fdf.\n    Parameters\n    ----------\n    h2fdf : (M,Q,Z) NDarray\n        h_s^2 * f / df of a source in each bin.\n    Returns\n    -------\n    indices : ?\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_11sort_h2fdf = {"sort_h2fdf", (PyCFunction)__pyx_pw_8holodeck_7cyutils_11sort_h2fdf, METH_O, __pyx_doc_8holodeck_7cyutils_10sort_h2fdf};
static PyObject *__pyx_pw_8holodeck_7cyutils_11sort_h2fdf(PyObject *__pyx_self, PyObject *__pyx_v_h2fdf) {
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sort_h2fdf (wrapper)", 0);
  __pyx_r = __pyx_pf_8holodeck_7cyutils_10sort_h2fdf(__pyx_self, ((PyObject *)__pyx_v_h2fdf));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_10sort_h2fdf(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_h2fdf) {
  __Pyx_memviewslice __pyx_v_shape = { 0, 0, { 0 }, { 0 }, { 0 } };
  long __pyx_v_size;
  __Pyx_memviewslice __pyx_v_flat_h2fdf = { 0, 0, { 0 }, { 0 }, { 0 } };
  long __pyx_v_ii;
  int *__pyx_v_indices;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("sort_h2fdf", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __Pyx_AddTraceback("holodeck.cyutils.sort_h2fdf", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_shape, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_v_flat_h2fdf, 1);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__36 = PyTuple_Pack(6, __pyx_n_s_h2fdf, __pyx_n_s_shape, __pyx_n_s_size, __pyx_n_s_flat_h2fdf, __pyx_n_s_ii, __pyx_n_s_indices); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__36);
  __Pyx_GIVEREF(__pyx_tuple__36);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_11sort_h2fdf, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sort_h2fdf, __pyx_t_3) < 0) __PYX_ERR(0, 1180, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__36, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_sort_h2fdf, 1180, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 1180, __pyx_L1_error)

 1181:     """ Get indices of sorted h2fdf.

 1182:     Parameters

 1183:     ----------

 1184:     h2fdf : (M,Q,Z) NDarray

 1185:         h_s^2 * f / df of a source in each bin.

 1186:     Returns

 1187:     -------

 1188:     indices : ?

 1189:     """

+1190:     cdef long[:] shape = np.array(h2fdf.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_h2fdf, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1190, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1190, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_shape = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

+1191:     cdef long size = shape[0] * shape[1] * shape[2]

  __pyx_t_6 = 0;
  __pyx_t_7 = -1;
  if (__pyx_t_6 < 0) {
    __pyx_t_6 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_6 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1191, __pyx_L1_error)
  }
  __pyx_t_8 = 1;
  __pyx_t_7 = -1;
  if (__pyx_t_8 < 0) {
    __pyx_t_8 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_8 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_8 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1191, __pyx_L1_error)
  }
  __pyx_t_9 = 2;
  __pyx_t_7 = -1;
  if (__pyx_t_9 < 0) {
    __pyx_t_9 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_9 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_9 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1191, __pyx_L1_error)
  }
  __pyx_v_size = (((*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_6 * __pyx_v_shape.strides[0]) ))) * (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_8 * __pyx_v_shape.strides[0]) )))) * (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_9 * __pyx_v_shape.strides[0]) ))));

 1192: 

+1193:     cdef double[:]flat_h2fdf = h2fdf.flatten()

  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_h2fdf, __pyx_n_s_flatten); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = NULL;
  if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_2)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_2);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1193, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1193, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_flat_h2fdf = __pyx_t_10;
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;

 1194: 

+1195:     print('flattened array elements')

  __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* … */
  __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_flattened_array_elements); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 1195, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple_);
  __Pyx_GIVEREF(__pyx_tuple_);

+1196:     for ii in range(size):

  __pyx_t_11 = __pyx_v_size;
  __pyx_t_12 = __pyx_t_11;
  for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
    __pyx_v_ii = __pyx_t_13;

+1197:         print(flat_h2fdf[ii])

    __pyx_t_9 = __pyx_v_ii;
    __pyx_t_7 = -1;
    if (__pyx_t_9 < 0) {
      __pyx_t_9 += __pyx_v_flat_h2fdf.shape[0];
      if (unlikely(__pyx_t_9 < 0)) __pyx_t_7 = 0;
    } else if (unlikely(__pyx_t_9 >= __pyx_v_flat_h2fdf.shape[0])) __pyx_t_7 = 0;
    if (unlikely(__pyx_t_7 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_7);
      __PYX_ERR(0, 1197, __pyx_L1_error)
    }
    __pyx_t_1 = PyFloat_FromDouble((*((double *) ( /* dim=0 */ (__pyx_v_flat_h2fdf.data + __pyx_t_9 * __pyx_v_flat_h2fdf.strides[0]) )))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1197, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1197, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  }

 1198: 

+1199:     indices = _sort_h2fdf(flat_h2fdf, size)

  __pyx_v_indices = __pyx_f_8holodeck_7cyutils__sort_h2fdf(__pyx_v_flat_h2fdf, __pyx_v_size);

 1200: 

+1201:     print('\nsorted array elements')

  __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* … */
  __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_sorted_array_elements); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 1201, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__2);
  __Pyx_GIVEREF(__pyx_tuple__2);

+1202:     for ii in range(size):

  __pyx_t_11 = __pyx_v_size;
  __pyx_t_12 = __pyx_t_11;
  for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
    __pyx_v_ii = __pyx_t_13;

+1203:         print(flat_h2fdf[indices[ii]])

    __pyx_t_9 = (__pyx_v_indices[__pyx_v_ii]);
    __pyx_t_7 = -1;
    if (__pyx_t_9 < 0) {
      __pyx_t_9 += __pyx_v_flat_h2fdf.shape[0];
      if (unlikely(__pyx_t_9 < 0)) __pyx_t_7 = 0;
    } else if (unlikely(__pyx_t_9 >= __pyx_v_flat_h2fdf.shape[0])) __pyx_t_7 = 0;
    if (unlikely(__pyx_t_7 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_7);
      __PYX_ERR(0, 1203, __pyx_L1_error)
    }
    __pyx_t_3 = PyFloat_FromDouble((*((double *) ( /* dim=0 */ (__pyx_v_flat_h2fdf.data + __pyx_t_9 * __pyx_v_flat_h2fdf.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1203, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  }

 1204: 

+1205:     return

  __Pyx_XDECREF(__pyx_r);
  __pyx_r = Py_None; __Pyx_INCREF(Py_None);
  goto __pyx_L0;

 1206: 

+1207: cdef (int *) _sort_h2fdf(double[:] flat_h2fdf, long size):

static int *__pyx_f_8holodeck_7cyutils__sort_h2fdf(__Pyx_memviewslice __pyx_v_flat_h2fdf, long __pyx_v_size) {
  double *__pyx_v_array;
  int *__pyx_v_indices;
  long __pyx_v_ii;
  int *__pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_sort_h2fdf", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_WriteUnraisable("holodeck.cyutils._sort_h2fdf", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1208: 

+1209:     cdef (double *)array = <double *>malloc(size * sizeof(double))

  __pyx_v_array = ((double *)malloc((__pyx_v_size * (sizeof(double)))));

+1210:     cdef (int *)indices = <int *>malloc(size * sizeof(int))

  __pyx_v_indices = ((int *)malloc((__pyx_v_size * (sizeof(int)))));

 1211: 

+1212:     for ii in range(size):

  __pyx_t_1 = __pyx_v_size;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_ii = __pyx_t_3;

+1213:         array[ii] = flat_h2fdf[ii]

    __pyx_t_4 = __pyx_v_ii;
    __pyx_t_5 = -1;
    if (__pyx_t_4 < 0) {
      __pyx_t_4 += __pyx_v_flat_h2fdf.shape[0];
      if (unlikely(__pyx_t_4 < 0)) __pyx_t_5 = 0;
    } else if (unlikely(__pyx_t_4 >= __pyx_v_flat_h2fdf.shape[0])) __pyx_t_5 = 0;
    if (unlikely(__pyx_t_5 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_5);
      __PYX_ERR(0, 1213, __pyx_L1_error)
    }
    (__pyx_v_array[__pyx_v_ii]) = (*((double *) ( /* dim=0 */ (__pyx_v_flat_h2fdf.data + __pyx_t_4 * __pyx_v_flat_h2fdf.strides[0]) )));
  }

 1214: 

+1215:     argsort(array, size, &indices)

  __pyx_f_8holodeck_7cyutils_argsort(__pyx_v_array, __pyx_v_size, (&__pyx_v_indices));

 1216: 

+1217:     return indices

  __pyx_r = __pyx_v_indices;
  goto __pyx_L0;

 1218: 

 1219: 

+1220: def loudest_hc_from_sorted(number, h2fdf, nreals, nloudest, msort, qsort, zsort, normal_threshold=1e10):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_13loudest_hc_from_sorted(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_12loudest_hc_from_sorted[] = "\n    Calculates the characteristic strain from loud single sources and a background of all other sources.\n\n    Parameters\n    ------------------------\n    number : [M, Q, Z, F] NDarray\n        number in each bin\n    h2fdf : [M, Q, Z, F] NDarray\n        Strain amplitude squared x frequency / frequency bin width for each bin.\n    nreals\n        Number of realizations.\n    nloudest\n        Number of loudest sources to separate in each frequency bin.\n    msort : (M*Q*Z,) 1Darray\n        M indices of each bin, sorted from largest to smallest h2fdf.\n    qsort : (M*Q*Z,) 1Darray\n        q indices of each bin, sorted from largest to smallest h2fdf.\n    zsort : (M*Q*Z,) 1Darray\n        z indices of each bin, sorted from largest to smallest h2fdf.\n    normal_threshold : float\n        Threshold for approximating poisson sampling as normal.\n\n    Returns\n    --------------------------\n    hc2ss : (F, R, L) Ndarray of scalars\n        Char strain squared of the loudest single sources.\n    hc2bg : (F, R) Ndarray of scalars\n        Char strain squared of the background.\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_13loudest_hc_from_sorted = {"loudest_hc_from_sorted", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_13loudest_hc_from_sorted, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_12loudest_hc_from_sorted};
static PyObject *__pyx_pw_8holodeck_7cyutils_13loudest_hc_from_sorted(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_number = 0;
  PyObject *__pyx_v_h2fdf = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_v_nloudest = 0;
  PyObject *__pyx_v_msort = 0;
  PyObject *__pyx_v_qsort = 0;
  PyObject *__pyx_v_zsort = 0;
  PyObject *__pyx_v_normal_threshold = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("loudest_hc_from_sorted (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_h2fdf,&__pyx_n_s_nreals,&__pyx_n_s_nloudest,&__pyx_n_s_msort,&__pyx_n_s_qsort,&__pyx_n_s_zsort,&__pyx_n_s_normal_threshold,0};
    PyObject* values[8] = {0,0,0,0,0,0,0,0};
    values[7] = ((PyObject *)__pyx_float_1e10);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_number)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_h2fdf)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, 1); __PYX_ERR(0, 1220, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, 2); __PYX_ERR(0, 1220, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nloudest)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, 3); __PYX_ERR(0, 1220, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, 4); __PYX_ERR(0, 1220, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_qsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, 5); __PYX_ERR(0, 1220, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_zsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, 6); __PYX_ERR(0, 1220, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normal_threshold);
          if (value) { values[7] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loudest_hc_from_sorted") < 0)) __PYX_ERR(0, 1220, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_number = values[0];
    __pyx_v_h2fdf = values[1];
    __pyx_v_nreals = values[2];
    __pyx_v_nloudest = values[3];
    __pyx_v_msort = values[4];
    __pyx_v_qsort = values[5];
    __pyx_v_zsort = values[6];
    __pyx_v_normal_threshold = values[7];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("loudest_hc_from_sorted", 0, 7, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1220, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.loudest_hc_from_sorted", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_12loudest_hc_from_sorted(__pyx_self, __pyx_v_number, __pyx_v_h2fdf, __pyx_v_nreals, __pyx_v_nloudest, __pyx_v_msort, __pyx_v_qsort, __pyx_v_zsort, __pyx_v_normal_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_12loudest_hc_from_sorted(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_number, PyObject *__pyx_v_h2fdf, PyObject *__pyx_v_nreals, PyObject *__pyx_v_nloudest, PyObject *__pyx_v_msort, PyObject *__pyx_v_qsort, PyObject *__pyx_v_zsort, PyObject *__pyx_v_normal_threshold) {
  __Pyx_memviewslice __pyx_v_shape = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_F = NULL;
  PyObject *__pyx_v_R = NULL;
  PyObject *__pyx_v_L = NULL;
  PyArrayObject *__pyx_v_hc2ss = 0;
  PyArrayObject *__pyx_v_hc2bg = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2bg;
  __Pyx_Buffer __pyx_pybuffer_hc2bg;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2ss;
  __Pyx_Buffer __pyx_pybuffer_hc2ss;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("loudest_hc_from_sorted", 0);
  __pyx_pybuffer_hc2ss.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2ss.refcount = 0;
  __pyx_pybuffernd_hc2ss.data = NULL;
  __pyx_pybuffernd_hc2ss.rcbuffer = &__pyx_pybuffer_hc2ss;
  __pyx_pybuffer_hc2bg.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2bg.refcount = 0;
  __pyx_pybuffernd_hc2bg.data = NULL;
  __pyx_pybuffernd_hc2bg.rcbuffer = &__pyx_pybuffer_hc2bg;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_15, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_16, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.loudest_hc_from_sorted", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
  __pyx_L2:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_shape, 1);
  __Pyx_XDECREF(__pyx_v_F);
  __Pyx_XDECREF(__pyx_v_R);
  __Pyx_XDECREF(__pyx_v_L);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2ss);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2bg);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__38 = PyTuple_Pack(14, __pyx_n_s_number, __pyx_n_s_h2fdf, __pyx_n_s_nreals, __pyx_n_s_nloudest, __pyx_n_s_msort, __pyx_n_s_qsort, __pyx_n_s_zsort, __pyx_n_s_normal_threshold, __pyx_n_s_shape, __pyx_n_s_F, __pyx_n_s_R, __pyx_n_s_L, __pyx_n_s_hc2ss, __pyx_n_s_hc2bg); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(0, 1220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__38);
  __Pyx_GIVEREF(__pyx_tuple__38);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_13loudest_hc_from_sorted, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1220, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_loudest_hc_from_sorted, __pyx_t_3) < 0) __PYX_ERR(0, 1220, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(8, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__38, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_loudest_hc_from_sorted, 1220, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(0, 1220, __pyx_L1_error)

 1221:     """

 1222:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1223: 

 1224:     Parameters

 1225:     ------------------------

 1226:     number : [M, Q, Z, F] NDarray

 1227:         number in each bin

 1228:     h2fdf : [M, Q, Z, F] NDarray

 1229:         Strain amplitude squared x frequency / frequency bin width for each bin.

 1230:     nreals

 1231:         Number of realizations.

 1232:     nloudest

 1233:         Number of loudest sources to separate in each frequency bin.

 1234:     msort : (M*Q*Z,) 1Darray

 1235:         M indices of each bin, sorted from largest to smallest h2fdf.

 1236:     qsort : (M*Q*Z,) 1Darray

 1237:         q indices of each bin, sorted from largest to smallest h2fdf.

 1238:     zsort : (M*Q*Z,) 1Darray

 1239:         z indices of each bin, sorted from largest to smallest h2fdf.

 1240:     normal_threshold : float

 1241:         Threshold for approximating poisson sampling as normal.

 1242: 

 1243:     Returns

 1244:     --------------------------

 1245:     hc2ss : (F, R, L) Ndarray of scalars

 1246:         Char strain squared of the loudest single sources.

 1247:     hc2bg : (F, R) Ndarray of scalars

 1248:         Char strain squared of the background.

 1249:     """

 1250: 

+1251:     cdef long[:] shape = np.array(number.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_number, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1251, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_shape = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

+1252:     F = shape[3]

  __pyx_t_6 = 3;
  __pyx_t_7 = -1;
  if (__pyx_t_6 < 0) {
    __pyx_t_6 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_6 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1252, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyInt_From_long((*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_6 * __pyx_v_shape.strides[0]) )))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1252, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_F = __pyx_t_1;
  __pyx_t_1 = 0;

+1253:     R = nreals

  __Pyx_INCREF(__pyx_v_nreals);
  __pyx_v_R = __pyx_v_nreals;

+1254:     L = nloudest

  __Pyx_INCREF(__pyx_v_nloudest);
  __pyx_v_L = __pyx_v_nloudest;

+1255:     cdef np.ndarray[np.double_t, ndim=3] hc2ss = np.zeros((F,R,L))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1255, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1255, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1255, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_R);
  __Pyx_INCREF(__pyx_v_L);
  __Pyx_GIVEREF(__pyx_v_L);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_L);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1255, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1255, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2ss = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1255, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2ss.diminfo[0].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2ss.diminfo[0].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2ss.diminfo[1].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2ss.diminfo[1].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_hc2ss.diminfo[2].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_hc2ss.diminfo[2].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_hc2ss = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1256:     cdef np.ndarray[np.double_t, ndim=2] hc2bg = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1256, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1256, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2bg = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1256, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2bg.diminfo[0].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2bg.diminfo[0].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2bg.diminfo[1].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2bg.diminfo[1].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_hc2bg = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1257:     _loudest_hc_from_sorted(shape, h2fdf, number, nreals, nloudest, normal_threshold,

  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_h2fdf, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1257, __pyx_L1_error)
  __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_number, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1257, __pyx_L1_error)
  __pyx_t_12 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_12 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1257, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyInt_As_long(__pyx_v_nloudest); if (unlikely((__pyx_t_13 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1257, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_normal_threshold); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1257, __pyx_L1_error)
/* … */
  __pyx_f_8holodeck_7cyutils__loudest_hc_from_sorted(__pyx_v_shape, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_5, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __pyx_t_11.memview = NULL;
  __pyx_t_11.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_15, 1);
  __pyx_t_15.memview = NULL;
  __pyx_t_15.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_16, 1);
  __pyx_t_16.memview = NULL;
  __pyx_t_16.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __pyx_t_17.memview = NULL;
  __pyx_t_17.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __pyx_t_18.memview = NULL;
  __pyx_t_18.data = NULL;

+1258:                             msort, qsort, zsort,

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_msort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1258, __pyx_L1_error)
  __pyx_t_15 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_qsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_15.memview)) __PYX_ERR(0, 1258, __pyx_L1_error)
  __pyx_t_16 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_zsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_16.memview)) __PYX_ERR(0, 1258, __pyx_L1_error)

+1259:                             hc2ss, hc2bg)

  __pyx_t_17 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_hc2ss), PyBUF_WRITABLE); if (unlikely(!__pyx_t_17.memview)) __PYX_ERR(0, 1259, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2bg), PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(0, 1259, __pyx_L1_error)

+1260:     return hc2ss, hc2bg

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1260, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2ss));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2ss));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_hc2ss));
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2bg));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2bg));
  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_hc2bg));
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1261: 

 1262: @cython.boundscheck(True)

 1263: @cython.wraparound(True)

 1264: @cython.nonecheck(True)

 1265: @cython.cdivision(True)

+1266: cdef void _loudest_hc_from_sorted(long[:] shape, double[:,:,:,:] h2fdf, double[:,:,:,:] number,

static void __pyx_f_8holodeck_7cyutils__loudest_hc_from_sorted(__Pyx_memviewslice __pyx_v_shape, __Pyx_memviewslice __pyx_v_h2fdf, __Pyx_memviewslice __pyx_v_number, long __pyx_v_nreals, long __pyx_v_nloudest, long __pyx_v_thresh, __Pyx_memviewslice __pyx_v_msort, __Pyx_memviewslice __pyx_v_qsort, __Pyx_memviewslice __pyx_v_zsort, __Pyx_memviewslice __pyx_v_hc2ss, __Pyx_memviewslice __pyx_v_hc2bg) {
  int __pyx_v_M;
  int __pyx_v_Q;
  int __pyx_v_Z;
  int __pyx_v_F;
  int __pyx_v_L;
  int __pyx_v_R;
  int __pyx_v_mm;
  int __pyx_v_qq;
  int __pyx_v_zz;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_ll;
  double __pyx_v_num;
  double __pyx_v_sum;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  int __pyx_v_bb;
  double __pyx_v_std;
  PyObject *__pyx_v_cur = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_loudest_hc_from_sorted", 0);
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_WriteUnraisable("holodeck.cyutils._loudest_hc_from_sorted", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_XDECREF(__pyx_v_cur);
  __Pyx_RefNannyFinishContext();
}

 1267:             long nreals, long nloudest, long thresh,

 1268:             long[:] msort, long[:] qsort, long[:] zsort,

 1269:             double[:,:,:] hc2ss, double[:,:] hc2bg):

 1270:     """

 1271:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1272: 

 1273:     Parameters

 1274:     ----------

 1275:     shape : long[:] array

 1276:         Shape of number, [M, Q, Z, F].

 1277:     number : double[:,:,:,:] array

 1278:         Number per bin.

 1279:     h2fdf : double[:,:,:,:] array

 1280:         Strain amplitude squared * f/Delta f for a single source in each bin.

 1281:     nreals : int

 1282:         Number of realizations.

 1283:     nloudest : int

 1284:         Number of loudest sources at each source.

 1285:     msort : (M*Q*Z,) 1Darray

 1286:         M indices of each bin, sorted from largest to smallest h2fdf.

 1287:     qsort : (M*Q*Z,) 1Darray

 1288:         q indices of each bin, sorted from largest to smallest h2fdf.

 1289:     zsort : (M*Q*Z,) 1Darray

 1290:         z indices of each bin, sorted from largest to smallest h2fdf.

 1291:     hc2ss : double[:,:,:] array

 1292:         (Memory address of) single source characteristic strain squared array.

 1293:     hc2bg : double[:,:] array

 1294:         (Memory address of) background characteristic strain squared array.

 1295: 

 1296:     Returns

 1297:     -------

 1298:     void

 1299:     updated via memory address: hc2ss, hc2bg, ssidx, bg_par

 1300:     """

 1301: 

+1302:     cdef int M = shape[0]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1302, __pyx_L1_error)
  }
  __pyx_t_1 = 0;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1302, __pyx_L1_error)
  }
  __pyx_v_M = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1303:     cdef int Q = shape[1]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1303, __pyx_L1_error)
  }
  __pyx_t_1 = 1;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1303, __pyx_L1_error)
  }
  __pyx_v_Q = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1304:     cdef int Z = shape[2]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1304, __pyx_L1_error)
  }
  __pyx_t_1 = 2;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1304, __pyx_L1_error)
  }
  __pyx_v_Z = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1305:     cdef int F = shape[3]

  if (unlikely(((PyObject *) __pyx_v_shape.memview) == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
    __PYX_ERR(0, 1305, __pyx_L1_error)
  }
  __pyx_t_1 = 3;
  __pyx_t_2 = -1;
  if (__pyx_t_1 < 0) {
    __pyx_t_1 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_1 < 0)) __pyx_t_2 = 0;
  } else if (unlikely(__pyx_t_1 >= __pyx_v_shape.shape[0])) __pyx_t_2 = 0;
  if (unlikely(__pyx_t_2 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_2);
    __PYX_ERR(0, 1305, __pyx_L1_error)
  }
  __pyx_v_F = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1306:     cdef int L = nloudest

  __pyx_v_L = __pyx_v_nloudest;

+1307:     cdef int R = nreals

  __pyx_v_R = __pyx_v_nreals;

 1308: 

 1309:     cdef int mm, qq, zz, ff, rr, ll

 1310:     cdef double num, sum

 1311: 

 1312:     # Setup random number generator from numpy library

 1313:     cdef bitgen_t *rng

+1314:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+1315:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_5)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_5);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_capsule); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1315, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_v_capsule = __pyx_t_4;
  __pyx_t_4 = 0;

 1316:     # Cast the pointer

+1317:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_6 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_6 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1317, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_6);

+1318:     for rr in range(R):

  __pyx_t_2 = __pyx_v_R;
  __pyx_t_7 = __pyx_t_2;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
    __pyx_v_rr = __pyx_t_8;

+1319:         for ff in range(F):

    __pyx_t_9 = __pyx_v_F;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
      __pyx_v_ff = __pyx_t_11;

+1320:             ll = 0 # track which index in the loudest list you're currently storing

      __pyx_v_ll = 0;

 1321:                      # start at 0 for the loudest of all.

+1322:             sum = 0

      __pyx_v_sum = 0.0;

+1323:             for bb in range(M*Q*Z): #iterate through bins, loudest to quietest

      __pyx_t_12 = ((__pyx_v_M * __pyx_v_Q) * __pyx_v_Z);
      __pyx_t_13 = __pyx_t_12;
      for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
        __pyx_v_bb = __pyx_t_14;

+1324:                 mm = msort[bb]

        if (unlikely(((PyObject *) __pyx_v_msort.memview) == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
          __PYX_ERR(0, 1324, __pyx_L1_error)
        }
        __pyx_t_1 = __pyx_v_bb;
        __pyx_t_15 = -1;
        if (__pyx_t_1 < 0) {
          __pyx_t_1 += __pyx_v_msort.shape[0];
          if (unlikely(__pyx_t_1 < 0)) __pyx_t_15 = 0;
        } else if (unlikely(__pyx_t_1 >= __pyx_v_msort.shape[0])) __pyx_t_15 = 0;
        if (unlikely(__pyx_t_15 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_15);
          __PYX_ERR(0, 1324, __pyx_L1_error)
        }
        __pyx_v_mm = (*((long *) ( /* dim=0 */ (__pyx_v_msort.data + __pyx_t_1 * __pyx_v_msort.strides[0]) )));

+1325:                 qq = qsort[bb]

        if (unlikely(((PyObject *) __pyx_v_qsort.memview) == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
          __PYX_ERR(0, 1325, __pyx_L1_error)
        }
        __pyx_t_1 = __pyx_v_bb;
        __pyx_t_15 = -1;
        if (__pyx_t_1 < 0) {
          __pyx_t_1 += __pyx_v_qsort.shape[0];
          if (unlikely(__pyx_t_1 < 0)) __pyx_t_15 = 0;
        } else if (unlikely(__pyx_t_1 >= __pyx_v_qsort.shape[0])) __pyx_t_15 = 0;
        if (unlikely(__pyx_t_15 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_15);
          __PYX_ERR(0, 1325, __pyx_L1_error)
        }
        __pyx_v_qq = (*((long *) ( /* dim=0 */ (__pyx_v_qsort.data + __pyx_t_1 * __pyx_v_qsort.strides[0]) )));

+1326:                 zz = zsort[bb]

        if (unlikely(((PyObject *) __pyx_v_zsort.memview) == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
          __PYX_ERR(0, 1326, __pyx_L1_error)
        }
        __pyx_t_1 = __pyx_v_bb;
        __pyx_t_15 = -1;
        if (__pyx_t_1 < 0) {
          __pyx_t_1 += __pyx_v_zsort.shape[0];
          if (unlikely(__pyx_t_1 < 0)) __pyx_t_15 = 0;
        } else if (unlikely(__pyx_t_1 >= __pyx_v_zsort.shape[0])) __pyx_t_15 = 0;
        if (unlikely(__pyx_t_15 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_15);
          __PYX_ERR(0, 1326, __pyx_L1_error)
        }
        __pyx_v_zz = (*((long *) ( /* dim=0 */ (__pyx_v_zsort.data + __pyx_t_1 * __pyx_v_zsort.strides[0]) )));

+1327:                 num = number[mm,qq,zz,ff]

        if (unlikely(((PyObject *) __pyx_v_number.memview) == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
          __PYX_ERR(0, 1327, __pyx_L1_error)
        }
        __pyx_t_1 = __pyx_v_mm;
        __pyx_t_16 = __pyx_v_qq;
        __pyx_t_17 = __pyx_v_zz;
        __pyx_t_18 = __pyx_v_ff;
        __pyx_t_15 = -1;
        if (__pyx_t_1 < 0) {
          __pyx_t_1 += __pyx_v_number.shape[0];
          if (unlikely(__pyx_t_1 < 0)) __pyx_t_15 = 0;
        } else if (unlikely(__pyx_t_1 >= __pyx_v_number.shape[0])) __pyx_t_15 = 0;
        if (__pyx_t_16 < 0) {
          __pyx_t_16 += __pyx_v_number.shape[1];
          if (unlikely(__pyx_t_16 < 0)) __pyx_t_15 = 1;
        } else if (unlikely(__pyx_t_16 >= __pyx_v_number.shape[1])) __pyx_t_15 = 1;
        if (__pyx_t_17 < 0) {
          __pyx_t_17 += __pyx_v_number.shape[2];
          if (unlikely(__pyx_t_17 < 0)) __pyx_t_15 = 2;
        } else if (unlikely(__pyx_t_17 >= __pyx_v_number.shape[2])) __pyx_t_15 = 2;
        if (__pyx_t_18 < 0) {
          __pyx_t_18 += __pyx_v_number.shape[3];
          if (unlikely(__pyx_t_18 < 0)) __pyx_t_15 = 3;
        } else if (unlikely(__pyx_t_18 >= __pyx_v_number.shape[3])) __pyx_t_15 = 3;
        if (unlikely(__pyx_t_15 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_15);
          __PYX_ERR(0, 1327, __pyx_L1_error)
        }
        __pyx_v_num = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_number.data + __pyx_t_1 * __pyx_v_number.strides[0]) ) + __pyx_t_16 * __pyx_v_number.strides[1]) ) + __pyx_t_17 * __pyx_v_number.strides[2]) ) + __pyx_t_18 * __pyx_v_number.strides[3]) )));

+1328:                 if (num>thresh): # Gaussian sample

        __pyx_t_19 = ((__pyx_v_num > __pyx_v_thresh) != 0);
        if (__pyx_t_19) {
/* … */
          goto __pyx_L9;
        }

+1329:                     std = sqrt(num)

          __pyx_v_std = sqrt(__pyx_v_num);

+1330:                     num = <double>random_normal(rng, num, std)

          __pyx_v_num = ((double)random_normal(__pyx_v_rng, __pyx_v_num, __pyx_v_std));

 1331:                 else:            # Poisson sample

+1332:                     num = <double>random_poisson(rng, num)

        /*else*/ {
          __pyx_v_num = ((double)random_poisson(__pyx_v_rng, __pyx_v_num));
        }
        __pyx_L9:;

+1333:                 if(num < 1):

        __pyx_t_19 = ((__pyx_v_num < 1.0) != 0);
        if (__pyx_t_19) {
/* … */
        }

+1334:                     continue

          goto __pyx_L7_continue;

+1335:                 cur = h2fdf[mm,qq,zz,ff]

        if (unlikely(((PyObject *) __pyx_v_h2fdf.memview) == Py_None)) {
          PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
          __PYX_ERR(0, 1335, __pyx_L1_error)
        }
        __pyx_t_18 = __pyx_v_mm;
        __pyx_t_17 = __pyx_v_qq;
        __pyx_t_16 = __pyx_v_zz;
        __pyx_t_1 = __pyx_v_ff;
        __pyx_t_15 = -1;
        if (__pyx_t_18 < 0) {
          __pyx_t_18 += __pyx_v_h2fdf.shape[0];
          if (unlikely(__pyx_t_18 < 0)) __pyx_t_15 = 0;
        } else if (unlikely(__pyx_t_18 >= __pyx_v_h2fdf.shape[0])) __pyx_t_15 = 0;
        if (__pyx_t_17 < 0) {
          __pyx_t_17 += __pyx_v_h2fdf.shape[1];
          if (unlikely(__pyx_t_17 < 0)) __pyx_t_15 = 1;
        } else if (unlikely(__pyx_t_17 >= __pyx_v_h2fdf.shape[1])) __pyx_t_15 = 1;
        if (__pyx_t_16 < 0) {
          __pyx_t_16 += __pyx_v_h2fdf.shape[2];
          if (unlikely(__pyx_t_16 < 0)) __pyx_t_15 = 2;
        } else if (unlikely(__pyx_t_16 >= __pyx_v_h2fdf.shape[2])) __pyx_t_15 = 2;
        if (__pyx_t_1 < 0) {
          __pyx_t_1 += __pyx_v_h2fdf.shape[3];
          if (unlikely(__pyx_t_1 < 0)) __pyx_t_15 = 3;
        } else if (unlikely(__pyx_t_1 >= __pyx_v_h2fdf.shape[3])) __pyx_t_15 = 3;
        if (unlikely(__pyx_t_15 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_15);
          __PYX_ERR(0, 1335, __pyx_L1_error)
        }
        __pyx_t_4 = PyFloat_FromDouble((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_18 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_17 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_16 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[3]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1335, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __Pyx_XDECREF_SET(__pyx_v_cur, __pyx_t_4);
        __pyx_t_4 = 0;

+1336:                 if (num<1):

        __pyx_t_19 = ((__pyx_v_num < 1.0) != 0);
        if (__pyx_t_19) {
/* … */
        }

+1337:                     continue # to next loudest bin

          goto __pyx_L7_continue;

+1338:                 while (ll < L) and (num > 0):

        while (1) {
          __pyx_t_20 = ((__pyx_v_ll < __pyx_v_L) != 0);
          if (__pyx_t_20) {
          } else {
            __pyx_t_19 = __pyx_t_20;
            goto __pyx_L14_bool_binop_done;
          }
          __pyx_t_20 = ((__pyx_v_num > 0.0) != 0);
          __pyx_t_19 = __pyx_t_20;
          __pyx_L14_bool_binop_done:;
          if (!__pyx_t_19) break;

+1339:                     hc2ss[ff,rr,ll] = cur

          __pyx_t_21 = __pyx_PyFloat_AsDouble(__pyx_v_cur); if (unlikely((__pyx_t_21 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1339, __pyx_L1_error)
          if (unlikely(((PyObject *) __pyx_v_hc2ss.memview) == Py_None)) {
            PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
            __PYX_ERR(0, 1339, __pyx_L1_error)
          }
          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_16 = __pyx_v_rr;
          __pyx_t_17 = __pyx_v_ll;
          __pyx_t_15 = -1;
          if (__pyx_t_1 < 0) {
            __pyx_t_1 += __pyx_v_hc2ss.shape[0];
            if (unlikely(__pyx_t_1 < 0)) __pyx_t_15 = 0;
          } else if (unlikely(__pyx_t_1 >= __pyx_v_hc2ss.shape[0])) __pyx_t_15 = 0;
          if (__pyx_t_16 < 0) {
            __pyx_t_16 += __pyx_v_hc2ss.shape[1];
            if (unlikely(__pyx_t_16 < 0)) __pyx_t_15 = 1;
          } else if (unlikely(__pyx_t_16 >= __pyx_v_hc2ss.shape[1])) __pyx_t_15 = 1;
          if (__pyx_t_17 < 0) {
            __pyx_t_17 += __pyx_v_hc2ss.shape[2];
            if (unlikely(__pyx_t_17 < 0)) __pyx_t_15 = 2;
          } else if (unlikely(__pyx_t_17 >= __pyx_v_hc2ss.shape[2])) __pyx_t_15 = 2;
          if (unlikely(__pyx_t_15 != -1)) {
            __Pyx_RaiseBufferIndexError(__pyx_t_15);
            __PYX_ERR(0, 1339, __pyx_L1_error)
          }
          *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2ss.data + __pyx_t_1 * __pyx_v_hc2ss.strides[0]) ) + __pyx_t_16 * __pyx_v_hc2ss.strides[1]) ) + __pyx_t_17 * __pyx_v_hc2ss.strides[2]) )) = __pyx_t_21;

+1340:                     num -= 1

          __pyx_v_num = (__pyx_v_num - 1.0);

+1341:                     ll += 1

          __pyx_v_ll = (__pyx_v_ll + 1);
        }

+1342:                 sum += num * cur

        __pyx_t_4 = PyFloat_FromDouble(__pyx_v_sum); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1342, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_4);
        __pyx_t_3 = PyFloat_FromDouble(__pyx_v_num); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1342, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __pyx_t_5 = PyNumber_Multiply(__pyx_t_3, __pyx_v_cur); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1342, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_5);
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1342, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_3);
        __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
        __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
        __pyx_t_21 = __pyx_PyFloat_AsDouble(__pyx_t_3); if (unlikely((__pyx_t_21 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1342, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
        __pyx_v_sum = __pyx_t_21;
        __pyx_L7_continue:;
      }

 1343: 

+1344:             hc2bg[ff,rr] = sum

      if (unlikely(((PyObject *) __pyx_v_hc2bg.memview) == Py_None)) {
        PyErr_SetString(PyExc_TypeError, "Cannot index None memoryview slice");
        __PYX_ERR(0, 1344, __pyx_L1_error)
      }
      __pyx_t_17 = __pyx_v_ff;
      __pyx_t_16 = __pyx_v_rr;
      __pyx_t_12 = -1;
      if (__pyx_t_17 < 0) {
        __pyx_t_17 += __pyx_v_hc2bg.shape[0];
        if (unlikely(__pyx_t_17 < 0)) __pyx_t_12 = 0;
      } else if (unlikely(__pyx_t_17 >= __pyx_v_hc2bg.shape[0])) __pyx_t_12 = 0;
      if (__pyx_t_16 < 0) {
        __pyx_t_16 += __pyx_v_hc2bg.shape[1];
        if (unlikely(__pyx_t_16 < 0)) __pyx_t_12 = 1;
      } else if (unlikely(__pyx_t_16 >= __pyx_v_hc2bg.shape[1])) __pyx_t_12 = 1;
      if (unlikely(__pyx_t_12 != -1)) {
        __Pyx_RaiseBufferIndexError(__pyx_t_12);
        __PYX_ERR(0, 1344, __pyx_L1_error)
      }
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2bg.data + __pyx_t_17 * __pyx_v_hc2bg.strides[0]) ) + __pyx_t_16 * __pyx_v_hc2bg.strides[1]) )) = __pyx_v_sum;
    }
  }

 1345: 

 1346: 

+1347: def loudest_hc_and_par_from_sorted(number, h2fdf, nreals, nloudest, mt, mr, rz, msort, qsort, zsort, normal_threshold=1e10):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_15loudest_hc_and_par_from_sorted(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_14loudest_hc_and_par_from_sorted[] = "\n    Calculates the characteristic strain from loud single sources and a background of all other sources.\n\n    Parameters\n    ------------------------\n    number : [M, Q, Z, F] NDarray\n        number in each bin\n    h2fdf : [M, Q, Z, F] NDarray\n        Strain amplitude squared x frequency / frequency bin width for each bin.\n    nreals\n        Number of realizations.\n    nloudest\n        Number of loudest sources to separate in each frequency bin.\n    mt : (M,) 1Darray of scalars\n        Total masses, M, of each bin center.\n    mr : (Q,) 1Darray of scalars\n        Mass ratios, q, of each bin center.\n    rz : (Z,) 1Darray of scalars\n        Redshifts, z, of each bin center.\n    msort : (M*Q*Z,) 1Darray\n        M indices of each bin, sorted from largest to smallest h2fdf.\n    qsort : (M*Q*Z,) 1Darray\n        q indices of each bin, sorted from largest to smallest h2fdf.\n    zsort : (M*Q*Z,) 1Darray\n        z indices of each bin, sorted from largest to smallest h2fdf.\n    normal_threshold : float\n        Threshold for approximating poisson sampling as normal.\n\n    Returns\n    --------------------------\n    hc2ss : (F, R, L) Ndarray of scalars\n        Char strain squared of the loudest single sources.\n    hc2bg : (F, R) Ndarray of scalars\n        Char strain squared of the background.\n    lspar : (3, F, R) NDarray of scalars\n        Average effective M, q, z parameters of the loudest L sources.\n    bgpar : (3, F, R) NDarray of scalars\n        Average effective M, q, z parameters of the background.\n    ssidx : (3, F, R, L) NDarray of ints\n        Indices of the loudest single sources.\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_15loudest_hc_and_par_from_sorted = {"loudest_hc_and_par_from_sorted", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_15loudest_hc_and_par_from_sorted, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_14loudest_hc_and_par_from_sorted};
static PyObject *__pyx_pw_8holodeck_7cyutils_15loudest_hc_and_par_from_sorted(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_number = 0;
  PyObject *__pyx_v_h2fdf = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_v_nloudest = 0;
  PyObject *__pyx_v_mt = 0;
  PyObject *__pyx_v_mr = 0;
  PyObject *__pyx_v_rz = 0;
  PyObject *__pyx_v_msort = 0;
  PyObject *__pyx_v_qsort = 0;
  PyObject *__pyx_v_zsort = 0;
  PyObject *__pyx_v_normal_threshold = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("loudest_hc_and_par_from_sorted (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_h2fdf,&__pyx_n_s_nreals,&__pyx_n_s_nloudest,&__pyx_n_s_mt,&__pyx_n_s_mr,&__pyx_n_s_rz,&__pyx_n_s_msort,&__pyx_n_s_qsort,&__pyx_n_s_zsort,&__pyx_n_s_normal_threshold,0};
    PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0};
    values[10] = ((PyObject *)__pyx_float_1e10);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
        CYTHON_FALLTHROUGH;
        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        CYTHON_FALLTHROUGH;
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_number)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_h2fdf)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 1); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 2); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nloudest)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 3); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mt)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 4); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mr)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 5); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rz)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 6); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 7); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_qsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 8); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  9:
        if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_zsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, 9); __PYX_ERR(0, 1347, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case 10:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normal_threshold);
          if (value) { values[10] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loudest_hc_and_par_from_sorted") < 0)) __PYX_ERR(0, 1347, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
        CYTHON_FALLTHROUGH;
        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_number = values[0];
    __pyx_v_h2fdf = values[1];
    __pyx_v_nreals = values[2];
    __pyx_v_nloudest = values[3];
    __pyx_v_mt = values[4];
    __pyx_v_mr = values[5];
    __pyx_v_rz = values[6];
    __pyx_v_msort = values[7];
    __pyx_v_qsort = values[8];
    __pyx_v_zsort = values[9];
    __pyx_v_normal_threshold = values[10];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted", 0, 10, 11, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1347, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.loudest_hc_and_par_from_sorted", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_14loudest_hc_and_par_from_sorted(__pyx_self, __pyx_v_number, __pyx_v_h2fdf, __pyx_v_nreals, __pyx_v_nloudest, __pyx_v_mt, __pyx_v_mr, __pyx_v_rz, __pyx_v_msort, __pyx_v_qsort, __pyx_v_zsort, __pyx_v_normal_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_14loudest_hc_and_par_from_sorted(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_number, PyObject *__pyx_v_h2fdf, PyObject *__pyx_v_nreals, PyObject *__pyx_v_nloudest, PyObject *__pyx_v_mt, PyObject *__pyx_v_mr, PyObject *__pyx_v_rz, PyObject *__pyx_v_msort, PyObject *__pyx_v_qsort, PyObject *__pyx_v_zsort, PyObject *__pyx_v_normal_threshold) {
  __Pyx_memviewslice __pyx_v_shape = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_F = NULL;
  PyObject *__pyx_v_R = NULL;
  PyObject *__pyx_v_L = NULL;
  PyArrayObject *__pyx_v_hc2ss = 0;
  PyArrayObject *__pyx_v_hc2bg = 0;
  PyArrayObject *__pyx_v_lspar = 0;
  PyArrayObject *__pyx_v_bgpar = 0;
  PyArrayObject *__pyx_v_ssidx = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_bgpar;
  __Pyx_Buffer __pyx_pybuffer_bgpar;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2bg;
  __Pyx_Buffer __pyx_pybuffer_hc2bg;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2ss;
  __Pyx_Buffer __pyx_pybuffer_hc2ss;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_lspar;
  __Pyx_Buffer __pyx_pybuffer_lspar;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ssidx;
  __Pyx_Buffer __pyx_pybuffer_ssidx;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("loudest_hc_and_par_from_sorted", 0);
  __pyx_pybuffer_hc2ss.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2ss.refcount = 0;
  __pyx_pybuffernd_hc2ss.data = NULL;
  __pyx_pybuffernd_hc2ss.rcbuffer = &__pyx_pybuffer_hc2ss;
  __pyx_pybuffer_hc2bg.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2bg.refcount = 0;
  __pyx_pybuffernd_hc2bg.data = NULL;
  __pyx_pybuffernd_hc2bg.rcbuffer = &__pyx_pybuffer_hc2bg;
  __pyx_pybuffer_lspar.pybuffer.buf = NULL;
  __pyx_pybuffer_lspar.refcount = 0;
  __pyx_pybuffernd_lspar.data = NULL;
  __pyx_pybuffernd_lspar.rcbuffer = &__pyx_pybuffer_lspar;
  __pyx_pybuffer_bgpar.pybuffer.buf = NULL;
  __pyx_pybuffer_bgpar.refcount = 0;
  __pyx_pybuffernd_bgpar.data = NULL;
  __pyx_pybuffernd_bgpar.rcbuffer = &__pyx_pybuffer_bgpar;
  __pyx_pybuffer_ssidx.pybuffer.buf = NULL;
  __pyx_pybuffer_ssidx.refcount = 0;
  __pyx_pybuffernd_ssidx.data = NULL;
  __pyx_pybuffernd_ssidx.rcbuffer = &__pyx_pybuffer_ssidx;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_14, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_23, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_26, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_27, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_lspar.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.loudest_hc_and_par_from_sorted", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_lspar.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer);
  __pyx_L2:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_shape, 1);
  __Pyx_XDECREF(__pyx_v_F);
  __Pyx_XDECREF(__pyx_v_R);
  __Pyx_XDECREF(__pyx_v_L);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2ss);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2bg);
  __Pyx_XDECREF((PyObject *)__pyx_v_lspar);
  __Pyx_XDECREF((PyObject *)__pyx_v_bgpar);
  __Pyx_XDECREF((PyObject *)__pyx_v_ssidx);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__40 = PyTuple_Pack(20, __pyx_n_s_number, __pyx_n_s_h2fdf, __pyx_n_s_nreals, __pyx_n_s_nloudest, __pyx_n_s_mt, __pyx_n_s_mr, __pyx_n_s_rz, __pyx_n_s_msort, __pyx_n_s_qsort, __pyx_n_s_zsort, __pyx_n_s_normal_threshold, __pyx_n_s_shape, __pyx_n_s_F, __pyx_n_s_R, __pyx_n_s_L, __pyx_n_s_hc2ss, __pyx_n_s_hc2bg, __pyx_n_s_lspar, __pyx_n_s_bgpar, __pyx_n_s_ssidx); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 1347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__40);
  __Pyx_GIVEREF(__pyx_tuple__40);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_15loudest_hc_and_par_from_sorted, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1347, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_loudest_hc_and_par_from_sorted, __pyx_t_3) < 0) __PYX_ERR(0, 1347, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__41 = (PyObject*)__Pyx_PyCode_New(11, 0, 20, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__40, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_loudest_hc_and_par_from_sorted, 1347, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__41)) __PYX_ERR(0, 1347, __pyx_L1_error)

 1348:     """

 1349:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1350: 

 1351:     Parameters

 1352:     ------------------------

 1353:     number : [M, Q, Z, F] NDarray

 1354:         number in each bin

 1355:     h2fdf : [M, Q, Z, F] NDarray

 1356:         Strain amplitude squared x frequency / frequency bin width for each bin.

 1357:     nreals

 1358:         Number of realizations.

 1359:     nloudest

 1360:         Number of loudest sources to separate in each frequency bin.

 1361:     mt : (M,) 1Darray of scalars

 1362:         Total masses, M, of each bin center.

 1363:     mr : (Q,) 1Darray of scalars

 1364:         Mass ratios, q, of each bin center.

 1365:     rz : (Z,) 1Darray of scalars

 1366:         Redshifts, z, of each bin center.

 1367:     msort : (M*Q*Z,) 1Darray

 1368:         M indices of each bin, sorted from largest to smallest h2fdf.

 1369:     qsort : (M*Q*Z,) 1Darray

 1370:         q indices of each bin, sorted from largest to smallest h2fdf.

 1371:     zsort : (M*Q*Z,) 1Darray

 1372:         z indices of each bin, sorted from largest to smallest h2fdf.

 1373:     normal_threshold : float

 1374:         Threshold for approximating poisson sampling as normal.

 1375: 

 1376:     Returns

 1377:     --------------------------

 1378:     hc2ss : (F, R, L) Ndarray of scalars

 1379:         Char strain squared of the loudest single sources.

 1380:     hc2bg : (F, R) Ndarray of scalars

 1381:         Char strain squared of the background.

 1382:     lspar : (3, F, R) NDarray of scalars

 1383:         Average effective M, q, z parameters of the loudest L sources.

 1384:     bgpar : (3, F, R) NDarray of scalars

 1385:         Average effective M, q, z parameters of the background.

 1386:     ssidx : (3, F, R, L) NDarray of ints

 1387:         Indices of the loudest single sources.

 1388:     """

 1389: 

+1390:     cdef long[:] shape = np.array(number.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1390, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1390, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_number, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1390, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1390, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1390, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_shape = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

+1391:     F = shape[3]

  __pyx_t_6 = 3;
  __pyx_t_7 = -1;
  if (__pyx_t_6 < 0) {
    __pyx_t_6 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_6 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1391, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyInt_From_long((*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_6 * __pyx_v_shape.strides[0]) )))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1391, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_F = __pyx_t_1;
  __pyx_t_1 = 0;

+1392:     R = nreals

  __Pyx_INCREF(__pyx_v_nreals);
  __pyx_v_R = __pyx_v_nreals;

+1393:     L = nloudest

  __Pyx_INCREF(__pyx_v_nloudest);
  __pyx_v_L = __pyx_v_nloudest;

+1394:     cdef np.ndarray[np.double_t, ndim=3] hc2ss = np.zeros((F,R,L))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_R);
  __Pyx_INCREF(__pyx_v_L);
  __Pyx_GIVEREF(__pyx_v_L);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_L);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1394, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1394, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2ss = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1394, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2ss.diminfo[0].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2ss.diminfo[0].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2ss.diminfo[1].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2ss.diminfo[1].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_hc2ss.diminfo[2].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_hc2ss.diminfo[2].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_hc2ss = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1395:     cdef np.ndarray[np.double_t, ndim=2] hc2bg = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1395, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1395, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2bg = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1395, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2bg.diminfo[0].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2bg.diminfo[0].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2bg.diminfo[1].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2bg.diminfo[1].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_hc2bg = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1396:     cdef np.ndarray[np.double_t, ndim=3] lspar = np.zeros((3,F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1396, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1396, __pyx_L1_error)
  __pyx_t_10 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_lspar.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_lspar = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_lspar.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1396, __pyx_L1_error)
    } else {__pyx_pybuffernd_lspar.diminfo[0].strides = __pyx_pybuffernd_lspar.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_lspar.diminfo[0].shape = __pyx_pybuffernd_lspar.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_lspar.diminfo[1].strides = __pyx_pybuffernd_lspar.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_lspar.diminfo[1].shape = __pyx_pybuffernd_lspar.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_lspar.diminfo[2].strides = __pyx_pybuffernd_lspar.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_lspar.diminfo[2].shape = __pyx_pybuffernd_lspar.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_10 = 0;
  __pyx_v_lspar = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1397:     cdef np.ndarray[np.double_t, ndim=3] bgpar = np.zeros((3,F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1397, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1397, __pyx_L1_error)
  __pyx_t_11 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_bgpar = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1397, __pyx_L1_error)
    } else {__pyx_pybuffernd_bgpar.diminfo[0].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_bgpar.diminfo[0].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_bgpar.diminfo[1].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_bgpar.diminfo[1].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_bgpar.diminfo[2].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_bgpar.diminfo[2].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_11 = 0;
  __pyx_v_bgpar = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1398:     cdef np.ndarray[np.longlong_t, ndim=4] ssidx = np.zeros((3,F,R,L), dtype=int)

  __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(__pyx_int_3);
  __Pyx_GIVEREF(__pyx_int_3);
  PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_int_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_R);
  __Pyx_INCREF(__pyx_v_L);
  __Pyx_GIVEREF(__pyx_v_L);
  PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_L);
  __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_1);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_dtype, ((PyObject *)(&PyInt_Type))) < 0) __PYX_ERR(0, 1398, __pyx_L1_error)
  __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1398, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1398, __pyx_L1_error)
  __pyx_t_12 = ((PyArrayObject *)__pyx_t_4);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ssidx.rcbuffer->pybuffer, (PyObject*)__pyx_t_12, &__Pyx_TypeInfo_nn___pyx_t_5numpy_longlong_t, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
      __pyx_v_ssidx = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1398, __pyx_L1_error)
    } else {__pyx_pybuffernd_ssidx.diminfo[0].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ssidx.diminfo[0].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ssidx.diminfo[1].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ssidx.diminfo[1].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_ssidx.diminfo[2].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_ssidx.diminfo[2].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_ssidx.diminfo[3].strides = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_ssidx.diminfo[3].shape = __pyx_pybuffernd_ssidx.rcbuffer->pybuffer.shape[3];
    }
  }
  __pyx_t_12 = 0;
  __pyx_v_ssidx = ((PyArrayObject *)__pyx_t_4);
  __pyx_t_4 = 0;

+1399:     _loudest_hc_and_par_from_sorted(shape, h2fdf, number, nreals, nloudest, normal_threshold,

  __pyx_t_13 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_h2fdf, PyBUF_WRITABLE); if (unlikely(!__pyx_t_13.memview)) __PYX_ERR(0, 1399, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_number, PyBUF_WRITABLE); if (unlikely(!__pyx_t_14.memview)) __PYX_ERR(0, 1399, __pyx_L1_error)
  __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1399, __pyx_L1_error)
  __pyx_t_16 = __Pyx_PyInt_As_long(__pyx_v_nloudest); if (unlikely((__pyx_t_16 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1399, __pyx_L1_error)
  __pyx_t_17 = __Pyx_PyInt_As_long(__pyx_v_normal_threshold); if (unlikely((__pyx_t_17 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1399, __pyx_L1_error)
/* … */
  __pyx_f_8holodeck_7cyutils__loudest_hc_and_par_from_sorted(__pyx_v_shape, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_5, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_t_27);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __pyx_t_13.memview = NULL;
  __pyx_t_13.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_14, 1);
  __pyx_t_14.memview = NULL;
  __pyx_t_14.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __pyx_t_18.memview = NULL;
  __pyx_t_18.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __pyx_t_19.memview = NULL;
  __pyx_t_19.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __pyx_t_20.memview = NULL;
  __pyx_t_20.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __pyx_t_21.memview = NULL;
  __pyx_t_21.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1);
  __pyx_t_22.memview = NULL;
  __pyx_t_22.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_23, 1);
  __pyx_t_23.memview = NULL;
  __pyx_t_23.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1);
  __pyx_t_24.memview = NULL;
  __pyx_t_24.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1);
  __pyx_t_25.memview = NULL;
  __pyx_t_25.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_26, 1);
  __pyx_t_26.memview = NULL;
  __pyx_t_26.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_27, 1);
  __pyx_t_27.memview = NULL;
  __pyx_t_27.data = NULL;

+1400:                             mt, mr, rz, msort, qsort, zsort,

  __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mt, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(0, 1400, __pyx_L1_error)
  __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(0, 1400, __pyx_L1_error)
  __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_rz, PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(0, 1400, __pyx_L1_error)
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_msort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1400, __pyx_L1_error)
  __pyx_t_21 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_qsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_21.memview)) __PYX_ERR(0, 1400, __pyx_L1_error)
  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_zsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 1400, __pyx_L1_error)

+1401:                             hc2ss, hc2bg, lspar, bgpar, ssidx)

  __pyx_t_23 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_hc2ss), PyBUF_WRITABLE); if (unlikely(!__pyx_t_23.memview)) __PYX_ERR(0, 1401, __pyx_L1_error)
  __pyx_t_24 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2bg), PyBUF_WRITABLE); if (unlikely(!__pyx_t_24.memview)) __PYX_ERR(0, 1401, __pyx_L1_error)
  __pyx_t_25 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_lspar), PyBUF_WRITABLE); if (unlikely(!__pyx_t_25.memview)) __PYX_ERR(0, 1401, __pyx_L1_error)
  __pyx_t_26 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_bgpar), PyBUF_WRITABLE); if (unlikely(!__pyx_t_26.memview)) __PYX_ERR(0, 1401, __pyx_L1_error)
  __pyx_t_27 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_long(((PyObject *)__pyx_v_ssidx), PyBUF_WRITABLE); if (unlikely(!__pyx_t_27.memview)) __PYX_ERR(0, 1401, __pyx_L1_error)

+1402:     return hc2ss, hc2bg, lspar, bgpar, ssidx

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyTuple_New(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1402, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2ss));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2ss));
  PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_v_hc2ss));
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2bg));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2bg));
  PyTuple_SET_ITEM(__pyx_t_4, 1, ((PyObject *)__pyx_v_hc2bg));
  __Pyx_INCREF(((PyObject *)__pyx_v_lspar));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_lspar));
  PyTuple_SET_ITEM(__pyx_t_4, 2, ((PyObject *)__pyx_v_lspar));
  __Pyx_INCREF(((PyObject *)__pyx_v_bgpar));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_bgpar));
  PyTuple_SET_ITEM(__pyx_t_4, 3, ((PyObject *)__pyx_v_bgpar));
  __Pyx_INCREF(((PyObject *)__pyx_v_ssidx));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_ssidx));
  PyTuple_SET_ITEM(__pyx_t_4, 4, ((PyObject *)__pyx_v_ssidx));
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

 1403: 

 1404: 

 1405: @cython.boundscheck(False)

 1406: @cython.wraparound(False)

 1407: @cython.nonecheck(False)

 1408: @cython.cdivision(True)

+1409: cdef void _loudest_hc_and_par_from_sorted(long[:] shape, double[:,:,:,:] h2fdf, double[:,:,:,:] number,

static void __pyx_f_8holodeck_7cyutils__loudest_hc_and_par_from_sorted(__Pyx_memviewslice __pyx_v_shape, __Pyx_memviewslice __pyx_v_h2fdf, __Pyx_memviewslice __pyx_v_number, long __pyx_v_nreals, long __pyx_v_nloudest, long __pyx_v_thresh, __Pyx_memviewslice __pyx_v_mt, __Pyx_memviewslice __pyx_v_mr, __Pyx_memviewslice __pyx_v_rz, __Pyx_memviewslice __pyx_v_msort, __Pyx_memviewslice __pyx_v_qsort, __Pyx_memviewslice __pyx_v_zsort, __Pyx_memviewslice __pyx_v_hc2ss, __Pyx_memviewslice __pyx_v_hc2bg, __Pyx_memviewslice __pyx_v_lspar, __Pyx_memviewslice __pyx_v_bgpar, __Pyx_memviewslice __pyx_v_ssidx) {
  int __pyx_v_M;
  int __pyx_v_Q;
  int __pyx_v_Z;
  int __pyx_v_F;
  int __pyx_v_L;
  int __pyx_v_R;
  int __pyx_v_mm;
  int __pyx_v_qq;
  int __pyx_v_zz;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_ll;
  double __pyx_v_num;
  double __pyx_v_cur;
  double __pyx_v_sum_bg;
  double __pyx_v_sum_ls;
  double __pyx_v_m_bg;
  double __pyx_v_q_bg;
  double __pyx_v_z_bg;
  double __pyx_v_m_ls;
  double __pyx_v_q_ls;
  double __pyx_v_z_ls;
  CYTHON_UNUSED PyArrayObject *__pyx_v_maxes = 0;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  int __pyx_v_bb;
  double __pyx_v_std;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_maxes;
  __Pyx_Buffer __pyx_pybuffer_maxes;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_loudest_hc_and_par_from_sorted", 0);
  __pyx_pybuffer_maxes.pybuffer.buf = NULL;
  __pyx_pybuffer_maxes.refcount = 0;
  __pyx_pybuffernd_maxes.data = NULL;
  __pyx_pybuffernd_maxes.rcbuffer = &__pyx_pybuffer_maxes;
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_7);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_maxes.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_WriteUnraisable("holodeck.cyutils._loudest_hc_and_par_from_sorted", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_maxes.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_maxes);
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_RefNannyFinishContext();
}

 1410:             long nreals, long nloudest, long thresh,

 1411:             double[:] mt, double[:] mr, double[:] rz,

 1412:             long[:] msort, long[:] qsort, long[:] zsort,

 1413:             double[:,:,:] hc2ss, double[:,:] hc2bg, double[:,:,:] lspar, double[:,:,:] bgpar, long[:,:,:,:] ssidx):

 1414:     """

 1415:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1416: 

 1417:     Parameters

 1418:     ----------

 1419:     shape : long[:] array

 1420:         Shape of number, [M, Q, Z, F].

 1421:     number : double[:,:,:,:] array

 1422:         Number per bin.

 1423:     h2fdf : double[:,:,:,:] array

 1424:         Strain amplitude squared * f/Delta f for a single source in each bin.

 1425:     nreals : int

 1426:         Number of realizations.

 1427:     nloudest : int

 1428:         Number of loudest sources at each source.

 1429:     mt : (M,) 1Darray of scalars

 1430:         Total masses of each bin center.

 1431:     mr : (Q,) 1Darray of scalars

 1432:         Mass ratios of each bin center.

 1433:     rz : (Z,) 1Darray of scalars

 1434:         Redshifts of each bin center.

 1435:     msort : (M*Q*Z,) 1Darray

 1436:         M indices of each bin, sorted from largest to smallest h2fdf.

 1437:     qsort : (M*Q*Z,) 1Darray

 1438:         q indices of each bin, sorted from largest to smallest h2fdf.

 1439:     zsort : (M*Q*Z,) 1Darray

 1440:         z indices of each bin, sorted from largest to smallest h2fdf.

 1441:     hc2ss : double[:,:,:] array

 1442:         (Memory address of) single source characteristic strain squared array.

 1443:     hc2bg : double[:,:] array

 1444:         (Memory address of) background characteristic strain squared array.

 1445:     lspar : (3, F, R) NDarray of scalars

 1446:         Average effective M, q, z parameters of the loudest L sources.

 1447:     bgpar : (3, F, R) NDarray of scalars

 1448:         Average effective M, q, z parameters of the background.

 1449:     ssidx : (3, F, R, L) NDarray of ints

 1450:         Indices of the loudest sources.

 1451: 

 1452:     Returns

 1453:     -------

 1454:     void

 1455:     updated via memory address: hc2ss, hc2bg, lspar, bgpar, ssidx

 1456:     """

 1457: 

+1458:     cdef int M = shape[0]

  __pyx_t_1 = 0;
  __pyx_v_M = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1459:     cdef int Q = shape[1]

  __pyx_t_1 = 1;
  __pyx_v_Q = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1460:     cdef int Z = shape[2]

  __pyx_t_1 = 2;
  __pyx_v_Z = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1461:     cdef int F = shape[3]

  __pyx_t_1 = 3;
  __pyx_v_F = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1462:     cdef int L = nloudest

  __pyx_v_L = __pyx_v_nloudest;

+1463:     cdef int R = nreals

  __pyx_v_R = __pyx_v_nreals;

 1464: 

 1465:     cdef int mm, qq, zz, ff, rr, ll

 1466:     cdef double num, cur, sum_bg, sum_ls, m_bg, q_bg, z_bg, m_ls, q_ls, z_ls

+1467:     cdef np.ndarray[np.double_t, ndim=3] maxes = np.zeros((F,R,L))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_F); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_R); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_L); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_7);
  __Pyx_GIVEREF(__pyx_t_3);
  PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3);
  __Pyx_GIVEREF(__pyx_t_5);
  PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_6);
  PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_t_6);
  __pyx_t_3 = 0;
  __pyx_t_5 = 0;
  __pyx_t_6 = 0;
  __pyx_t_6 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_6)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_6);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_2 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7);
  __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
  __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1467, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1467, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_2);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_maxes.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_maxes = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_maxes.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1467, __pyx_L1_error)
    } else {__pyx_pybuffernd_maxes.diminfo[0].strides = __pyx_pybuffernd_maxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_maxes.diminfo[0].shape = __pyx_pybuffernd_maxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_maxes.diminfo[1].strides = __pyx_pybuffernd_maxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_maxes.diminfo[1].shape = __pyx_pybuffernd_maxes.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_maxes.diminfo[2].strides = __pyx_pybuffernd_maxes.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_maxes.diminfo[2].shape = __pyx_pybuffernd_maxes.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_maxes = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;

 1468: 

 1469:     # Setup random number generator from numpy library

 1470:     cdef bitgen_t *rng

+1471:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+1472:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_7 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_7)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_7);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_2 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_capsule); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1472, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_capsule = __pyx_t_4;
  __pyx_t_4 = 0;

 1473:     # Cast the pointer

+1474:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_9 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_9 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1474, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_9);

+1475:     for rr in range(R):

  __pyx_t_10 = __pyx_v_R;
  __pyx_t_11 = __pyx_t_10;
  for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
    __pyx_v_rr = __pyx_t_12;

+1476:         for ff in range(F):

    __pyx_t_13 = __pyx_v_F;
    __pyx_t_14 = __pyx_t_13;
    for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) {
      __pyx_v_ff = __pyx_t_15;

+1477:             ll = 0 # track which index in the loudest list you're currently storing

      __pyx_v_ll = 0;

 1478:                      # start at 0 for the loudest of all.

 1479:             # reset strain sums

+1480:             sum_bg = 0 # sum of bg h2fdf, for parameter averaging and gwb

      __pyx_v_sum_bg = 0.0;

+1481:             sum_ls = 0 # sum of ls h2fdf, for parameter averaging

      __pyx_v_sum_ls = 0.0;

 1482:             # reset parameter averaging sums

+1483:             m_ls = 0

      __pyx_v_m_ls = 0.0;

+1484:             q_ls = 0

      __pyx_v_q_ls = 0.0;

+1485:             z_ls = 0

      __pyx_v_z_ls = 0.0;

+1486:             m_bg = 0

      __pyx_v_m_bg = 0.0;

+1487:             q_bg = 0

      __pyx_v_q_bg = 0.0;

+1488:             z_bg = 0

      __pyx_v_z_bg = 0.0;

+1489:             for bb in range(M*Q*Z): #iterate through bins, loudest to quietest

      __pyx_t_16 = ((__pyx_v_M * __pyx_v_Q) * __pyx_v_Z);
      __pyx_t_17 = __pyx_t_16;
      for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) {
        __pyx_v_bb = __pyx_t_18;

+1490:                 mm = msort[bb]

        __pyx_t_1 = __pyx_v_bb;
        __pyx_v_mm = (*((long *) ( /* dim=0 */ (__pyx_v_msort.data + __pyx_t_1 * __pyx_v_msort.strides[0]) )));

+1491:                 qq = qsort[bb]

        __pyx_t_1 = __pyx_v_bb;
        __pyx_v_qq = (*((long *) ( /* dim=0 */ (__pyx_v_qsort.data + __pyx_t_1 * __pyx_v_qsort.strides[0]) )));

+1492:                 zz = zsort[bb]

        __pyx_t_1 = __pyx_v_bb;
        __pyx_v_zz = (*((long *) ( /* dim=0 */ (__pyx_v_zsort.data + __pyx_t_1 * __pyx_v_zsort.strides[0]) )));

+1493:                 num = number[mm,qq,zz,ff]

        __pyx_t_1 = __pyx_v_mm;
        __pyx_t_19 = __pyx_v_qq;
        __pyx_t_20 = __pyx_v_zz;
        __pyx_t_21 = __pyx_v_ff;
        __pyx_v_num = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_number.data + __pyx_t_1 * __pyx_v_number.strides[0]) ) + __pyx_t_19 * __pyx_v_number.strides[1]) ) + __pyx_t_20 * __pyx_v_number.strides[2]) ) + __pyx_t_21 * __pyx_v_number.strides[3]) )));

+1494:                 if (num>thresh): # Gaussian sample

        __pyx_t_22 = ((__pyx_v_num > __pyx_v_thresh) != 0);
        if (__pyx_t_22) {
/* … */
          goto __pyx_L9;
        }

+1495:                     std = sqrt(num)

          __pyx_v_std = sqrt(__pyx_v_num);

+1496:                     num = <double>random_normal(rng, num, std)

          __pyx_v_num = ((double)random_normal(__pyx_v_rng, __pyx_v_num, __pyx_v_std));

 1497:                 else:            # Poisson sample

+1498:                     num = <double>random_poisson(rng, num)

        /*else*/ {
          __pyx_v_num = ((double)random_poisson(__pyx_v_rng, __pyx_v_num));
        }
        __pyx_L9:;

+1499:                 if(num < 1):

        __pyx_t_22 = ((__pyx_v_num < 1.0) != 0);
        if (__pyx_t_22) {
/* … */
        }

+1500:                     continue

          goto __pyx_L7_continue;

+1501:                 cur = h2fdf[mm,qq,zz,ff] # h^2 * f/df of current bin

        __pyx_t_21 = __pyx_v_mm;
        __pyx_t_20 = __pyx_v_qq;
        __pyx_t_19 = __pyx_v_zz;
        __pyx_t_1 = __pyx_v_ff;
        __pyx_v_cur = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_21 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_20 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_19 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[3]) )));

+1502:                 if (num<1):

        __pyx_t_22 = ((__pyx_v_num < 1.0) != 0);
        if (__pyx_t_22) {
/* … */
        }

+1503:                     continue # to next loudest bin

          goto __pyx_L7_continue;

+1504:                 while (ll < L) and (num > 0):

        while (1) {
          __pyx_t_23 = ((__pyx_v_ll < __pyx_v_L) != 0);
          if (__pyx_t_23) {
          } else {
            __pyx_t_22 = __pyx_t_23;
            goto __pyx_L14_bool_binop_done;
          }
          __pyx_t_23 = ((__pyx_v_num > 0.0) != 0);
          __pyx_t_22 = __pyx_t_23;
          __pyx_L14_bool_binop_done:;
          if (!__pyx_t_22) break;

 1505:                     # store ll loudest source strain

+1506:                     hc2ss[ff,rr,ll] = cur

          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_19 = __pyx_v_rr;
          __pyx_t_20 = __pyx_v_ll;
          *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2ss.data + __pyx_t_1 * __pyx_v_hc2ss.strides[0]) ) + __pyx_t_19 * __pyx_v_hc2ss.strides[1]) ) + __pyx_t_20 * __pyx_v_hc2ss.strides[2]) )) = __pyx_v_cur;

 1507: 

 1508:                     # store indices of ll loudest source

+1509:                     ssidx[0,ff,rr,ll] = mm

          __pyx_t_20 = 0;
          __pyx_t_19 = __pyx_v_ff;
          __pyx_t_1 = __pyx_v_rr;
          __pyx_t_21 = __pyx_v_ll;
          *((long *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_20 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_19 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_1 * __pyx_v_ssidx.strides[2]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[3]) )) = __pyx_v_mm;

+1510:                     ssidx[1,ff,rr,ll] = qq

          __pyx_t_21 = 1;
          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_19 = __pyx_v_rr;
          __pyx_t_20 = __pyx_v_ll;
          *((long *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_21 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_1 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_19 * __pyx_v_ssidx.strides[2]) ) + __pyx_t_20 * __pyx_v_ssidx.strides[3]) )) = __pyx_v_qq;

+1511:                     ssidx[2,ff,rr,ll] = zz

          __pyx_t_20 = 2;
          __pyx_t_19 = __pyx_v_ff;
          __pyx_t_1 = __pyx_v_rr;
          __pyx_t_21 = __pyx_v_ll;
          *((long *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_ssidx.data + __pyx_t_20 * __pyx_v_ssidx.strides[0]) ) + __pyx_t_19 * __pyx_v_ssidx.strides[1]) ) + __pyx_t_1 * __pyx_v_ssidx.strides[2]) ) + __pyx_t_21 * __pyx_v_ssidx.strides[3]) )) = __pyx_v_zz;

 1512: 

 1513: 

+1514:                     sum_ls += cur # tot ls h2fdf

          __pyx_v_sum_ls = (__pyx_v_sum_ls + __pyx_v_cur);

 1515:                     # add to average parameters of loudest sources

+1516:                     m_ls += cur * mt[mm] # tot weighted ls mass

          __pyx_t_21 = __pyx_v_mm;
          __pyx_v_m_ls = (__pyx_v_m_ls + (__pyx_v_cur * (*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_21 * __pyx_v_mt.strides[0]) )))));

+1517:                     q_ls += cur * mr[qq] # tot weighted ls ratio

          __pyx_t_21 = __pyx_v_qq;
          __pyx_v_q_ls = (__pyx_v_q_ls + (__pyx_v_cur * (*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_21 * __pyx_v_mr.strides[0]) )))));

+1518:                     z_ls += cur * rz[zz] # tot weighted ls redshift

          __pyx_t_21 = __pyx_v_zz;
          __pyx_v_z_ls = (__pyx_v_z_ls + (__pyx_v_cur * (*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_21 * __pyx_v_rz.strides[0]) )))));

 1519: 

 1520:                     # update number and ll index

+1521:                     num -= 1

          __pyx_v_num = (__pyx_v_num - 1.0);

+1522:                     ll += 1

          __pyx_v_ll = (__pyx_v_ll + 1);
        }

 1523: 

+1524:                 sum_bg += num * cur # tot bg h2fdf

        __pyx_v_sum_bg = (__pyx_v_sum_bg + (__pyx_v_num * __pyx_v_cur));

 1525:                 # add to average parameters of background sources

+1526:                 m_bg += num * cur * mt[mm] # tot weight bg mass

        __pyx_t_21 = __pyx_v_mm;
        __pyx_v_m_bg = (__pyx_v_m_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_21 * __pyx_v_mt.strides[0]) )))));

+1527:                 q_bg += num * cur * mr[qq] # tot weighted bg ratio

        __pyx_t_21 = __pyx_v_qq;
        __pyx_v_q_bg = (__pyx_v_q_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_21 * __pyx_v_mr.strides[0]) )))));

+1528:                 z_bg += num * cur * rz[zz] # tot weighted bg redshift

        __pyx_t_21 = __pyx_v_zz;
        __pyx_v_z_bg = (__pyx_v_z_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_21 * __pyx_v_rz.strides[0]) )))));
        __pyx_L7_continue:;
      }

 1529: 

+1530:             hc2bg[ff,rr] = sum_bg # background strain

      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_1 = __pyx_v_rr;
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2bg.data + __pyx_t_21 * __pyx_v_hc2bg.strides[0]) ) + __pyx_t_1 * __pyx_v_hc2bg.strides[1]) )) = __pyx_v_sum_bg;

 1531:             # background average parameters

+1532:             bgpar[0,ff,rr] = m_bg/sum_bg # bg avg mass

      __pyx_t_1 = 0;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_19 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_1 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_21 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_19 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_m_bg / __pyx_v_sum_bg);

+1533:             bgpar[1,ff,rr] = q_bg/sum_bg # bg avg ratio

      __pyx_t_19 = 1;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_1 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_19 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_21 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_1 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_q_bg / __pyx_v_sum_bg);

+1534:             bgpar[2,ff,rr] = z_bg/sum_bg # bg avg redshift

      __pyx_t_1 = 2;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_19 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_1 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_21 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_19 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_z_bg / __pyx_v_sum_bg);

 1535:             # loudest source average parameters

+1536:             lspar[0,ff,rr] = m_ls/sum_ls # ls avg mass

      __pyx_t_19 = 0;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_1 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_lspar.data + __pyx_t_19 * __pyx_v_lspar.strides[0]) ) + __pyx_t_21 * __pyx_v_lspar.strides[1]) ) + __pyx_t_1 * __pyx_v_lspar.strides[2]) )) = (__pyx_v_m_ls / __pyx_v_sum_ls);

+1537:             lspar[1,ff,rr] = q_ls/sum_ls # ls avg ratio

      __pyx_t_1 = 1;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_19 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_lspar.data + __pyx_t_1 * __pyx_v_lspar.strides[0]) ) + __pyx_t_21 * __pyx_v_lspar.strides[1]) ) + __pyx_t_19 * __pyx_v_lspar.strides[2]) )) = (__pyx_v_q_ls / __pyx_v_sum_ls);

+1538:             lspar[2,ff,rr] = z_ls/sum_ls # ls avg redshift

      __pyx_t_19 = 2;
      __pyx_t_21 = __pyx_v_ff;
      __pyx_t_1 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_lspar.data + __pyx_t_19 * __pyx_v_lspar.strides[0]) ) + __pyx_t_21 * __pyx_v_lspar.strides[1]) ) + __pyx_t_1 * __pyx_v_lspar.strides[2]) )) = (__pyx_v_z_ls / __pyx_v_sum_ls);
    }
  }

 1539: 

 1540: 

+1541: def loudest_hc_and_par_from_sorted_redz(

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_17loudest_hc_and_par_from_sorted_redz(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_16loudest_hc_and_par_from_sorted_redz[] = "\n    Calculates the characteristic strain and binary parameters from loud single sources and a\n    background of all other sources.\n\n    Parameters\n    ------------------------\n    number : [M, Q, Z, F] NDarray\n        number in each bin\n    h2fdf : [M, Q, Z, F] NDarray\n        Strain amplitude squared x frequency / frequency bin width for each bin.\n    nreals\n        Number of realizations.\n    nloudest\n        Number of loudest sources to separate in each frequency bin.\n    mt : (M,) 1Darray of scalars\n        Total masses, M, of each bin center.\n    mr : (Q,) 1Darray of scalars\n        Mass ratios, q, of each bin center.\n    rz : (Z,) 1Darray of scalars\n        Redshifts, z, of each bin center.\n    redz_final : (M,Q,Z,F) NDarray of scalars\n        Final redshifts of each bin.\n    dcom_final : (M,Q,Z,F) NDarray of scalars\n        Final comoving distances of each bin.\n    sepa : (M,Q,Z,F) NDarray of scalars\n        Final separations of each mass and frequency combination.\n    angs : (M,Q,Z,F)\n        Final angular separations of each bin.\n    msort : (M*Q*Z,) 1Darray\n        M indices of each bin, sorted from largest to smallest h2fdf.\n    qsort : (M*Q*Z,) 1Darray\n        q indices of each bin, sorted from largest to smallest h2fdf.\n    zsort : (M*Q*Z,) 1Darray\n        z indices of each bin, sorted from largest to smallest h2fdf.\n    normal_threshold : float\n        Threshold for approximating poisson sampling as normal.\n\n    Returns\n    --------------------------\n    hc2ss : (F, R, L) Ndarray of scalars\n        Char strain squared of the loudest single sources.\n    hc2bg : (F, R) Ndarray of scalars\n        Char strain squared of the background.\n    sspar : (4, F, R) NDarray of scalars\n        Effective M, q, z parameters of the loudest L sources.\n        mass, ratio, redshift, redshift_final\n    bgpar : (4, F, R) NDarray of scalars\n        Average effective M, q, z parameters of the background.\n        mass, ratio, r""edshift, redshift_final\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_17loudest_hc_and_par_from_sorted_redz = {"loudest_hc_and_par_from_sorted_redz", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_17loudest_hc_and_par_from_sorted_redz, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_16loudest_hc_and_par_from_sorted_redz};
static PyObject *__pyx_pw_8holodeck_7cyutils_17loudest_hc_and_par_from_sorted_redz(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_number = 0;
  PyObject *__pyx_v_h2fdf = 0;
  PyObject *__pyx_v_nreals = 0;
  PyObject *__pyx_v_nloudest = 0;
  PyObject *__pyx_v_mt = 0;
  PyObject *__pyx_v_mr = 0;
  PyObject *__pyx_v_rz = 0;
  PyObject *__pyx_v_redz_final = 0;
  PyObject *__pyx_v_dcom_final = 0;
  PyObject *__pyx_v_sepa = 0;
  PyObject *__pyx_v_angs = 0;
  PyObject *__pyx_v_msort = 0;
  PyObject *__pyx_v_qsort = 0;
  PyObject *__pyx_v_zsort = 0;
  PyObject *__pyx_v_normal_threshold = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("loudest_hc_and_par_from_sorted_redz (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_number,&__pyx_n_s_h2fdf,&__pyx_n_s_nreals,&__pyx_n_s_nloudest,&__pyx_n_s_mt,&__pyx_n_s_mr,&__pyx_n_s_rz,&__pyx_n_s_redz_final,&__pyx_n_s_dcom_final,&__pyx_n_s_sepa,&__pyx_n_s_angs,&__pyx_n_s_msort,&__pyx_n_s_qsort,&__pyx_n_s_zsort,&__pyx_n_s_normal_threshold,0};
    PyObject* values[15] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
    values[14] = ((PyObject *)__pyx_float_1e10);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
        CYTHON_FALLTHROUGH;
        case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
        CYTHON_FALLTHROUGH;
        case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
        CYTHON_FALLTHROUGH;
        case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
        CYTHON_FALLTHROUGH;
        case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
        CYTHON_FALLTHROUGH;
        case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        CYTHON_FALLTHROUGH;
        case  9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        CYTHON_FALLTHROUGH;
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_number)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_h2fdf)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 1); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nreals)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 2); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nloudest)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 3); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mt)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 4); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mr)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 5); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rz)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 6); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_redz_final)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 7); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  8:
        if (likely((values[8] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dcom_final)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 8); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  9:
        if (likely((values[9] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sepa)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 9); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case 10:
        if (likely((values[10] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_angs)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 10); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case 11:
        if (likely((values[11] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_msort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 11); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case 12:
        if (likely((values[12] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_qsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 12); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case 13:
        if (likely((values[13] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_zsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, 13); __PYX_ERR(0, 1541, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case 14:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_normal_threshold);
          if (value) { values[14] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loudest_hc_and_par_from_sorted_redz") < 0)) __PYX_ERR(0, 1541, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
        CYTHON_FALLTHROUGH;
        case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
        values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
        values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
        values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
        values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
        values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
        values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_number = values[0];
    __pyx_v_h2fdf = values[1];
    __pyx_v_nreals = values[2];
    __pyx_v_nloudest = values[3];
    __pyx_v_mt = values[4];
    __pyx_v_mr = values[5];
    __pyx_v_rz = values[6];
    __pyx_v_redz_final = values[7];
    __pyx_v_dcom_final = values[8];
    __pyx_v_sepa = values[9];
    __pyx_v_angs = values[10];
    __pyx_v_msort = values[11];
    __pyx_v_qsort = values[12];
    __pyx_v_zsort = values[13];
    __pyx_v_normal_threshold = values[14];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("loudest_hc_and_par_from_sorted_redz", 0, 14, 15, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1541, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.loudest_hc_and_par_from_sorted_redz", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_16loudest_hc_and_par_from_sorted_redz(__pyx_self, __pyx_v_number, __pyx_v_h2fdf, __pyx_v_nreals, __pyx_v_nloudest, __pyx_v_mt, __pyx_v_mr, __pyx_v_rz, __pyx_v_redz_final, __pyx_v_dcom_final, __pyx_v_sepa, __pyx_v_angs, __pyx_v_msort, __pyx_v_qsort, __pyx_v_zsort, __pyx_v_normal_threshold);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_16loudest_hc_and_par_from_sorted_redz(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_number, PyObject *__pyx_v_h2fdf, PyObject *__pyx_v_nreals, PyObject *__pyx_v_nloudest, PyObject *__pyx_v_mt, PyObject *__pyx_v_mr, PyObject *__pyx_v_rz, PyObject *__pyx_v_redz_final, PyObject *__pyx_v_dcom_final, PyObject *__pyx_v_sepa, PyObject *__pyx_v_angs, PyObject *__pyx_v_msort, PyObject *__pyx_v_qsort, PyObject *__pyx_v_zsort, PyObject *__pyx_v_normal_threshold) {
  __Pyx_memviewslice __pyx_v_shape = { 0, 0, { 0 }, { 0 }, { 0 } };
  PyObject *__pyx_v_F = NULL;
  PyObject *__pyx_v_R = NULL;
  PyObject *__pyx_v_L = NULL;
  PyArrayObject *__pyx_v_hc2ss = 0;
  PyArrayObject *__pyx_v_hc2bg = 0;
  PyArrayObject *__pyx_v_sspar = 0;
  PyArrayObject *__pyx_v_bgpar = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_bgpar;
  __Pyx_Buffer __pyx_pybuffer_bgpar;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2bg;
  __Pyx_Buffer __pyx_pybuffer_hc2bg;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_hc2ss;
  __Pyx_Buffer __pyx_pybuffer_hc2ss;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_sspar;
  __Pyx_Buffer __pyx_pybuffer_sspar;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("loudest_hc_and_par_from_sorted_redz", 0);
  __pyx_pybuffer_hc2ss.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2ss.refcount = 0;
  __pyx_pybuffernd_hc2ss.data = NULL;
  __pyx_pybuffernd_hc2ss.rcbuffer = &__pyx_pybuffer_hc2ss;
  __pyx_pybuffer_hc2bg.pybuffer.buf = NULL;
  __pyx_pybuffer_hc2bg.refcount = 0;
  __pyx_pybuffernd_hc2bg.data = NULL;
  __pyx_pybuffernd_hc2bg.rcbuffer = &__pyx_pybuffer_hc2bg;
  __pyx_pybuffer_sspar.pybuffer.buf = NULL;
  __pyx_pybuffer_sspar.refcount = 0;
  __pyx_pybuffernd_sspar.data = NULL;
  __pyx_pybuffernd_sspar.rcbuffer = &__pyx_pybuffer_sspar;
  __pyx_pybuffer_bgpar.pybuffer.buf = NULL;
  __pyx_pybuffer_bgpar.refcount = 0;
  __pyx_pybuffernd_bgpar.data = NULL;
  __pyx_pybuffernd_bgpar.rcbuffer = &__pyx_pybuffer_bgpar;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_23, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_26, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_27, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_28, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_29, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sspar.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.loudest_hc_and_par_from_sorted_redz", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer);
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sspar.rcbuffer->pybuffer);
  __pyx_L2:;
  __PYX_XDEC_MEMVIEW(&__pyx_v_shape, 1);
  __Pyx_XDECREF(__pyx_v_F);
  __Pyx_XDECREF(__pyx_v_R);
  __Pyx_XDECREF(__pyx_v_L);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2ss);
  __Pyx_XDECREF((PyObject *)__pyx_v_hc2bg);
  __Pyx_XDECREF((PyObject *)__pyx_v_sspar);
  __Pyx_XDECREF((PyObject *)__pyx_v_bgpar);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__42 = PyTuple_Pack(23, __pyx_n_s_number, __pyx_n_s_h2fdf, __pyx_n_s_nreals, __pyx_n_s_nloudest, __pyx_n_s_mt, __pyx_n_s_mr, __pyx_n_s_rz, __pyx_n_s_redz_final, __pyx_n_s_dcom_final, __pyx_n_s_sepa, __pyx_n_s_angs, __pyx_n_s_msort, __pyx_n_s_qsort, __pyx_n_s_zsort, __pyx_n_s_normal_threshold, __pyx_n_s_shape, __pyx_n_s_F, __pyx_n_s_R, __pyx_n_s_L, __pyx_n_s_hc2ss, __pyx_n_s_hc2bg, __pyx_n_s_sspar, __pyx_n_s_bgpar); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(0, 1541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__42);
  __Pyx_GIVEREF(__pyx_tuple__42);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_17loudest_hc_and_par_from_sorted_redz, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1541, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_loudest_hc_and_par_from_sorted_r, __pyx_t_3) < 0) __PYX_ERR(0, 1541, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__43 = (PyObject*)__Pyx_PyCode_New(15, 0, 23, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__42, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_loudest_hc_and_par_from_sorted_r, 1541, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__43)) __PYX_ERR(0, 1541, __pyx_L1_error)

 1542:     number, h2fdf, nreals, nloudest,

 1543:     mt, mr, rz, redz_final, dcom_final, sepa, angs,

 1544:     msort, qsort, zsort, normal_threshold=1e10):

 1545:     """

 1546:     Calculates the characteristic strain and binary parameters from loud single sources and a

 1547:     background of all other sources.

 1548: 

 1549:     Parameters

 1550:     ------------------------

 1551:     number : [M, Q, Z, F] NDarray

 1552:         number in each bin

 1553:     h2fdf : [M, Q, Z, F] NDarray

 1554:         Strain amplitude squared x frequency / frequency bin width for each bin.

 1555:     nreals

 1556:         Number of realizations.

 1557:     nloudest

 1558:         Number of loudest sources to separate in each frequency bin.

 1559:     mt : (M,) 1Darray of scalars

 1560:         Total masses, M, of each bin center.

 1561:     mr : (Q,) 1Darray of scalars

 1562:         Mass ratios, q, of each bin center.

 1563:     rz : (Z,) 1Darray of scalars

 1564:         Redshifts, z, of each bin center.

 1565:     redz_final : (M,Q,Z,F) NDarray of scalars

 1566:         Final redshifts of each bin.

 1567:     dcom_final : (M,Q,Z,F) NDarray of scalars

 1568:         Final comoving distances of each bin.

 1569:     sepa : (M,Q,Z,F) NDarray of scalars

 1570:         Final separations of each mass and frequency combination.

 1571:     angs : (M,Q,Z,F)

 1572:         Final angular separations of each bin.

 1573:     msort : (M*Q*Z,) 1Darray

 1574:         M indices of each bin, sorted from largest to smallest h2fdf.

 1575:     qsort : (M*Q*Z,) 1Darray

 1576:         q indices of each bin, sorted from largest to smallest h2fdf.

 1577:     zsort : (M*Q*Z,) 1Darray

 1578:         z indices of each bin, sorted from largest to smallest h2fdf.

 1579:     normal_threshold : float

 1580:         Threshold for approximating poisson sampling as normal.

 1581: 

 1582:     Returns

 1583:     --------------------------

 1584:     hc2ss : (F, R, L) Ndarray of scalars

 1585:         Char strain squared of the loudest single sources.

 1586:     hc2bg : (F, R) Ndarray of scalars

 1587:         Char strain squared of the background.

 1588:     sspar : (4, F, R) NDarray of scalars

 1589:         Effective M, q, z parameters of the loudest L sources.

 1590:         mass, ratio, redshift, redshift_final

 1591:     bgpar : (4, F, R) NDarray of scalars

 1592:         Average effective M, q, z parameters of the background.

 1593:         mass, ratio, redshift, redshift_final

 1594:     """

 1595: 

+1596:     cdef long[:] shape = np.array(number.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_array); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_number, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1596, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1596, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_shape = __pyx_t_5;
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;

+1597:     F = shape[3]

  __pyx_t_6 = 3;
  __pyx_t_7 = -1;
  if (__pyx_t_6 < 0) {
    __pyx_t_6 += __pyx_v_shape.shape[0];
    if (unlikely(__pyx_t_6 < 0)) __pyx_t_7 = 0;
  } else if (unlikely(__pyx_t_6 >= __pyx_v_shape.shape[0])) __pyx_t_7 = 0;
  if (unlikely(__pyx_t_7 != -1)) {
    __Pyx_RaiseBufferIndexError(__pyx_t_7);
    __PYX_ERR(0, 1597, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_PyInt_From_long((*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_6 * __pyx_v_shape.strides[0]) )))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1597, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_F = __pyx_t_1;
  __pyx_t_1 = 0;

+1598:     R = nreals

  __Pyx_INCREF(__pyx_v_nreals);
  __pyx_v_R = __pyx_v_nreals;

+1599:     L = nloudest

  __Pyx_INCREF(__pyx_v_nloudest);
  __pyx_v_L = __pyx_v_nloudest;

+1600:     cdef np.ndarray[np.double_t, ndim=3] hc2ss = np.zeros((F,R,L))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_R);
  __Pyx_INCREF(__pyx_v_L);
  __Pyx_GIVEREF(__pyx_v_L);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_L);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1600, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1600, __pyx_L1_error)
  __pyx_t_8 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2ss.rcbuffer->pybuffer, (PyObject*)__pyx_t_8, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2ss = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1600, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2ss.diminfo[0].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2ss.diminfo[0].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2ss.diminfo[1].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2ss.diminfo[1].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_hc2ss.diminfo[2].strides = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_hc2ss.diminfo[2].shape = __pyx_pybuffernd_hc2ss.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_8 = 0;
  __pyx_v_hc2ss = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1601:     cdef np.ndarray[np.double_t, ndim=2] hc2bg = np.zeros((F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1601, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1601, __pyx_L1_error)
  __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_hc2bg.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_hc2bg = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1601, __pyx_L1_error)
    } else {__pyx_pybuffernd_hc2bg.diminfo[0].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_hc2bg.diminfo[0].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_hc2bg.diminfo[1].strides = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_hc2bg.diminfo[1].shape = __pyx_pybuffernd_hc2bg.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_9 = 0;
  __pyx_v_hc2bg = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1602:     cdef np.ndarray[np.double_t, ndim=4] sspar = np.zeros((4,F,R,L))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1602, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1602, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1602, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_int_4);
  __Pyx_GIVEREF(__pyx_int_4);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_int_4);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_R);
  __Pyx_INCREF(__pyx_v_L);
  __Pyx_GIVEREF(__pyx_v_L);
  PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_L);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1602, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1602, __pyx_L1_error)
  __pyx_t_10 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sspar.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
      __pyx_v_sspar = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_sspar.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1602, __pyx_L1_error)
    } else {__pyx_pybuffernd_sspar.diminfo[0].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sspar.diminfo[0].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sspar.diminfo[1].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sspar.diminfo[1].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_sspar.diminfo[2].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_sspar.diminfo[2].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_sspar.diminfo[3].strides = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_sspar.diminfo[3].shape = __pyx_pybuffernd_sspar.rcbuffer->pybuffer.shape[3];
    }
  }
  __pyx_t_10 = 0;
  __pyx_v_sspar = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1603:     cdef np.ndarray[np.double_t, ndim=3] bgpar = np.zeros((7,F,R))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_INCREF(__pyx_int_7);
  __Pyx_GIVEREF(__pyx_int_7);
  PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_int_7);
  __Pyx_INCREF(__pyx_v_F);
  __Pyx_GIVEREF(__pyx_v_F);
  PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_F);
  __Pyx_INCREF(__pyx_v_R);
  __Pyx_GIVEREF(__pyx_v_R);
  PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_R);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1603, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1603, __pyx_L1_error)
  __pyx_t_11 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_bgpar.rcbuffer->pybuffer, (PyObject*)__pyx_t_11, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_bgpar = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1603, __pyx_L1_error)
    } else {__pyx_pybuffernd_bgpar.diminfo[0].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_bgpar.diminfo[0].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_bgpar.diminfo[1].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_bgpar.diminfo[1].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_bgpar.diminfo[2].strides = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_bgpar.diminfo[2].shape = __pyx_pybuffernd_bgpar.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_11 = 0;
  __pyx_v_bgpar = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1604:     _loudest_hc_and_par_from_sorted_redz(shape, h2fdf, number, nreals, nloudest, normal_threshold,

  __pyx_t_12 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_h2fdf, PyBUF_WRITABLE); if (unlikely(!__pyx_t_12.memview)) __PYX_ERR(0, 1604, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_number, PyBUF_WRITABLE); if (unlikely(!__pyx_t_13.memview)) __PYX_ERR(0, 1604, __pyx_L1_error)
  __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1604, __pyx_L1_error)
  __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_v_nloudest); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1604, __pyx_L1_error)
  __pyx_t_16 = __Pyx_PyInt_As_long(__pyx_v_normal_threshold); if (unlikely((__pyx_t_16 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1604, __pyx_L1_error)
/* … */
  __pyx_f_8holodeck_7cyutils__loudest_hc_and_par_from_sorted_redz(__pyx_v_shape, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19, __pyx_t_20, __pyx_t_21, __pyx_t_22, __pyx_t_23, __pyx_t_5, __pyx_t_24, __pyx_t_25, __pyx_t_26, __pyx_t_27, __pyx_t_28, __pyx_t_29);
  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
  __pyx_t_12.memview = NULL;
  __pyx_t_12.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __pyx_t_13.memview = NULL;
  __pyx_t_13.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_17, 1);
  __pyx_t_17.memview = NULL;
  __pyx_t_17.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_18, 1);
  __pyx_t_18.memview = NULL;
  __pyx_t_18.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __pyx_t_19.memview = NULL;
  __pyx_t_19.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_20, 1);
  __pyx_t_20.memview = NULL;
  __pyx_t_20.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_21, 1);
  __pyx_t_21.memview = NULL;
  __pyx_t_21.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_22, 1);
  __pyx_t_22.memview = NULL;
  __pyx_t_22.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_23, 1);
  __pyx_t_23.memview = NULL;
  __pyx_t_23.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_5, 1);
  __pyx_t_5.memview = NULL;
  __pyx_t_5.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_24, 1);
  __pyx_t_24.memview = NULL;
  __pyx_t_24.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1);
  __pyx_t_25.memview = NULL;
  __pyx_t_25.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_26, 1);
  __pyx_t_26.memview = NULL;
  __pyx_t_26.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_27, 1);
  __pyx_t_27.memview = NULL;
  __pyx_t_27.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_28, 1);
  __pyx_t_28.memview = NULL;
  __pyx_t_28.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_29, 1);
  __pyx_t_29.memview = NULL;
  __pyx_t_29.data = NULL;

+1605:                             mt, mr, rz, redz_final, dcom_final, sepa, angs,

  __pyx_t_17 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mt, PyBUF_WRITABLE); if (unlikely(!__pyx_t_17.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_mr, PyBUF_WRITABLE); if (unlikely(!__pyx_t_18.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_rz, PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_t_20 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_redz_final, PyBUF_WRITABLE); if (unlikely(!__pyx_t_20.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_t_21 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_dcom_final, PyBUF_WRITABLE); if (unlikely(!__pyx_t_21.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_t_22 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_sepa, PyBUF_WRITABLE); if (unlikely(!__pyx_t_22.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)
  __pyx_t_23 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_angs, PyBUF_WRITABLE); if (unlikely(!__pyx_t_23.memview)) __PYX_ERR(0, 1605, __pyx_L1_error)

+1606:                             msort, qsort, zsort,

  __pyx_t_5 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_msort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_5.memview)) __PYX_ERR(0, 1606, __pyx_L1_error)
  __pyx_t_24 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_qsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_24.memview)) __PYX_ERR(0, 1606, __pyx_L1_error)
  __pyx_t_25 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_zsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_25.memview)) __PYX_ERR(0, 1606, __pyx_L1_error)

+1607:                             hc2ss, hc2bg, sspar, bgpar)

  __pyx_t_26 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_hc2ss), PyBUF_WRITABLE); if (unlikely(!__pyx_t_26.memview)) __PYX_ERR(0, 1607, __pyx_L1_error)
  __pyx_t_27 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_hc2bg), PyBUF_WRITABLE); if (unlikely(!__pyx_t_27.memview)) __PYX_ERR(0, 1607, __pyx_L1_error)
  __pyx_t_28 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(((PyObject *)__pyx_v_sspar), PyBUF_WRITABLE); if (unlikely(!__pyx_t_28.memview)) __PYX_ERR(0, 1607, __pyx_L1_error)
  __pyx_t_29 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_bgpar), PyBUF_WRITABLE); if (unlikely(!__pyx_t_29.memview)) __PYX_ERR(0, 1607, __pyx_L1_error)

+1608:     return hc2ss, hc2bg, sspar, bgpar

  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1608, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2ss));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2ss));
  PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_hc2ss));
  __Pyx_INCREF(((PyObject *)__pyx_v_hc2bg));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_hc2bg));
  PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_hc2bg));
  __Pyx_INCREF(((PyObject *)__pyx_v_sspar));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_sspar));
  PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_v_sspar));
  __Pyx_INCREF(((PyObject *)__pyx_v_bgpar));
  __Pyx_GIVEREF(((PyObject *)__pyx_v_bgpar));
  PyTuple_SET_ITEM(__pyx_t_1, 3, ((PyObject *)__pyx_v_bgpar));
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

 1609: 

 1610: 

 1611: @cython.boundscheck(False)

 1612: @cython.wraparound(False)

 1613: @cython.nonecheck(False)

 1614: @cython.cdivision(True)

+1615: cdef void _loudest_hc_and_par_from_sorted_redz(long[:] shape, double[:,:,:,:] h2fdf, double[:,:,:,:] number,

static void __pyx_f_8holodeck_7cyutils__loudest_hc_and_par_from_sorted_redz(__Pyx_memviewslice __pyx_v_shape, __Pyx_memviewslice __pyx_v_h2fdf, __Pyx_memviewslice __pyx_v_number, long __pyx_v_nreals, long __pyx_v_nloudest, long __pyx_v_thresh, __Pyx_memviewslice __pyx_v_mt, __Pyx_memviewslice __pyx_v_mr, __Pyx_memviewslice __pyx_v_rz, __Pyx_memviewslice __pyx_v_redz_final, __Pyx_memviewslice __pyx_v_dcom_final, __Pyx_memviewslice __pyx_v_sepa, __Pyx_memviewslice __pyx_v_angs, __Pyx_memviewslice __pyx_v_msort, __Pyx_memviewslice __pyx_v_qsort, __Pyx_memviewslice __pyx_v_zsort, __Pyx_memviewslice __pyx_v_hc2ss, __Pyx_memviewslice __pyx_v_hc2bg, __Pyx_memviewslice __pyx_v_sspar, __Pyx_memviewslice __pyx_v_bgpar) {
  int __pyx_v_M;
  int __pyx_v_Q;
  int __pyx_v_Z;
  int __pyx_v_F;
  int __pyx_v_L;
  int __pyx_v_R;
  int __pyx_v_mm;
  int __pyx_v_qq;
  int __pyx_v_zz;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_ll;
  double __pyx_v_num;
  double __pyx_v_cur;
  double __pyx_v_sum_bg;
  double __pyx_v_m_bg;
  double __pyx_v_q_bg;
  double __pyx_v_z_bg;
  double __pyx_v_zfinal_bg;
  double __pyx_v_dcom_bg;
  double __pyx_v_sepa_bg;
  double __pyx_v_angs_bg;
  bitgen_t *__pyx_v_rng;
  char const *__pyx_v_capsule_name;
  PyObject *__pyx_v_capsule = NULL;
  int __pyx_v_bb;
  double __pyx_v_std;
  PyObject *__pyx_v_err = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_loudest_hc_and_par_from_sorted_redz", 0);
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_WriteUnraisable("holodeck.cyutils._loudest_hc_and_par_from_sorted_redz", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_capsule);
  __Pyx_XDECREF(__pyx_v_err);
  __Pyx_RefNannyFinishContext();
}

 1616:             long nreals, long nloudest, long thresh,

 1617:             double[:] mt, double[:] mr, double[:] rz,

 1618:             double[:,:,:,:] redz_final, double[:,:,:,:] dcom_final, double[:,:,:,:] sepa, double[:,:,:,:] angs,

 1619:             long[:] msort, long[:] qsort, long[:] zsort,

 1620:             double[:,:,:] hc2ss, double[:,:] hc2bg, double[:,:,:,:] sspar, double[:,:,:] bgpar):

 1621:     """

 1622:     Calculates the characteristic strain from loud single sources and a background of all other sources.

 1623: 

 1624:     Parameters

 1625:     ----------

 1626:     shape : long[:] array

 1627:         Shape of number, [M, Q, Z, F].

 1628:     number : double[:,:,:,:] array

 1629:         Number per bin.

 1630:     h2fdf : double[:,:,:,:] array

 1631:         Strain amplitude squared * f/Delta f for a single source in each bin.

 1632:     nreals : int

 1633:         Number of realizations.

 1634:     nloudest : int

 1635:         Number of loudest sources at each source.

 1636:     mt : (M,) 1Darray of scalars

 1637:         Total masses of each bin center.

 1638:     mr : (Q,) 1Darray of scalars

 1639:         Mass ratios of each bin center.

 1640:     rz : (Z,) 1Darray of scalars

 1641:         Redshifts, z, of each bin center.

 1642:     redz_final : (M,Q,Z,F) NDarray of scalars

 1643:         Final redshifts of each bin.

 1644:     dcom_final : (M,Q,Z,F) NDarray of scalars

 1645:         Final comoving distances of each bin.

 1646:     sepa : (M,Q,Z,F) NDarray of scalars

 1647:         Final separations of each bin.

 1648:     angs : (M,Q,Z,F)

 1649:         Final angular separations of each bin.

 1650:     msort : (M*Q*Z,) 1Darray

 1651:         M indices of each bin, sorted from largest to smallest h2fdf.

 1652:     qsort : (M*Q*Z,) 1Darray

 1653:         q indices of each bin, sorted from largest to smallest h2fdf.

 1654:     zsort : (M*Q*Z,) 1Darray

 1655:         z indices of each bin, sorted from largest to smallest h2fdf.

 1656:     hc2ss : double[:,:,:] array

 1657:         (Memory address of) single source characteristic strain squared array.

 1658:     hc2bg : double[:,:] array

 1659:         (Memory address of) background characteristic strain squared array.

 1660:     sspar : (4, F, R) NDarray of scalars

 1661:         Effective M, q, z parameters of the loudest L sources.

 1662:         mass, ratio, redshift, redshift_final

 1663:     bgpar : (4, F, R) NDarray of scalars

 1664:         Average effective M, q, z parameters of the background.

 1665:         mass, ratio, redshift, redshift_final

 1666: 

 1667:     Returns

 1668:     -------

 1669:     void

 1670:     updated via memory address: hc2ss, hc2bg, sspar, bgpar

 1671:     """

 1672: 

+1673:     cdef int M = shape[0]

  __pyx_t_1 = 0;
  __pyx_v_M = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1674:     cdef int Q = shape[1]

  __pyx_t_1 = 1;
  __pyx_v_Q = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1675:     cdef int Z = shape[2]

  __pyx_t_1 = 2;
  __pyx_v_Z = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1676:     cdef int F = shape[3]

  __pyx_t_1 = 3;
  __pyx_v_F = (*((long *) ( /* dim=0 */ (__pyx_v_shape.data + __pyx_t_1 * __pyx_v_shape.strides[0]) )));

+1677:     cdef int L = nloudest

  __pyx_v_L = __pyx_v_nloudest;

+1678:     cdef int R = nreals

  __pyx_v_R = __pyx_v_nreals;

 1679: 

 1680:     cdef int mm, qq, zz, ff, rr, ll

 1681:     cdef double num, cur, sum_bg, m_bg, q_bg, z_bg, zfinal_bg, dcom_bg, sepa_bg, angs_bg

 1682: 

 1683:     # # check all redz_final are positive

 1684:     # for mm in range(len(redz_final)):

 1685:     #     for qq in range(len(redz_final[0])):

 1686:     #         for zz in range(len(redz_final[0,0])):

 1687:     #             for ff in range(len(redz_final[0,0,0])):

 1688:     #                 if (redz_final[mm,qq,zz,ff]<0 and redz_final[mm,qq,zz,ff] !=-1):

 1689:     #                     err = f"redz_final[{mm},{qq},{zz},{ff},] = {redz_final[mm,qq,zz,ff]} < 0"

 1690:     #                     raise ValueError(err)

 1691:     # print("passed redz_final check in _loudest_hc_and_par_from_sorted_redz")

 1692: 

 1693: 

 1694: 

 1695:     # Setup random number generator from numpy library

 1696:     cdef bitgen_t *rng

+1697:     cdef const char *capsule_name = "BitGenerator"

  __pyx_v_capsule_name = ((char const *)"BitGenerator");

+1698:     capsule = PCG64().capsule

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_PCG64); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1698, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1698, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_capsule); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1698, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_capsule = __pyx_t_3;
  __pyx_t_3 = 0;

 1699:     # Cast the pointer

+1700:     rng = <bitgen_t *> PyCapsule_GetPointer(capsule, capsule_name)

  __pyx_t_5 = PyCapsule_GetPointer(__pyx_v_capsule, __pyx_v_capsule_name); if (unlikely(__pyx_t_5 == ((void *)NULL) && PyErr_Occurred())) __PYX_ERR(0, 1700, __pyx_L1_error)
  __pyx_v_rng = ((bitgen_t *)__pyx_t_5);

+1701:     for rr in range(R):

  __pyx_t_6 = __pyx_v_R;
  __pyx_t_7 = __pyx_t_6;
  for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) {
    __pyx_v_rr = __pyx_t_8;

+1702:         for ff in range(F):

    __pyx_t_9 = __pyx_v_F;
    __pyx_t_10 = __pyx_t_9;
    for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
      __pyx_v_ff = __pyx_t_11;

+1703:             ll = 0 # track which index in the loudest list you're currently storing

      __pyx_v_ll = 0;

 1704:                      # start at 0 for the loudest of all.

 1705:             # reset strain sums

+1706:             sum_bg = 0 # sum of bg h2fdf, for parameter averaging and gwb

      __pyx_v_sum_bg = 0.0;

 1707:             # reset parameter averaging sums

+1708:             m_bg = 0

      __pyx_v_m_bg = 0.0;

+1709:             q_bg = 0

      __pyx_v_q_bg = 0.0;

+1710:             z_bg = 0

      __pyx_v_z_bg = 0.0;

+1711:             zfinal_bg = 0

      __pyx_v_zfinal_bg = 0.0;

+1712:             dcom_bg = 0

      __pyx_v_dcom_bg = 0.0;

+1713:             sepa_bg = 0

      __pyx_v_sepa_bg = 0.0;

+1714:             angs_bg = 0

      __pyx_v_angs_bg = 0.0;

+1715:             for bb in range(M*Q*Z): #iterate through bins, loudest to quietest

      __pyx_t_12 = ((__pyx_v_M * __pyx_v_Q) * __pyx_v_Z);
      __pyx_t_13 = __pyx_t_12;
      for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
        __pyx_v_bb = __pyx_t_14;

+1716:                 mm = msort[bb]

        __pyx_t_1 = __pyx_v_bb;
        __pyx_v_mm = (*((long *) ( /* dim=0 */ (__pyx_v_msort.data + __pyx_t_1 * __pyx_v_msort.strides[0]) )));

+1717:                 qq = qsort[bb]

        __pyx_t_1 = __pyx_v_bb;
        __pyx_v_qq = (*((long *) ( /* dim=0 */ (__pyx_v_qsort.data + __pyx_t_1 * __pyx_v_qsort.strides[0]) )));

+1718:                 zz = zsort[bb]

        __pyx_t_1 = __pyx_v_bb;
        __pyx_v_zz = (*((long *) ( /* dim=0 */ (__pyx_v_zsort.data + __pyx_t_1 * __pyx_v_zsort.strides[0]) )));

+1719:                 num = number[mm,qq,zz,ff]

        __pyx_t_1 = __pyx_v_mm;
        __pyx_t_15 = __pyx_v_qq;
        __pyx_t_16 = __pyx_v_zz;
        __pyx_t_17 = __pyx_v_ff;
        __pyx_v_num = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_number.data + __pyx_t_1 * __pyx_v_number.strides[0]) ) + __pyx_t_15 * __pyx_v_number.strides[1]) ) + __pyx_t_16 * __pyx_v_number.strides[2]) ) + __pyx_t_17 * __pyx_v_number.strides[3]) )));

+1720:                 if (num>thresh): # Gaussian sample

        __pyx_t_18 = ((__pyx_v_num > __pyx_v_thresh) != 0);
        if (__pyx_t_18) {
/* … */
          goto __pyx_L9;
        }

+1721:                     std = sqrt(num)

          __pyx_v_std = sqrt(__pyx_v_num);

+1722:                     num = <double>random_normal(rng, num, std)

          __pyx_v_num = ((double)random_normal(__pyx_v_rng, __pyx_v_num, __pyx_v_std));

 1723:                 else:            # Poisson sample

+1724:                     num = <double>random_poisson(rng, num)

        /*else*/ {
          __pyx_v_num = ((double)random_poisson(__pyx_v_rng, __pyx_v_num));
        }
        __pyx_L9:;

+1725:                 cur = h2fdf[mm,qq,zz,ff] # h^2 * f/df of current bin

        __pyx_t_17 = __pyx_v_mm;
        __pyx_t_16 = __pyx_v_qq;
        __pyx_t_15 = __pyx_v_zz;
        __pyx_t_1 = __pyx_v_ff;
        __pyx_v_cur = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_h2fdf.data + __pyx_t_17 * __pyx_v_h2fdf.strides[0]) ) + __pyx_t_16 * __pyx_v_h2fdf.strides[1]) ) + __pyx_t_15 * __pyx_v_h2fdf.strides[2]) ) + __pyx_t_1 * __pyx_v_h2fdf.strides[3]) )));

 1726: 

+1727:                 if (num < 1) or (cur == 0):

        __pyx_t_19 = ((__pyx_v_num < 1.0) != 0);
        if (!__pyx_t_19) {
        } else {
          __pyx_t_18 = __pyx_t_19;
          goto __pyx_L11_bool_binop_done;
        }
        __pyx_t_19 = ((__pyx_v_cur == 0.0) != 0);
        __pyx_t_18 = __pyx_t_19;
        __pyx_L11_bool_binop_done:;
        if (__pyx_t_18) {
/* … */
        }

+1728:                     continue # to next loudest bin

          goto __pyx_L7_continue;

+1729:                 while (ll < L) and (num > 0):

        while (1) {
          __pyx_t_19 = ((__pyx_v_ll < __pyx_v_L) != 0);
          if (__pyx_t_19) {
          } else {
            __pyx_t_18 = __pyx_t_19;
            goto __pyx_L15_bool_binop_done;
          }
          __pyx_t_19 = ((__pyx_v_num > 0.0) != 0);
          __pyx_t_18 = __pyx_t_19;
          __pyx_L15_bool_binop_done:;
          if (!__pyx_t_18) break;

 1730:                     # store ll loudest source strain

+1731:                     hc2ss[ff,rr,ll] = cur

          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_15 = __pyx_v_rr;
          __pyx_t_16 = __pyx_v_ll;
          *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2ss.data + __pyx_t_1 * __pyx_v_hc2ss.strides[0]) ) + __pyx_t_15 * __pyx_v_hc2ss.strides[1]) ) + __pyx_t_16 * __pyx_v_hc2ss.strides[2]) )) = __pyx_v_cur;

 1732: 

 1733:                     # store indices of ll loudest source

+1734:                     sspar[0,ff,rr,ll] = mt[mm]

          __pyx_t_16 = __pyx_v_mm;
          __pyx_t_15 = 0;
          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_17 = __pyx_v_rr;
          __pyx_t_20 = __pyx_v_ll;
          *((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_15 * __pyx_v_sspar.strides[0]) ) + __pyx_t_1 * __pyx_v_sspar.strides[1]) ) + __pyx_t_17 * __pyx_v_sspar.strides[2]) ) + __pyx_t_20 * __pyx_v_sspar.strides[3]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_16 * __pyx_v_mt.strides[0]) )));

+1735:                     sspar[1,ff,rr,ll] = mr[qq]

          __pyx_t_16 = __pyx_v_qq;
          __pyx_t_20 = 1;
          __pyx_t_17 = __pyx_v_ff;
          __pyx_t_1 = __pyx_v_rr;
          __pyx_t_15 = __pyx_v_ll;
          *((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_20 * __pyx_v_sspar.strides[0]) ) + __pyx_t_17 * __pyx_v_sspar.strides[1]) ) + __pyx_t_1 * __pyx_v_sspar.strides[2]) ) + __pyx_t_15 * __pyx_v_sspar.strides[3]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_16 * __pyx_v_mr.strides[0]) )));

+1736:                     sspar[2,ff,rr,ll] = rz[zz]

          __pyx_t_16 = __pyx_v_zz;
          __pyx_t_15 = 2;
          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_17 = __pyx_v_rr;
          __pyx_t_20 = __pyx_v_ll;
          *((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_15 * __pyx_v_sspar.strides[0]) ) + __pyx_t_1 * __pyx_v_sspar.strides[1]) ) + __pyx_t_17 * __pyx_v_sspar.strides[2]) ) + __pyx_t_20 * __pyx_v_sspar.strides[3]) )) = (*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_16 * __pyx_v_rz.strides[0]) )));

+1737:                     sspar[3,ff,rr,ll] = redz_final[mm,qq,zz,ff]

          __pyx_t_16 = __pyx_v_mm;
          __pyx_t_20 = __pyx_v_qq;
          __pyx_t_17 = __pyx_v_zz;
          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_15 = 3;
          __pyx_t_21 = __pyx_v_ff;
          __pyx_t_22 = __pyx_v_rr;
          __pyx_t_23 = __pyx_v_ll;
          *((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sspar.data + __pyx_t_15 * __pyx_v_sspar.strides[0]) ) + __pyx_t_21 * __pyx_v_sspar.strides[1]) ) + __pyx_t_22 * __pyx_v_sspar.strides[2]) ) + __pyx_t_23 * __pyx_v_sspar.strides[3]) )) = (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_redz_final.data + __pyx_t_16 * __pyx_v_redz_final.strides[0]) ) + __pyx_t_20 * __pyx_v_redz_final.strides[1]) ) + __pyx_t_17 * __pyx_v_redz_final.strides[2]) ) + __pyx_t_1 * __pyx_v_redz_final.strides[3]) )));

 1738: 

 1739:                     # check for negative redz_final

+1740:                     if redz_final[mm,qq,zz,ff]<0 and redz_final[mm,qq,zz,ff]!=-1:

          __pyx_t_1 = __pyx_v_mm;
          __pyx_t_17 = __pyx_v_qq;
          __pyx_t_20 = __pyx_v_zz;
          __pyx_t_16 = __pyx_v_ff;
          __pyx_t_19 = (((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_redz_final.data + __pyx_t_1 * __pyx_v_redz_final.strides[0]) ) + __pyx_t_17 * __pyx_v_redz_final.strides[1]) ) + __pyx_t_20 * __pyx_v_redz_final.strides[2]) ) + __pyx_t_16 * __pyx_v_redz_final.strides[3]) ))) < 0.0) != 0);
          if (__pyx_t_19) {
          } else {
            __pyx_t_18 = __pyx_t_19;
            goto __pyx_L18_bool_binop_done;
          }
          __pyx_t_16 = __pyx_v_mm;
          __pyx_t_20 = __pyx_v_qq;
          __pyx_t_17 = __pyx_v_zz;
          __pyx_t_1 = __pyx_v_ff;
          __pyx_t_19 = (((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_redz_final.data + __pyx_t_16 * __pyx_v_redz_final.strides[0]) ) + __pyx_t_20 * __pyx_v_redz_final.strides[1]) ) + __pyx_t_17 * __pyx_v_redz_final.strides[2]) ) + __pyx_t_1 * __pyx_v_redz_final.strides[3]) ))) != -1.0) != 0);
          __pyx_t_18 = __pyx_t_19;
          __pyx_L18_bool_binop_done:;
          if (__pyx_t_18) {
/* … */
          }

 1741:                         # badz = badz+1

+1742:                         err = f"redz_final[{mm},{qq},{zz},{ff}] = {redz_final[mm,qq,zz,ff]} < 0"

            __pyx_t_3 = PyTuple_New(11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __pyx_t_24 = 0;
            __pyx_t_25 = 127;
            __Pyx_INCREF(__pyx_kp_u_redz_final_2);
            __pyx_t_24 += 11;
            __Pyx_GIVEREF(__pyx_kp_u_redz_final_2);
            PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_kp_u_redz_final_2);
            __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_mm, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_24 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_2);
            PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2);
            __pyx_t_2 = 0;
            __Pyx_INCREF(__pyx_kp_u__3);
            __pyx_t_24 += 1;
            __Pyx_GIVEREF(__pyx_kp_u__3);
            PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_kp_u__3);
            __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_qq, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_24 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_2);
            PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_t_2);
            __pyx_t_2 = 0;
            __Pyx_INCREF(__pyx_kp_u__3);
            __pyx_t_24 += 1;
            __Pyx_GIVEREF(__pyx_kp_u__3);
            PyTuple_SET_ITEM(__pyx_t_3, 4, __pyx_kp_u__3);
            __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_zz, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_24 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_2);
            PyTuple_SET_ITEM(__pyx_t_3, 5, __pyx_t_2);
            __pyx_t_2 = 0;
            __Pyx_INCREF(__pyx_kp_u__3);
            __pyx_t_24 += 1;
            __Pyx_GIVEREF(__pyx_kp_u__3);
            PyTuple_SET_ITEM(__pyx_t_3, 6, __pyx_kp_u__3);
            __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_ff, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_24 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2);
            __Pyx_GIVEREF(__pyx_t_2);
            PyTuple_SET_ITEM(__pyx_t_3, 7, __pyx_t_2);
            __pyx_t_2 = 0;
            __Pyx_INCREF(__pyx_kp_u__4);
            __pyx_t_24 += 4;
            __Pyx_GIVEREF(__pyx_kp_u__4);
            PyTuple_SET_ITEM(__pyx_t_3, 8, __pyx_kp_u__4);
            __pyx_t_1 = __pyx_v_mm;
            __pyx_t_17 = __pyx_v_qq;
            __pyx_t_20 = __pyx_v_zz;
            __pyx_t_16 = __pyx_v_ff;
            __pyx_t_2 = PyFloat_FromDouble((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_redz_final.data + __pyx_t_1 * __pyx_v_redz_final.strides[0]) ) + __pyx_t_17 * __pyx_v_redz_final.strides[1]) ) + __pyx_t_20 * __pyx_v_redz_final.strides[2]) ) + __pyx_t_16 * __pyx_v_redz_final.strides[3]) )))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_2);
            __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_t_2, __pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
            __pyx_t_25 = (__Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) > __pyx_t_25) ? __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_4) : __pyx_t_25;
            __pyx_t_24 += __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4);
            __Pyx_GIVEREF(__pyx_t_4);
            PyTuple_SET_ITEM(__pyx_t_3, 9, __pyx_t_4);
            __pyx_t_4 = 0;
            __Pyx_INCREF(__pyx_kp_u_0);
            __pyx_t_24 += 4;
            __Pyx_GIVEREF(__pyx_kp_u_0);
            PyTuple_SET_ITEM(__pyx_t_3, 10, __pyx_kp_u_0);
            __pyx_t_4 = __Pyx_PyUnicode_Join(__pyx_t_3, 11, __pyx_t_24, __pyx_t_25); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1742, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
            __Pyx_XDECREF_SET(__pyx_v_err, ((PyObject*)__pyx_t_4));
            __pyx_t_4 = 0;

+1743:                         print("ERROR IN CYUTILS:", err)

            __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1743, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_4);
            __Pyx_INCREF(__pyx_kp_u_ERROR_IN_CYUTILS);
            __Pyx_GIVEREF(__pyx_kp_u_ERROR_IN_CYUTILS);
            PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_kp_u_ERROR_IN_CYUTILS);
            __Pyx_INCREF(__pyx_v_err);
            __Pyx_GIVEREF(__pyx_v_err);
            PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_err);
            __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1743, __pyx_L1_error)
            __Pyx_GOTREF(__pyx_t_3);
            __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
            __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

 1744: 

 1745:                     # update number and ll index

+1746:                     num -= 1

          __pyx_v_num = (__pyx_v_num - 1.0);

+1747:                     ll += 1

          __pyx_v_ll = (__pyx_v_ll + 1);
        }

 1748: 

+1749:                 sum_bg += num * cur # tot bg h2fdf

        __pyx_v_sum_bg = (__pyx_v_sum_bg + (__pyx_v_num * __pyx_v_cur));

 1750:                 # add to average parameters of background sources

+1751:                 m_bg += num * cur * mt[mm] # tot weight bg mass

        __pyx_t_16 = __pyx_v_mm;
        __pyx_v_m_bg = (__pyx_v_m_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=0 */ (__pyx_v_mt.data + __pyx_t_16 * __pyx_v_mt.strides[0]) )))));

+1752:                 q_bg += num * cur * mr[qq] # tot weighted bg ratio

        __pyx_t_16 = __pyx_v_qq;
        __pyx_v_q_bg = (__pyx_v_q_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=0 */ (__pyx_v_mr.data + __pyx_t_16 * __pyx_v_mr.strides[0]) )))));

+1753:                 z_bg += num * cur * rz[zz] # tot weighted bg redshift

        __pyx_t_16 = __pyx_v_zz;
        __pyx_v_z_bg = (__pyx_v_z_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=0 */ (__pyx_v_rz.data + __pyx_t_16 * __pyx_v_rz.strides[0]) )))));

+1754:                 zfinal_bg += num * cur * redz_final[mm,qq,zz,ff] # tot weighted bg redshift after hardening

        __pyx_t_16 = __pyx_v_mm;
        __pyx_t_20 = __pyx_v_qq;
        __pyx_t_17 = __pyx_v_zz;
        __pyx_t_1 = __pyx_v_ff;
        __pyx_v_zfinal_bg = (__pyx_v_zfinal_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_redz_final.data + __pyx_t_16 * __pyx_v_redz_final.strides[0]) ) + __pyx_t_20 * __pyx_v_redz_final.strides[1]) ) + __pyx_t_17 * __pyx_v_redz_final.strides[2]) ) + __pyx_t_1 * __pyx_v_redz_final.strides[3]) )))));

+1755:                 dcom_bg += num * cur * dcom_final[mm,qq,zz,ff] # tot weighted bg com. dist. after hardening

        __pyx_t_1 = __pyx_v_mm;
        __pyx_t_17 = __pyx_v_qq;
        __pyx_t_20 = __pyx_v_zz;
        __pyx_t_16 = __pyx_v_ff;
        __pyx_v_dcom_bg = (__pyx_v_dcom_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_dcom_final.data + __pyx_t_1 * __pyx_v_dcom_final.strides[0]) ) + __pyx_t_17 * __pyx_v_dcom_final.strides[1]) ) + __pyx_t_20 * __pyx_v_dcom_final.strides[2]) ) + __pyx_t_16 * __pyx_v_dcom_final.strides[3]) )))));

+1756:                 sepa_bg += num * cur * sepa[mm,qq,zz,ff] # tot weighted bg separation after hardening

        __pyx_t_16 = __pyx_v_mm;
        __pyx_t_20 = __pyx_v_qq;
        __pyx_t_17 = __pyx_v_zz;
        __pyx_t_1 = __pyx_v_ff;
        __pyx_v_sepa_bg = (__pyx_v_sepa_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sepa.data + __pyx_t_16 * __pyx_v_sepa.strides[0]) ) + __pyx_t_20 * __pyx_v_sepa.strides[1]) ) + __pyx_t_17 * __pyx_v_sepa.strides[2]) ) + __pyx_t_1 * __pyx_v_sepa.strides[3]) )))));

+1757:                 angs_bg += num * cur * angs[mm,qq,zz,ff] # tot weighted bg angular separation after hardening

        __pyx_t_1 = __pyx_v_mm;
        __pyx_t_17 = __pyx_v_qq;
        __pyx_t_20 = __pyx_v_zz;
        __pyx_t_16 = __pyx_v_ff;
        __pyx_v_angs_bg = (__pyx_v_angs_bg + ((__pyx_v_num * __pyx_v_cur) * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_angs.data + __pyx_t_1 * __pyx_v_angs.strides[0]) ) + __pyx_t_17 * __pyx_v_angs.strides[1]) ) + __pyx_t_20 * __pyx_v_angs.strides[2]) ) + __pyx_t_16 * __pyx_v_angs.strides[3]) )))));
        __pyx_L7_continue:;
      }

 1758: 

+1759:             hc2bg[ff,rr] = sum_bg # background strain

      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_20 = __pyx_v_rr;
      *((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc2bg.data + __pyx_t_16 * __pyx_v_hc2bg.strides[0]) ) + __pyx_t_20 * __pyx_v_hc2bg.strides[1]) )) = __pyx_v_sum_bg;

 1760:             # background average parameters

+1761:             bgpar[0,ff,rr] = m_bg/sum_bg # bg avg mass

      __pyx_t_20 = 0;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_17 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_20 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_17 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_m_bg / __pyx_v_sum_bg);

+1762:             bgpar[1,ff,rr] = q_bg/sum_bg # bg avg ratio

      __pyx_t_17 = 1;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_20 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_17 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_20 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_q_bg / __pyx_v_sum_bg);

+1763:             bgpar[2,ff,rr] = z_bg/sum_bg # bg avg redshift

      __pyx_t_20 = 2;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_17 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_20 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_17 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_z_bg / __pyx_v_sum_bg);

+1764:             bgpar[3,ff,rr] = zfinal_bg/sum_bg # bg avg redshift after hardening

      __pyx_t_17 = 3;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_20 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_17 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_20 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_zfinal_bg / __pyx_v_sum_bg);

+1765:             bgpar[4,ff,rr] = dcom_bg/sum_bg # bg avg comoving distance after hardening

      __pyx_t_20 = 4;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_17 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_20 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_17 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_dcom_bg / __pyx_v_sum_bg);

+1766:             bgpar[5,ff,rr] = sepa_bg/sum_bg # bg avg binary separation after hardening

      __pyx_t_17 = 5;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_20 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_17 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_20 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_sepa_bg / __pyx_v_sum_bg);

+1767:             bgpar[6,ff,rr] = angs_bg/sum_bg # bg avg binary angular separation after hardening

      __pyx_t_20 = 6;
      __pyx_t_16 = __pyx_v_ff;
      __pyx_t_17 = __pyx_v_rr;
      *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_bgpar.data + __pyx_t_20 * __pyx_v_bgpar.strides[0]) ) + __pyx_t_16 * __pyx_v_bgpar.strides[1]) ) + __pyx_t_17 * __pyx_v_bgpar.strides[2]) )) = (__pyx_v_angs_bg / __pyx_v_sum_bg);
    }
  }

 1768: 

 1769: 

 1770: 

 1771: 

+1772: def interp_2d(xnew, xold, yold, xlog=False, ylog=False, extrap=False):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_19interp_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_19interp_2d = {"interp_2d", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_19interp_2d, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_8holodeck_7cyutils_19interp_2d(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_xnew = 0;
  PyObject *__pyx_v_xold = 0;
  PyObject *__pyx_v_yold = 0;
  PyObject *__pyx_v_xlog = 0;
  PyObject *__pyx_v_ylog = 0;
  PyObject *__pyx_v_extrap = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("interp_2d (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_xnew,&__pyx_n_s_xold,&__pyx_n_s_yold,&__pyx_n_s_xlog,&__pyx_n_s_ylog,&__pyx_n_s_extrap,0};
    PyObject* values[6] = {0,0,0,0,0,0};
    values[3] = ((PyObject *)Py_False);
    values[4] = ((PyObject *)Py_False);
    values[5] = ((PyObject *)Py_False);
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xnew)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xold)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("interp_2d", 0, 3, 6, 1); __PYX_ERR(0, 1772, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_yold)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("interp_2d", 0, 3, 6, 2); __PYX_ERR(0, 1772, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_xlog);
          if (value) { values[3] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ylog);
          if (value) { values[4] = value; kw_args--; }
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (kw_args > 0) {
          PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_extrap);
          if (value) { values[5] = value; kw_args--; }
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "interp_2d") < 0)) __PYX_ERR(0, 1772, __pyx_L3_error)
      }
    } else {
      switch (PyTuple_GET_SIZE(__pyx_args)) {
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        break;
        default: goto __pyx_L5_argtuple_error;
      }
    }
    __pyx_v_xnew = values[0];
    __pyx_v_xold = values[1];
    __pyx_v_yold = values[2];
    __pyx_v_xlog = values[3];
    __pyx_v_ylog = values[4];
    __pyx_v_extrap = values[5];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("interp_2d", 0, 3, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1772, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.interp_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_18interp_2d(__pyx_self, __pyx_v_xnew, __pyx_v_xold, __pyx_v_yold, __pyx_v_xlog, __pyx_v_ylog, __pyx_v_extrap);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_18interp_2d(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_xnew, PyObject *__pyx_v_xold, PyObject *__pyx_v_yold, PyObject *__pyx_v_xlog, PyObject *__pyx_v_ylog, PyObject *__pyx_v_extrap) {
  long __pyx_v_extrap_flag;
  PyObject *__pyx_v_ynew = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("interp_2d", 0);
  __Pyx_INCREF(__pyx_v_xnew);
  __Pyx_INCREF(__pyx_v_xold);
  __Pyx_INCREF(__pyx_v_yold);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __Pyx_XDECREF(__pyx_t_11);
  __Pyx_AddTraceback("holodeck.cyutils.interp_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_ynew);
  __Pyx_XDECREF(__pyx_v_xnew);
  __Pyx_XDECREF(__pyx_v_xold);
  __Pyx_XDECREF(__pyx_v_yold);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__44 = PyTuple_Pack(8, __pyx_n_s_xnew, __pyx_n_s_xold, __pyx_n_s_yold, __pyx_n_s_xlog, __pyx_n_s_ylog, __pyx_n_s_extrap, __pyx_n_s_extrap_flag, __pyx_n_s_ynew); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__44);
  __Pyx_GIVEREF(__pyx_tuple__44);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_19interp_2d, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_interp_2d, __pyx_t_3) < 0) __PYX_ERR(0, 1772, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(6, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_interp_2d, 1772, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 1772, __pyx_L1_error)

+1773:     if xlog:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_xlog); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1773, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+1774:         xnew = np.log10(xnew)

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1774, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_log10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1774, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_v_xnew) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_xnew);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1774, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF_SET(__pyx_v_xnew, __pyx_t_2);
    __pyx_t_2 = 0;

+1775:         xold = np.log10(xold)

    __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1775, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_log10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1775, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __pyx_t_4 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
      __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
      if (likely(__pyx_t_4)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
        __Pyx_INCREF(__pyx_t_4);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_3, function);
      }
    }
    __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_v_xold) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_xold);
    __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1775, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __Pyx_DECREF_SET(__pyx_v_xold, __pyx_t_2);
    __pyx_t_2 = 0;

+1776:     if ylog:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ylog); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1776, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+1777:         yold = np.log10(yold)

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1777, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_log10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1777, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = NULL;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_4, function);
      }
    }
    __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_v_yold) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_yold);
    __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
    if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1777, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF_SET(__pyx_v_yold, __pyx_t_2);
    __pyx_t_2 = 0;

 1778: 

+1779:     assert xnew.shape[0] == xold.shape[0]

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_xnew, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1779, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1779, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_4);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_xold, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1779, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_2, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1779, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __pyx_t_2 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1779, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1779, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    if (unlikely(!__pyx_t_1)) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(0, 1779, __pyx_L1_error)
    }
  }
  #endif

+1780:     assert xold.shape == yold.shape

  #ifndef CYTHON_WITHOUT_ASSERTIONS
  if (unlikely(__pyx_assertions_enabled())) {
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_xold, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1780, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_yold, __pyx_n_s_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1780, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1780, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1780, __pyx_L1_error)
    __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
    if (unlikely(!__pyx_t_1)) {
      PyErr_SetNone(PyExc_AssertionError);
      __PYX_ERR(0, 1780, __pyx_L1_error)
    }
  }
  #endif

 1781: 

+1782:     extrap_flag = 1 if extrap else 0

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_extrap); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1782, __pyx_L1_error)
  if (__pyx_t_1) {
    __pyx_t_5 = 1;
  } else {
    __pyx_t_5 = 0;
  }
  __pyx_v_extrap_flag = __pyx_t_5;

+1783:     ynew = _interp_2d(xnew, xold, yold, extrap_flag)

  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_v_xnew, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 1783, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_v_xold, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 1783, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_v_yold, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 1783, __pyx_L1_error)
  __pyx_t_9 = __pyx_f_8holodeck_7cyutils__interp_2d(__pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_v_extrap_flag); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1783, __pyx_L1_error)
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;
  __pyx_t_4 = __pyx_memoryview_fromslice(__pyx_t_9, 2, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1783, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;
  __pyx_v_ynew = __pyx_t_4;
  __pyx_t_4 = 0;

 1784: 

+1785:     if ylog:

  __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_ylog); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 1785, __pyx_L1_error)
  if (__pyx_t_1) {
/* … */
  }

+1786:         ynew = np.power(10.0, ynew)

    __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1786, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_3);
    __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_power); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1786, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_2);
    __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
    __pyx_t_3 = NULL;
    __pyx_t_10 = 0;
    if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
      __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
      if (likely(__pyx_t_3)) {
        PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
        __Pyx_INCREF(__pyx_t_3);
        __Pyx_INCREF(function);
        __Pyx_DECREF_SET(__pyx_t_2, function);
        __pyx_t_10 = 1;
      }
    }
    #if CYTHON_FAST_PYCALL
    if (PyFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_float_10_0, __pyx_v_ynew};
      __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1786, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_4);
    } else
    #endif
    #if CYTHON_FAST_PYCCALL
    if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
      PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_float_10_0, __pyx_v_ynew};
      __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1786, __pyx_L1_error)
      __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
      __Pyx_GOTREF(__pyx_t_4);
    } else
    #endif
    {
      __pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 1786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_11);
      if (__pyx_t_3) {
        __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); __pyx_t_3 = NULL;
      }
      __Pyx_INCREF(__pyx_float_10_0);
      __Pyx_GIVEREF(__pyx_float_10_0);
      PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_float_10_0);
      __Pyx_INCREF(__pyx_v_ynew);
      __Pyx_GIVEREF(__pyx_v_ynew);
      PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_v_ynew);
      __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1786, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_4);
      __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
    }
    __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
    __Pyx_DECREF_SET(__pyx_v_ynew, __pyx_t_4);
    __pyx_t_4 = 0;

+1787:     return ynew

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(__pyx_v_ynew);
  __pyx_r = __pyx_v_ynew;
  goto __pyx_L0;

 1788: 

 1789: 

 1790: @cython.boundscheck(False)

 1791: @cython.wraparound(False)

 1792: @cython.nonecheck(False)

 1793: @cython.cdivision(True)

+1794: cdef double[:, :] _interp_2d(

static __Pyx_memviewslice __pyx_f_8holodeck_7cyutils__interp_2d(__Pyx_memviewslice __pyx_v_xnew, __Pyx_memviewslice __pyx_v_xold, __Pyx_memviewslice __pyx_v_yold, int __pyx_v_extrap) {
  int __pyx_v_num;
  int __pyx_v_new_size;
  int __pyx_v_old_size;
  int __pyx_v_last;
  int __pyx_v_ii;
  int __pyx_v_nn;
  int __pyx_v_oo;
  double __pyx_v_newval;
  PyArrayObject *__pyx_v_ynew = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_ynew;
  __Pyx_Buffer __pyx_pybuffer_ynew;
  __Pyx_memviewslice __pyx_r = { 0, 0, { 0 }, { 0 }, { 0 } };
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_interp_2d", 0);
  __pyx_pybuffer_ynew.pybuffer.buf = NULL;
  __pyx_pybuffer_ynew.refcount = 0;
  __pyx_pybuffernd_ynew.data = NULL;
  __pyx_pybuffernd_ynew.rcbuffer = &__pyx_pybuffer_ynew;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_XDECREF(__pyx_t_5);
  __PYX_XDEC_MEMVIEW(&__pyx_t_25, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ynew.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __pyx_r.data = NULL;
  __pyx_r.memview = NULL;
  __Pyx_AddTraceback("holodeck.cyutils._interp_2d", __pyx_clineno, __pyx_lineno, __pyx_filename);
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_ynew.rcbuffer->pybuffer);
  if (unlikely(!__pyx_r.memview)) {
    PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized");
  }
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_ynew);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1795:     double[:, :] xnew, double[:, :] xold, double[:, :] yold, int extrap,

 1796: ):

+1797:     cdef int num = xnew.shape[0]

  __pyx_v_num = (__pyx_v_xnew.shape[0]);

+1798:     cdef int new_size = xnew.shape[1]

  __pyx_v_new_size = (__pyx_v_xnew.shape[1]);

+1799:     cdef int old_size = xold.shape[1]

  __pyx_v_old_size = (__pyx_v_xold.shape[1]);

+1800:     cdef int last = old_size - 1

  __pyx_v_last = (__pyx_v_old_size - 1);

 1801: 

 1802:     cdef int ii, nn, oo

 1803:     cdef double newval

 1804: 

+1805:     cdef np.ndarray[np.double_t, ndim=2] ynew = np.empty((num, new_size))

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_empty); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_num); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_new_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_5);
  __Pyx_GIVEREF(__pyx_t_2);
  PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_2);
  __Pyx_GIVEREF(__pyx_t_4);
  PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4);
  __pyx_t_2 = 0;
  __pyx_t_4 = 0;
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1805, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1805, __pyx_L1_error)
  __pyx_t_6 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_ynew.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) {
      __pyx_v_ynew = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_ynew.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1805, __pyx_L1_error)
    } else {__pyx_pybuffernd_ynew.diminfo[0].strides = __pyx_pybuffernd_ynew.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_ynew.diminfo[0].shape = __pyx_pybuffernd_ynew.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_ynew.diminfo[1].strides = __pyx_pybuffernd_ynew.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_ynew.diminfo[1].shape = __pyx_pybuffernd_ynew.rcbuffer->pybuffer.shape[1];
    }
  }
  __pyx_t_6 = 0;
  __pyx_v_ynew = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

+1806:     for ii in range(num):

  __pyx_t_7 = __pyx_v_num;
  __pyx_t_8 = __pyx_t_7;
  for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
    __pyx_v_ii = __pyx_t_9;

+1807:         oo = 0

    __pyx_v_oo = 0;

+1808:         for nn in range(new_size):

    __pyx_t_10 = __pyx_v_new_size;
    __pyx_t_11 = __pyx_t_10;
    for (__pyx_t_12 = 0; __pyx_t_12 < __pyx_t_11; __pyx_t_12+=1) {
      __pyx_v_nn = __pyx_t_12;

+1809:             newval = xnew[ii, nn]

      __pyx_t_13 = __pyx_v_ii;
      __pyx_t_14 = __pyx_v_nn;
      __pyx_v_newval = (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_xnew.data + __pyx_t_13 * __pyx_v_xnew.strides[0]) ) + __pyx_t_14 * __pyx_v_xnew.strides[1]) )));

+1810:             while (xold[ii, oo+1] < newval) and (oo < last-1):

      while (1) {
        __pyx_t_14 = __pyx_v_ii;
        __pyx_t_13 = (__pyx_v_oo + 1);
        __pyx_t_16 = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_14 * __pyx_v_xold.strides[0]) ) + __pyx_t_13 * __pyx_v_xold.strides[1]) ))) < __pyx_v_newval) != 0);
        if (__pyx_t_16) {
        } else {
          __pyx_t_15 = __pyx_t_16;
          goto __pyx_L9_bool_binop_done;
        }
        __pyx_t_16 = ((__pyx_v_oo < (__pyx_v_last - 1)) != 0);
        __pyx_t_15 = __pyx_t_16;
        __pyx_L9_bool_binop_done:;
        if (!__pyx_t_15) break;

+1811:                 oo += 1

        __pyx_v_oo = (__pyx_v_oo + 1);
      }

 1812: 

+1813:             if extrap == 1 or ((xold[ii, oo] < newval) and (newval < xold[ii, oo+1])):

      __pyx_t_16 = ((__pyx_v_extrap == 1) != 0);
      if (!__pyx_t_16) {
      } else {
        __pyx_t_15 = __pyx_t_16;
        goto __pyx_L12_bool_binop_done;
      }
      __pyx_t_13 = __pyx_v_ii;
      __pyx_t_14 = __pyx_v_oo;
      __pyx_t_16 = (((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_13 * __pyx_v_xold.strides[0]) ) + __pyx_t_14 * __pyx_v_xold.strides[1]) ))) < __pyx_v_newval) != 0);
      if (__pyx_t_16) {
      } else {
        __pyx_t_15 = __pyx_t_16;
        goto __pyx_L12_bool_binop_done;
      }
      __pyx_t_14 = __pyx_v_ii;
      __pyx_t_13 = (__pyx_v_oo + 1);
      __pyx_t_16 = ((__pyx_v_newval < (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_14 * __pyx_v_xold.strides[0]) ) + __pyx_t_13 * __pyx_v_xold.strides[1]) )))) != 0);
      __pyx_t_15 = __pyx_t_16;
      __pyx_L12_bool_binop_done:;
      if (__pyx_t_15) {
/* … */
        goto __pyx_L11;
      }

+1814:                 ynew[ii, nn] = _interp_between_vals(newval, xold[ii, oo], xold[ii, oo+1], yold[ii, oo], yold[ii, oo+1])

        __pyx_t_13 = __pyx_v_ii;
        __pyx_t_14 = __pyx_v_oo;
        __pyx_t_17 = __pyx_v_ii;
        __pyx_t_18 = (__pyx_v_oo + 1);
        __pyx_t_19 = __pyx_v_ii;
        __pyx_t_20 = __pyx_v_oo;
        __pyx_t_21 = __pyx_v_ii;
        __pyx_t_22 = (__pyx_v_oo + 1);
        __pyx_t_23 = __pyx_v_ii;
        __pyx_t_24 = __pyx_v_nn;
        *__Pyx_BufPtrStrided2d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_ynew.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_ynew.diminfo[0].strides, __pyx_t_24, __pyx_pybuffernd_ynew.diminfo[1].strides) = __pyx_f_8holodeck_7cyutils__interp_between_vals(__pyx_v_newval, (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_13 * __pyx_v_xold.strides[0]) ) + __pyx_t_14 * __pyx_v_xold.strides[1]) ))), (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_xold.data + __pyx_t_17 * __pyx_v_xold.strides[0]) ) + __pyx_t_18 * __pyx_v_xold.strides[1]) ))), (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_yold.data + __pyx_t_19 * __pyx_v_yold.strides[0]) ) + __pyx_t_20 * __pyx_v_yold.strides[1]) ))), (*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_yold.data + __pyx_t_21 * __pyx_v_yold.strides[0]) ) + __pyx_t_22 * __pyx_v_yold.strides[1]) ))));

 1815:             else:

+1816:                 ynew[ii, nn] = NAN

      /*else*/ {
        __pyx_t_22 = __pyx_v_ii;
        __pyx_t_21 = __pyx_v_nn;
        *__Pyx_BufPtrStrided2d(__pyx_t_5numpy_double_t *, __pyx_pybuffernd_ynew.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_ynew.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_ynew.diminfo[1].strides) = NAN;
      }
      __pyx_L11:;
    }
  }

 1817: 

+1818:     return ynew

  __pyx_t_25 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(((PyObject *)__pyx_v_ynew), PyBUF_WRITABLE); if (unlikely(!__pyx_t_25.memview)) __PYX_ERR(0, 1818, __pyx_L1_error)
  __pyx_r = __pyx_t_25;
  __pyx_t_25.memview = NULL;
  __pyx_t_25.data = NULL;
  goto __pyx_L0;

 1819: 

 1820: 

 1821: 

 1822: 

 1823: 

 1824: 

 1825: 

 1826: 

 1827: # ==================================================================================================

 1828: # ====    DetStats Functions    ====

 1829: # ==================================================================================================

 1830: 

 1831: 

+1832: def gamma_of_rho_interp(rho, rsort, rho_interp_grid, gamma_interp_grid):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_21gamma_of_rho_interp(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_20gamma_of_rho_interp[] = "\n    rho : 1Darray of scalars\n        SNR of single sources, in flat array\n    rsort : 1Darray\n        order of flat rho values smallest to largest\n    rho_interp_grid : 1Darray\n        rho values corresponding to each gamma\n    gamma_interp_grid : 1Darray\n        gamma values corresponding to each rho\n\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_21gamma_of_rho_interp = {"gamma_of_rho_interp", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_21gamma_of_rho_interp, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_20gamma_of_rho_interp};
static PyObject *__pyx_pw_8holodeck_7cyutils_21gamma_of_rho_interp(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_rho = 0;
  PyObject *__pyx_v_rsort = 0;
  PyObject *__pyx_v_rho_interp_grid = 0;
  PyObject *__pyx_v_gamma_interp_grid = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("gamma_of_rho_interp (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rho,&__pyx_n_s_rsort,&__pyx_n_s_rho_interp_grid,&__pyx_n_s_gamma_interp_grid,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rho)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rsort)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("gamma_of_rho_interp", 1, 4, 4, 1); __PYX_ERR(0, 1832, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_rho_interp_grid)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("gamma_of_rho_interp", 1, 4, 4, 2); __PYX_ERR(0, 1832, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gamma_interp_grid)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("gamma_of_rho_interp", 1, 4, 4, 3); __PYX_ERR(0, 1832, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "gamma_of_rho_interp") < 0)) __PYX_ERR(0, 1832, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_rho = values[0];
    __pyx_v_rsort = values[1];
    __pyx_v_rho_interp_grid = values[2];
    __pyx_v_gamma_interp_grid = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("gamma_of_rho_interp", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1832, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.gamma_of_rho_interp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_20gamma_of_rho_interp(__pyx_self, __pyx_v_rho, __pyx_v_rsort, __pyx_v_rho_interp_grid, __pyx_v_gamma_interp_grid);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_20gamma_of_rho_interp(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_rho, PyObject *__pyx_v_rsort, PyObject *__pyx_v_rho_interp_grid, PyObject *__pyx_v_gamma_interp_grid) {
  PyArrayObject *__pyx_v_gamma = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_gamma;
  __Pyx_Buffer __pyx_pybuffer_gamma;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("gamma_of_rho_interp", 0);
  __pyx_pybuffer_gamma.pybuffer.buf = NULL;
  __pyx_pybuffer_gamma.refcount = 0;
  __pyx_pybuffernd_gamma.data = NULL;
  __pyx_pybuffernd_gamma.rcbuffer = &__pyx_pybuffer_gamma;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gamma.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.gamma_of_rho_interp", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_gamma.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF((PyObject *)__pyx_v_gamma);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__46 = PyTuple_Pack(5, __pyx_n_s_rho, __pyx_n_s_rsort, __pyx_n_s_rho_interp_grid, __pyx_n_s_gamma_interp_grid, __pyx_n_s_gamma); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__46);
  __Pyx_GIVEREF(__pyx_tuple__46);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_21gamma_of_rho_interp, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_gamma_of_rho_interp, __pyx_t_3) < 0) __PYX_ERR(0, 1832, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(4, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_gamma_of_rho_interp, 1832, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 1832, __pyx_L1_error)

 1833:     """

 1834:     rho : 1Darray of scalars

 1835:         SNR of single sources, in flat array

 1836:     rsort : 1Darray

 1837:         order of flat rho values smallest to largest

 1838:     rho_interp_grid : 1Darray

 1839:         rho values corresponding to each gamma

 1840:     gamma_interp_grid : 1Darray

 1841:         gamma values corresponding to each rho

 1842: 

 1843:     """

 1844:     # pass in the interp grid

+1845:     cdef np.ndarray[np.double_t, ndim=1] gamma = np.zeros(rho.shape)

  __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rho, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_4 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
    __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
    if (likely(__pyx_t_4)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
      __Pyx_INCREF(__pyx_t_4);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_3, function);
    }
  }
  __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2);
  __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1845, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1845, __pyx_L1_error)
  __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_gamma.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
      __pyx_v_gamma = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_gamma.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1845, __pyx_L1_error)
    } else {__pyx_pybuffernd_gamma.diminfo[0].strides = __pyx_pybuffernd_gamma.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_gamma.diminfo[0].shape = __pyx_pybuffernd_gamma.rcbuffer->pybuffer.shape[0];
    }
  }
  __pyx_t_5 = 0;
  __pyx_v_gamma = ((PyArrayObject *)__pyx_t_1);
  __pyx_t_1 = 0;

 1846: 

+1847:     _gamma_of_rho_interp(rho, rsort, rho_interp_grid, gamma_interp_grid, gamma)

  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_rho, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 1847, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_ds_long(__pyx_v_rsort, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 1847, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_rho_interp_grid, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 1847, __pyx_L1_error)
  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_gamma_interp_grid, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1847, __pyx_L1_error)
  __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(((PyObject *)__pyx_v_gamma), PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1847, __pyx_L1_error)
  (void)(__pyx_f_8holodeck_7cyutils__gamma_of_rho_interp(__pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10));
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_10, 1);
  __pyx_t_10.memview = NULL;
  __pyx_t_10.data = NULL;

 1848: 

+1849:     return gamma

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_gamma));
  __pyx_r = ((PyObject *)__pyx_v_gamma);
  goto __pyx_L0;

 1850: 

 1851: @cython.boundscheck(False)

 1852: @cython.wraparound(False)

 1853: @cython.nonecheck(False)

 1854: @cython.cdivision(True)

+1855: cdef int _gamma_of_rho_interp(

static int __pyx_f_8holodeck_7cyutils__gamma_of_rho_interp(__Pyx_memviewslice __pyx_v_rho, __Pyx_memviewslice __pyx_v_rsort, __Pyx_memviewslice __pyx_v_rho_interp_grid, __Pyx_memviewslice __pyx_v_gamma_interp_grid, __Pyx_memviewslice __pyx_v_gamma) {
  int __pyx_v_n_rho;
  int __pyx_v_n_interp;
  int __pyx_v_ii;
  int __pyx_v_kk;
  int __pyx_v_rr;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_gamma_of_rho_interp", 0);
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_WriteUnraisable("holodeck.cyutils._gamma_of_rho_interp", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1856:     double[:] rho, long[:] rsort,

 1857:     double[:] rho_interp_grid, double[:] gamma_interp_grid,

 1858:     # output

 1859:     double[:] gamma

 1860:     ):

 1861:     """ Find gamma of rho by interpolation over rho and gamma grids.

 1862:     """

 1863: 

+1864:     cdef int n_rho = rho.size

  __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_rho, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1864, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_v_n_rho = __pyx_t_3;

+1865:     cdef int n_interp = rho_interp_grid.size

  __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_rho_interp_grid, 1, (PyObject *(*)(char *)) __pyx_memview_get_double, (int (*)(char *, PyObject *)) __pyx_memview_set_double, 0);; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1865, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_n_interp = __pyx_t_3;

 1866:     cdef int ii, kk, rr

+1867:     ii = 0 # get rho in order using rho[rsort[ii]]

  __pyx_v_ii = 0;

 1868: 

+1869:     for kk in range(n_rho):

  __pyx_t_3 = __pyx_v_n_rho;
  __pyx_t_4 = __pyx_t_3;
  for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) {
    __pyx_v_kk = __pyx_t_5;

+1870:         rr = rsort[kk] # index of next largest rho, equiv to rev in redz calculation

    __pyx_t_6 = __pyx_v_kk;
    __pyx_v_rr = (*((long *) ( /* dim=0 */ (__pyx_v_rsort.data + __pyx_t_6 * __pyx_v_rsort.strides[0]) )));

 1871:         # print('kk =',kk,' rr =', rr, 'rho[rr] =', rho[rr])

 1872:         # get to the right index of the interpolation-grid

+1873:         while (rho_interp_grid[ii+1] < rho[rr]) and (ii < n_interp -2):

    while (1) {
      __pyx_t_6 = (__pyx_v_ii + 1);
      __pyx_t_8 = __pyx_v_rr;
      __pyx_t_9 = (((*((double *) ( /* dim=0 */ (__pyx_v_rho_interp_grid.data + __pyx_t_6 * __pyx_v_rho_interp_grid.strides[0]) ))) < (*((double *) ( /* dim=0 */ (__pyx_v_rho.data + __pyx_t_8 * __pyx_v_rho.strides[0]) )))) != 0);
      if (__pyx_t_9) {
      } else {
        __pyx_t_7 = __pyx_t_9;
        goto __pyx_L7_bool_binop_done;
      }
      __pyx_t_9 = ((__pyx_v_ii < (__pyx_v_n_interp - 2)) != 0);
      __pyx_t_7 = __pyx_t_9;
      __pyx_L7_bool_binop_done:;
      if (!__pyx_t_7) break;

+1874:             ii += 1

      __pyx_v_ii = (__pyx_v_ii + 1);
    }

 1875:         # print('ii =',ii, ' rho_interp[ii] =', rho_interp_grid[ii], ' rho_interp[ii+1] =', rho_interp_grid[ii+1])

 1876:         # interpolate

+1877:         gamma[rr] = interp_at_index(ii, rho[rr], rho_interp_grid, gamma_interp_grid)

    __pyx_t_8 = __pyx_v_rr;
    __pyx_t_6 = __pyx_v_rr;
    *((double *) ( /* dim=0 */ (__pyx_v_gamma.data + __pyx_t_6 * __pyx_v_gamma.strides[0]) )) = __pyx_f_8holodeck_7cyutils_interp_at_index(__pyx_v_ii, (*((double *) ( /* dim=0 */ (__pyx_v_rho.data + __pyx_t_8 * __pyx_v_rho.strides[0]) ))), __pyx_v_rho_interp_grid, __pyx_v_gamma_interp_grid);
  }

 1878:         # print('rho =', rho[rr], ' gamma =', gamma[rr], '\n')\

 1879: 

+1880:     return 0

  __pyx_r = 0;
  goto __pyx_L0;

 1881: 

 1882: 

+1883: def snr_ss(amp, F_iplus, F_icross, iotas, dur, Phi_0, S_i, freqs):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_23snr_ss(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_22snr_ss[] = "Calculate single source SNR.\n\n    Parameters\n    ----------\n    amp : (F,R,L) NDarray\n        Dimensionless strain amplitude of loudest single sources\n    F_iplus : (P,F,S,L) NDarray\n        Antenna pattern function for each pulsar.\n    F_icross : (P,F,S,L) NDarray\n        Antenna pattern function for each pulsar.\n    iotas : (F,S,L) NDarray\n        Inclination, used to calculate:\n        :math:`a_pol = 1 + np.cos(iotas)^2`\n        :math:`b_pol = -2 np.cos(iotas)`\n    dur : scalar\n        Duration of observations.\n    Phi_0 : (F,S,L) NDarray\n        Initial GW phase\n    S_i : (P,F,R,L) NDarray\n        Total noise of each pulsar wrt detection of each single source, in $s^3$.\n    freqs : (F,) 1Darray\n        Observed frequency bin centers.\n\n    Returns\n    -------\n    snr_ss : (F,R,S,L) NDarray\n        SNR from the whole PTA for each single source with\n        each realized sky position (S) and realized strain (R)\n\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_23snr_ss = {"snr_ss", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_23snr_ss, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_22snr_ss};
static PyObject *__pyx_pw_8holodeck_7cyutils_23snr_ss(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_amp = 0;
  PyObject *__pyx_v_F_iplus = 0;
  PyObject *__pyx_v_F_icross = 0;
  PyObject *__pyx_v_iotas = 0;
  PyObject *__pyx_v_dur = 0;
  PyObject *__pyx_v_Phi_0 = 0;
  PyObject *__pyx_v_S_i = 0;
  PyObject *__pyx_v_freqs = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("snr_ss (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_amp,&__pyx_n_s_F_iplus,&__pyx_n_s_F_icross,&__pyx_n_s_iotas,&__pyx_n_s_dur,&__pyx_n_s_Phi_0,&__pyx_n_s_S_i,&__pyx_n_s_freqs,0};
    PyObject* values[8] = {0,0,0,0,0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
        CYTHON_FALLTHROUGH;
        case  7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
        CYTHON_FALLTHROUGH;
        case  6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
        CYTHON_FALLTHROUGH;
        case  5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
        CYTHON_FALLTHROUGH;
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_amp)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_F_iplus)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 1); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_F_icross)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 2); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_iotas)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 3); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  4:
        if (likely((values[4] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dur)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 4); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  5:
        if (likely((values[5] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Phi_0)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 5); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  6:
        if (likely((values[6] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_S_i)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 6); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  7:
        if (likely((values[7] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_freqs)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, 7); __PYX_ERR(0, 1883, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "snr_ss") < 0)) __PYX_ERR(0, 1883, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 8) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
      values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
      values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
      values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
      values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
    }
    __pyx_v_amp = values[0];
    __pyx_v_F_iplus = values[1];
    __pyx_v_F_icross = values[2];
    __pyx_v_iotas = values[3];
    __pyx_v_dur = values[4];
    __pyx_v_Phi_0 = values[5];
    __pyx_v_S_i = values[6];
    __pyx_v_freqs = values[7];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("snr_ss", 1, 8, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1883, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.snr_ss", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_22snr_ss(__pyx_self, __pyx_v_amp, __pyx_v_F_iplus, __pyx_v_F_icross, __pyx_v_iotas, __pyx_v_dur, __pyx_v_Phi_0, __pyx_v_S_i, __pyx_v_freqs);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_22snr_ss(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_amp, PyObject *__pyx_v_F_iplus, PyObject *__pyx_v_F_icross, PyObject *__pyx_v_iotas, PyObject *__pyx_v_dur, PyObject *__pyx_v_Phi_0, PyObject *__pyx_v_S_i, PyObject *__pyx_v_freqs) {
  PyObject *__pyx_v_nfreqs = NULL;
  PyObject *__pyx_v_nreals = NULL;
  PyObject *__pyx_v_nloudest = NULL;
  PyObject *__pyx_v_npsrs = NULL;
  PyObject *__pyx_v_nskies = NULL;
  PyArrayObject *__pyx_v_snr_ss = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_snr_ss;
  __Pyx_Buffer __pyx_pybuffer_snr_ss;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("snr_ss", 0);
  __pyx_pybuffer_snr_ss.pybuffer.buf = NULL;
  __pyx_pybuffer_snr_ss.refcount = 0;
  __pyx_pybuffernd_snr_ss.data = NULL;
  __pyx_pybuffernd_snr_ss.rcbuffer = &__pyx_pybuffer_snr_ss;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_snr_ss.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.snr_ss", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_snr_ss.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_nfreqs);
  __Pyx_XDECREF(__pyx_v_nreals);
  __Pyx_XDECREF(__pyx_v_nloudest);
  __Pyx_XDECREF(__pyx_v_npsrs);
  __Pyx_XDECREF(__pyx_v_nskies);
  __Pyx_XDECREF((PyObject *)__pyx_v_snr_ss);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__48 = PyTuple_Pack(14, __pyx_n_s_amp, __pyx_n_s_F_iplus, __pyx_n_s_F_icross, __pyx_n_s_iotas, __pyx_n_s_dur, __pyx_n_s_Phi_0, __pyx_n_s_S_i, __pyx_n_s_freqs, __pyx_n_s_nfreqs, __pyx_n_s_nreals, __pyx_n_s_nloudest, __pyx_n_s_npsrs, __pyx_n_s_nskies, __pyx_n_s_snr_ss); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__48);
  __Pyx_GIVEREF(__pyx_tuple__48);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_23snr_ss, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_snr_ss, __pyx_t_3) < 0) __PYX_ERR(0, 1883, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(8, 0, 14, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_snr_ss, 1883, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 1883, __pyx_L1_error)

 1884:     """Calculate single source SNR.

 1885: 

 1886:     Parameters

 1887:     ----------

 1888:     amp : (F,R,L) NDarray

 1889:         Dimensionless strain amplitude of loudest single sources

 1890:     F_iplus : (P,F,S,L) NDarray

 1891:         Antenna pattern function for each pulsar.

 1892:     F_icross : (P,F,S,L) NDarray

 1893:         Antenna pattern function for each pulsar.

 1894:     iotas : (F,S,L) NDarray

 1895:         Inclination, used to calculate:

 1896:         :math:`a_pol = 1 + np.cos(iotas)^2`

 1897:         :math:`b_pol = -2 np.cos(iotas)`

 1898:     dur : scalar

 1899:         Duration of observations.

 1900:     Phi_0 : (F,S,L) NDarray

 1901:         Initial GW phase

 1902:     S_i : (P,F,R,L) NDarray

 1903:         Total noise of each pulsar wrt detection of each single source, in $s^3$.

 1904:     freqs : (F,) 1Darray

 1905:         Observed frequency bin centers.

 1906: 

 1907:     Returns

 1908:     -------

 1909:     snr_ss : (F,R,S,L) NDarray

 1910:         SNR from the whole PTA for each single source with

 1911:         each realized sky position (S) and realized strain (R)

 1912: 

 1913:     """

+1914:     nfreqs, nreals, nloudest = amp.shape[0], amp.shape[1], amp.shape[2]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_amp, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_amp, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_amp, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1914, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_nfreqs = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_nreals = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_nloudest = __pyx_t_4;
  __pyx_t_4 = 0;

+1915:     npsrs, nskies = F_iplus.shape[0], F_iplus.shape[2]

  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_F_iplus, __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_F_iplus, __pyx_n_s_shape); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_4, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1915, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  __pyx_v_npsrs = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_nskies = __pyx_t_2;
  __pyx_t_2 = 0;

+1916:     cdef np.ndarray[np.double_t, ndim=4] snr_ss = np.zeros((nfreqs, nreals, nskies, nloudest))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_nfreqs);
  __Pyx_GIVEREF(__pyx_v_nfreqs);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_nfreqs);
  __Pyx_INCREF(__pyx_v_nreals);
  __Pyx_GIVEREF(__pyx_v_nreals);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_nreals);
  __Pyx_INCREF(__pyx_v_nskies);
  __Pyx_GIVEREF(__pyx_v_nskies);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_nskies);
  __Pyx_INCREF(__pyx_v_nloudest);
  __Pyx_GIVEREF(__pyx_v_nloudest);
  PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_nloudest);
  __pyx_t_1 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
    if (likely(__pyx_t_1)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_4, function);
    }
  }
  __pyx_t_2 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1916, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
  if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 1916, __pyx_L1_error)
  __pyx_t_5 = ((PyArrayObject *)__pyx_t_2);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_snr_ss.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 4, 0, __pyx_stack) == -1)) {
      __pyx_v_snr_ss = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 1916, __pyx_L1_error)
    } else {__pyx_pybuffernd_snr_ss.diminfo[0].strides = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_snr_ss.diminfo[0].shape = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_snr_ss.diminfo[1].strides = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_snr_ss.diminfo[1].shape = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_snr_ss.diminfo[2].strides = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_snr_ss.diminfo[2].shape = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.shape[2]; __pyx_pybuffernd_snr_ss.diminfo[3].strides = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.strides[3]; __pyx_pybuffernd_snr_ss.diminfo[3].shape = __pyx_pybuffernd_snr_ss.rcbuffer->pybuffer.shape[3];
    }
  }
  __pyx_t_5 = 0;
  __pyx_v_snr_ss = ((PyArrayObject *)__pyx_t_2);
  __pyx_t_2 = 0;

+1917:     _snr_ss(

  (void)(__pyx_f_8holodeck_7cyutils__snr_ss(__pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13, __pyx_t_14, __pyx_t_15, __pyx_t_16, __pyx_t_17, __pyx_t_18, __pyx_t_19));
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_9, 1);
  __pyx_t_9.memview = NULL;
  __pyx_t_9.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_11, 1);
  __pyx_t_11.memview = NULL;
  __pyx_t_11.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_12, 1);
  __pyx_t_12.memview = NULL;
  __pyx_t_12.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __pyx_t_13.memview = NULL;
  __pyx_t_13.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_19, 1);
  __pyx_t_19.memview = NULL;
  __pyx_t_19.data = NULL;

+1918:         amp, F_iplus, F_icross, iotas, dur, Phi_0, S_i, freqs,

  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_v_amp, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_F_iplus, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_F_icross, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_v_iotas, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_10 = __pyx_PyFloat_AsDouble(__pyx_v_dur); if (unlikely((__pyx_t_10 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_v_Phi_0, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_12 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(__pyx_v_S_i, PyBUF_WRITABLE); if (unlikely(!__pyx_t_12.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_freqs, PyBUF_WRITABLE); if (unlikely(!__pyx_t_13.memview)) __PYX_ERR(0, 1918, __pyx_L1_error)

+1919:         npsrs, nfreqs, nreals, nskies, nloudest,

  __pyx_t_14 = __Pyx_PyInt_As_long(__pyx_v_npsrs); if (unlikely((__pyx_t_14 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1919, __pyx_L1_error)
  __pyx_t_15 = __Pyx_PyInt_As_long(__pyx_v_nfreqs); if (unlikely((__pyx_t_15 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1919, __pyx_L1_error)
  __pyx_t_16 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_16 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1919, __pyx_L1_error)
  __pyx_t_17 = __Pyx_PyInt_As_long(__pyx_v_nskies); if (unlikely((__pyx_t_17 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1919, __pyx_L1_error)
  __pyx_t_18 = __Pyx_PyInt_As_long(__pyx_v_nloudest); if (unlikely((__pyx_t_18 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1919, __pyx_L1_error)

+1920:         snr_ss)

  __pyx_t_19 = __Pyx_PyObject_to_MemoryviewSlice_dsdsdsds_double(((PyObject *)__pyx_v_snr_ss), PyBUF_WRITABLE); if (unlikely(!__pyx_t_19.memview)) __PYX_ERR(0, 1920, __pyx_L1_error)

+1921:     return snr_ss

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_snr_ss));
  __pyx_r = ((PyObject *)__pyx_v_snr_ss);
  goto __pyx_L0;

 1922: 

 1923: @cython.boundscheck(False)

 1924: @cython.wraparound(False)

 1925: @cython.nonecheck(False)

 1926: @cython.cdivision(True)

+1927: cdef int _snr_ss(

static int __pyx_f_8holodeck_7cyutils__snr_ss(__Pyx_memviewslice __pyx_v_amp, __Pyx_memviewslice __pyx_v_F_iplus, __Pyx_memviewslice __pyx_v_F_icross, __Pyx_memviewslice __pyx_v_iotas, double __pyx_v_dur, __Pyx_memviewslice __pyx_v_Phi_0, __Pyx_memviewslice __pyx_v_S_i, __Pyx_memviewslice __pyx_v_freqs, long __pyx_v_npsrs, long __pyx_v_nfreqs, long __pyx_v_nreals, long __pyx_v_nskies, long __pyx_v_nloudest, __Pyx_memviewslice __pyx_v_snr_ss) {
  int __pyx_v_pp;
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_ss;
  int __pyx_v_ll;
  float __pyx_v_a_pol;
  float __pyx_v_b_pol;
  float __pyx_v_Phi_T;
  float __pyx_v_pta_snr_sq;
  float __pyx_v_coef;
  float __pyx_v_term1;
  float __pyx_v_term2;
  float __pyx_v_term3;
  int __pyx_r;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_snr_ss", 0);
/* … */
  /* function exit code */
  __pyx_r = 0;
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

 1928:     double[:,:,:] amp,

 1929:     double[:,:,:,:] F_iplus,

 1930:     double[:,:,:,:] F_icross,

 1931:     double[:,:,:] iotas,

 1932:     double dur,

 1933:     double[:,:,:] Phi_0,

 1934:     double[:,:,:,:] S_i,

 1935:     double[:] freqs,

 1936:     long npsrs, long nfreqs, long nreals, long nskies, long nloudest,

 1937:     # output

 1938:     double[:,:,:,:] snr_ss

 1939:     ):

 1940:     """

 1941: 

 1942:     Parameters

 1943:     ----------

 1944:     amp : (F,R,L) NDarray

 1945:         Dimensionless strain amplitude of loudest single sources

 1946:     F_iplus : (P,F,S,L) NDarray

 1947:         Antenna pattern function for each pulsar.

 1948:     F_icross : (P,F,S,L) NDarray

 1949:         Antenna pattern function for each pulsar.

 1950:     iotas : (F,S,L) NDarray

 1951:         Inclination, used to calculate:

 1952:         a_pol = 1 + np.cos(iotas) **2

 1953:         b_pol = -2 * np.cos(iotas)

 1954:     dur : scalar

 1955:         Duration of observations.

 1956:     Phi_0 : (F,S,L) NDarray

 1957:         Initial GW phase

 1958:     S_i : (P,F,R,L) NDarray

 1959:         Total noise of each pulsar wrt detection of each single source, in s^3

 1960:     freqs : (F,) 1Darray

 1961:         Observed frequency bin centers.

 1962:     snr_ss : (F,R,S,L) NDarray

 1963:         Pointer to single source SNR array, to be calculated.

 1964: 

 1965:     NOTE: This may be improved by moving some of the math outside the function.

 1966:     I.e., passing in sin/cos of NDarrays to be used.

 1967:     """

 1968: 

 1969:     cdef int pp, ff, rr, ss, ll

 1970:     cdef float a_pol, b_pol, Phi_T, pta_snr_sq, coef, term1, term2, term3

 1971:     # print('npsrs %d, nfreqs %d, nreals %d, nskies %d, nloudest %d' % (npsrs, nfreqs, nreals, nskies, nloudest))

 1972: 

+1973:     for ff in range(nfreqs):

  __pyx_t_1 = __pyx_v_nfreqs;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_ff = __pyx_t_3;

+1974:         for ss in range(nskies):

    __pyx_t_4 = __pyx_v_nskies;
    __pyx_t_5 = __pyx_t_4;
    for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
      __pyx_v_ss = __pyx_t_6;

+1975:             for ll in range(nloudest):

      __pyx_t_7 = __pyx_v_nloudest;
      __pyx_t_8 = __pyx_t_7;
      for (__pyx_t_9 = 0; __pyx_t_9 < __pyx_t_8; __pyx_t_9+=1) {
        __pyx_v_ll = __pyx_t_9;

+1976:                 a_pol = 1 + pow(cos(iotas[ff,ss,ll]), 2.0)

        __pyx_t_10 = __pyx_v_ff;
        __pyx_t_11 = __pyx_v_ss;
        __pyx_t_12 = __pyx_v_ll;
        __pyx_v_a_pol = (1.0 + pow(cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_iotas.data + __pyx_t_10 * __pyx_v_iotas.strides[0]) ) + __pyx_t_11 * __pyx_v_iotas.strides[1]) ) + __pyx_t_12 * __pyx_v_iotas.strides[2]) )))), 2.0));

+1977:                 b_pol = -2 * cos(iotas[ff,ss,ll])

        __pyx_t_12 = __pyx_v_ff;
        __pyx_t_11 = __pyx_v_ss;
        __pyx_t_10 = __pyx_v_ll;
        __pyx_v_b_pol = (-2.0 * cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_iotas.data + __pyx_t_12 * __pyx_v_iotas.strides[0]) ) + __pyx_t_11 * __pyx_v_iotas.strides[1]) ) + __pyx_t_10 * __pyx_v_iotas.strides[2]) )))));

+1978:                 Phi_T = 2 * M_PI * freqs[ff] * dur + Phi_0[ff,ss,ll]

        __pyx_t_10 = __pyx_v_ff;
        __pyx_t_11 = __pyx_v_ff;
        __pyx_t_12 = __pyx_v_ss;
        __pyx_t_13 = __pyx_v_ll;
        __pyx_v_Phi_T = ((((2.0 * M_PI) * (*((double *) ( /* dim=0 */ (__pyx_v_freqs.data + __pyx_t_10 * __pyx_v_freqs.strides[0]) )))) * __pyx_v_dur) + (*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_11 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_12 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_13 * __pyx_v_Phi_0.strides[2]) ))));

+1979:                 for rr in range(nreals):

        __pyx_t_14 = __pyx_v_nreals;
        __pyx_t_15 = __pyx_t_14;
        for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
          __pyx_v_rr = __pyx_t_16;

+1980:                     pta_snr_sq = 0

          __pyx_v_pta_snr_sq = 0.0;

+1981:                     for pp in range(npsrs):

          __pyx_t_17 = __pyx_v_npsrs;
          __pyx_t_18 = __pyx_t_17;
          for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_18; __pyx_t_19+=1) {
            __pyx_v_pp = __pyx_t_19;

 1982:                         # calculate coefficient depending on

 1983:                         # function of amp, S_i, and freqs

+1984:                         coef = pow(amp[ff,rr,ll], 2.0) / (S_i[pp,ff,rr,ll] * 8 * pow(M_PI * freqs[ff], 3.0))

            __pyx_t_13 = __pyx_v_ff;
            __pyx_t_12 = __pyx_v_rr;
            __pyx_t_11 = __pyx_v_ll;
            __pyx_t_10 = __pyx_v_pp;
            __pyx_t_20 = __pyx_v_ff;
            __pyx_t_21 = __pyx_v_rr;
            __pyx_t_22 = __pyx_v_ll;
            __pyx_t_23 = __pyx_v_ff;
            __pyx_v_coef = (pow((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_amp.data + __pyx_t_13 * __pyx_v_amp.strides[0]) ) + __pyx_t_12 * __pyx_v_amp.strides[1]) ) + __pyx_t_11 * __pyx_v_amp.strides[2]) ))), 2.0) / (((*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_S_i.data + __pyx_t_10 * __pyx_v_S_i.strides[0]) ) + __pyx_t_20 * __pyx_v_S_i.strides[1]) ) + __pyx_t_21 * __pyx_v_S_i.strides[2]) ) + __pyx_t_22 * __pyx_v_S_i.strides[3]) ))) * 8.0) * pow((M_PI * (*((double *) ( /* dim=0 */ (__pyx_v_freqs.data + __pyx_t_23 * __pyx_v_freqs.strides[0]) )))), 3.0)));

 1985: 

 1986:                         # calculate terms that depend on p, f, s, and l

 1987:                         # functions of F_iplus, F_icross, a_pol, b_pol, Phi_0, and Phi_T

 1988:                         term1 = (

+1989:                             pow(a_pol * F_iplus[pp,ff,ss,ll], 2.0)

            __pyx_t_23 = __pyx_v_pp;
            __pyx_t_22 = __pyx_v_ff;
            __pyx_t_21 = __pyx_v_ss;
            __pyx_t_20 = __pyx_v_ll;

+1990:                             * (Phi_T * (1.0 + 2.0 * pow(sin(Phi_0[ff,ss,ll]), 2.0))

            __pyx_t_10 = __pyx_v_ff;
            __pyx_t_11 = __pyx_v_ss;
            __pyx_t_12 = __pyx_v_ll;
/* … */
            __pyx_v_term1 = (pow((__pyx_v_a_pol * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_F_iplus.data + __pyx_t_23 * __pyx_v_F_iplus.strides[0]) ) + __pyx_t_22 * __pyx_v_F_iplus.strides[1]) ) + __pyx_t_21 * __pyx_v_F_iplus.strides[2]) ) + __pyx_t_20 * __pyx_v_F_iplus.strides[3]) )))), 2.0) * (((__pyx_v_Phi_T * (1.0 + (2.0 * pow(sin((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_10 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_11 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_12 * __pyx_v_Phi_0.strides[2]) )))), 2.0)))) + (cos(__pyx_v_Phi_T) * ((-1.0 * sin(__pyx_v_Phi_T)) + (4.0 * cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_13 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_24 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_25 * __pyx_v_Phi_0.strides[2]) )))))))) - (4.0 * sin((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_26 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_27 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_28 * __pyx_v_Phi_0.strides[2]) )))))));

+1991:                                 + cos(Phi_T) * (-1.0 * sin(Phi_T) + 4.0 * cos(Phi_0[ff,ss,ll]))

            __pyx_t_13 = __pyx_v_ff;
            __pyx_t_24 = __pyx_v_ss;
            __pyx_t_25 = __pyx_v_ll;

+1992:                                 - 4.0 * sin(Phi_0[ff,ss,ll])

            __pyx_t_26 = __pyx_v_ff;
            __pyx_t_27 = __pyx_v_ss;
            __pyx_t_28 = __pyx_v_ll;

 1993:                                 )

 1994:                         )

 1995:                         term2 = (

+1996:                             pow(b_pol * F_icross[pp,ff,ss,ll], 2.0)

            __pyx_t_28 = __pyx_v_pp;
            __pyx_t_27 = __pyx_v_ff;
            __pyx_t_26 = __pyx_v_ss;
            __pyx_t_25 = __pyx_v_ll;

+1997:                             * (Phi_T * (1.0 + 2.0 * pow(cos(Phi_0[ff,ss,ll]), 2.0))

            __pyx_t_24 = __pyx_v_ff;
            __pyx_t_13 = __pyx_v_ss;
            __pyx_t_12 = __pyx_v_ll;
/* … */
            __pyx_v_term2 = (pow((__pyx_v_b_pol * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_F_icross.data + __pyx_t_28 * __pyx_v_F_icross.strides[0]) ) + __pyx_t_27 * __pyx_v_F_icross.strides[1]) ) + __pyx_t_26 * __pyx_v_F_icross.strides[2]) ) + __pyx_t_25 * __pyx_v_F_icross.strides[3]) )))), 2.0) * (((__pyx_v_Phi_T * (1.0 + (2.0 * pow(cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_24 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_13 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_12 * __pyx_v_Phi_0.strides[2]) )))), 2.0)))) + (sin(__pyx_v_Phi_T) * cos(__pyx_v_Phi_T))) - (4.0 * cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_11 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_10 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_20 * __pyx_v_Phi_0.strides[2]) )))))));

+1998:                                 + sin(Phi_T) * cos(Phi_T) - 4.0 * cos(Phi_0[ff,ss,ll])

            __pyx_t_11 = __pyx_v_ff;
            __pyx_t_10 = __pyx_v_ss;
            __pyx_t_20 = __pyx_v_ll;

 1999:                                 )

 2000:                         )

 2001:                         term3 = (

+2002:                             -2.0 * a_pol * b_pol * F_iplus[pp,ff,ss,ll] * F_icross[pp,ff,ss,ll]

            __pyx_t_20 = __pyx_v_pp;
            __pyx_t_10 = __pyx_v_ff;
            __pyx_t_11 = __pyx_v_ss;
            __pyx_t_12 = __pyx_v_ll;
            __pyx_t_13 = __pyx_v_pp;
            __pyx_t_24 = __pyx_v_ff;
            __pyx_t_25 = __pyx_v_ss;
            __pyx_t_26 = __pyx_v_ll;

+2003:                             * (2.0 * Phi_T * sin(Phi_T) *cos(Phi_0[ff,ss,ll])

            __pyx_t_27 = __pyx_v_ff;
            __pyx_t_28 = __pyx_v_ss;
            __pyx_t_21 = __pyx_v_ll;
/* … */
            __pyx_v_term3 = (((((-2.0 * __pyx_v_a_pol) * __pyx_v_b_pol) * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_F_iplus.data + __pyx_t_20 * __pyx_v_F_iplus.strides[0]) ) + __pyx_t_10 * __pyx_v_F_iplus.strides[1]) ) + __pyx_t_11 * __pyx_v_F_iplus.strides[2]) ) + __pyx_t_12 * __pyx_v_F_iplus.strides[3]) )))) * (*((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_F_icross.data + __pyx_t_13 * __pyx_v_F_icross.strides[0]) ) + __pyx_t_24 * __pyx_v_F_icross.strides[1]) ) + __pyx_t_25 * __pyx_v_F_icross.strides[2]) ) + __pyx_t_26 * __pyx_v_F_icross.strides[3]) )))) * ((((2.0 * __pyx_v_Phi_T) * sin(__pyx_v_Phi_T)) * cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_27 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_28 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_21 * __pyx_v_Phi_0.strides[2]) ))))) + (sin(__pyx_v_Phi_T) * (((sin(__pyx_v_Phi_T) - (2.0 * sin((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_22 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_23 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_29 * __pyx_v_Phi_0.strides[2]) )))))) + ((2.0 * cos(__pyx_v_Phi_T)) * cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_30 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_31 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_32 * __pyx_v_Phi_0.strides[2]) )))))) - (2.0 * cos((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Phi_0.data + __pyx_t_33 * __pyx_v_Phi_0.strides[0]) ) + __pyx_t_34 * __pyx_v_Phi_0.strides[1]) ) + __pyx_t_35 * __pyx_v_Phi_0.strides[2]) )))))))));

+2004:                                 + sin(Phi_T) * (sin(Phi_T) - 2.0 * sin(Phi_0[ff,ss,ll])

            __pyx_t_22 = __pyx_v_ff;
            __pyx_t_23 = __pyx_v_ss;
            __pyx_t_29 = __pyx_v_ll;

+2005:                                                 + 2.0 * cos(Phi_T) * cos(Phi_0[ff,ss,ll])

            __pyx_t_30 = __pyx_v_ff;
            __pyx_t_31 = __pyx_v_ss;
            __pyx_t_32 = __pyx_v_ll;

+2006:                                                 - 2.0 * cos(Phi_0[ff,ss,ll])

            __pyx_t_33 = __pyx_v_ff;
            __pyx_t_34 = __pyx_v_ss;
            __pyx_t_35 = __pyx_v_ll;

 2007:                                                 )

 2008:                             )

 2009:                         )

+2010:                         pta_snr_sq += coef*(term1 + term2 + term3) # sum snr^2 of all pulsars for a single source

            __pyx_v_pta_snr_sq = (__pyx_v_pta_snr_sq + (__pyx_v_coef * ((__pyx_v_term1 + __pyx_v_term2) + __pyx_v_term3)));
          }

 2011: 

 2012:                     # set snr for a single source, using sum from all pulsars

+2013:                     snr_ss[ff,rr,ss,ll] = sqrt(pta_snr_sq)

          __pyx_t_35 = __pyx_v_ff;
          __pyx_t_34 = __pyx_v_rr;
          __pyx_t_33 = __pyx_v_ss;
          __pyx_t_32 = __pyx_v_ll;
          *((double *) ( /* dim=3 */ (( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_snr_ss.data + __pyx_t_35 * __pyx_v_snr_ss.strides[0]) ) + __pyx_t_34 * __pyx_v_snr_ss.strides[1]) ) + __pyx_t_33 * __pyx_v_snr_ss.strides[2]) ) + __pyx_t_32 * __pyx_v_snr_ss.strides[3]) )) = sqrt(__pyx_v_pta_snr_sq);
        }
      }
    }
  }

 2014: 

 2015: 

+2016: def Sh_rest(hc_ss, hc_bg, freqs, nexcl):

/* Python wrapper */
static PyObject *__pyx_pw_8holodeck_7cyutils_25Sh_rest(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_8holodeck_7cyutils_24Sh_rest[] = "\n    Calculate the noise from all the single sources except the source in question\n    and the next N_excl loudest sources.\n\n    Parameters\n    ----------\n    hc_ss : (F,R,L) NDarray\n        Characteristic strain from all loud single sources.\n    hc_bg : (F,R) NDarray\n        Characteristic strain from all but loudest source at each frequency.\n    freqs : (F,) 1Darray\n        Frequency bin centers.\n    nexcl : int\n        Number of loudest single sources to exclude from hc_rest noise, in addition\n        to the source in question.\n\n    Returns\n    -------\n    Sh_rest : (F,R,L) NDarray of scalars\n        The noise in a single pulsar from other GW sources for detecting each single source.\n\n    ";
static PyMethodDef __pyx_mdef_8holodeck_7cyutils_25Sh_rest = {"Sh_rest", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_8holodeck_7cyutils_25Sh_rest, METH_VARARGS|METH_KEYWORDS, __pyx_doc_8holodeck_7cyutils_24Sh_rest};
static PyObject *__pyx_pw_8holodeck_7cyutils_25Sh_rest(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_hc_ss = 0;
  PyObject *__pyx_v_hc_bg = 0;
  PyObject *__pyx_v_freqs = 0;
  PyObject *__pyx_v_nexcl = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("Sh_rest (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_hc_ss,&__pyx_n_s_hc_bg,&__pyx_n_s_freqs,&__pyx_n_s_nexcl,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_hc_ss)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_hc_bg)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("Sh_rest", 1, 4, 4, 1); __PYX_ERR(0, 2016, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_freqs)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("Sh_rest", 1, 4, 4, 2); __PYX_ERR(0, 2016, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nexcl)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("Sh_rest", 1, 4, 4, 3); __PYX_ERR(0, 2016, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "Sh_rest") < 0)) __PYX_ERR(0, 2016, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_hc_ss = values[0];
    __pyx_v_hc_bg = values[1];
    __pyx_v_freqs = values[2];
    __pyx_v_nexcl = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("Sh_rest", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 2016, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("holodeck.cyutils.Sh_rest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_8holodeck_7cyutils_24Sh_rest(__pyx_self, __pyx_v_hc_ss, __pyx_v_hc_bg, __pyx_v_freqs, __pyx_v_nexcl);
  int __pyx_lineno = 0;
  const char *__pyx_filename = NULL;
  int __pyx_clineno = 0;

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_8holodeck_7cyutils_24Sh_rest(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_hc_ss, PyObject *__pyx_v_hc_bg, PyObject *__pyx_v_freqs, PyObject *__pyx_v_nexcl) {
  PyObject *__pyx_v_nfreqs = NULL;
  PyObject *__pyx_v_nreals = NULL;
  PyObject *__pyx_v_nloudest = NULL;
  PyArrayObject *__pyx_v_Sh_rest = 0;
  __Pyx_LocalBuf_ND __pyx_pybuffernd_Sh_rest;
  __Pyx_Buffer __pyx_pybuffer_Sh_rest;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("Sh_rest", 0);
  __pyx_pybuffer_Sh_rest.pybuffer.buf = NULL;
  __pyx_pybuffer_Sh_rest.refcount = 0;
  __pyx_pybuffernd_Sh_rest.data = NULL;
  __pyx_pybuffernd_Sh_rest.rcbuffer = &__pyx_pybuffer_Sh_rest;
/* … */
  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  __Pyx_XDECREF(__pyx_t_4);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
    __Pyx_PyThreadState_declare
    __Pyx_PyThreadState_assign
    __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
    __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer);
  __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
  __Pyx_AddTraceback("holodeck.cyutils.Sh_rest", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  goto __pyx_L2;
  __pyx_L0:;
  __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer);
  __pyx_L2:;
  __Pyx_XDECREF(__pyx_v_nfreqs);
  __Pyx_XDECREF(__pyx_v_nreals);
  __Pyx_XDECREF(__pyx_v_nloudest);
  __Pyx_XDECREF((PyObject *)__pyx_v_Sh_rest);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}
/* … */
  __pyx_tuple__50 = PyTuple_Pack(8, __pyx_n_s_hc_ss, __pyx_n_s_hc_bg, __pyx_n_s_freqs, __pyx_n_s_nexcl, __pyx_n_s_nfreqs, __pyx_n_s_nreals, __pyx_n_s_nloudest, __pyx_n_s_Sh_rest); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 2016, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__50);
  __Pyx_GIVEREF(__pyx_tuple__50);
/* … */
  __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_8holodeck_7cyutils_25Sh_rest, NULL, __pyx_n_s_holodeck_cyutils); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2016, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_Sh_rest, __pyx_t_3) < 0) __PYX_ERR(0, 2016, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(4, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_holodeck_cyutils_pyx, __pyx_n_s_Sh_rest, 2016, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(0, 2016, __pyx_L1_error)

 2017:     """

 2018:     Calculate the noise from all the single sources except the source in question

 2019:     and the next N_excl loudest sources.

 2020: 

 2021:     Parameters

 2022:     ----------

 2023:     hc_ss : (F,R,L) NDarray

 2024:         Characteristic strain from all loud single sources.

 2025:     hc_bg : (F,R) NDarray

 2026:         Characteristic strain from all but loudest source at each frequency.

 2027:     freqs : (F,) 1Darray

 2028:         Frequency bin centers.

 2029:     nexcl : int

 2030:         Number of loudest single sources to exclude from hc_rest noise, in addition

 2031:         to the source in question.

 2032: 

 2033:     Returns

 2034:     -------

 2035:     Sh_rest : (F,R,L) NDarray of scalars

 2036:         The noise in a single pulsar from other GW sources for detecting each single source.

 2037: 

 2038:     """

 2039: 

+2040:     nfreqs, nreals, nloudest = hc_ss.shape[0], hc_ss.shape[1], hc_ss.shape[2]

  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_hc_ss, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_hc_ss, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_hc_ss, __pyx_n_s_shape); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_4 = __Pyx_GetItemInt(__pyx_t_1, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2040, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
  __pyx_v_nfreqs = __pyx_t_2;
  __pyx_t_2 = 0;
  __pyx_v_nreals = __pyx_t_3;
  __pyx_t_3 = 0;
  __pyx_v_nloudest = __pyx_t_4;
  __pyx_t_4 = 0;

+2041:     cdef np.ndarray[np.double_t, ndim=3] Sh_rest = np.zeros((nfreqs, nreals, nloudest))

  __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2041, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2041, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2041, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  __Pyx_INCREF(__pyx_v_nfreqs);
  __Pyx_GIVEREF(__pyx_v_nfreqs);
  PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_nfreqs);
  __Pyx_INCREF(__pyx_v_nreals);
  __Pyx_GIVEREF(__pyx_v_nreals);
  PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_nreals);
  __Pyx_INCREF(__pyx_v_nloudest);
  __Pyx_GIVEREF(__pyx_v_nloudest);
  PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_nloudest);
  __pyx_t_1 = NULL;
  if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
    __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
    if (likely(__pyx_t_1)) {
      PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
      __Pyx_INCREF(__pyx_t_1);
      __Pyx_INCREF(function);
      __Pyx_DECREF_SET(__pyx_t_2, function);
    }
  }
  __pyx_t_4 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3);
  __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
  if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2041, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 2041, __pyx_L1_error)
  __pyx_t_5 = ((PyArrayObject *)__pyx_t_4);
  {
    __Pyx_BufFmt_StackElem __pyx_stack[1];
    if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_double_t, PyBUF_FORMAT| PyBUF_STRIDES, 3, 0, __pyx_stack) == -1)) {
      __pyx_v_Sh_rest = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.buf = NULL;
      __PYX_ERR(0, 2041, __pyx_L1_error)
    } else {__pyx_pybuffernd_Sh_rest.diminfo[0].strides = __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_Sh_rest.diminfo[0].shape = __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_Sh_rest.diminfo[1].strides = __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_Sh_rest.diminfo[1].shape = __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.shape[1]; __pyx_pybuffernd_Sh_rest.diminfo[2].strides = __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.strides[2]; __pyx_pybuffernd_Sh_rest.diminfo[2].shape = __pyx_pybuffernd_Sh_rest.rcbuffer->pybuffer.shape[2];
    }
  }
  __pyx_t_5 = 0;
  __pyx_v_Sh_rest = ((PyArrayObject *)__pyx_t_4);
  __pyx_t_4 = 0;

+2042:     _Sh_rest(hc_ss, hc_bg, freqs, nexcl, nreals, nfreqs, nloudest, Sh_rest)

  __pyx_t_6 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(__pyx_v_hc_ss, PyBUF_WRITABLE); if (unlikely(!__pyx_t_6.memview)) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_7 = __Pyx_PyObject_to_MemoryviewSlice_dsds_double(__pyx_v_hc_bg, PyBUF_WRITABLE); if (unlikely(!__pyx_t_7.memview)) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_ds_double(__pyx_v_freqs, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_9 = __Pyx_PyInt_As_long(__pyx_v_nexcl); if (unlikely((__pyx_t_9 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_10 = __Pyx_PyInt_As_long(__pyx_v_nreals); if (unlikely((__pyx_t_10 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_11 = __Pyx_PyInt_As_long(__pyx_v_nfreqs); if (unlikely((__pyx_t_11 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_12 = __Pyx_PyInt_As_long(__pyx_v_nloudest); if (unlikely((__pyx_t_12 == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_t_13 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_double(((PyObject *)__pyx_v_Sh_rest), PyBUF_WRITABLE); if (unlikely(!__pyx_t_13.memview)) __PYX_ERR(0, 2042, __pyx_L1_error)
  __pyx_f_8holodeck_7cyutils__Sh_rest(__pyx_t_6, __pyx_t_7, __pyx_t_8, __pyx_t_9, __pyx_t_10, __pyx_t_11, __pyx_t_12, __pyx_t_13);
  __PYX_XDEC_MEMVIEW(&__pyx_t_6, 1);
  __pyx_t_6.memview = NULL;
  __pyx_t_6.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_7, 1);
  __pyx_t_7.memview = NULL;
  __pyx_t_7.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_8, 1);
  __pyx_t_8.memview = NULL;
  __pyx_t_8.data = NULL;
  __PYX_XDEC_MEMVIEW(&__pyx_t_13, 1);
  __pyx_t_13.memview = NULL;
  __pyx_t_13.data = NULL;

+2043:     return Sh_rest

  __Pyx_XDECREF(__pyx_r);
  __Pyx_INCREF(((PyObject *)__pyx_v_Sh_rest));
  __pyx_r = ((PyObject *)__pyx_v_Sh_rest);
  goto __pyx_L0;

 2044: 

 2045: 

+2046: cdef void _Sh_rest(

static void __pyx_f_8holodeck_7cyutils__Sh_rest(__Pyx_memviewslice __pyx_v_hc_ss, __Pyx_memviewslice __pyx_v_hc_bg, __Pyx_memviewslice __pyx_v_freqs, long __pyx_v_nexcl, long __pyx_v_nreals, long __pyx_v_nfreqs, long __pyx_v_nloudest, __Pyx_memviewslice __pyx_v_Sh_rest) {
  int __pyx_v_ff;
  int __pyx_v_rr;
  int __pyx_v_ll;
  int __pyx_v_count;
  double __pyx_v_Sh_ss;
  double __pyx_v_Sh_bg;
  PyObject *__pyx_v_freq = NULL;
  long __pyx_v_ii;
  PyObject *__pyx_v_err = NULL;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("_Sh_rest", 0);
/* … */
  /* function exit code */
  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_26);
  __Pyx_WriteUnraisable("holodeck.cyutils._Sh_rest", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0);
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_freq);
  __Pyx_XDECREF(__pyx_v_err);
  __Pyx_RefNannyFinishContext();
}

 2047:     double[:,:,:] hc_ss, double[:,:,] hc_bg, double[:] freqs, long nexcl,

 2048:     long nreals, long nfreqs, long nloudest,

 2049:     double[:,:,:] Sh_rest):

 2050:     """

 2051:     Calculate the noise from all the single sources except the source in question

 2052:     and the next N_excl loudest sources.

 2053: 

 2054:     Parameters

 2055:     ----------

 2056:     hc_ss : (F,R,L) NDarray

 2057:         Characteristic strain from all loud single sources.

 2058:     hc_bg : (F,R) NDarray

 2059:         Characteristic strain from all but loudest source at each frequency.

 2060:     freqs : (F,) 1Darray

 2061:         Frequency bin centers.

 2062:     nexcl : int

 2063:         Number of loudest single sources to exclude from hc_rest noise, in addition

 2064:         to the source in question.

 2065: 

 2066:     Returns

 2067:     -------

 2068:     void

 2069:     Sh_rest : (F,R,L) NDarray of scalars, updated via memory address

 2070: 

 2071: 

 2072:     Sh = hc^2 / (f^3 12 pi^2)

 2073: 

 2074:     """

 2075:     cdef int ff, rr, ll, count

 2076:     cdef double Sh_ss, Sh_bg

 2077: 

+2078:     for ff in range(nfreqs):

  __pyx_t_1 = __pyx_v_nfreqs;
  __pyx_t_2 = __pyx_t_1;
  for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) {
    __pyx_v_ff = __pyx_t_3;

+2079:         freq = freqs[ff]

    __pyx_t_4 = __pyx_v_ff;
    __pyx_t_5 = -1;
    if (__pyx_t_4 < 0) {
      __pyx_t_4 += __pyx_v_freqs.shape[0];
      if (unlikely(__pyx_t_4 < 0)) __pyx_t_5 = 0;
    } else if (unlikely(__pyx_t_4 >= __pyx_v_freqs.shape[0])) __pyx_t_5 = 0;
    if (unlikely(__pyx_t_5 != -1)) {
      __Pyx_RaiseBufferIndexError(__pyx_t_5);
      __PYX_ERR(0, 2079, __pyx_L1_error)
    }
    __pyx_t_6 = PyFloat_FromDouble((*((double *) ( /* dim=0 */ (__pyx_v_freqs.data + __pyx_t_4 * __pyx_v_freqs.strides[0]) )))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2079, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_XDECREF_SET(__pyx_v_freq, __pyx_t_6);
    __pyx_t_6 = 0;

+2080:         for rr in range(nreals):

    __pyx_t_7 = __pyx_v_nreals;
    __pyx_t_8 = __pyx_t_7;
    for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_8; __pyx_t_5+=1) {
      __pyx_v_rr = __pyx_t_5;

+2081:             for ll in range(nloudest): # calculating for the llth loduest

      __pyx_t_9 = __pyx_v_nloudest;
      __pyx_t_10 = __pyx_t_9;
      for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) {
        __pyx_v_ll = __pyx_t_11;

+2082:                 Sh_ss = 0

        __pyx_v_Sh_ss = 0.0;

+2083:                 count = 0

        __pyx_v_count = 0;

+2084:                 for ii in range(nloudest): # adding other loudest with index ii

        __pyx_t_12 = __pyx_v_nloudest;
        __pyx_t_13 = __pyx_t_12;
        for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) {
          __pyx_v_ii = __pyx_t_14;

+2085:                     if (ii != ll): # check it's not our current source

          __pyx_t_15 = ((__pyx_v_ii != __pyx_v_ll) != 0);
          if (__pyx_t_15) {
/* … */
          }
        }

 2086:                     # if current is in top N_excl, must be (N_excl+1)th or above

 2087:                     # if current is >= top N_excl, must be (N_excl)th or above

+2088:                         if ((ll < nexcl) and (ii > nexcl)) or ((ll >= nexcl) and (ii > nexcl-1)):

            __pyx_t_16 = ((__pyx_v_ll < __pyx_v_nexcl) != 0);
            if (!__pyx_t_16) {
              goto __pyx_L14_next_or;
            } else {
            }
            __pyx_t_16 = ((__pyx_v_ii > __pyx_v_nexcl) != 0);
            if (!__pyx_t_16) {
            } else {
              __pyx_t_15 = __pyx_t_16;
              goto __pyx_L13_bool_binop_done;
            }
            __pyx_L14_next_or:;
            __pyx_t_16 = ((__pyx_v_ll >= __pyx_v_nexcl) != 0);
            if (__pyx_t_16) {
            } else {
              __pyx_t_15 = __pyx_t_16;
              goto __pyx_L13_bool_binop_done;
            }
            __pyx_t_16 = ((__pyx_v_ii > (__pyx_v_nexcl - 1)) != 0);
            __pyx_t_15 = __pyx_t_16;
            __pyx_L13_bool_binop_done:;
            if (__pyx_t_15) {
/* … */
            }

+2089:                             Sh_ss += pow(hc_ss[ff,rr,ii], 2.0) / pow(freq, 3.0) / (12*pow(M_PI, 2.0))

              __pyx_t_4 = __pyx_v_ff;
              __pyx_t_17 = __pyx_v_rr;
              __pyx_t_18 = __pyx_v_ii;
              __pyx_t_19 = -1;
              if (__pyx_t_4 < 0) {
                __pyx_t_4 += __pyx_v_hc_ss.shape[0];
                if (unlikely(__pyx_t_4 < 0)) __pyx_t_19 = 0;
              } else if (unlikely(__pyx_t_4 >= __pyx_v_hc_ss.shape[0])) __pyx_t_19 = 0;
              if (__pyx_t_17 < 0) {
                __pyx_t_17 += __pyx_v_hc_ss.shape[1];
                if (unlikely(__pyx_t_17 < 0)) __pyx_t_19 = 1;
              } else if (unlikely(__pyx_t_17 >= __pyx_v_hc_ss.shape[1])) __pyx_t_19 = 1;
              if (__pyx_t_18 < 0) {
                __pyx_t_18 += __pyx_v_hc_ss.shape[2];
                if (unlikely(__pyx_t_18 < 0)) __pyx_t_19 = 2;
              } else if (unlikely(__pyx_t_18 >= __pyx_v_hc_ss.shape[2])) __pyx_t_19 = 2;
              if (unlikely(__pyx_t_19 != -1)) {
                __Pyx_RaiseBufferIndexError(__pyx_t_19);
                __PYX_ERR(0, 2089, __pyx_L1_error)
              }
              __pyx_t_20 = pow((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc_ss.data + __pyx_t_4 * __pyx_v_hc_ss.strides[0]) ) + __pyx_t_17 * __pyx_v_hc_ss.strides[1]) ) + __pyx_t_18 * __pyx_v_hc_ss.strides[2]) ))), 2.0);
              __pyx_t_21 = __pyx_PyFloat_AsDouble(__pyx_v_freq); if (unlikely((__pyx_t_21 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2089, __pyx_L1_error)
              __pyx_t_22 = pow(__pyx_t_21, 3.0);
              if (unlikely(__pyx_t_22 == 0)) {
                PyErr_SetString(PyExc_ZeroDivisionError, "float division");
                __PYX_ERR(0, 2089, __pyx_L1_error)
              }
              __pyx_t_21 = (__pyx_t_20 / __pyx_t_22);
              __pyx_t_22 = (12.0 * pow(M_PI, 2.0));
              if (unlikely(__pyx_t_22 == 0)) {
                PyErr_SetString(PyExc_ZeroDivisionError, "float division");
                __PYX_ERR(0, 2089, __pyx_L1_error)
              }
              __pyx_v_Sh_ss = (__pyx_v_Sh_ss + (__pyx_t_21 / __pyx_t_22));

+2090:                             count += 1

              __pyx_v_count = (__pyx_v_count + 1);

+2091:                 Sh_bg = pow(hc_bg[ff,rr], 2.0) / pow(freq, 3.0) / (12*pow(M_PI, 2.0))

        __pyx_t_18 = __pyx_v_ff;
        __pyx_t_17 = __pyx_v_rr;
        __pyx_t_19 = -1;
        if (__pyx_t_18 < 0) {
          __pyx_t_18 += __pyx_v_hc_bg.shape[0];
          if (unlikely(__pyx_t_18 < 0)) __pyx_t_19 = 0;
        } else if (unlikely(__pyx_t_18 >= __pyx_v_hc_bg.shape[0])) __pyx_t_19 = 0;
        if (__pyx_t_17 < 0) {
          __pyx_t_17 += __pyx_v_hc_bg.shape[1];
          if (unlikely(__pyx_t_17 < 0)) __pyx_t_19 = 1;
        } else if (unlikely(__pyx_t_17 >= __pyx_v_hc_bg.shape[1])) __pyx_t_19 = 1;
        if (unlikely(__pyx_t_19 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_19);
          __PYX_ERR(0, 2091, __pyx_L1_error)
        }
        __pyx_t_22 = pow((*((double *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_hc_bg.data + __pyx_t_18 * __pyx_v_hc_bg.strides[0]) ) + __pyx_t_17 * __pyx_v_hc_bg.strides[1]) ))), 2.0);
        __pyx_t_21 = __pyx_PyFloat_AsDouble(__pyx_v_freq); if (unlikely((__pyx_t_21 == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 2091, __pyx_L1_error)
        __pyx_t_20 = pow(__pyx_t_21, 3.0);
        if (unlikely(__pyx_t_20 == 0)) {
          PyErr_SetString(PyExc_ZeroDivisionError, "float division");
          __PYX_ERR(0, 2091, __pyx_L1_error)
        }
        __pyx_t_21 = (__pyx_t_22 / __pyx_t_20);
        __pyx_t_20 = (12.0 * pow(M_PI, 2.0));
        if (unlikely(__pyx_t_20 == 0)) {
          PyErr_SetString(PyExc_ZeroDivisionError, "float division");
          __PYX_ERR(0, 2091, __pyx_L1_error)
        }
        __pyx_v_Sh_bg = (__pyx_t_21 / __pyx_t_20);

+2092:                 Sh_rest[ff,rr,ll] = Sh_rest[ff,rr,ll] + Sh_ss + Sh_bg

        __pyx_t_17 = __pyx_v_ff;
        __pyx_t_18 = __pyx_v_rr;
        __pyx_t_4 = __pyx_v_ll;
        __pyx_t_19 = -1;
        if (__pyx_t_17 < 0) {
          __pyx_t_17 += __pyx_v_Sh_rest.shape[0];
          if (unlikely(__pyx_t_17 < 0)) __pyx_t_19 = 0;
        } else if (unlikely(__pyx_t_17 >= __pyx_v_Sh_rest.shape[0])) __pyx_t_19 = 0;
        if (__pyx_t_18 < 0) {
          __pyx_t_18 += __pyx_v_Sh_rest.shape[1];
          if (unlikely(__pyx_t_18 < 0)) __pyx_t_19 = 1;
        } else if (unlikely(__pyx_t_18 >= __pyx_v_Sh_rest.shape[1])) __pyx_t_19 = 1;
        if (__pyx_t_4 < 0) {
          __pyx_t_4 += __pyx_v_Sh_rest.shape[2];
          if (unlikely(__pyx_t_4 < 0)) __pyx_t_19 = 2;
        } else if (unlikely(__pyx_t_4 >= __pyx_v_Sh_rest.shape[2])) __pyx_t_19 = 2;
        if (unlikely(__pyx_t_19 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_19);
          __PYX_ERR(0, 2092, __pyx_L1_error)
        }
        __pyx_t_23 = __pyx_v_ff;
        __pyx_t_24 = __pyx_v_rr;
        __pyx_t_25 = __pyx_v_ll;
        __pyx_t_19 = -1;
        if (__pyx_t_23 < 0) {
          __pyx_t_23 += __pyx_v_Sh_rest.shape[0];
          if (unlikely(__pyx_t_23 < 0)) __pyx_t_19 = 0;
        } else if (unlikely(__pyx_t_23 >= __pyx_v_Sh_rest.shape[0])) __pyx_t_19 = 0;
        if (__pyx_t_24 < 0) {
          __pyx_t_24 += __pyx_v_Sh_rest.shape[1];
          if (unlikely(__pyx_t_24 < 0)) __pyx_t_19 = 1;
        } else if (unlikely(__pyx_t_24 >= __pyx_v_Sh_rest.shape[1])) __pyx_t_19 = 1;
        if (__pyx_t_25 < 0) {
          __pyx_t_25 += __pyx_v_Sh_rest.shape[2];
          if (unlikely(__pyx_t_25 < 0)) __pyx_t_19 = 2;
        } else if (unlikely(__pyx_t_25 >= __pyx_v_Sh_rest.shape[2])) __pyx_t_19 = 2;
        if (unlikely(__pyx_t_19 != -1)) {
          __Pyx_RaiseBufferIndexError(__pyx_t_19);
          __PYX_ERR(0, 2092, __pyx_L1_error)
        }
        *((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Sh_rest.data + __pyx_t_23 * __pyx_v_Sh_rest.strides[0]) ) + __pyx_t_24 * __pyx_v_Sh_rest.strides[1]) ) + __pyx_t_25 * __pyx_v_Sh_rest.strides[2]) )) = (((*((double *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_Sh_rest.data + __pyx_t_17 * __pyx_v_Sh_rest.strides[0]) ) + __pyx_t_18 * __pyx_v_Sh_rest.strides[1]) ) + __pyx_t_4 * __pyx_v_Sh_rest.strides[2]) ))) + __pyx_v_Sh_ss) + __pyx_v_Sh_bg);

+2093:                 if count != (nloudest - nexcl - 1):

        __pyx_t_15 = ((__pyx_v_count != ((__pyx_v_nloudest - __pyx_v_nexcl) - 1)) != 0);
        if (__pyx_t_15) {
/* … */
        }
      }
    }
  }

+2094:                     err = (f"ERROR in calculate Sh_rest! count of sources={count}")

          __pyx_t_6 = __Pyx_PyUnicode_From_int(__pyx_v_count, 0, ' ', 'd'); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2094, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_6);
          __pyx_t_26 = __Pyx_PyUnicode_Concat(__pyx_kp_u_ERROR_in_calculate_Sh_rest_count, __pyx_t_6); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 2094, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_26);
          __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
          __Pyx_XDECREF_SET(__pyx_v_err, ((PyObject*)__pyx_t_26));
          __pyx_t_26 = 0;

+2095:                     print(err)

          __pyx_t_26 = __Pyx_PyObject_CallOneArg(__pyx_builtin_print, __pyx_v_err); if (unlikely(!__pyx_t_26)) __PYX_ERR(0, 2095, __pyx_L1_error)
          __Pyx_GOTREF(__pyx_t_26);
          __Pyx_DECREF(__pyx_t_26); __pyx_t_26 = 0;

 2096: 

 2097: 

 2098: